ziex 0.0.1-dev.6 → 0.1.0-dev.1000

package/kv.d.ts

@@ -0,0 +1,42 @@
+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;
+        }[];
+    }>;
+}
+export interface SyncKVNamespace extends KVNamespace {
+    getSync(key: string): string | null;
+    putSync(key: string, value: string, options?: {
+        expiration?: number;
+        expirationTtl?: number;
+    }): void;
+    deleteSync(key: string): void;
+    listSync(options?: {
+        prefix?: string;
+    }): {
+        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 `run({ kv: ... })`.
+ * Always returns a valid import object. When JSPI is unavailable it uses
+ * synchronous bindings when available, otherwise falls back to stubbed no-ops.
+ */
+export declare function createKVImports(bindings: Record<string, KVNamespace>, getMemory: () => WebAssembly.Memory): Record<string, unknown>;

package/package.json

@@ -1,17 +1,25 @@
 {
   "name": "ziex",
+  "version": "0.1.0-dev.1000",
   "description": "ZX is a framework for building web applications with Zig.",
   "main": "index.js",
   "type": "module",
+  "bin": {
+    "ziex": "bin/ziex"
+  },
   "exports": {
     ".": "./index.js",
     "./react": "./react/index.js",
-    "./wasm": "./wasm/index.js"
+    "./wasm": "./wasm/index.js",
+    "./wasm/init": "./wasm/init.js",
+    "./cloudflare": "./cloudflare/index.js",
+    "./aws-lambda": "./aws-lambda/index.js",
+    "./vercel": "./vercel/index.js"
   },
-  "homepage": "https://github.com/nurulhudaapon/zx",
+  "homepage": "https://ziex.dev",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nurulhudaapon/zx.git"
+    "url": "git+https://github.com/ziex-dev/ziex.git"
   },
   "keywords": [
     "zx",
@@ -27,7 +35,18 @@
   ],
   "author": "Nurul Huda (Apon) <me@nurulhudaapon.com>",
   "license": "MIT",
+  "scripts": {},
+  "dependencies": {
+    "@ziex/cli": "0.1.0-dev.1000"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
   "module": "index.js",
-  "types": "index.d.ts",
-  "version": "0.0.1-dev.6"
+  "types": "index.d.ts"
 }

package/react/dom.d.ts

@@ -1,135 +1,21 @@
 import type { ComponentMetadata } from "./types";
-/**
- * Result of preparing a component for hydration.
- *
- * Contains all the necessary data to render a React component into its server-rendered container.
- */
 export type PreparedComponent = {
-    /**
-     * The HTML element where the component should be rendered.
-     *
-     * This is the DOM node that was server-rendered by ZX with the component's unique ID.
-     * The element already exists in the DOM and contains the server-rendered fallback content.
-     * React will hydrate this element, replacing its contents with the interactive component.
-     *
-     * @example
-     * ```tsx
-     * // The DOM node corresponds to HTML like:
-     * // <div id="zx-dcde04c415da9d1b15ca2690d8b497ae" data-props="...">...</div>
-     *
-     * const { domNode } = await prepareComponent(component);
-     * createRoot(domNode).render(<Component {...props} />);
-     * ```
-     */
     domNode: HTMLElement;
-    /**
-     * Component props parsed from the server-rendered HTML.
-     *
-     * Props are extracted from the `data-props` attribute (JSON-encoded) on the component's
-     * container element. If the component has children from server side then they are automatically converted to
-     * `dangerouslySetInnerHTML` for React compatibility.
-     *
-     * @example
-     * ```tsx
-     * // Server-rendered HTML:
-     * // <div data-props='{"max_count":10,"label":"Counter"}' data-children="<span>0</span>">...</div>
-     *
-     * const { props } = await prepareComponent(component);
-     * // props = {
-     * //   max_count: 10,
-     * //   label: "Counter",
-     * //   dangerouslySetInnerHTML: { __html: "<span>0</span>" }
-     * // }
-     * ```
-     */
     props: Record<string, any> & {
-        /**
-         * React's special prop for setting inner HTML directly.
-         *
-         * Automatically added when the component has children in the ZX file. The HTML string
-         * is extracted from the `data-children` attribute on the server-rendered element.
-         *
-         * @example
-         * ```tsx
-         * // In ZX file:
-         * <MyComponent @rendering={.csr}>
-         *   <p>Child content</p>
-         * </MyComponent>
-         *
-         * // Results in:
-         * // props.dangerouslySetInnerHTML = { __html: "<p>Child content</p>" }
-         * ```
-         */
         dangerouslySetInnerHTML?: {
             __html: string;
         };
     };
-    /**
-     * The loaded React component function ready to render.
-     *
-     * This is the default export from the component module, lazy-loaded via the component's
-     * import function. The component is ready to be rendered with React's `createRoot().render()`.
-     *
-     * @example
-     * ```tsx
-     * const { Component, props, domNode } = await prepareComponent(component);
-     *
-     * // Component is the default export from the component file:
-     * // export default function CounterComponent({ max_count }: { max_count: number }) {
-     * //   return <div>Count: {max_count}</div>;
-     * // }
-     *
-     * createRoot(domNode).render(<Component {...props} />);
-     * ```
-     */
     Component: (props: any) => React.ReactElement;
 };
-/**
- * Prepares a client-side component for hydration by locating its DOM container, extracting
- * props and children from server-rendered HTML attributes, and lazy-loading the component module.
- *
- * This function bridges server-rendered HTML (from ZX's Zig transpiler) and client-side React
- * components. It reads data attributes (`data-props`, `data-children`) from the DOM element
- * with the component's unique ID, then lazy-loads the component module for rendering.
- *
- * @param component - The component metadata containing ID, import function, and other metadata
- *                    needed to locate and load the component
- *
- * @returns A Promise that resolves to a `PreparedComponent` object containing the DOM node,
- *          parsed props, and the loaded React component function
- *
- * @throws {Error} If the component's container element cannot be found in the DOM. This typically
- *                 happens if the component ID doesn't match any element, the script runs before
- *                 the HTML is loaded, or there's a mismatch between server and client metadata
- *
- * @example
- * ```tsx
- * // Basic usage with React:
- * import { createRoot } from "react-dom/client";
- * import { prepareComponent } from "ziex";
- * import { components } from "@ziex/components";
- *
- * for (const component of components) {
- *   prepareComponent(component).then(({ domNode, Component, props }) => {
- *     createRoot(domNode).render(<Component {...props} />);
- *   }).catch(console.error);
- * }
- * ```
- *
- * @example
- * ```tsx
- * // With async/await:
- * async function hydrateComponent(component: ComponentMetadata) {
- *   try {
- *     const { domNode, Component, props } = await prepareComponent(component);
- *     createRoot(domNode).render(<Component {...props} />);
- *   } catch (error) {
- *     console.error(`Failed to hydrate ${component.name}:`, error);
- *   }
- * }
- *
- * Promise.all(components.map(hydrateComponent));
- * ```
- */
 export declare function prepareComponent(component: ComponentMetadata): Promise<PreparedComponent>;
 export declare function filterComponents(components: ComponentMetadata[]): ComponentMetadata[];
+export type DiscoveredComponent = {
+    id: string;
+    name: string;
+    props: Record<string, any>;
+    container: HTMLElement;
+};
+export declare function discoverComponents(): DiscoveredComponent[];
+export type ComponentRegistry = Record<string, () => Promise<(props: any) => React.ReactElement>>;
+export declare function hydrateAll(registry: ComponentRegistry, render: (container: HTMLElement, Component: (props: any) => React.ReactElement, props: Record<string, any>) => void): Promise<void>;

package/react/index.d.ts

@@ -1,2 +1,2 @@
-export { prepareComponent, filterComponents, type PreparedComponent } from "./dom";
+export { prepareComponent, filterComponents, discoverComponents, hydrateAll, type PreparedComponent, type DiscoveredComponent, type ComponentRegistry, } from "./dom";
 export type { ComponentMetadata } from "./types";

package/react/index.js

@@ -1 +1,148 @@
-async function S(k){let G=document.getElementById(k.id);if(!G)throw Error(`Root element ${k.id} not found`,{cause:k});let J=JSON.parse(G.getAttribute("data-props")||"{}"),K=G.getAttribute("data-children")??void 0;if(K)J.dangerouslySetInnerHTML={__html:K};let Q=await k.import();return{domNode:G,props:J,Component:Q}}function U(k){let G=window.location.pathname;return k.filter((J)=>J.route===G||!J.route)}export{S as prepareComponent,U as filterComponents};
+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/react/dom.ts
+function findCommentMarker(id) {
+  const startPrefix = `$${id} `;
+  const endMarker = `/$${id}`;
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_COMMENT, null);
+  let startComment = null;
+  let endComment = null;
+  let name = "";
+  let props = {};
+  let node;
+  while (node = walker.nextNode()) {
+    const text = node.textContent?.trim() || "";
+    if (text.startsWith(startPrefix)) {
+      startComment = node;
+      const content = text.slice(startPrefix.length);
+      const jsonStart = content.indexOf("{");
+      if (jsonStart !== -1) {
+        name = content.slice(0, jsonStart).trim();
+        const jsonStr = content.slice(jsonStart);
+        try {
+          props = JSON.parse(jsonStr);
+        } catch {}
+      } else {
+        name = content.trim();
+      }
+    }
+    if (text === endMarker) {
+      endComment = node;
+      break;
+    }
+  }
+  if (startComment && endComment) {
+    return { startComment, endComment, name, props };
+  }
+  return null;
+}
+function createContainerBetweenMarkers(startComment, endComment) {
+  const container = document.createElement("div");
+  container.style.display = "contents";
+  let current = startComment.nextSibling;
+  while (current && current !== endComment) {
+    const next = current.nextSibling;
+    container.appendChild(current);
+    current = next;
+  }
+  endComment.parentNode?.insertBefore(container, endComment);
+  return container;
+}
+async function prepareComponent(component) {
+  const marker = findCommentMarker(component.id);
+  if (!marker) {
+    throw new Error(`Comment marker for ${component.id} not found`, { cause: component });
+  }
+  const props = marker.props;
+  const domNode = createContainerBetweenMarkers(marker.startComment, marker.endComment);
+  const Component = await component.import();
+  return { domNode, props, Component };
+}
+function filterComponents(components) {
+  const currentPath = window.location.pathname;
+  return components.filter((component) => component.route === currentPath || !component.route);
+}
+function discoverComponents() {
+  const components = [];
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_COMMENT, null);
+  const markers = [];
+  let node;
+  while (node = walker.nextNode()) {
+    const text = node.textContent?.trim() || "";
+    if (text.startsWith("$") && !text.startsWith("/$")) {
+      const spaceIdx = text.indexOf(" ");
+      if (spaceIdx !== -1) {
+        const id = text.slice(1, spaceIdx);
+        const content = text.slice(spaceIdx + 1);
+        if (content.startsWith("[")) {
+          continue;
+        }
+        const jsonStart = content.indexOf("{");
+        let name = "";
+        let props = {};
+        if (jsonStart !== -1) {
+          name = content.slice(0, jsonStart).trim();
+          try {
+            props = JSON.parse(content.slice(jsonStart));
+          } catch {}
+        } else {
+          name = content.trim();
+        }
+        markers.push({ id, name, props, startComment: node, endComment: null });
+      }
+    } else if (text.startsWith("/$")) {
+      const id = text.slice(2);
+      const marker = markers.find((m) => m.id === id && !m.endComment);
+      if (marker) {
+        marker.endComment = node;
+      }
+    }
+  }
+  for (const marker of markers) {
+    if (!marker.endComment)
+      continue;
+    const container = createContainerBetweenMarkers(marker.startComment, marker.endComment);
+    components.push({
+      id: marker.id,
+      name: marker.name,
+      props: marker.props,
+      container
+    });
+  }
+  return components;
+}
+async function hydrateAll(registry, render) {
+  const components = discoverComponents();
+  await Promise.all(components.map(async ({ name, props, container }) => {
+    const importer = registry[name];
+    if (!importer) {
+      console.warn(`Component "${name}" not found in registry`);
+      return;
+    }
+    try {
+      const Component = await importer();
+      render(container, Component, props);
+    } catch (error) {
+      console.error(`Failed to hydrate "${name}":`, error);
+    }
+  }));
+}
+export {
+  prepareComponent,
+  hydrateAll,
+  filterComponents,
+  discoverComponents
+};

package/react/types.d.ts

@@ -2,14 +2,14 @@
  * Metadata for a client-side component used within a ZX file.
  *
  * This type represents the metadata for components that are marked with the `@rendering` attribute
- * in ZX files. When a component is declared with `@rendering={.csr}` or `@rendering={.csz}` in a
+ * in ZX files. When a component is declared with `@rendering={.react}` or `@rendering={.client}` in a
  * `.zx` file, the ZX transpiler generates a `ComponentMetadata` entry that is included in the
  * generated `components` array.
  *
  * @example
  * ```tsx
  * // In a ZX file (page.zx):
- * <CounterComponent @rendering={.csr} max_count={10} />
+ * <CounterComponent @rendering={.react} max_count={10} />
  *
  * // Generated components array (components.ts):
  * export const components: ComponentMetadata[] = [
@@ -17,7 +17,7 @@
  *     name: "CounterComponent",
  *     path: "./components/CounterComponent.tsx",
  *     id: "zx-dcde04c415da9d1b15ca2690d8b497ae",
- *     type: "csr",
+ *     type: "react",
  *     import: () => import('./components/CounterComponent.tsx')
  *   }
  * ];
@@ -44,7 +44,7 @@ export type ComponentMetadata = {
      * @example
      * ```tsx
      * // In ZX file:
-     * <CounterComponent @rendering={.csr} />
+     * <CounterComponent @rendering={.react} />
      *
      * // name will be: "CounterComponent"
      * ```
@@ -54,7 +54,7 @@ export type ComponentMetadata = {
      * The file path to the component module.
      *
      * This is the relative or absolute path to the component file that will be dynamically imported
-     * at runtime. For CSR components, this typically points to a `.tsx` or `.jsx` file. For CSZ
+     * at runtime. For CSR components, this typically points to a `.tsx` or `.jsx` file. For Client
      * components, this points to a Zig component file.
      *
      * The path is determined from the `@jsImport` directive in the ZX file, or defaults to
@@ -64,7 +64,7 @@ export type ComponentMetadata = {
      * ```tsx
      * // In ZX file:
      * const CounterComponent = @jsImport("components/Counter.tsx");
-     * <CounterComponent @rendering={.csr} />
+     * <CounterComponent @rendering={.react} />
      *
      * // path will be: "components/Counter.tsx"
      * ```
@@ -72,7 +72,7 @@ export type ComponentMetadata = {
      * @example
      * ```tsx
      * // Without explicit @jsImport:
-     * <MyComponent @rendering={.csr} />
+     * <MyComponent @rendering={.react} />
      *
      * // path will default to: "./MyComponent.tsx"
      * ```
@@ -85,17 +85,16 @@ export type ComponentMetadata = {
      */
     route: string | null;
     /**
-     * A unique HTML element identifier for the component's root DOM node.
+     * A unique identifier for the component's hydration boundary.
      *
      * This ID is generated by hashing the component's path and name using MD5, then formatting it
-     * as a hex string with the "zx-" prefix. The ID is used to locate the component's container
-     * element in the DOM during client-side hydration.
+     * as a hex string with the "zx-" prefix and a counter suffix. The ID is used to locate the
+     * component's comment markers in the DOM during client-side hydration.
      *
-     * The ID format is: `zx-{32 hex characters}` (e.g., `zx-dcde04c415da9d1b15ca2690d8b497ae`)
+     * The ID format is: `zx-{32 hex characters}-{counter}` (e.g., `zx-dcde04c415da9d1b15ca2690d8b497ae-0`)
      *
-     * When the same component is used multiple times on a page, each instance gets the same base ID
-     * since they share the same path and name. The ZX runtime uses this ID along with `data-props`
-     * and `data-children` attributes to hydrate the component with the correct props and children.
+     * The ZX runtime renders components with comment markers in the format:
+     * `<!--$id name props-->...<!--/$id-->`
      *
      * @example
      * ```tsx
@@ -103,36 +102,34 @@ export type ComponentMetadata = {
      * {
      *   name: "CounterComponent",
      *   path: "./components/Counter.tsx",
-     *   id: "zx-dcde04c415da9d1b15ca2690d8b497ae"
+     *   id: "zx-dcde04c415da9d1b15ca2690d8b497ae-0"
      * }
      *
-     * // Generated HTML:
-     * <div id="zx-dcde04c415da9d1b15ca2690d8b497ae"
-     *      data-props='{"max_count":10}'
-     *      data-children="...">
-     *   <!-- Server-rendered content -->
-     * </div>
+     * // Generated HTML with comment markers:
+     * <!--$zx-dcde04c415da9d1b15ca2690d8b497ae-0 CounterComponent {"max_count":10}-->
+     * <button>0</button>
+     * <!--/$zx-dcde04c415da9d1b15ca2690d8b497ae-0-->
      * ```
      */
     id: string;
     /**
      * The rendering type of the component, determining how it will be rendered on the client.
      *
-     * - **"csr"** (Client Side React): The component is a React component that will be rendered
+     * - **"react"** (Client Side React): The component is a React component that will be rendered
      *   using React's client-side rendering. The component file should export a default React
      *   component function. This is the most common type for interactive UI components.
      *
-     * - **"csz"** (Client Side Zig): The component is a Zig component that will be compiled to
+     * - **"client"** (Client Side Zig): The component is a Zig component that will be compiled to
      *   WebAssembly and rendered on the client side. This allows you to use Zig's performance
      *   and type safety for client-side components.
      *
-     * The type is determined by the `@rendering` attribute value in the ZX file (`.csr` or `.csz`).
+     * The type is determined by the `@rendering` attribute value in the ZX file (`.react` or `.client`).
      *
      * @example
      * ```tsx
      * // CSR component (React):
-     * <CounterComponent @rendering={.csr} max_count={10} />
-     * // type: "csr"
+     * <CounterComponent @rendering={.react} max_count={10} />
+     * // type: "react"
      *
      * // Component file (CounterComponent.tsx):
      * export default function CounterComponent({ max_count }: { max_count: number }) {
@@ -142,9 +139,9 @@ export type ComponentMetadata = {
      *
      * @example
      * ```tsx
-     * // CSZ component (Zig/WASM):
-     * <CounterComponent @rendering={.csz} />
-     * // type: "csz"
+     * // Client component (Zig/WASM):
+     * <CounterComponent @rendering={.client} />
+     * // type: "client"
      *
      * // Component file (CounterComponent.zig):
      * pub fn CounterComponent(allocator: zx.Allocator) zx.Component {
@@ -152,7 +149,7 @@ export type ComponentMetadata = {
      * }
      * ```
      */
-    type: "csr" | "csz";
+    type: "react" | "client";
     /**
      * A lazy-loading function that dynamically imports the component module.
      *
@@ -161,7 +158,7 @@ export type ComponentMetadata = {
      * by only loading components when they are needed.
      *
      * For CSR components, the imported module should export a default React component.
-     * For CSZ components, the import mechanism depends on the WASM module structure.
+     * For Client components, the import mechanism depends on the WASM module structure.
      *
      * The function is called during client-side hydration to load and render the component
      * into its corresponding DOM container element.

package/runtime.d.ts

@@ -0,0 +1,73 @@
+import type { WASI } from "./wasi";
+import type { KVNamespace } from "./kv";
+import type { D1Database } from "./db";
+/** Minimal Durable Object namespace shape needed for WebSocket routing. */
+export type DurableObjectNamespace = {
+    idFromName(name: string): unknown;
+    get(id: unknown): {
+        fetch(req: Request): Promise<Response>;
+    };
+};
+export 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;
+};
+/** Build the __zx_ws import object for a given connection state. */
+export declare function buildWsImports(Suspending: any, mem: () => WebAssembly.Memory, decoder: TextDecoder, ws: WsState): {
+    ws_upgrade: () => void;
+    ws_write: (ptr: number, len: number) => void;
+    ws_close: (code: number, reason_ptr: number, reason_len: number) => void;
+    ws_recv: any;
+    ws_subscribe: (ptr: number, len: number) => void;
+    ws_unsubscribe: (ptr: number, len: number) => void;
+    ws_publish: (topic_ptr: number, topic_len: number, data_ptr: number, data_len: number) => number;
+    ws_is_subscribed: (ptr: number, len: number) => number;
+};
+/** Create WebSocketPair, wire message/close listeners, flush pending writes. */
+export declare function attachWebSocket(ws: WsState): {
+    client: WebSocket;
+};
+/**
+ * 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 run({
+ *   request, env, ctx, module,
+ *   kv: { default: env.KV, users: env.USERS_KV },
+ * });
+ * ```
+ */
+export declare function run({ request, env, ctx, module, kv: kvBindings, db: dbBindings, 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, KVNamespace>;
+    /** D1 bindings — `{ default: env.DB, analytics: env.ANALYTICS_DB }` */
+    db?: Record<string, D1Database>;
+    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.
+     */
+    websocket?: DurableObjectNamespace;
+}): Promise<Response>;

package/vercel/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Ziex adapter for Vercel Edge Functions.
+ *
+ * @example
+ * ```ts
+ * import { Ziex } from "ziex/cloudflare";
+ * import { handle } from "ziex/vercel";
+ * import module from "./app.wasm"; // or fetch at runtime
+ *
+ * const app = new Ziex({ module });
+ *
+ * export const config = { runtime: "edge" };
+ * export default handle(app);
+ * ```
+ */
+type FetchApp = {
+    fetch(req: Request, env?: unknown, ctx?: unknown): Promise<Response>;
+};
+/**
+ * Wrap a Ziex app as a Vercel Edge Function handler.
+ *
+ * Returns a standard `(req: Request) => Promise<Response>` function.
+ * Vercel's edge runtime calls it directly — just export it as default.
+ */
+export declare function handle(app: FetchApp): (req: Request) => Promise<Response>;
+export {};

package/vercel/index.js

@@ -0,0 +1,22 @@
+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/vercel/index.ts
+function handle(app) {
+  return (req) => app.fetch(req);
+}
+export {
+  handle
+};