@evjs/runtime 0.0.1-rc.6 → 0.0.1-rc.7

package/AGENT.md

@@ -1,78 +1,310 @@
-# @evjs/runtime
+# @evjs/runtime — Agent Guide
 
-Core runtime for the ev React framework. Provides client-side routing, data fetching, and server-side handling.
+> AI-agent reference for developing apps with the `@evjs/runtime` package.
 
-## Client API (`@evjs/runtime/client`)
+## Overview
+
+Core runtime for evjs apps. Two entry points:
+- `@evjs/runtime` + `@evjs/runtime/client` — client-side (React, TanStack)
+- `@evjs/runtime/server` — server-side (Hono)
+- `@evjs/runtime/server/ecma` — edge/serverless adapter
+
+## Client API
 
 ### App Bootstrap
-- `createApp({ routeTree, routerOptions?, queryClientConfig? })` — Bootstrap Router + Query + DOM. Injects `queryClient` into router context.
-- `createAppRootRoute(options)` — Create root route with typed `context.queryClient` for route loaders.
+
+```tsx
+import { createApp, createAppRootRoute, createRoute } from "@evjs/runtime";
+
+const rootRoute = createAppRootRoute({ component: RootLayout });
+
+const homeRoute = createRoute({
+  getParentRoute: () => rootRoute,
+  path: "/",
+  component: HomePage,
+});
+
+const routeTree = rootRoute.addChildren([homeRoute]);
+
+const app = createApp({ routeTree });
+
+// REQUIRED for type-safe useParams, useSearch, Link, etc.
+declare module "@tanstack/react-router" {
+  interface Register {
+    router: typeof app.router;
+  }
+}
+
+app.render("#app");
+```
+
+**Key functions:**
+| API | Import | Purpose |
+|-----|--------|---------|
+| `createApp` | `@evjs/runtime` | Bootstrap Router + QueryClient + render to DOM |
+| `createAppRootRoute` | `@evjs/runtime` | Root route with typed `context.queryClient` |
+| `createRoute` | `@evjs/runtime` | Define a route (re-export from TanStack Router) |
 
 ### Server Function Proxies
-Always use these instead of raw `useQuery`/`useMutation` for server functions:
+
+**Always use `query()` / `mutation()` wrappers.** Never call `useQuery` with manual fetch.
 
 ```tsx
-import { query, mutation, createQueryProxy, createMutationProxy } from "@evjs/runtime/client";
+import { query, mutation } from "@evjs/runtime/client";
 import { getUsers, createUser } from "./api/users.server";
 
-// Direct wrapper
-const { data } = query(getUsers).useQuery([]);
-const { mutate } = mutation(createUser).useMutation();
+// Data fetching
+const { data, isLoading, error } = query(getUsers).useQuery();
 
-// Module proxy
-const api = { query: createQueryProxy({ getUsers }), mutation: createMutationProxy({ createUser }) };
-api.query.getUsers.useQuery([]);
+// With arguments (spread, not wrapped in array)
+const { data } = query(getUser).useQuery(userId);
 
-// queryOptions (for loaders, prefetch)
-const opts = query(getUsers).queryOptions([]);
+// Mutations
+const { mutate, isPending } = mutation(createUser).useMutation();
+mutate([{ name: "Alice", email: "alice@example.com" }]);
+
+// queryOptions — for route loaders, prefetching, cache control
+const opts = query(getUsers).queryOptions();
 queryClient.ensureQueryData(opts);
+queryClient.prefetchQuery(opts);
 
-// Query key (for invalidation)
+// Cache invalidation
 queryClient.invalidateQueries({ queryKey: query(getUsers).queryKey() });
+// or by evId
+queryClient.invalidateQueries({ queryKey: [getUsers.evId] });
+
+// Module proxy (for grouping)
+import { createQueryProxy, createMutationProxy } from "@evjs/runtime/client";
+const api = {
+  query: createQueryProxy({ getUsers, getUser }),
+  mutation: createMutationProxy({ createUser }),
+};
+api.query.getUsers.useQuery();
 ```
 
 ### Route Loader Pattern
+
+Prefetch data before route renders — no loading spinners:
+
 ```tsx
-const rootRoute = createAppRootRoute({ component: Root });
 const usersRoute = createRoute({
   getParentRoute: () => rootRoute,
   path: "/users",
   loader: ({ context }) =>
-    context.queryClient.ensureQueryData(query(getUsers).queryOptions([])),
+    context.queryClient.ensureQueryData(query(getUsers).queryOptions()),
   component: UsersPage,
 });
 ```
 
-### Routing (re-exports from @tanstack/react-router)
-`createRootRoute`, `createRoute`, `createRouter`, `Link`, `Outlet`, `Navigate`, `useParams`, `useSearch`, `useNavigate`, `useLocation`, `useMatch`, `useLoaderData`, `redirect`, `notFound`, `lazyRouteComponent`
+### Routing
 
-### Data (re-exports from @tanstack/react-query)
-`useQuery`, `useMutation`, `useQueryClient`, `useSuspenseQuery`, `QueryClient`, `QueryClientProvider`
 
-### Transport
+**Recommended structure:**
+
+```
+src/
+├── main.tsx              ← route tree wiring + type registration
+├── api/*.server.ts       ← server functions
+└── pages/
+    ├── __root.tsx         ← root layout (nav + <Outlet />)
+    ├── home.tsx           ← static route
+    ├── posts/index.tsx    ← nested group (layout + index + $postId)
+    ├── dashboard.tsx      ← pathless layout + child route
+    ├── search.tsx         ← typed search params
+    └── catch.tsx          ← redirect + 404
+```
+
+**Key patterns:**
+
+| Pattern | Code | Notes |
+|---------|------|-------|
+| Dynamic slug | `path: "$postId"` | Access via `route.useParams()` → `{ postId: string }` |
+| Pathless layout | `id: "dashboard-layout"` | Shared UI without URL segment, use `<Outlet />` |
+| Index route | `path: "/"` inside a group | Shown when parent matches exactly |
+| Catch-all / 404 | `path: "*"` | Matches unmatched URLs |
+| Search params | `validateSearch: (s) => ({ q: s.q ?? "" })` | Access via `route.useSearch()` |
+| Redirect | `beforeLoad: () => { throw redirect({ to: "/posts" }) }` | |
+| Route nesting | `postsRoute.addChildren([indexRoute, detailRoute])` | |
+| Loader prefetch | `loader: ({ params, context }) => context.queryClient.ensureQueryData(...)` | |
+
+**Type-safe routing (CRITICAL):**
+
+```tsx
+// main.tsx — ALWAYS register the router type
+const app = createApp({ routeTree });
+
+declare module "@tanstack/react-router" {
+  interface Register {
+    router: typeof app.router;
+  }
+}
+
+app.render("#app");
+```
+
+Without this declaration, `useParams()`, `useSearch()`, and `Link` all return `any`.
+
+**Use route-scoped hooks** (not global):
+
+```tsx
+// ✅ Type-safe — postId: string
+const { postId } = postDetailRoute.useParams();
+
+// ❌ Untyped — returns any
+const params = useParams({ from: "/posts/$postId" });
+
+
+
+### Transport Configuration
+
 ```tsx
 import { initTransport } from "@evjs/runtime/client";
 
-// Simple: custom base URL and endpoint path
+// Default HTTP transport (usually no config needed)
+initTransport({ endpoint: "/api/fn" });
+
+// Custom API host (e.g., separate backend)
 initTransport({
   baseUrl: "https://api.example.com",
-  endpoint: "/server-function",  // default: "/api/fn"
+  endpoint: "/api/fn",
+});
+
+// WebSocket transport
+initTransport({
+  transport: {
+    send: async (fnId, args) => {
+      // custom WebSocket implementation
+    },
+  },
 });
 
-// Advanced: fully custom transport
-initTransport({ transport: { send: async (fnId, args) => { /* custom */ } } });
+// Custom codec (e.g., MessagePack)
+initTransport({
+  codec: {
+    encode: (data) => msgpack.encode(data),
+    decode: (buffer) => msgpack.decode(buffer),
+    contentType: "application/msgpack",
+  },
+});
 ```
 
-## Server API (`@evjs/runtime/server`)
+### Routing Re-exports
 
-- `createApp(options?)` — Create Hono app with server function handler. Options: `{ endpoint?: string, port?: number }`. Default endpoint path: `/api/fn`.
-- `serve(app, { port?, host? })` — Start on Node.js (default port 3001).
-- `registerServerFn(fnId, fn)` — Register server function (called by build-tools).
-- `createHandler()` — Standalone Hono server function handler.
+From `@tanstack/react-router`:
+`createRootRoute`, `createRoute`, `createRouter`, `Link`, `Outlet`, `Navigate`, `useParams`, `useSearch`, `useNavigate`, `useLocation`, `useMatch`, `useLoaderData`, `redirect`, `notFound`, `lazyRouteComponent`
 
-## ECMA Adapter (`@evjs/runtime/server/ecma`)
+### Data Re-exports
 
-- `createFetchHandler(app)` — Wraps a Hono app for deployment to Deno, Bun, or any Fetch-compatible runtime.
+From `@tanstack/react-query`:
+`useQuery`, `useMutation`, `useQueryClient`, `useSuspenseQuery`, `QueryClient`, `QueryClientProvider`
 
 ## Server Functions
-Files must start with `"use server";`, use named async exports, and end in `.server.ts`.
+
+```ts
+// src/api/users.server.ts
+"use server";
+
+export async function getUsers() {
+  return await db.users.findMany();
+}
+
+export async function getUser(id: string) {
+  const user = await db.users.find(id);
+  if (!user) {
+    throw new ServerError("NOT_FOUND", { message: "User not found", id });
+  }
+  return user;
+}
+
+export async function createUser(name: string, email: string) {
+  return await db.users.create({ data: { name, email } });
+}
+```
+
+**Rules:**
+- File must start with `"use server";` directive
+- Only **named async function exports** are supported
+- No default exports, no arrow function exports
+- Arguments are positional, transported as a tuple
+- Use `.server.ts` extension or place in `src/api/`
+- Build system auto-discovers — no manual registration
+
+## Server API
+
+```ts
+import { createApp, serve, createHandler, registerMiddleware } from "@evjs/runtime/server";
+```
+
+| API | Purpose |
+|-----|---------|
+| `createApp({ endpoint? })` | Hono app with server function handler |
+| `serve(app, { port?, host? })` | Node.js HTTP server with graceful shutdown |
+| `createHandler()` | Standalone server function Hono handler |
+| `registerServerFn(id, fn)` | Register a server function (used by build tools) |
+| `registerMiddleware(fn)` | Register Hono middleware |
+
+### ECMA Adapter (Edge / Serverless)
+
+```ts
+import { createFetchHandler } from "@evjs/runtime/server/ecma";
+
+const app = createApp({ endpoint: "/api/fn" });
+const handler = createFetchHandler(app);
+
+// Deno
+Deno.serve(handler);
+
+// Bun
+export default { fetch: handler };
+
+// Cloudflare Workers
+export default { fetch: handler };
+```
+
+## Error Handling
+
+```ts
+import { ServerError } from "@evjs/runtime";
+
+// Server — throw structured errors
+export async function getUser(id: string) {
+  const user = await db.users.find(id);
+  if (!user) throw new ServerError("NOT_FOUND", { id });
+  return user;
+}
+
+// Client — catch typed errors
+import { ServerError } from "@evjs/runtime";
+
+try {
+  await getUser("123");
+} catch (e) {
+  if (e instanceof ServerError) {
+    e.code;  // "NOT_FOUND"
+    e.data;  // { id: "123" }
+  }
+}
+```
+
+## Middleware
+
+```ts
+// src/middleware/auth.ts
+import { registerMiddleware } from "@evjs/runtime/server";
+
+registerMiddleware(async (c, next) => {
+  const token = c.req.header("Authorization");
+  if (!token) return c.json({ error: "Unauthorized" }, 401);
+  await next();
+});
+```
+
+## Common Mistakes
+
+1. **Don't use raw `useQuery`** for server functions — use `query(fn).useQuery(args)`
+2. **Arguments are spread, not wrapped** — `query(getUser).useQuery(id)` not `query(getUser).useQuery([id])`
+3. **Don't call server functions directly in components** — wrap with `query()` or `mutation()`
+4. **Don't forget `"use server";`** at the top of `.server.ts` files
+5. **Import `ServerError` from `@evjs/runtime`** — not from `/server` or `/client`
+6. **Always register the router type** — without `declare module "@tanstack/react-router" { interface Register { router: typeof app.router } }`, all route params/search will be `any`
+7. **Use `route.useParams()`** not the global `useParams()` — the route-scoped version gives proper type inference

package/esm/client/context.d.ts

@@ -17,7 +17,7 @@ export interface AppRouteContext {
  *   getParentRoute: () => rootRoute,
  *   path: "/users",
  *   loader: ({ context }) =>
- *     context.queryClient.ensureQueryData(query(getUsers).queryOptions([])),
+ *     context.queryClient.ensureQueryData(query(getUsers).queryOptions()),
  * });
  * ```
  */

package/esm/client/context.js

@@ -13,7 +13,7 @@ import { createRootRouteWithContext } from "@tanstack/react-router";
  *   getParentRoute: () => rootRoute,
  *   path: "/users",
  *   loader: ({ context }) =>
- *     context.queryClient.ensureQueryData(query(getUsers).queryOptions([])),
+ *     context.queryClient.ensureQueryData(query(getUsers).queryOptions()),
  * });
  * ```
  */

package/esm/client/create-app.d.ts

@@ -1,15 +1,11 @@
 import { QueryClient, type QueryClientConfig } from "@tanstack/react-query";
-import type { AnyRoute, AnyRouter } from "@tanstack/react-router";
+import type { AnyRoute } from "@tanstack/react-router";
 /**
  * Options for creating an ev application.
  */
 export interface CreateAppOptions<TRouteTree extends AnyRoute> {
     /** The root route tree produced by createRootRoute and addChildren. */
     routeTree: TRouteTree;
-    /**
-     * Optional configuration for the TanStack Router.
-     */
-    routerOptions?: Omit<Parameters<typeof import("@tanstack/react-router").createRouter>[0], "routeTree">;
     /**
      * Optional configuration for the TanStack Query Client.
      */
@@ -22,10 +18,25 @@ export interface CreateAppOptions<TRouteTree extends AnyRoute> {
 }
 /**
  * An initialized ev application instance.
+ *
+ * Register the router type for full IDE type safety on `useParams`,
+ * `useSearch`, `Link`, etc:
+ *
+ * ```tsx
+ * const app = createApp({ routeTree });
+ *
+ * declare module "@tanstack/react-router" {
+ *   interface Register {
+ *     router: typeof app.router;
+ *   }
+ * }
+ *
+ * app.render("#app");
+ * ```
  */
-export interface App {
-    /** The TanStack Router instance. */
-    router: AnyRouter;
+export interface App<TRouter> {
+    /** The TanStack Router instance (use `typeof app.router` for type registration). */
+    router: TRouter;
     /** The TanStack Query Client instance. */
     queryClient: QueryClient;
     /**
@@ -40,14 +51,25 @@ export interface App {
  * This function initializes the router and query client and returns
  * an app object that can be mounted into the DOM.
  *
- * @param options - Application configuration options.
- * @returns An initialized App instance.
+ * Register the router type globally for full IDE type-safety on
+ * `useParams`, `useSearch`, `Link`, etc:
  *
  * @example
  * ```tsx
  * const app = createApp({ routeTree });
+ *
+ * declare module "@tanstack/react-router" {
+ *   interface Register {
+ *     router: typeof app.router;
+ *   }
+ * }
+ *
  * app.render("#app");
  * ```
  */
-export declare function createApp<TRouteTree extends AnyRoute>(options: CreateAppOptions<TRouteTree>): App;
+export declare function createApp<TRouteTree extends AnyRoute>(options: CreateAppOptions<TRouteTree>): {
+    router: import("@tanstack/router-core").RouterCore<TRouteTree, "never", false, import("@tanstack/history").RouterHistory, Record<string, any>>;
+    queryClient: QueryClient;
+    render: (container: string | HTMLElement) => void;
+};
 //# sourceMappingURL=create-app.d.ts.map

package/esm/client/create-app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-app.d.ts","sourceRoot":"","sources":["../../src/client/create-app.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,KAAK,iBAAiB,EAEvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAKlE;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,UAAU,SAAS,QAAQ;IAC3D,uEAAuE;IACvE,SAAS,EAAE,UAAU,CAAC;IACtB;;OAEG;IACH,aAAa,CAAC,EAAE,IAAI,CAClB,UAAU,CAAC,cAAc,wBAAwB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,EACnE,WAAW,CACZ,CAAC;IACF;;OAEG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,GAAG;IAClB,oCAAoC;IACpC,MAAM,EAAE,SAAS,CAAC;IAClB,0CAA0C;IAC1C,WAAW,EAAE,WAAW,CAAC;IACzB;;;OAGG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAAC;CAC/C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,UAAU,SAAS,QAAQ,EACnD,OAAO,EAAE,gBAAgB,CAAC,UAAU,CAAC,GACpC,GAAG,CAoCL"}
+{"version":3,"file":"create-app.d.ts","sourceRoot":"","sources":["../../src/client/create-app.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,KAAK,iBAAiB,EAEvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAMvD;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,UAAU,SAAS,QAAQ;IAC3D,uEAAuE;IACvE,SAAS,EAAE,UAAU,CAAC;IACtB;;OAEG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,GAAG,CAAC,OAAO;IAC1B,oFAAoF;IACpF,MAAM,EAAE,OAAO,CAAC;IAChB,0CAA0C;IAC1C,WAAW,EAAE,WAAW,CAAC;IACzB;;;OAGG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,UAAU,SAAS,QAAQ,EACnD,OAAO,EAAE,gBAAgB,CAAC,UAAU,CAAC;;;wBAgBV,MAAM,GAAG,WAAW,KAAG,IAAI;EAqBvD"}

package/esm/client/create-app.js

@@ -9,25 +9,32 @@ import { initTransport } from "./transport";
  * This function initializes the router and query client and returns
  * an app object that can be mounted into the DOM.
  *
- * @param options - Application configuration options.
- * @returns An initialized App instance.
+ * Register the router type globally for full IDE type-safety on
+ * `useParams`, `useSearch`, `Link`, etc:
  *
  * @example
  * ```tsx
  * const app = createApp({ routeTree });
+ *
+ * declare module "@tanstack/react-router" {
+ *   interface Register {
+ *     router: typeof app.router;
+ *   }
+ * }
+ *
  * app.render("#app");
  * ```
  */
 export function createApp(options) {
-    const { routeTree, routerOptions, queryClientConfig, endpoint } = options;
+    const { routeTree, queryClientConfig, endpoint } = options;
     if (endpoint) {
         initTransport({ endpoint: endpoint });
     }
     const queryClient = new QueryClient(queryClientConfig);
     const router = createRouter({
-        ...routerOptions,
         routeTree,
-        context: { queryClient, ...routerOptions?.context },
+        defaultPreload: "intent",
+        context: { queryClient },
     });
     function render(container) {
         const el = typeof container === "string"

package/esm/client/create-app.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-app.js","sourceRoot":"","sources":["../../src/client/create-app.tsx"],"names":[],"mappings":";AAAA,OAAO,EACL,WAAW,EAEX,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAyC5C;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,SAAS,CACvB,OAAqC;IAErC,MAAM,EAAE,SAAS,EAAE,aAAa,EAAE,iBAAiB,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;IAE1E,IAAI,QAAQ,EAAE,CAAC;QACb,aAAa,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,iBAAiB,CAAC,CAAC;IAEvD,MAAM,MAAM,GAAG,YAAY,CAAC;QAC1B,GAAG,aAAa;QAChB,SAAS;QACT,OAAO,EAAE,EAAE,WAAW,EAAE,GAAG,aAAa,EAAE,OAAO,EAAE;KACd,CAAC,CAAC;IAEzC,SAAS,MAAM,CAAC,SAA+B;QAC7C,MAAM,EAAE,GACN,OAAO,SAAS,KAAK,QAAQ;YAC3B,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAc,SAAS,CAAC;YAChD,CAAC,CAAC,SAAS,CAAC;QAEhB,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,MAAM,IAAI,KAAK,CACb,0CAA0C,MAAM,CAAC,SAAS,CAAC,EAAE,CAC9D,CAAC;QACJ,CAAC;QAED,MAAM,IAAI,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC;QAC5B,IAAI,CAAC,MAAM,CACT,KAAC,mBAAmB,IAAC,MAAM,EAAE,WAAW,YACtC,KAAC,cAAc,IAAC,MAAM,EAAE,MAAM,GAAI,GACd,CACvB,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC;AACzC,CAAC"}
+{"version":3,"file":"create-app.js","sourceRoot":"","sources":["../../src/client/create-app.tsx"],"names":[],"mappings":";AAAA,OAAO,EACL,WAAW,EAEX,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAiD5C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,SAAS,CACvB,OAAqC;IAErC,MAAM,EAAE,SAAS,EAAE,iBAAiB,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;IAE3D,IAAI,QAAQ,EAAE,CAAC;QACb,aAAa,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,iBAAiB,CAAC,CAAC;IAEvD,MAAM,MAAM,GAAG,YAAY,CAAC;QAC1B,SAAS;QACT,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,EAAE,WAAW,EAAqB;KAC5C,CAAC,CAAC;IAEH,SAAS,MAAM,CAAC,SAA+B;QAC7C,MAAM,EAAE,GACN,OAAO,SAAS,KAAK,QAAQ;YAC3B,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAc,SAAS,CAAC;YAChD,CAAC,CAAC,SAAS,CAAC;QAEhB,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,MAAM,IAAI,KAAK,CACb,0CAA0C,MAAM,CAAC,SAAS,CAAC,EAAE,CAC9D,CAAC;QACJ,CAAC;QAED,MAAM,IAAI,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC;QAC5B,IAAI,CAAC,MAAM,CACT,KAAC,mBAAmB,IAAC,MAAM,EAAE,WAAW,YACtC,KAAC,cAAc,IAAC,MAAM,EAAE,MAAM,GAAI,GACd,CACvB,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC;AACzC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evjs/runtime",
-  "version": "0.0.1-rc.6",
+  "version": "0.0.1-rc.7",
   "description": "",
   "dependencies": {
     "@hono/node-server": "^1.19.11",