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

package/src/loader-store.ts

@@ -0,0 +1,202 @@
+/**
+ * LoaderStore — shared subscription model for `useLoader` / `useFetchLoader`.
+ *
+ * Each loader id (loader.$$id) gets one entry that holds the latest committed
+ * snapshot plus a set of listeners. Snapshots are frozen and replaced atomically
+ * on mutation, so subscribers can compare snapshot identity and avoid
+ * unnecessary updates between real changes.
+ *
+ * Mutations that come in for an old request id (e.g. a slow response that
+ * resolves after a newer load() was issued, or after a navigation cleared the
+ * entry) are silently dropped. `reserveRequestId` is the only way to claim the
+ * "latest" slot; `clear` bumps it too so pre-navigation in-flight loads cannot
+ * commit into the new route's context.
+ *
+ * The store is intentionally module-level: each browser tab is its own JS
+ * realm, so there is no cross-request pollution. Server renders never mutate
+ * the store — the hook falls back to `OutletContext.loaderData`.
+ */
+
+export interface LoaderEntry<T = unknown> {
+  readonly value: T | undefined;
+  readonly error: Error | null;
+  readonly isLoading: boolean;
+  /** Identifies the request that produced this snapshot. 0 means "no request". */
+  readonly requestId: number;
+}
+
+const EMPTY_SNAPSHOT: LoaderEntry = Object.freeze({
+  value: undefined,
+  error: null,
+  isLoading: false,
+  requestId: 0,
+});
+
+interface InternalEntry {
+  snapshot: LoaderEntry;
+  listeners: Set<() => void>;
+  /** Monotonically increasing. Bumped by reserveRequestId() and clear(). */
+  latestRequestId: number;
+}
+
+export class LoaderStore {
+  private readonly entries = new Map<string, InternalEntry>();
+
+  private getOrCreate(id: string): InternalEntry {
+    let e = this.entries.get(id);
+    if (!e) {
+      e = {
+        snapshot: EMPTY_SNAPSHOT,
+        listeners: new Set(),
+        latestRequestId: 0,
+      };
+      this.entries.set(id, e);
+    }
+    return e;
+  }
+
+  /**
+   * Subscribe to entry changes for `id`.
+   * Returns an unsubscribe function. The store keeps the entry around even
+   * after the last subscriber leaves so that an in-flight `load()` can still
+   * commit if the consumer remounts.
+   */
+  subscribe(id: string, cb: () => void): () => void {
+    const e = this.getOrCreate(id);
+    e.listeners.add(cb);
+    return () => {
+      e.listeners.delete(cb);
+    };
+  }
+
+  /**
+   * Returns the current snapshot for `id`. Stable reference between mutations
+   * — subscribers rely on this to avoid spurious re-renders.
+   * Returns `EMPTY_SNAPSHOT` (a singleton) when the entry has never been
+   * mutated or has been cleared.
+   */
+  getSnapshot(id: string): LoaderEntry {
+    return this.entries.get(id)?.snapshot ?? EMPTY_SNAPSHOT;
+  }
+
+  /**
+   * Reserve a fresh request id for an upcoming `load()` call. The returned id
+   * is the new "latest"; any older in-flight requests will fail their gating
+   * check on `finishData` / `finishError` / `finishLoading` and be dropped.
+   *
+   * Callers should follow with `beginRequest(id, requestId)` to flip the
+   * loading flag on AND clear any leftover error from a previous attempt
+   * — the latter matters for `throwOnError: false` consumers, which would
+   * otherwise keep showing the stale error throughout the retry.
+   */
+  reserveRequestId(id: string): number {
+    const e = this.getOrCreate(id);
+    e.latestRequestId++;
+    return e.latestRequestId;
+  }
+
+  /**
+   * Mark the request as in-flight: `isLoading = true`, `error = null`.
+   * Combines the two operations so a retry doesn't render the previous
+   * error during the new request. Gated on `requestId === latestRequestId`
+   * for symmetry with the other mutators.
+   */
+  beginRequest(id: string, requestId: number): void {
+    const e = this.entries.get(id);
+    if (!e || requestId !== e.latestRequestId) return;
+    if (e.snapshot.isLoading && e.snapshot.error === null) return;
+    e.snapshot = Object.freeze({
+      value: e.snapshot.value,
+      error: null,
+      isLoading: true,
+      requestId,
+    });
+    this.notify(e);
+  }
+
+  /**
+   * Commit a successful result. No-op if `requestId` is not the latest
+   * (a newer `load()` was issued or `clear()` ran). Clearing `error` is
+   * intentional: a successful refetch should hide the previous failure.
+   */
+  finishData<T>(id: string, requestId: number, value: T): void {
+    const e = this.entries.get(id);
+    if (!e || requestId !== e.latestRequestId) return;
+    e.snapshot = Object.freeze({
+      value,
+      error: null,
+      isLoading: false,
+      requestId,
+    });
+    this.notify(e);
+  }
+
+  /**
+   * Commit an error. Preserves the last good `value` so consumers can keep
+   * showing previous data while displaying the error if they choose. No-op
+   * if `requestId` is not the latest.
+   */
+  finishError(id: string, requestId: number, error: Error): void {
+    const e = this.entries.get(id);
+    if (!e || requestId !== e.latestRequestId) return;
+    e.snapshot = Object.freeze({
+      value: e.snapshot.value,
+      error,
+      isLoading: false,
+      requestId,
+    });
+    this.notify(e);
+  }
+
+  /**
+   * Update loading flag. Gated on `requestId` to fix the race where an old
+   * load() finishes after a new one started — its `setLoading(false)` would
+   * otherwise hide the new request's spinner.
+   */
+  setLoading(id: string, requestId: number, isLoading: boolean): void {
+    const e = this.entries.get(id);
+    if (!e || requestId !== e.latestRequestId) return;
+    if (e.snapshot.isLoading === isLoading) return;
+    e.snapshot = Object.freeze({
+      ...e.snapshot,
+      isLoading,
+    });
+    this.notify(e);
+  }
+
+  /**
+   * Reset the entry. Bumps `latestRequestId` so any in-flight `load()` whose
+   * promise is still pending will fail its gate when it resolves and be
+   * dropped — prevents pre-navigation loads from clobbering the new route's
+   * context.
+   */
+  clear(id: string): void {
+    const e = this.entries.get(id);
+    if (!e) return;
+    e.latestRequestId++;
+    if (e.snapshot === EMPTY_SNAPSHOT) return;
+    e.snapshot = EMPTY_SNAPSHOT;
+    this.notify(e);
+  }
+
+  private notify(e: InternalEntry): void {
+    for (const cb of e.listeners) cb();
+  }
+
+  /**
+   * Test-only escape hatch. Drops every entry. Production code should never
+   * call this; the store is process-scoped and lives for the tab's lifetime.
+   * @internal
+   */
+  reset(): void {
+    this.entries.clear();
+  }
+}
+
+/**
+ * Module-level singleton. Each browser tab gets its own; SSR never mutates it.
+ * The hook falls through to `OutletContext.loaderData` during the server render.
+ */
+export const loaderStore: LoaderStore = new LoaderStore();
+
+export const EMPTY_LOADER_SNAPSHOT: LoaderEntry = EMPTY_SNAPSHOT;

package/src/loader.rsc.ts

@@ -5,9 +5,9 @@
  * Only used in react-server context via export conditions.
  *
  * For non-fetchable loaders: returns a loader definition with fn included
- * For fetchable loaders: stores fn in registry and returns a serializable loader with action
+ * For fetchable loaders: stores fn in registry and returns a serializable loader
  *
- * The $$id is injected by the Vite exposeLoaderId plugin as a hidden parameter.
+ * The $$id is injected by the Vite exposeInternalIds plugin as a hidden parameter.
  * Users don't need to pass any name - IDs are auto-generated from file path.
  */
 
@@ -17,90 +17,54 @@ import type {
   LoaderFn,
 } from "./types.js";
 import type { MiddlewareFn } from "./router/middleware.js";
-import { getRequestContext } from "./server/request-context.js";
+import {
+  registerFetchableLoader,
+  getFetchableLoader,
+} from "./server/fetchable-loader-store.js";
 
-// Internal registry for fetchable loaders (server-side only)
-// Maps loader $$id to its function and middleware
-//
-// WHY TWO REGISTRIES?
-// This registry (fetchableLoaderRegistry) is populated immediately when createLoader() runs.
-// The other registry in loader-registry.ts (loaderRegistry) is a cache used by the RSC handler
-// for GET-based fetching. The RSC handler calls getFetchableLoader() from here to populate
-// its cache. This separation allows:
-// 1. Server actions to look up loaders directly without going through lazy loading
-// 2. The RSC handler to use lazy loading for production builds
-// 3. Both to share the same source of truth (this registry)
-const fetchableLoaderRegistry = new Map<
-  string,
-  { fn: LoaderFn<any, any, any>; middleware: MiddlewareFn[] }
->();
-
-/**
- * Register a fetchable loader's function internally
- * Called during module initialization with the $$id
- */
-function registerFetchableLoader(
-  id: string,
-  fn: LoaderFn<any, any, any>,
-  middleware: MiddlewareFn[]
-): void {
-  fetchableLoaderRegistry.set(id, { fn, middleware });
-}
-
-/**
- * Get a fetchable loader's function from the internal registry by $$id
- *
- * This is used internally by:
- * - Server actions (loaderAction) to execute loader functions
- * - loader-registry.ts to populate the main registry for GET-based fetching
- *
- * Loaders are registered here when createLoader() is called with fetchable: true.
- * The $$id is injected by the Vite exposeLoaderId plugin.
- *
- * @param id - The loader's $$id (auto-generated from file path + export name)
- * @returns The loader function and middleware, or undefined if not found
- *
- * @internal This is primarily for internal use by the router infrastructure
- */
-export function getFetchableLoader(
-  id: string
-): { fn: LoaderFn<any, any, any>; middleware: MiddlewareFn[] } | undefined {
-  return fetchableLoaderRegistry.get(id);
-}
+export { getFetchableLoader };
 
 // Overload 1: With function only (not fetchable)
 export function createLoader<T>(
-  fn: LoaderFn<T, Record<string, string | undefined>, any>
+  fn: LoaderFn<T, Record<string, string | undefined>, any>,
 ): LoaderDefinition<Awaited<T>, Record<string, string | undefined>>;
 
 // Overload 2: Fetchable with `true` (no middleware)
 export function createLoader<T>(
   fn: LoaderFn<T, Record<string, string | undefined>, any>,
-  fetchable: true
+  fetchable: true,
 ): LoaderDefinition<Awaited<T>, Record<string, string | undefined>>;
 
 // Overload 3: Fetchable with middleware options
 export function createLoader<T>(
   fn: LoaderFn<T, Record<string, string | undefined>, any>,
-  options: FetchableLoaderOptions
+  options: FetchableLoaderOptions,
 ): LoaderDefinition<Awaited<T>, Record<string, string | undefined>>;
 
 // Implementation - the $$id parameter is injected by Vite plugin, not user-provided
 export function createLoader<T>(
   fn: LoaderFn<T, Record<string, string | undefined>, any>,
   fetchable?: true | FetchableLoaderOptions,
-  // Hidden parameter injected by Vite exposeLoaderId plugin
-  __injectedId?: string
+  // Hidden parameter injected by Vite exposeInternalIds plugin
+  __injectedId?: string,
 ): LoaderDefinition<Awaited<T>, Record<string, string | undefined>> {
   // The $$id will be set on the returned object by Vite plugin
   // For fetchable loaders, __injectedId is also passed as a parameter
   const loaderId = __injectedId || "";
 
-  // If not fetchable, store fn in registry and return a plain object.
-  // Server-side code looks up fn via getFetchableLoader($$id).
+  if (!loaderId && process.env.NODE_ENV === "development") {
+    throw new Error(
+      "[rsc-router] Loader is missing $$id. " +
+        "Make sure the exposeInternalIds Vite plugin is enabled and " +
+        "the loader is exported with: export const MyLoader = createLoader(...)",
+    );
+  }
+
+  // If not fetchable, store fn in registry (for SSR ctx.use() resolution)
+  // but mark fetchable=false so the _rsc_loader endpoint rejects it.
   if (fetchable === undefined) {
     if (fn && loaderId) {
-      registerFetchableLoader(loaderId, fn, []);
+      registerFetchableLoader(loaderId, fn, [], false);
     }
     return {
       __brand: "loader",
@@ -113,95 +77,13 @@ export function createLoader<T>(
     fetchable === true ? [] : fetchable?.middleware || [];
 
   // Register the function in the internal registry by $$id (server-side only)
-  // The server action will look it up by $$id when executed
+  // The loader fetch handler looks it up by $$id when load() is called from the client.
   if (fn && loaderId) {
-    registerFetchableLoader(loaderId, fn, middleware);
-  }
-
-  // Create server action for form-based fetching
-  // This action is serializable and can be passed to client components
-  // The loaderId is captured in closure (it's a primitive string)
-  //
-  // IMPORTANT: The signature must be (prevState, formData) for useActionState compatibility.
-  // When used with useActionState, React passes the previous state as the first argument.
-  // The prevState is ignored here since loaders are stateless data fetchers.
-  async function loaderAction(
-    _prevState: Awaited<T> | null,
-    formData: FormData
-  ): Promise<Awaited<T>> {
-    "use server";
-
-    // Look up the loader from registry by $$id
-    const registered = fetchableLoaderRegistry.get(loaderId);
-    if (!registered) {
-      throw new Error(`Loader "${loaderId}" not found in registry`);
-    }
-
-    // Get request context (env, request, url, variables) from the RSC handler
-    // This is set by runWithRequestContext in rsc/index.ts when executing actions
-    const requestCtx = getRequestContext();
-
-    // Convert FormData to params object
-    const params: Record<string, string> = {};
-    formData.forEach((value, key) => {
-      if (typeof value === "string") {
-        params[key] = value;
-      }
-    });
-
-    // Use real request/url from context, or fall back to synthetic for edge cases
-    const actionUrl = requestCtx?.url ?? new URL("http://localhost/");
-    const actionRequest = requestCtx?.request ?? new Request(actionUrl, { method: "POST" });
-    const env = requestCtx?.env ?? {};
-
-    // Merge variables from request context (app-level middleware) with loader-specific variables
-    // requestCtx.var is the shared variables object from the handler
-    const variables: Record<string, any> = { ...requestCtx?.var };
-
-    // Execute middleware for auth checks, headers, cookies
-    // Headers/cookies set on ctx.res will be merged into the final response
-    if (registered.middleware.length > 0 && requestCtx?.res) {
-      const { executeServerActionMiddleware } = await import(
-        "./router/middleware.js"
-      );
-      await executeServerActionMiddleware(
-        registered.middleware,
-        actionRequest,
-        env,
-        params,
-        variables,
-        requestCtx.res
-      );
-    }
-
-    // Build context using createHandlerContext for consistency with route handlers
-    // Variables are now accessed from request context via getRequestContext()
-    const { createHandlerContext } = await import("./router/handler-context.js");
-    const baseCtx = createHandlerContext(
-      params,
-      actionRequest,
-      actionUrl.searchParams,
-      actionUrl.pathname,
-      actionUrl,
-      env
-    );
-
-    // Extend with server action specific properties
-    const ctx: any = {
-      ...baseCtx,
-      method: "POST",
-      formData,
-    };
-
-    // Execute and return result
-    return registered.fn(ctx);
+    registerFetchableLoader(loaderId, fn, middleware, true);
   }
 
-  // Return a plain object with action for form-based fetching.
-  // loaderAction has "use server" so RSC Flight serializes it natively as a server action reference.
   return {
     __brand: "loader",
     $$id: loaderId,
-    action: loaderAction,
   };
 }

package/src/loader.ts

@@ -2,10 +2,15 @@
  * rsc-router/loader (client version)
  *
  * Client-only stub for createLoader. Returns a minimal loader definition
- * that can be passed to hooks like useLoader. The actual loader function
- * is not included - it only exists on the server.
+ * ({ __brand, $$id }) that can be passed to hooks like useLoader.
+ * The actual loader function is not included -- it only exists on the server.
  *
- * The $$id is injected by the Vite exposeLoaderId plugin.
+ * For export-only loader files, the Vite plugin replaces the entire file with
+ * object literals (bypassing this function). Those stubs only contain
+ * { __brand, $$id }.
+ * This function only runs when loaders are in mixed files (not export-only).
+ *
+ * The $$id is injected by the Vite exposeInternalIds plugin.
  */
 
 import type {
@@ -16,32 +21,44 @@ import type {
 
 // Overload 1: With function only (not fetchable)
 export function createLoader<T>(
-  fn: LoaderFn<T, Record<string, string | undefined>, any>
+  fn: LoaderFn<T, Record<string, string | undefined>, any>,
 ): LoaderDefinition<Awaited<T>, Record<string, string | undefined>>;
 
 // Overload 2: Fetchable with `true` (no middleware)
 export function createLoader<T>(
   fn: LoaderFn<T, Record<string, string | undefined>, any>,
-  fetchable: true
+  fetchable: true,
 ): LoaderDefinition<Awaited<T>, Record<string, string | undefined>>;
 
 // Overload 3: Fetchable with middleware options
 export function createLoader<T>(
   fn: LoaderFn<T, Record<string, string | undefined>, any>,
-  options: FetchableLoaderOptions
+  options: FetchableLoaderOptions,
 ): LoaderDefinition<Awaited<T>, Record<string, string | undefined>>;
 
 // Implementation - client stub that just returns the loader definition
 // The $$id parameter is injected by Vite plugin, not user-provided
+//
+// NOTE: For export-only loader files, the Vite plugin replaces the entire
+// file with object literals (bypassing this function). This function only
+// runs when loaders are in mixed files (not export-only).
 export function createLoader<T>(
   _fn: LoaderFn<T, Record<string, string | undefined>, any>,
   _fetchable?: true | FetchableLoaderOptions,
-  __injectedId?: string
+  __injectedId?: string,
 ): LoaderDefinition<Awaited<T>, Record<string, string | undefined>> {
-  // Client only needs the $$id for identification
-  // The actual loader function is only used on the server
+  const loaderId = __injectedId || "";
+
+  if (!loaderId && process.env.NODE_ENV === "development") {
+    throw new Error(
+      "[rsc-router] Loader is missing $$id. " +
+        "Make sure the exposeInternalIds Vite plugin is enabled and " +
+        "the loader is exported with: export const MyLoader = createLoader(...)",
+    );
+  }
+
   return {
     __brand: "loader",
-    $$id: __injectedId || "",
+    $$id: loaderId,
   };
 }

package/src/network-error-thrower.tsx

@@ -16,6 +16,8 @@ interface NetworkErrorThrowerProps {
  * 1. Errors must be thrown during React's render phase to be caught by error boundaries
  * 2. The error occurs in async code (fetch), so we need to propagate it to React's render
  */
-export function NetworkErrorThrower({ error }: NetworkErrorThrowerProps): ReactNode {
+export function NetworkErrorThrower({
+  error,
+}: NetworkErrorThrowerProps): ReactNode {
   throw error;
 }

package/src/outlet-context.ts

@@ -1,4 +1,4 @@
-import { Context, createContext, type ReactNode } from "react";
+import { type Context, createContext, type ReactNode } from "react";
 import type { ResolvedSegment } from "./types";
 
 export interface OutletContextValue {

package/src/outlet-provider.tsx

@@ -0,0 +1,45 @@
+"use client";
+
+import { useContext, useMemo, type ReactNode } from "react";
+import { OutletContext, type OutletContextValue } from "./outlet-context.js";
+import type { ResolvedSegment } from "./types.js";
+
+/**
+ * Provider for outlet content - used internally by renderSegments
+ *
+ * Stores a reference to parent context so useLoader can walk up the chain
+ * to find loader data from parent layouts. If this segment defines a loading
+ * component, Outlet will wrap content with Suspense using that as fallback.
+ */
+export function OutletProvider({
+  content,
+  parallel,
+  segment,
+  loaderData,
+  children,
+}: {
+  content: ReactNode;
+  parallel?: ResolvedSegment[];
+  segment?: ResolvedSegment;
+  loaderData?: Record<string, any>;
+  children: ReactNode;
+}): ReactNode {
+  // Get parent context to enable walking up the chain for loader lookups
+  const parentContext = useContext(OutletContext);
+
+  const value = useMemo(
+    () => ({
+      content,
+      parallel,
+      segment,
+      loaderData,
+      parent: parentContext,
+      loading: segment?.loading,
+    }),
+    [content, parallel, segment, loaderData, parentContext],
+  );
+
+  return (
+    <OutletContext.Provider value={value}>{children}</OutletContext.Provider>
+  );
+}

package/src/prerender/param-hash.ts

@@ -17,8 +17,10 @@ export function hashParams(params: Record<string, string>): string {
   const entries = Object.entries(params);
   if (entries.length === 0) return "_";
 
-  const sorted = entries.sort(([a], [b]) => a.localeCompare(b));
-  const str = sorted.map(([k, v]) => `${k}=${v}`).join("&");
+  const sorted = entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+  const str = sorted
+    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .join("&");
   return djb2Hex(str);
 }