@rangojs/router 0.0.0-experimental.8 → 0.0.0-experimental.81

package/skills/typesafety/SKILL.md

@@ -15,17 +15,49 @@ argument-hint: [setup]
 import { createRouter } from "@rangojs/router";
 import { urlpatterns } from "./urls";
 
-const router = createRouter<AppEnv>({
+const router = createRouter<AppBindings>({
   document: Document,
-  urls: urlpatterns,
-});
+}).routes(urlpatterns);
 
-// Server-side named-route href (type-safe via routeMap)
-export const href = router.href;
+// Server-side named-route reverse (type-safe via routeMap)
+export const reverse = router.reverse;
 
 export default router;
 ```
 
+### Which global type should I use?
+
+Use the generated route map by default. Manual `RegisteredRoutes` augmentation
+is only needed when you want the richer `typeof router.routeMap` shape
+available globally.
+
+- `GeneratedRouteMap` — auto-registered by `router.named-routes.gen.ts`
+  Use for `Handler<"name">`, `Prerender<"name">`, server `ctx.reverse()`,
+  and named-route param/search inference.
+- `typeof router.routeMap` — the real merged route map from your router
+  instance, including response-route metadata such as `{ path, response }`.
+- `RegisteredRoutes` — manual global hook for exposing `typeof router.routeMap`
+  to utilities like `href()`, `ValidPaths`, and `PathResponse`.
+
+Recommended setup:
+
+```typescript
+// router.tsx
+import { createRouter } from "@rangojs/router";
+import { urlpatterns } from "./urls";
+import type { AppBindings, AppVars } from "./env";
+
+export const router = createRouter<AppBindings>({}).routes(urlpatterns);
+
+declare global {
+  namespace RSCRouter {
+    interface Env extends AppBindings {}
+    interface Vars extends AppVars {}
+    interface RegisteredRoutes extends typeof router.routeMap {}
+  }
+}
+```
+
 ## Route Definition with Type-Safe Names
 
 ```typescript
@@ -45,22 +77,35 @@ export const urlpatterns = urls(({ path, layout }) => [
 
 ## Type-Safe href()
 
-### Server: ctx.href + scopedHref
+### Server: ctx.reverse with route names
 
-In route handlers, use `scopedHref()` for local route name autocomplete:
+In route handlers, `ctx.reverse()` uses two namespaces:
+
+- **`.name`** — local route, resolved within the current `include()` scope
+- **`name`** — global route, from the named-routes definition
 
 ```typescript
-import { scopedHref } from "@rangojs/router";
+import type { Handler } from "@rangojs/router";
 
-path("/product/:slug", (ctx) => {
-  const href = scopedHref<typeof shopPatterns>(ctx.href);
+export const ProductHandler: Handler<"shop.product"> = (ctx) => {
+  ctx.reverse(".cart"); // Local: /shop/cart
+  ctx.reverse(".product", { slug: "widget" }); // Local: /shop/product/widget
+  ctx.reverse("blog.post", { slug: "1" }); // Global: /blog/1
+};
+```
 
-  href("cart");                        // Type-safe local name
-  href("product", { slug: "widget" }); // Type-safe with params
-  href("blog.post");                   // Absolute names always allowed
+For type-safe local names, generate a route types file with `npx rango generate urls/shop.tsx`
+and pass it as the second generic to `Handler` or `Prerender`:
 
-  return <ProductPage slug={ctx.params.slug} />;
-}, { name: "product" })
+```typescript
+import type { Handler } from "@rangojs/router";
+import type { routes } from "./shop.gen.js";
+
+export const ProductHandler: Handler<"shop.product", routes> = (ctx) => {
+  ctx.reverse(".cart"); // Type-safe local name
+  ctx.reverse(".product", { slug: "widget" }); // Type-safe local with params
+  ctx.reverse("blog.post", { slug: "hi" }); // Type-safe global name
+};
 ```
 
 ### Client: href + useHref
@@ -82,6 +127,17 @@ function ShopNav() {
 }
 ```
 
+`href()` and path-based response utilities read from `RegisteredRoutes`, so if
+you want them typed globally you should augment:
+
+```typescript
+declare global {
+  namespace RSCRouter {
+    interface RegisteredRoutes extends typeof router.routeMap {}
+  }
+}
+```
+
 See `/links` for full URL generation guide.
 
 ## Environment Type Setup
@@ -90,50 +146,57 @@ Define your app's environment for type-safe bindings and variables:
 
 ```typescript
 // env.ts
-import type { RouterEnv } from "@rangojs/router";
 
-// Cloudflare bindings
-interface AppBindings {
+// Cloudflare bindings — passed as TEnv to createRouter<TEnv>()
+export interface AppBindings {
   DB: D1Database;
   KV: KVNamespace;
   CACHE: KVNamespace;
   AI: Ai;
 }
 
-// Variables set by middleware
-interface AppVariables {
+// Variables set by middleware — declared via module augmentation
+export interface AppVariables {
   user?: { id: string; email: string; role: string };
   requestId?: string;
   permissions?: string[];
 }
-
-// Combined environment type
-export type AppEnv = RouterEnv<AppBindings, AppVariables>;
 ```
 
 ### Using Environment Types
 
 ```typescript
 // router.tsx
-import type { AppEnv } from "./env";
+import type { AppBindings, AppVariables } from "./env";
 
-const router = createRouter<AppEnv>({
+const router = createRouter<AppBindings>({
   document: Document,
-  urls: urlpatterns,
-});
+}).routes(urlpatterns);
+
+// Register bindings and variables globally for implicit typing
+declare global {
+  namespace RSCRouter {
+    interface Env extends AppBindings {}
+    interface Vars extends AppVariables {}
+  }
+}
 
-// middleware - typed ctx.env.Variables
-import { createMiddleware } from "@rangojs/router";
+// middleware - typed via ctx.set / ctx.get
+import type { Middleware } from "@rangojs/router";
 
-export const authMiddleware = createMiddleware(async (ctx, next) => {
-  ctx.env.Variables.user = { id: "123", email: "user@example.com", role: "admin" };
+export const authMiddleware: Middleware = async (ctx, next) => {
+  ctx.set("user", {
+    id: "123",
+    email: "user@example.com",
+    role: "admin",
+  });
   await next();
-});
+};
 
 // loaders - typed context
-export const UserLoader = createLoader("user", async (ctx) => {
-  const db = ctx.env.Bindings.DB;  // D1Database
-  const userId = ctx.env.Variables.user?.id;
+export const UserLoader = createLoader(async (ctx) => {
+  const db = ctx.env.DB; // D1Database (plain bindings)
+  const userId = ctx.get("user")?.id; // from RSCRouter.Vars
   return db.prepare("SELECT * FROM users WHERE id = ?").bind(userId).first();
 });
 ```
@@ -146,7 +209,8 @@ Register environment types globally for implicit typing:
 // router.tsx
 declare global {
   namespace RSCRouter {
-    interface Env extends AppEnv {}
+    interface Env extends AppBindings {}
+    interface Vars extends AppVariables {}
   }
 }
 ```
@@ -155,21 +219,113 @@ Now handlers have typed context without explicit imports:
 
 ```typescript
 // In loaders
-export const DashboardLoader = createLoader("dashboard", async (ctx) => {
-  // ctx.env.Variables.user is typed from global Env
-  // ctx.params is typed from route pattern
-  const user = ctx.env.Variables.user;
+export const DashboardLoader = createLoader(async (ctx) => {
+  // ctx.env.DB is typed from global RSCRouter.Env
+  // ctx.get("user") is typed from global RSCRouter.Vars
+  const user = ctx.get("user");
   return { user };
 });
 ```
 
+## Typed Search Params
+
+Add a `search` schema to `path()` options for type-safe query parameters:
+
+```typescript
+// Route definition with search schema
+path("/search", SearchPage, {
+  name: "search",
+  search: { q: "string", page: "number?", sort: "string?" },
+});
+```
+
+### Handler with typed search params
+
+`Handler<"name">` automatically resolves route params and search params from the
+global `GeneratedRouteMap` (the gen file). No explicit route map import needed:
+
+```typescript
+// pages/search.tsx
+import type { Handler } from "@rangojs/router";
+
+export const SearchPage: Handler<"search"> = (ctx) => {
+  // ctx.search is typed: { q: string; page?: number; sort?: string }
+  const { q, page, sort } = ctx.search;
+  return <SearchResults q={q} page={page} sort={sort} />;
+};
+```
+
+This avoids circular references because `Handler` defaults to `GeneratedRouteMap`
+(from `router.named-routes.gen.ts`) instead of `RegisteredRoutes` (which depends on `router.tsx`).
+
+You can also pass an explicit route map for per-module isolation (opt-in,
+after running `npx rango generate`):
+
+```typescript
+import type { Handler } from "@rangojs/router";
+import type { routes } from "./urls.gen.js";
+
+export const SearchPage: Handler<"search", routes> = (ctx) => { ... };
+```
+
+Supported types: `"string"`, `"number"`, `"boolean"`, with `?` suffix for optional.
+Values are automatically coerced from query string (e.g., `"2"` becomes `2` for numbers).
+Routes without a `search` schema keep the standard `URLSearchParams` behavior.
+
+### RouteSearchParams and RouteParams utility types
+
+Extract typed params by route name for use in component props, return types, or anywhere:
+
+```typescript
+import type { RouteSearchParams, RouteParams } from "@rangojs/router";
+
+// RouteSearchParams<"name"> resolves the search schema to a typed object
+type SP = RouteSearchParams<"search">;
+// { q: string | undefined; page?: number; sort?: string }
+
+// RouteParams<"name"> resolves URL params from the route pattern
+type P = RouteParams<"blogPost">;
+// { slug: string }
+
+// Use in component props
+interface SearchResultsProps {
+  params: RouteSearchParams<"search">;
+}
+```
+
+Both default to the global route map (`RegisteredRoutes` or `GeneratedRouteMap`).
+Pass an explicit route map as the second type argument when needed:
+
+```typescript
+import type { routes } from "./urls.gen.js";
+
+type SP = RouteSearchParams<"search", routes>;
+type P = RouteParams<"blogPost", routes>;
+```
+
+### Generated route types
+
+In the generated `router.named-routes.gen.ts`, routes with search schemas
+use `{ path, search }` objects:
+
+```typescript
+// router.named-routes.gen.ts (auto-generated)
+export const NamedRoutes = {
+  "search.index": {
+    path: "/search",
+    search: { q: "string", page: "number?", sort: "string?" },
+  },
+  "home.index": "/", // No search schema -> plain string
+} as const;
+```
+
 ## Loader Type Safety
 
 Loaders have typed return values:
 
 ```typescript
 // loaders/product.ts
-export const ProductLoader = createLoader("product", async (ctx) => {
+export const ProductLoader = createLoader(async (ctx) => {
   return {
     id: ctx.params.slug,
     name: "Widget",
@@ -178,7 +334,7 @@ export const ProductLoader = createLoader("product", async (ctx) => {
 });
 
 // In server component - type is inferred
-import { useLoader } from "@rangojs/router";
+import { useLoader } from "@rangojs/router/client";
 
 async function ProductPage() {
   const product = await useLoader(ProductLoader);
@@ -188,39 +344,110 @@ async function ProductPage() {
 
 // In client component - same type
 "use client";
-import { useLoaderData } from "@rangojs/router/client";
+import { useLoader } from "@rangojs/router/client";
 
 function ProductPrice() {
-  const { product } = useLoaderData(ProductLoader);
-  // product: { id: string; name: string; price: number }
+  const { data } = useLoader(ProductLoader);
+  // data: { id: string; name: string; price: number }
+  const product = data;
   return <span>${product.price}</span>;
 }
 ```
 
-## Handle Type Safety
+## Typed Context Variables
 
-Handles have typed data:
+`createVar<T>()` creates a typed token for `ctx.set()`/`ctx.get()`, making
+handler-to-layout data contracts explicit and compile-time verified:
 
 ```typescript
-// handles/breadcrumbs.ts
-import { createHandle } from "@rangojs/router";
+import { createVar } from "@rangojs/router";
 
-export const Breadcrumbs = createHandle<{ label: string; href: string }>();
+// Define a typed token (shared between producer and consumer)
+interface PaginationData {
+  current: number;
+  total: number;
+  perPage: number;
+}
+export const Pagination = createVar<PaginationData>();
 
-// In route definition - use handle() DSL
-import { urls } from "@rangojs/router";
+// Non-cacheable var — reading inside cache() or "use cache" throws at runtime
+const Session = createVar<SessionData>({ cache: false });
+```
 
-export const urlpatterns = urls(({ path, handle }) => [
-  path("/shop/product/:slug", ProductPage, { name: "product" }, () => [
-    handle(Breadcrumbs, { label: "Products", href: "/shop/products" }),
-  ]),
-]);
+`createVar` accepts an optional options object. The `cache` option (default
+`true`) controls whether the var's values can be read inside cache scopes.
+Write-level escalation is also supported: `ctx.set(Var, value, { cache: false })`
+marks a specific write as non-cacheable even if the var itself is cacheable.
+"Least cacheable wins" — if either says `cache: false`, the value throws on
+read inside `cache()` or `"use cache"`.
+
+### Producer (handler or middleware)
+
+```typescript
+import { Pagination } from "../vars/pagination.js";
+
+const ArticleList: Handler<"articles.list"> = async (ctx) => {
+  ctx.set(Pagination, {       // type-checked
+    current: 1,
+    total: 10,
+    perPage: 5,
+  });
+  return <Articles />;
+};
+```
+
+### Consumer (layout, parallel, or any context with get)
+
+```typescript
+import { Pagination } from "../vars/pagination.js";
+
+export function PaginationLayout(ctx: any) {
+  const pagination = ctx.get(Pagination);  // typed as PaginationData | undefined
+  if (!pagination) return <Outlet />;
+  return <nav>Page {pagination.current} of {pagination.total}</nav>;
+}
+```
+
+### Why not just use RSCRouter.Vars?
+
+`RSCRouter.Vars` (via module augmentation) provides app-global typing for
+`ctx.get("key")` / `ctx.set("key", value)`. It works for middleware state
+shared app-wide. `createVar<T>()` is for route-local or feature-scoped
+context -- the producer and consumer import the same token, creating a
+scoped contract without polluting global types.
+
+Both approaches coexist: `ctx.get("user")` (global via Vars) and
+`ctx.get(Pagination)` (scoped via createVar) work side by side.
+
+## Handle Type Safety
+
+Handles have typed data:
 
-// In client - typed array
+```typescript
+// Built-in Breadcrumbs handle — import from "@rangojs/router"
+import { Breadcrumbs } from "@rangojs/router";
+// Type: Handle<BreadcrumbItem, BreadcrumbItem[]>
+// BreadcrumbItem: { label: string; href: string; content?: ReactNode | Promise<ReactNode> }
+
+// In route handler — push is fully typed
+path("/shop/product/:slug", (ctx) => {
+  const breadcrumb = ctx.use(Breadcrumbs);
+  breadcrumb({ label: "Products", href: "/shop/products" });
+  return <ProductPage />;
+}, { name: "product" });
+
+// In client — typed array
+import { useHandle, Breadcrumbs } from "@rangojs/router/client";
 function BreadcrumbNav() {
   const crumbs = useHandle(Breadcrumbs);
-  // crumbs: Array<{ label: string; href: string }>
+  // crumbs: BreadcrumbItem[]
 }
+
+// Custom handles also work the same way
+import { createHandle } from "@rangojs/router";
+export const PageTitle = createHandle<string, string>(
+  (segments) => segments.flat().at(-1) ?? "Default Title"
+);
 ```
 
 ## Ref Prop Type Safety (Loaders & Handles)
@@ -234,24 +461,22 @@ export const ProductLoader = createLoader(async (ctx) => {
   return { product: await fetchProduct(ctx.params.slug) };
 });
 
-// handles.ts
-export const Breadcrumbs = createHandle<{ label: string; href: string }>();
+// Built-in Breadcrumbs — or any custom handle created with createHandle()
 
 // Client component — typeof infers all generics
-"use client";
-import { useLoader, useHandle } from "@rangojs/router/client";
+("use client");
+import { useLoader, useHandle, type Breadcrumbs } from "@rangojs/router/client";
 import type { ProductLoader } from "../loaders";
-import type { Breadcrumbs } from "../handles";
 
 function MyComponent({
   loader,
   handle,
 }: {
-  loader: typeof ProductLoader;   // LoaderDefinition<{ product: Product }>
-  handle: typeof Breadcrumbs;     // Handle<{ label: string; href: string }>
+  loader: typeof ProductLoader; // LoaderDefinition<{ product: Product }>
+  handle: typeof Breadcrumbs; // Handle<{ label: string; href: string }>
 }) {
-  const { data } = useLoader(loader);   // data is typed
-  const crumbs = useHandle(handle);     // crumbs is typed array
+  const { data } = useLoader(loader); // data is typed
+  const crumbs = useHandle(handle); // crumbs is typed array
   // ...
 }
 ```
@@ -266,6 +491,7 @@ full functionality from module-level registries.
 // location-states.ts
 import { createLocationState } from "@rangojs/router";
 
+// All export patterns work: export const, const + export { X }, export { X as Y }
 export const ProductPreview = createLocationState<{
   name: string;
   price: number;
@@ -312,8 +538,8 @@ global type declarations (like `RSCRouter.Env`).
     "skipLibCheck": true,
     "isolatedModules": true,
     "esModuleInterop": true,
-    "resolveJsonModule": true
-  }
+    "resolveJsonModule": true,
+  },
 }
 ```
 
@@ -322,7 +548,7 @@ global type declarations (like `RSCRouter.Env`).
 {
   "extends": "../../tsconfig.base.json",
   "include": ["src"],
-  "files": ["src/router.tsx"]
+  "files": ["src/router.tsx"],
 }
 ```
 
@@ -331,19 +557,27 @@ global type declarations (like `RSCRouter.Env`).
 {
   "extends": "../../tsconfig.base.json",
   "include": ["src"],
-  "files": ["src/router.tsx"]
+  "files": ["src/router.tsx"],
 }
 ```
 
-The `files` array ensures `router.tsx` (which contains `declare global { namespace RSCRouter { ... } }`)
-is always included in the compilation even if nothing directly imports it. Each app gets its own
-typed environment without interfering with other apps.
+The `files` array ensures `router.tsx` (which contains `declare global { namespace RSCRouter { interface Env; interface Vars } }`)
+is always included in the compilation even if nothing directly imports it. Route types come from the
+auto-generated `*.named-routes.gen.ts` file (via `rango generate`), not from manual declaration.
+Each app gets its own typed environment without interfering with other apps.
 
 ## Complete Type-Safe Setup
 
 ```typescript
 // 1. env.ts - Environment types
-export type AppEnv = RouterEnv<AppBindings, AppVariables>;
+export interface AppBindings {
+  DB: D1Database;
+  KV: KVNamespace;
+}
+
+export interface AppVariables {
+  user?: { id: string; email: string; role: string };
+}
 
 // 2. urls.tsx - Route definitions with names
 import { urls } from "@rangojs/router";
@@ -359,35 +593,40 @@ export const urlpatterns = urls(({ path, layout, loader }) => [
   ]),
 ]);
 
-// 3. router.tsx - Registration
-const router = createRouter<AppEnv>({
+// 3. router.tsx - Create router and export reverse
+const router = createRouter<AppBindings>({
   document: Document,
-  urls: urlpatterns,
-});
+}).routes(urlpatterns);
 
+// Register bindings and variables globally for implicit typing
 declare global {
   namespace RSCRouter {
-    interface Env extends AppEnv {}
+    interface Env extends AppBindings {}
+    interface Vars extends AppVariables {}
   }
 }
 
+export const reverse = router.reverse;
 export default router;
 
-// 4. loaders/*.ts - Type-safe loaders
-export const ProductLoader = createLoader("product", async (ctx) => {
+// 4. Run `npx rango generate src/router.tsx` to generate
+//    router.named-routes.gen.ts (auto-registers GeneratedRouteMap globally).
+//    No manual RegisteredRoutes declaration needed.
+
+// 5. loaders/*.ts - Type-safe loaders
+export const ProductLoader = createLoader(async (ctx) => {
   // ctx.params: { slug: string }
-  // ctx.env.Variables.user: User | undefined
-  // ctx.env.Bindings.DB: D1Database
+  // ctx.get("user"): User | undefined  (from RSCRouter.Vars)
+  // ctx.env.DB: D1Database  (plain bindings from RSCRouter.Env)
   return { product: await fetchProduct(ctx.params.slug) };
 });
 
-// 5. Server: ctx.href for named routes
+// 6. Server: ctx.reverse for named routes
 path("/product/:slug", (ctx) => {
-  const href = scopedHref<typeof urlpatterns>(ctx.href);
-  return <Link to={href("shop")}>Back to Shop</Link>;
+  return <Link to={ctx.reverse("shop")}>Back to Shop</Link>;
 }, { name: "product" })
 
-// 6. Client: useHref for mounted paths, href for absolute
+// 7. Client: useHref for mounted paths, href for absolute
 "use client";
 import { useHref, href, Link } from "@rangojs/router/client";
 <Link to={href("/shop/product/widget")}>Widget</Link>