@rangojs/router 0.0.0-experimental.10 → 0.0.0-experimental.100

package/src/index.rsc.ts

@@ -1,9 +1,9 @@
 /**
- * rsc-router (react-server environment)
+ * @rangojs/router (react-server environment)
  *
- * This file is used when importing "rsc-router" from RSC (server components).
+ * This file is used when importing "@rangojs/router" from RSC (server components).
  * It re-exports everything from the universal index.ts plus adds server-side
- * createLoader that includes the actual loader function.
+ * implementations that replace the client-side error stubs.
  *
  * The bundler uses the "react-server" export condition to select this file
  * in RSC context, while the regular index.ts is used in client components.
@@ -11,8 +11,6 @@
 
 // Re-export all universal exports from index.ts
 export {
-  // Universal rendering utilities
-  renderSegments,
   // Error classes
   RouteNotFoundError,
   DataNotFoundError,
@@ -21,22 +19,22 @@ export {
   HandlerError,
   BuildError,
   InvalidHandlerError,
-  NetworkError,
-  isNetworkError,
-  sanitizeError,
   RouterError,
+  Skip,
+  isSkip,
 } from "./index.js";
 
 // Re-export all types from types.ts (user-facing types only)
 export type {
   // Configuration types
   DocumentProps,
-  RouterEnv,
   DefaultEnv,
   RouteDefinition,
+  RouteConfig,
+  RouteDefinitionOptions,
+  TrailingSlashMode,
   // Handler types
   Handler,
-  ScopedRouteMap,
   HandlerContext,
   ExtractParams,
   GenericParams,
@@ -52,9 +50,6 @@ export type {
   LoaderContext,
   FetchableLoaderOptions,
   LoadOptions,
-  LoaderActionContext,
-  LoaderAction,
-  LoaderMiddlewareFn,
   // Error boundary types
   ErrorInfo,
   ErrorBoundaryFallbackProps,
@@ -64,26 +59,74 @@ export type {
   NotFoundInfo,
   NotFoundBoundaryFallbackProps,
   NotFoundBoundaryHandler,
+  // Error handling callback types
+  ErrorPhase,
+  OnErrorContext,
+  OnErrorCallback,
 } from "./types.js";
 
 // Router options type (server-only, so import directly)
-export type { RSCRouterOptions } from "./router.js";
+export type {
+  RSCRouterOptions,
+  SSRStreamMode,
+  SSROptions,
+  ResolveStreamingContext,
+} from "./router.js";
 
 // Server-side createLoader and redirect
-export { createLoader, redirect } from "./route-definition.js";
+export {
+  createLoader,
+  redirect,
+  type RouteHelpers,
+  type RouteHandlers,
+  // Globally importable route helpers for composition
+  layout,
+  cache,
+  middleware,
+  revalidate,
+  loader,
+  loading,
+  parallel,
+  intercept,
+  when,
+  errorBoundary,
+  notFoundBoundary,
+  transition,
+} from "./route-definition.js";
+
+// Composition types for reusable callback factories
+export type {
+  RouteUseItem,
+  LayoutUseItem,
+  AllUseItems,
+  UseItems,
+  HandlerUseItem,
+} from "./route-types.js";
 
 // Handle API
 export { createHandle, isHandle, type Handle } from "./handle.js";
 
+// Context variable API (typed ctx.set/ctx.get tokens)
+export { createVar, type ContextVar } from "./context-var.js";
+
+// CSP nonce token (use with ctx.get(nonce) in middleware/handlers)
+export { nonce } from "./rsc/nonce.js";
+
 // Pre-render handler API
 export {
-  createPrerenderHandler,
-  isPrerenderHandler,
+  Prerender,
+  Passthrough,
   type PrerenderHandlerDefinition,
+  type PassthroughHandlerDefinition,
   type PrerenderOptions,
   type BuildContext,
+  type StaticBuildContext,
+  type GetParamsContext,
 } from "./prerender.js";
 
+// Static handler API
+export { Static, type StaticHandlerDefinition } from "./static-handler.js";
+
 // Django-style URL patterns (RSC/server context)
 export {
   urls,
@@ -95,6 +138,14 @@ export {
   type RouteResponse,
   type ResponseError,
   type ResponseEnvelope,
+  type ResponseHandler,
+  type ResponseHandlerContext,
+  type JsonResponseHandler,
+  type TextResponseHandler,
+  type JsonValue,
+  type ResponsePathFn,
+  type JsonResponsePathFn,
+  type TextResponsePathFn,
 } from "./urls.js";
 
 // Core router (server-side)
@@ -102,6 +153,7 @@ export {
   createRouter,
   type RSCRouter,
   type RootLayoutProps,
+  type RouterRequestInput,
 } from "./router.js";
 
 // RSC handler types (server-side)
@@ -109,13 +161,78 @@ export type { HandlerCacheConfig } from "./rsc/types.js";
 
 // Built-in handles (server-side)
 export { Meta } from "./handles/meta.js";
+export { Breadcrumbs, type BreadcrumbItem } from "./handles/breadcrumbs.js";
+
+// Request context (for accessing request data in server actions/components).
+// Re-exported with a narrowed return type so that public consumers only see
+// public members. Internal code imports from "./server/request-context.js"
+// directly and gets the full type.
+import { getRequestContext as _getRequestContextInternal } from "./server/request-context.js";
+export type { PublicRequestContext as RequestContext } from "./server/request-context.js";
+import type { PublicRequestContext } from "./server/request-context.js";
+import type { DefaultEnv } from "./types/global-namespace.js";
+
+// Shared base for every user-facing request context (mirrors index.ts).
+export type { RequestScope, ExecutionContext } from "./types/request-scope.js";
+
+export const getRequestContext: <
+  TEnv = DefaultEnv,
+>() => PublicRequestContext<TEnv> = _getRequestContextInternal;
 
-// Request context (for accessing request data in server actions/components)
-export { getRequestContext, type RequestContext } from "./server/request-context.js";
+// Request-scoped shorthands
+export {
+  cookies,
+  headers,
+  type CookieStore,
+  type Cookie,
+  type ReadonlyHeaders,
+} from "./server/cookie-store.js";
 
 // Meta types
 export type { MetaDescriptor, MetaDescriptorBase } from "./router/types.js";
 
+// Middleware context types
+export type { MiddlewareContext, CookieOptions } from "./router/middleware.js";
+
 // Reverse type utilities for type-safe URL generation (Django-style URL reversal)
-export type { ScopedReverseFunction, ReverseFunction, ExtractLocalRoutes } from "./reverse.js";
-export { scopedReverse } from "./reverse.js";
+export type {
+  ScopedReverseFunction,
+  ReverseFunction,
+  ExtractLocalRoutes,
+  ParamsFor,
+} from "./reverse.js";
+export { scopedReverse, createReverse } from "./reverse.js";
+
+// Search params schema types
+export type {
+  SearchSchema,
+  SearchSchemaValue,
+  ResolveSearchSchema,
+  RouteSearchParams,
+  RouteParams,
+} from "./search-params.js";
+
+// Location state (universal)
+export {
+  createLocationState,
+  type LocationStateDefinition,
+  type LocationStateEntry,
+  type LocationStateOptions,
+} from "./browser/react/location-state-shared.js";
+
+// Path-based response type lookup from RegisteredRoutes
+export type { PathResponse } from "./href-client.js";
+
+// Telemetry sink
+export { createConsoleSink } from "./router/telemetry.js";
+export { createOTelSink } from "./router/telemetry-otel.js";
+export type { OTelTracer, OTelSpan } from "./router/telemetry-otel.js";
+export type { TelemetrySink, TelemetryEvent } from "./router/telemetry.js";
+
+// Timeout types and error class
+export { RouterTimeoutError } from "./router/timeout.js";
+export type {
+  RouterTimeouts,
+  TimeoutPhase,
+  TimeoutContext,
+} from "./router/timeout.js";

package/src/index.ts

@@ -1,18 +1,15 @@
 /**
- * rsc-router
+ * @rangojs/router
  *
- * Universal exports - types and utilities safe for both server and client
+ * Single user-facing entrypoint for all router APIs.
  *
- * For server-only exports (urls, createRouter, createLoader, etc.):
- *   import from "rsc-router/server"
+ * The "react-server" export condition selects index.rsc.ts (real implementations)
+ * vs this file (client stubs for server-only functions).
  *
- * For client-only exports (Outlet, useOutlet, etc.):
- *   import from "rsc-router/client"
+ * For client-only exports (Outlet, useOutlet, hooks, components):
+ *   import from "@rangojs/router/client"
  */
 
-// Universal rendering utilities (work on both server and client)
-export { renderSegments } from "./segment-system.js";
-
 // Error classes (can be used on both server and client)
 export {
   RouteNotFoundError,
@@ -22,22 +19,22 @@ export {
   HandlerError,
   BuildError,
   InvalidHandlerError,
-  NetworkError,
-  isNetworkError,
-  sanitizeError,
   RouterError,
+  Skip,
+  isSkip,
 } from "./errors.js";
 
 // Types (safe to import anywhere - no runtime code)
 export type {
   // Configuration types
   DocumentProps,
-  RouterEnv,
   DefaultEnv,
   RouteDefinition,
+  RouteConfig,
+  RouteDefinitionOptions,
+  TrailingSlashMode,
   // Handler types
-  Handler,            // Supports params object, path pattern, or route name
-  ScopedRouteMap,     // Scoped view of GeneratedRouteMap for Handler<"localName", ScopedRouteMap<"prefix">>
+  Handler, // Supports params object, path pattern, or route name
   HandlerContext,
   ExtractParams,
   GenericParams,
@@ -53,9 +50,6 @@ export type {
   LoaderContext,
   FetchableLoaderOptions,
   LoadOptions,
-  LoaderActionContext,
-  LoaderAction,
-  LoaderMiddlewareFn,
   // Error boundary types
   ErrorInfo,
   ErrorBoundaryFallbackProps,
@@ -65,12 +59,38 @@ export type {
   NotFoundInfo,
   NotFoundBoundaryFallbackProps,
   NotFoundBoundaryHandler,
+  // Error handling callback types
+  ErrorPhase,
+  OnErrorContext,
+  OnErrorCallback,
 } from "./types.js";
 
+// Search params schema types
+export type {
+  SearchSchema,
+  SearchSchemaValue,
+  ResolveSearchSchema,
+  RouteSearchParams,
+  RouteParams,
+} from "./search-params.js";
+
 // Client-safe createLoader - only stores the $$id, function is not included
 // Use this when defining loaders that will be imported by client components
 export { createLoader } from "./loader.js";
 
+// Route definition types (safe to import anywhere)
+export type { RouteHelpers, RouteHandlers } from "./route-definition.js";
+export type { TransitionConfig, ViewTransitionClass } from "./types.js";
+
+// Composition types for reusable callback factories
+export type {
+  RouteUseItem,
+  LayoutUseItem,
+  AllUseItems,
+  UseItems,
+  HandlerUseItem,
+} from "./route-types.js";
+
 // Response route types (usable in both server and client contexts)
 export type {
   ResponseHandler,
@@ -86,80 +106,215 @@ export type {
   ResponseEnvelope,
 } from "./urls.js";
 
+// Middleware context types
+export type { MiddlewareContext, CookieOptions } from "./router/middleware.js";
+
+function serverOnlyStubError(name: string): Error {
+  return new Error(
+    `${name}() is only available from "@rangojs/router" in a react-server/RSC environment. ` +
+      `For client hooks and components, import from "@rangojs/router/client".`,
+  );
+}
+
 /**
  * Error-throwing stub for server-only `urls` function.
- * Import from "@rangojs/router/server" or use within RSC context instead.
  */
 export function urls(): never {
-  throw new Error(
-    'urls() is server-only. Import from "@rangojs/router/server" instead, or ensure you\'re using it in a server component.'
-  );
+  throw serverOnlyStubError("urls");
 }
 
 /**
  * Error-throwing stub for server-only `createRouter` function.
- * Import from "@rangojs/router/server" instead.
  */
 export function createRouter(): never {
-  throw new Error(
-    'createRouter() is server-only. Import from "@rangojs/router/server" instead.'
-  );
+  throw serverOnlyStubError("createRouter");
 }
 
 /**
  * Error-throwing stub for server-only `redirect` function.
- * Import from "@rangojs/router/server" or use within RSC context instead.
  */
 export function redirect(): never {
-  throw new Error(
-    'redirect() is server-only. Import from "@rangojs/router/server" instead.'
-  );
+  throw serverOnlyStubError("redirect");
 }
 
+// Handle API (universal - works on both server and client)
+export { createHandle, isHandle, type Handle } from "./handle.js";
+
+// Context variable API (typed ctx.set/ctx.get tokens)
+export { createVar, type ContextVar } from "./context-var.js";
+
+// CSP nonce token (use with ctx.get(nonce) in middleware/handlers)
+export { nonce } from "./rsc/nonce.js";
+
 /**
- * Error-throwing stub for server-only `createHandle` function.
- * Import from "@rangojs/router/server" or use within RSC context instead.
+ * SSR/client stub for server-only `Prerender` function.
+ *
+ * Returns a lightweight stub object instead of throwing so that the
+ * production SSR build can safely bundle the RSC entry chunk — the SSR
+ * bundler resolves `@rangojs/router` to this (SSR) entry, so Prerender
+ * calls in RSC code must not crash at module-evaluation time.
  */
-export function createHandle(): never {
-  throw new Error(
-    'createHandle() is server-only. Import from "@rangojs/router/server" instead.'
-  );
+export function Prerender(
+  _handler?: any,
+  _optionsOrId?: any,
+  __injectedId?: string,
+): any {
+  const id =
+    typeof _optionsOrId === "string" ? _optionsOrId : __injectedId || "";
+  return { __brand: "prerenderHandler" as const, $$id: id };
 }
 
 /**
- * Error-throwing stub for server-only `createPrerenderHandler` function.
- * Import from "@rangojs/router/server" or use within RSC context instead.
+ * SSR/client stub for server-only `Passthrough` function.
  */
-export function createPrerenderHandler(): never {
-  throw new Error(
-    'createPrerenderHandler() is server-only. Import from "@rangojs/router/server" instead.'
-  );
+export function Passthrough(
+  _handler?: any,
+  _optionsOrId?: any,
+  __injectedId?: string,
+): any {
+  const id =
+    typeof _optionsOrId === "string" ? _optionsOrId : __injectedId || "";
+  return { __brand: "passthroughHandler" as const, $$id: id };
 }
 
-// Handle API (type-only exports safe for client)
-export { isHandle, type Handle } from "./handle.js";
+/**
+ * SSR/client stub for server-only `Static` function.
+ *
+ * Returns a lightweight stub object instead of throwing so that the
+ * production SSR build can safely bundle the RSC entry chunk — the SSR
+ * bundler resolves `@rangojs/router` to this (SSR) entry, so Static
+ * calls in RSC code must not crash at module-evaluation time.
+ */
+export function Static(
+  _handler?: any,
+  _optionsOrId?: any,
+  __injectedId?: string,
+): any {
+  const id =
+    typeof _optionsOrId === "string" ? _optionsOrId : __injectedId || "";
+  return { __brand: "staticHandler" as const, $$id: id };
+}
 
 /**
  * Error-throwing stub for server-only `getRequestContext` function.
- * Import from "@rangojs/router/server" or use within RSC context instead.
  */
 export function getRequestContext(): never {
-  throw new Error(
-    'getRequestContext() is server-only. Import from "@rangojs/router/server" instead.'
-  );
+  throw serverOnlyStubError("getRequestContext");
+}
+
+/**
+ * Error-throwing stub for server-only `cookies` function.
+ */
+export function cookies(): never {
+  throw serverOnlyStubError("cookies");
+}
+
+/**
+ * Error-throwing stub for server-only `headers` function.
+ */
+export function headers(): never {
+  throw serverOnlyStubError("headers");
+}
+
+/**
+ * Error-throwing stub for server-only `createReverse` function.
+ */
+export function createReverse(): never {
+  throw serverOnlyStubError("createReverse");
+}
+
+// Error-throwing stubs for server-only route helpers
+export function layout(): never {
+  throw serverOnlyStubError("layout");
+}
+export function cache(): never {
+  throw serverOnlyStubError("cache");
+}
+export function middleware(): never {
+  throw serverOnlyStubError("middleware");
+}
+export function revalidate(): never {
+  throw serverOnlyStubError("revalidate");
+}
+export function loader(): never {
+  throw serverOnlyStubError("loader");
+}
+export function loading(): never {
+  throw serverOnlyStubError("loading");
+}
+export function parallel(): never {
+  throw serverOnlyStubError("parallel");
+}
+export function intercept(): never {
+  throw serverOnlyStubError("intercept");
+}
+export function when(): never {
+  throw serverOnlyStubError("when");
+}
+export function errorBoundary(): never {
+  throw serverOnlyStubError("errorBoundary");
+}
+export function notFoundBoundary(): never {
+  throw serverOnlyStubError("notFoundBoundary");
+}
+export function transition(): never {
+  throw serverOnlyStubError("transition");
 }
 
 // Request context type (safe for client)
-export type { RequestContext } from "./server/request-context.js";
+export type { PublicRequestContext as RequestContext } from "./server/request-context.js";
+
+// Shared base for every user-facing request context.
+export type { RequestScope, ExecutionContext } from "./types/request-scope.js";
+
+// Cookie store types (safe for client)
+export type {
+  CookieStore,
+  Cookie,
+  ReadonlyHeaders,
+} from "./server/cookie-store.js";
+
+// Built-in handles (universal — work on both server and client)
+export { Meta } from "./handles/meta.js";
+export { Breadcrumbs } from "./handles/breadcrumbs.js";
 
 // Meta types
 export type { MetaDescriptor, MetaDescriptorBase } from "./router/types.js";
 
+// Breadcrumb types
+export type { BreadcrumbItem } from "./handles/breadcrumbs.js";
+
 // Reverse type utilities for type-safe URL generation (Django-style URL reversal)
-// ScopedReverseFunction is used with scopedReverse<typeof patterns>() for composable modules
-export type { ScopedReverseFunction, ReverseFunction, ExtractLocalRoutes } from "./reverse.js";
+export type {
+  ScopedReverseFunction,
+  ReverseFunction,
+  ExtractLocalRoutes,
+  ParamsFor,
+} from "./reverse.js";
 // scopedReverse() helper for handlers to get locally-typed reverse
 export { scopedReverse } from "./reverse.js";
 
+// Location state (universal - works on both server and client)
+export {
+  createLocationState,
+  type LocationStateDefinition,
+  type LocationStateEntry,
+  type LocationStateOptions,
+} from "./browser/react/location-state-shared.js";
+
 // Path-based response type lookup from RegisteredRoutes
 export type { PathResponse } from "./href-client.js";
+
+// Telemetry sink
+export { createConsoleSink } from "./router/telemetry.js";
+export { createOTelSink } from "./router/telemetry-otel.js";
+export type { OTelTracer, OTelSpan } from "./router/telemetry-otel.js";
+export type { TelemetrySink, TelemetryEvent } from "./router/telemetry.js";
+
+// Timeout types and error class
+export { RouterTimeoutError } from "./router/timeout.js";
+export type {
+  RouterTimeouts,
+  TimeoutPhase,
+  TimeoutContext,
+} from "./router/timeout.js";

package/src/internal-debug.ts

@@ -0,0 +1,11 @@
+// Internal debug gate. Enable with INTERNAL_RANGO_DEBUG=1 in the environment.
+// Uses a Vite define (__RANGO_DEBUG__) for compile-time injection so it works
+// in all runtimes including Cloudflare Workers where process.env is unavailable.
+// Falls back to process.env for non-Vite contexts (tests, direct Node usage).
+export const INTERNAL_RANGO_DEBUG: boolean =
+  typeof __RANGO_DEBUG__ !== "undefined"
+    ? __RANGO_DEBUG__
+    : typeof process !== "undefined" &&
+      Boolean((process as any).env?.INTERNAL_RANGO_DEBUG);
+
+declare const __RANGO_DEBUG__: boolean;