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

package/src/server/context.ts

@@ -1,7 +1,17 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { ReactNode } from "react";
-import type { PartialCacheOptions, ErrorBoundaryHandler, Handler, LoaderDefinition, MiddlewareFn, NotFoundBoundaryHandler, ShouldRevalidateFn } from "../types";
+import type {
+  PartialCacheOptions,
+  ErrorBoundaryHandler,
+  Handler,
+  LoaderDefinition,
+  MiddlewareFn,
+  NotFoundBoundaryHandler,
+  ShouldRevalidateFn,
+  TransitionConfig,
+} from "../types";
 import { invariant } from "../errors";
+import type { DefaultRouteName } from "../types/global-namespace.js";
 
 // ============================================================================
 //  Performance Metrics Types
@@ -13,9 +23,10 @@ import { invariant } from "../errors";
  * @internal This type is an implementation detail and may change without notice.
  */
 export interface PerformanceMetric {
-  label: string;      // e.g., "route-matching", "loader:UserLoader"
-  duration: number;   // milliseconds
-  startTime: number;  // relative to request start
+  label: string; // e.g., "route-matching", "loader:UserLoader"
+  duration: number; // milliseconds
+  startTime: number; // relative to request start
+  depth?: number; // nesting level for hierarchical display (0 = top-level)
 }
 
 /**
@@ -105,12 +116,14 @@ export type InterceptSegmentsState = {
  * @internal This type is an implementation detail and may change without notice.
  */
 export type InterceptSelectorContext<TEnv = any> = {
-  from: URL;                              // Source URL (where user is coming from)
-  to: URL;                                // Destination URL (where user is navigating to)
-  params: Record<string, string>;         // Matched route params
-  request: Request;                       // The HTTP request object
-  env: TEnv;                              // Platform bindings (Cloudflare env, etc.)
-  segments: InterceptSegmentsState;       // Client's current segments (where navigating FROM)
+  from: URL; // Source URL (where user is coming from)
+  to: URL; // Destination URL (where user is navigating to)
+  params: Record<string, string>; // Matched route params
+  request: Request; // The HTTP request object
+  env: TEnv; // Platform bindings (Cloudflare env, etc.)
+  segments: InterceptSegmentsState; // Client's current segments (where navigating FROM)
+  fromRouteName?: DefaultRouteName; // Named route being navigated away from (undefined for unnamed routes)
+  toRouteName?: DefaultRouteName; // Named route being navigated to (undefined for unnamed routes)
 };
 
 /**
@@ -119,7 +132,9 @@ export type InterceptSelectorContext<TEnv = any> = {
  *
  * @internal This type is an implementation detail and may change without notice.
  */
-export type InterceptWhenFn<TEnv = any> = (ctx: InterceptSelectorContext<TEnv>) => boolean;
+export type InterceptWhenFn<TEnv = any> = (
+  ctx: InterceptSelectorContext<TEnv>,
+) => boolean;
 
 /**
  * Intercept entry stored in EntryData
@@ -128,17 +143,18 @@ export type InterceptWhenFn<TEnv = any> = (ctx: InterceptSelectorContext<TEnv>)
  * @internal This type is an implementation detail and may change without notice.
  */
 export type InterceptEntry = {
-  slotName: `@${string}`;  // e.g., "@modal"
-  routeName: string;        // e.g., "card"
-  handler: ReactNode | Handler<any, any>;
+  slotName: `@${string}`; // e.g., "@modal"
+  routeName: string; // e.g., "card"
+  handler: ReactNode | Handler<any, any, any>;
   middleware: MiddlewareFn<any, any>[];
   revalidate: ShouldRevalidateFn<any, any>[];
   errorBoundary: (ReactNode | ErrorBoundaryHandler)[];
   notFoundBoundary: (ReactNode | NotFoundBoundaryHandler)[];
   loader: LoaderEntry[];
   loading?: ReactNode | false;
-  layout?: ReactNode | Handler<any, any>;  // Wrapper layout with <Outlet /> for content
-  when: InterceptWhenFn[];  // Selector conditions - all must return true to intercept
+  transition?: TransitionConfig;
+  layout?: ReactNode | Handler<any, any, any>; // Wrapper layout with <Outlet /> for content
+  when: InterceptWhenFn[]; // Selector conditions - all must return true to intercept
 };
 
 export type EntryPropSegments = {
@@ -151,32 +167,57 @@ export type EntryPropSegments = {
 export type EntryData =
   | ({
       type: "route";
-      handler: Handler<any, any>;
+      handler: Handler<any, any, any>;
       loading?: ReactNode | false;
+      transition?: TransitionConfig;
       /** URL pattern for this route (used by path() in urls()) */
       pattern?: string;
+      /** Set when handler is a Prerender definition */
+      isPrerender?: true;
+      /** Original PrerenderHandlerDefinition (for build-time getParams access) */
+      prerenderDef?: {
+        getParams?: (ctx: any) => Promise<any[]> | any[];
+        options?: { passthrough?: boolean };
+      };
+      /** Set when handler is a Static definition (build-time only) */
+      isStaticPrerender?: true;
+      /** Static handler $$id for build-time store lookup */
+      staticHandlerId?: string;
+      /** Response type for non-RSC routes (json, text, image, any) */
+      responseType?: string;
     } & EntryPropCommon &
       EntryPropDatas &
       EntryPropSegments)
   | ({
       type: "layout";
-      handler: ReactNode | Handler<any, any>;
+      handler: ReactNode | Handler<any, any, any>;
       loading?: ReactNode | false;
+      transition?: TransitionConfig;
+      /** Set when handler is a Static definition (build-time only) */
+      isStaticPrerender?: true;
+      /** Static handler $$id for build-time store lookup */
+      staticHandlerId?: string;
     } & EntryPropCommon &
       EntryPropDatas &
       EntryPropSegments)
   | ({
       type: "parallel";
-      handler: Record<`@${string}`, Handler<any, any> | ReactNode>;
+      handler: Record<`@${string}`, Handler<any, any, any> | ReactNode>;
       loading?: ReactNode | false;
+      transition?: TransitionConfig;
+      /** Set when any parallel slot is a Static definition */
+      isStaticPrerender?: true;
+      /** Per-slot static handler $$ids for build-time store lookup */
+      staticHandlerIds?: Record<string, string>;
     } & EntryPropCommon &
       EntryPropDatas &
       EntryPropSegments)
   | ({
       type: "cache";
       /** Cache entries create cache boundaries and render like layouts (with Outlet) */
-      handler: ReactNode | Handler<any, any>;
+      handler: ReactNode | Handler<any, any, any>;
       loading?: ReactNode | false;
+      transition?: TransitionConfig;
     } & EntryPropCommon &
       EntryPropDatas &
       EntryPropSegments);
@@ -211,17 +252,34 @@ interface HelperContext {
   patternsByPrefix?: Map<string, Map<string, string>>;
   /** Trailing slash config per route name */
   trailingSlash?: Map<string, "never" | "always" | "ignore">;
+  /** Search param schemas per route name */
+  searchSchemas?: Map<string, Record<string, string>>;
   /** URL prefix from include() - applied to all path() patterns */
   urlPrefix?: string;
   /** Name prefix from include() - applied to all named routes */
   namePrefix?: string;
+  /** True when this scope is at root level (no named include boundary above).
+   *  Routes at root scope allow dot-local reverse to fall back to bare names. */
+  rootScoped?: boolean;
   /** Run helper for cleaner middleware code */
   run?: <T>(fn: () => T | Promise<T>) => T | Promise<T>;
   /** Tracked includes for build-time manifest generation */
   trackedIncludes?: TrackedInclude[];
+  /** Cache profiles for DSL-time cache("profileName") resolution */
+  cacheProfiles?: Record<
+    string,
+    import("../cache/profile-registry.js").CacheProfile
+  >;
 }
-export const RSCRouterContext: AsyncLocalStorage<HelperContext> =
-  new AsyncLocalStorage<HelperContext>();
+// Use a global symbol key so the AsyncLocalStorage instance survives HMR
+// module re-evaluation. Without this, Vite's RSC module runner may create
+// a new instance when context.ts is re-evaluated, while other modules still
+// hold references to the old instance — causing getStore() to return
+// undefined even inside a run() callback.
+const RSC_CONTEXT_KEY = Symbol.for("rangojs-router:rsc-context");
+export const RSCRouterContext: AsyncLocalStorage<HelperContext> = ((
+  globalThis as any
+)[RSC_CONTEXT_KEY] ??= new AsyncLocalStorage<HelperContext>());
 
 export const getContext = (): {
   context: AsyncLocalStorage<HelperContext>;
@@ -229,21 +287,21 @@ export const getContext = (): {
   getParent: () => EntryData | null;
   getOrCreateStore: (forRoute?: string) => HelperContext;
   getNextIndex: (
-    type: (string & {}) | "layout" | "parallel" | "middleware" | "revalidate"
+    type: (string & {}) | "layout" | "parallel" | "middleware" | "revalidate",
   ) => string;
   getShortCode: (
-    type: "layout" | "parallel" | "route" | "loader" | "cache"
+    type: "layout" | "parallel" | "route" | "loader" | "cache",
   ) => string;
   run: <T>(
     namespace: string,
     parent: EntryData | null,
-    callback: (...args: any[]) => T
+    callback: (...args: any[]) => T,
   ) => T;
   runWithStore: <T>(
     store: HelperContext,
     namespace: string,
     parent: EntryData | null,
-    callback: (...args: any[]) => T
+    callback: (...args: any[]) => T,
   ) => T;
 } => {
   const context = RSCRouterContext;
@@ -262,6 +320,7 @@ export const getContext = (): {
           patterns: new Map<string, string>(),
           patternsByPrefix: new Map<string, Map<string, string>>(),
           trailingSlash: new Map<string, "never" | "always" | "ignore">(),
+          searchSchemas: new Map<string, Record<string, string>>(),
         } satisfies HelperContext;
       }
       return store;
@@ -270,7 +329,7 @@ export const getContext = (): {
       const store = context.getStore();
       if (!store) {
         throw new Error(
-          "RSC Router context store is not available. Make sure to run within RSC Router context."
+          "RSC Router context store is not available. Make sure to run within RSC Router context.",
         );
       }
       return store;
@@ -284,7 +343,7 @@ export const getContext = (): {
       return store.parent;
     },
     getNextIndex: (
-      type: (string & {}) | "layout" | "parallel" | "middleware" | "revalidate"
+      type: (string & {}) | "layout" | "parallel" | "middleware" | "revalidate",
     ) => {
       const store = context.getStore();
       invariant(store, "No context RSCRouterContext available");
@@ -293,17 +352,31 @@ export const getContext = (): {
       store.counters[type] = index + 1;
       return `$${type}.${index}`;
     },
-    getShortCode: (type: "layout" | "parallel" | "route" | "loader" | "cache") => {
+    getShortCode: (
+      type: "layout" | "parallel" | "route" | "loader" | "cache",
+    ) => {
       const store = context.getStore();
       invariant(store, "No context RSCRouterContext available");
 
       const parent = store.parent;
-      const prefix = type === "layout" ? "L" : type === "parallel" ? "P" : type === "loader" ? "D" : type === "cache" ? "C" : "R";
-      const mountPrefix = store.mountIndex !== undefined ? `M${store.mountIndex}` : "";
+      const prefix =
+        type === "layout"
+          ? "L"
+          : type === "parallel"
+            ? "P"
+            : type === "loader"
+              ? "D"
+              : type === "cache"
+                ? "C"
+                : "R";
+      const mountPrefix =
+        store.mountIndex !== undefined ? `M${store.mountIndex}` : "";
 
       if (!parent) {
         // Root entry: prefix with mount index and use mount-scoped counter
-        const counterKey = mountPrefix ? `${mountPrefix}_root_${type}` : `root_${type}`;
+        const counterKey = mountPrefix
+          ? `${mountPrefix}_root_${type}`
+          : `root_${type}`;
         store.counters[counterKey] ??= 0;
         const index = store.counters[counterKey];
         store.counters[counterKey] = index + 1;
@@ -321,7 +394,7 @@ export const getContext = (): {
       store: HelperContext,
       namespace: string,
       parent: EntryData | null,
-      callback: (...args: any[]) => T
+      callback: (...args: any[]) => T,
     ): T => {
       return context.run(
         {
@@ -335,24 +408,32 @@ export const getContext = (): {
           isSSR: store.isSSR,
           patterns: store.patterns,
           trailingSlash: store.trailingSlash,
+          searchSchemas: store.searchSchemas,
           urlPrefix: store.urlPrefix,
           namePrefix: store.namePrefix,
+          rootScoped: store.rootScoped,
           trackedIncludes: store.trackedIncludes,
+          cacheProfiles: store.cacheProfiles,
         },
-        callback
+        callback,
       );
     },
     run: <T>(
       namespace: string,
       parent: EntryData | null,
-      callback: (...args: any[]) => T
+      callback: (...args: any[]) => T,
     ) => {
       const store = context.getStore();
       // Preserve parent counters to ensure globally unique shortCodes
       const counters = store?.counters || {};
       const manifest = store ? store.manifest : new Map<string, EntryData>();
       const patterns = store?.patterns || new Map<string, string>();
-      const trailingSlash = store?.trailingSlash || new Map<string, "never" | "always" | "ignore">();
+      const patternsByPrefix = store?.patternsByPrefix;
+      const trailingSlash =
+        store?.trailingSlash ||
+        new Map<string, "never" | "always" | "ignore">();
+      const searchSchemas =
+        store?.searchSchemas || new Map<string, Record<string, string>>();
       return context.run(
         {
           manifest,
@@ -364,12 +445,16 @@ export const getContext = (): {
           metrics: store?.metrics,
           isSSR: store?.isSSR,
           patterns,
+          patternsByPrefix,
           trailingSlash,
+          searchSchemas,
           urlPrefix: store?.urlPrefix,
           namePrefix: store?.namePrefix,
+          rootScoped: store?.rootScoped,
           trackedIncludes: store?.trackedIncludes,
+          cacheProfiles: store?.cacheProfiles,
         },
-        callback
+        callback,
       );
     },
   };
@@ -382,30 +467,61 @@ export const getContext = (): {
 export function runWithPrefixes<T>(
   urlPrefix: string,
   namePrefix: string | undefined,
-  callback: () => T
+  callback: () => T,
 ): T {
   const store = RSCRouterContext.getStore();
   if (!store) {
     throw new Error("runWithPrefixes must be called within router context");
   }
 
-  // Combine prefixes if there are existing ones
-  const combinedUrlPrefix = store.urlPrefix
-    ? `${store.urlPrefix}${urlPrefix}`
-    : urlPrefix;
-  const combinedNamePrefix = namePrefix
-    ? store.namePrefix
-      ? `${store.namePrefix}.${namePrefix}`
-      : namePrefix
-    : store.namePrefix;
+  // Combine prefixes if there are existing ones, avoiding double slashes
+  let combinedUrlPrefix: string;
+  if (store.urlPrefix) {
+    if (store.urlPrefix.endsWith("/") && urlPrefix.startsWith("/")) {
+      combinedUrlPrefix = store.urlPrefix + urlPrefix.slice(1);
+    } else {
+      combinedUrlPrefix = store.urlPrefix + urlPrefix;
+    }
+  } else {
+    combinedUrlPrefix = urlPrefix;
+  }
+  const combinedNamePrefix =
+    namePrefix !== undefined
+      ? namePrefix === ""
+        ? store.namePrefix
+        : store.namePrefix
+          ? `${store.namePrefix}.${namePrefix}`
+          : namePrefix
+      : store.namePrefix;
+
+  // Track root scope for dot-local reverse resolution.
+  //
+  // The flag answers: "can this route reach bare names at root scope?"
+  // It propagates through the include chain:
+  //
+  //   { name: "" }    — transparent: inherit parent, default true
+  //   { name: "foo" } — inherit parent if already set, else create boundary (false)
+  //   no name          — inherit parent unchanged
+  //
+  // This means { name: "" } + nested { name: "sub" } keeps rootScoped=true
+  // (the outer transparent include establishes root access, and the inner
+  // named include inherits it). But a direct { name: "sub" } at root gets
+  // rootScoped=false (no prior root-access grant, so it creates a boundary).
+  const combinedRootScoped =
+    namePrefix === ""
+      ? (store.rootScoped ?? true)
+      : namePrefix !== undefined
+        ? (store.rootScoped ?? false)
+        : store.rootScoped;
 
   return RSCRouterContext.run(
     {
       ...store,
       urlPrefix: combinedUrlPrefix,
       namePrefix: combinedNamePrefix,
+      rootScoped: combinedRootScoped,
     },
-    callback
+    callback,
   );
 }
 
@@ -425,6 +541,15 @@ export function getNamePrefix(): string | undefined {
   return store?.namePrefix;
 }
 
+/**
+ * Get whether the current scope is at root level (no named include boundary above).
+ * Returns true at root or inside { name: "" } includes, false inside named includes.
+ */
+export function getRootScoped(): boolean {
+  const store = RSCRouterContext.getStore();
+  return store?.rootScoped ?? true;
+}
+
 // Export HelperContext type for use in other modules
 export type { HelperContext };
 
@@ -443,7 +568,7 @@ export type { HelperContext };
  * done(); // Records duration
  * ```
  */
-export function track(label: string): () => void {
+export function track(label: string, depth?: number): () => void {
   const store = RSCRouterContext.getStore();
 
   // No-op if context unavailable or metrics not enabled
@@ -454,7 +579,13 @@ export function track(label: string): () => void {
   const startTime = performance.now() - store.metrics.requestStart;
 
   return () => {
-    const duration = performance.now() - store.metrics!.requestStart - startTime;
-    store.metrics!.metrics.push({ label, duration, startTime });
+    const duration =
+      performance.now() - store.metrics!.requestStart - startTime;
+    store.metrics!.metrics.push({
+      label,
+      duration,
+      startTime,
+      ...(depth != null ? { depth } : {}),
+    });
   };
 }

package/src/server/cookie-store.ts

@@ -0,0 +1,190 @@
+/**
+ * Cookie Store — Next.js-style cookie facade backed by the response-derived model.
+ *
+ * `cookies()` returns a CookieStore scoped to the current request.
+ * Reads merge the original Cookie header with Set-Cookie mutations
+ * already queued on the response stub (last-write-wins).
+ * Writes append Set-Cookie to the response stub.
+ */
+
+import type { CookieOptions } from "../router/middleware-types.js";
+import { getRequestContext } from "./request-context.js";
+import { INSIDE_CACHE_EXEC } from "../cache/taint.js";
+
+/**
+ * A single cookie entry returned by get() and getAll().
+ */
+export interface Cookie {
+  name: string;
+  value: string;
+}
+
+/**
+ * Request-scoped cookie store.
+ *
+ * Reads see the effective merged view (original request + same-request mutations).
+ * Writes append Set-Cookie headers to the shared response stub.
+ */
+export interface CookieStore {
+  /** Get a single cookie by name. Returns undefined if not set or deleted. */
+  get(name: string): Cookie | undefined;
+
+  /** Get all effective cookies, or all cookies with a given name. */
+  getAll(name?: string): Cookie[];
+
+  /** Check whether a cookie exists in the effective view. */
+  has(name: string): boolean;
+
+  /** Set a cookie (appends Set-Cookie to the response stub). */
+  set(name: string, value: string, options?: CookieOptions): void;
+
+  /** Delete a cookie (appends Set-Cookie with maxAge=0 to the response stub). */
+  delete(name: string, options?: Pick<CookieOptions, "domain" | "path">): void;
+}
+
+/**
+ * Get the request-scoped cookie store.
+ *
+ * Must be called inside a request context (middleware, handler, loader, action).
+ * Throws if called outside request scope.
+ *
+ * @example
+ * ```typescript
+ * import { cookies } from "@rangojs/router";
+ *
+ * // In a handler, loader, or action:
+ * const session = cookies().get("session")?.value;
+ * cookies().set("session", "new-token", { httpOnly: true });
+ * cookies().delete("session");
+ * ```
+ */
+export function cookies(): CookieStore {
+  const ctx = getRequestContext();
+  assertNotInsideCacheContext(ctx, "cookies");
+  return createCookieStore(ctx);
+}
+
+/**
+ * Read-only view of HTTP headers.
+ * Exposes only the read methods of the Headers API.
+ */
+export interface ReadonlyHeaders {
+  get(name: string): string | null;
+  has(name: string): boolean;
+  entries(): HeadersIterator<[string, string]>;
+  keys(): HeadersIterator<string>;
+  values(): HeadersIterator<string>;
+  forEach(
+    callback: (value: string, name: string, parent: ReadonlyHeaders) => void,
+  ): void;
+  [Symbol.iterator](): HeadersIterator<[string, string]>;
+}
+
+// Minimal iterator interface (avoids pulling IterableIterator from lib.dom)
+type HeadersIterator<T> = IterableIterator<T>;
+
+/**
+ * Throw if called inside a "use cache" function.
+ * Reading request-scoped data (cookies, headers) inside a cached function
+ * produces results that vary per request but the cache key does not include
+ * those values, leading to one user's data being served to another.
+ */
+function assertNotInsideCacheContext(ctx: unknown, fnName: string): void {
+  if (
+    ctx !== null &&
+    ctx !== undefined &&
+    typeof ctx === "object" &&
+    (INSIDE_CACHE_EXEC as symbol) in (ctx as Record<symbol, unknown>)
+  ) {
+    throw new Error(
+      `${fnName}() cannot be called inside a "use cache" function. ` +
+        `Request-scoped data (cookies, headers) varies per request but is not ` +
+        `reflected in the cache key, so cached results would be served to the ` +
+        `wrong users. Extract the value before the cached function and pass it ` +
+        `as an argument:\n\n` +
+        `  const locale = cookies().get("locale")?.value ?? "en";\n` +
+        `  const data = await getCachedData(locale); // locale is now in the cache key`,
+    );
+  }
+}
+
+const HEADERS_MUTATION_METHODS = new Set(["set", "append", "delete"]);
+
+/**
+ * Get the original request headers (read-only).
+ *
+ * Must be called inside a request context.
+ * Returns a read-only view of the incoming request's headers.
+ * Mutation methods (set, append, delete) throw at runtime.
+ *
+ * @example
+ * ```typescript
+ * import { headers } from "@rangojs/router";
+ *
+ * const auth = headers().get("authorization");
+ * const contentType = headers().get("content-type");
+ * ```
+ */
+export function headers(): ReadonlyHeaders {
+  const ctx = getRequestContext();
+  assertNotInsideCacheContext(ctx, "headers");
+  return new Proxy(ctx.request.headers, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && HEADERS_MUTATION_METHODS.has(prop)) {
+        return () => {
+          throw new Error(
+            `headers().${prop}() is not allowed. headers() returns a read-only view of request headers. ` +
+              `Use ctx.header() to set response headers.`,
+          );
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+  }) as unknown as ReadonlyHeaders;
+}
+
+/**
+ * Create a CookieStore backed by a RequestContext.
+ * @internal Shared between cookies() shorthand and context methods.
+ */
+function createCookieStore(ctx: {
+  cookie(name: string): string | undefined;
+  cookies(): Record<string, string>;
+  setCookie(name: string, value: string, options?: CookieOptions): void;
+  deleteCookie(
+    name: string,
+    options?: Pick<CookieOptions, "domain" | "path">,
+  ): void;
+}): CookieStore {
+  return {
+    get(name: string): Cookie | undefined {
+      const value = ctx.cookie(name);
+      return value !== undefined ? { name, value } : undefined;
+    },
+
+    getAll(name?: string): Cookie[] {
+      const all = ctx.cookies();
+      if (name !== undefined) {
+        const value = all[name];
+        return value !== undefined ? [{ name, value }] : [];
+      }
+      return Object.entries(all).map(([n, v]) => ({ name: n, value: v }));
+    },
+
+    has(name: string): boolean {
+      return ctx.cookie(name) !== undefined;
+    },
+
+    set(name: string, value: string, options?: CookieOptions): void {
+      ctx.setCookie(name, value, options);
+    },
+
+    delete(
+      name: string,
+      options?: Pick<CookieOptions, "domain" | "path">,
+    ): void {
+      ctx.deleteCookie(name, options);
+    },
+  };
+}

package/src/server/fetchable-loader-store.ts

@@ -0,0 +1,37 @@
+/**
+ * Fetchable loader store - internal registry for fetchable loader functions.
+ *
+ * Extracted into its own module to avoid circular dependencies between
+ * loader.rsc.ts and request-context.ts. This module has no imports from
+ * either, so both can safely import from here.
+ *
+ * Populated by createLoader() in loader.rsc.ts.
+ * Read by request-context.ts (for ctx.use()) and loader-registry.ts (for GET-based fetching).
+ */
+
+import type { LoaderFn } from "../types.js";
+import type { MiddlewareFn } from "../router/middleware.js";
+
+export interface LoaderRegistryEntry {
+  fn: LoaderFn<any, any, any>;
+  middleware: MiddlewareFn[];
+  /** Whether this loader is fetchable via the _rsc_loader endpoint. */
+  fetchable: boolean;
+}
+
+const fetchableLoaderRegistry = new Map<string, LoaderRegistryEntry>();
+
+export function registerFetchableLoader(
+  id: string,
+  fn: LoaderFn<any, any, any>,
+  middleware: MiddlewareFn[],
+  fetchable: boolean,
+): void {
+  fetchableLoaderRegistry.set(id, { fn, middleware, fetchable });
+}
+
+export function getFetchableLoader(
+  id: string,
+): LoaderRegistryEntry | undefined {
+  return fetchableLoaderRegistry.get(id);
+}