@rangojs/router 0.23.0 → 0.24.1

package/src/rsc/rewrite-passes.ts

@@ -0,0 +1,203 @@
+/**
+ * The pass loop that honors `throw rewrite()` (route-definition/rewrite.ts):
+ * one catch around the global middleware chain moves the same request
+ * context to the target (server/request-context.ts rebaseRequestContext) and
+ * runs the request again from the top, as a direct visit to the target
+ * would run it. Shared by the request handler (rsc/handler.ts) and the
+ * dispatch testing primitive, so the two cannot drift.
+ */
+
+import { RewriteLoopError } from "../errors.js";
+import {
+  describeRewriteTarget,
+  isRewrite,
+  rewriteNotSupported,
+  type Rewrite,
+} from "../route-definition/rewrite.js";
+import { prefixBasename } from "../router/basename.js";
+import { createReverseFunction } from "../router/handler-context.js";
+import { stripInternalParams } from "../router/internal-params.js";
+import {
+  rebaseRequestContext,
+  type RequestContext,
+} from "../server/request-context.js";
+import { recordRewriteHop } from "../server/rewrite-trail.js";
+
+/** Response header naming the route path a rewritten request rendered. */
+export const REWRITE_HEADER = "x-rango-rewrite";
+
+/**
+ * Resolve a rewrite's target against the router's route map (global names,
+ * no param auto-fill, as middleware `ctx.reverse`) and the request origin.
+ * A path is basename-prefixed like `redirect()` and must stay under the
+ * basename once normalized (`/../admin` cannot step out of it). The
+ * target's own `_rsc*` params are dropped: only the visitor's transport
+ * params carry over. Throws for an unknown name, a missing param, another
+ * origin or a path outside the basename.
+ */
+export function resolveRewriteTarget(
+  rewrite: Rewrite,
+  routeMap: Record<string, string>,
+  base: URL,
+  basename?: string,
+): URL {
+  const { target } = rewrite;
+  const path =
+    "path" in target
+      ? prefixBasename(target.path, basename)
+      : // `{}`, not undefined: a route with params then throws for the
+        // missing ones instead of resolving to its raw pattern.
+        createReverseFunction(routeMap)(
+          target.name,
+          target.params ?? {},
+          target.search,
+        );
+  const resolved = stripInternalParams(new URL(path, base.origin));
+  if (resolved.origin !== base.origin) {
+    throw new TypeError(
+      `${describeRewriteTarget(target)} must name a path in this app, not another origin.`,
+    );
+  }
+  if (
+    basename &&
+    resolved.pathname !== basename &&
+    !resolved.pathname.startsWith(basename + "/")
+  ) {
+    throw new TypeError(
+      `${describeRewriteTarget(target)} resolves to ${resolved.pathname}, outside the router's basename ${basename}.`,
+    );
+  }
+  resolved.hash = "";
+  return resolved;
+}
+
+/**
+ * The raw URL of a rewritten pass: the target's path and search plus the
+ * visitor's internal `_rsc*` transport params, so a navigation stays a
+ * navigation (same segments, version, partial flag).
+ */
+function rewriteTransportUrl(target: URL, visitorRaw: URL): URL {
+  const raw = new URL(target);
+  visitorRaw.searchParams.forEach((value, key) => {
+    if (key.startsWith("_rsc")) raw.searchParams.append(key, value);
+  });
+  return raw;
+}
+
+/** The next pass of a rewritten request. */
+export interface RewritePass {
+  request: Request;
+  /** The pass's raw URL, `_rsc*` params included. */
+  url: URL;
+  /** The target's clean URL. */
+  target: URL;
+  hops: number;
+}
+
+/**
+ * Move the request context to `rewrite`'s target for the next pass: check
+ * that this request can be rewritten, resolve the target, count the hop,
+ * then rebase the context. Throws the site error for a mutation or a loader
+ * fetch, a resolution error, and RewriteLoopError.
+ */
+export function applyRewrite(
+  rewrite: Rewrite,
+  passRequest: Request,
+  reqCtx: RequestContext<any>,
+  routeMap: Record<string, string>,
+  basename: string | undefined,
+): RewritePass {
+  // A loader fetch first: `load()` with a body is a POST, and its refusal
+  // is the loader fetch's.
+  if (reqCtx.originalUrl.searchParams.has("_rsc_loader")) {
+    throw rewriteNotSupported(rewrite, "loader-fetch");
+  }
+  if (passRequest.method !== "GET" && passRequest.method !== "HEAD") {
+    throw rewriteNotSupported(rewrite, "mutation");
+  }
+  const target = resolveRewriteTarget(rewrite, routeMap, reqCtx.url, basename);
+  const hops = recordRewriteHop(reqCtx, reqCtx.url, target);
+  const url = rewriteTransportUrl(target, reqCtx.originalUrl);
+  const request = new Request(url, passRequest);
+  rebaseRequestContext(reqCtx, request, url);
+  return { request, url, target, hops };
+}
+
+/** The response to a rewrite loop. */
+export function loopDetectedResponse(): Response {
+  return new Response("Loop Detected", {
+    status: 508,
+    headers: { "content-type": "text/plain;charset=utf-8" },
+  });
+}
+
+export interface RewritePassesOptions {
+  reqCtx: RequestContext<any>;
+  /** The visitor's request and raw URL: the first pass. */
+  request: Request;
+  url: URL;
+  routeMap: () => Record<string, string>;
+  basename: string | undefined;
+  /** One pass: the global chain matched on `url`'s path around the core handler. */
+  runPass: (request: Request, url: URL) => Promise<Response>;
+  /** After a hop moved the context to its target. */
+  onHop?: (pass: RewritePass) => void;
+  /** Report a rewrite the request cannot take (onError, phase "routing"). */
+  report: (error: unknown, at: { request: Request; url: URL }) => void;
+  /**
+   * The response for a refused rewrite other than a loop (a loader fetch's
+   * error response); undefined rethrows the error.
+   */
+  refuse?: (error: unknown, rewrite: Rewrite) => Response | undefined;
+}
+
+export interface RewritePassesResult {
+  response: Response;
+  /** The pathname the final pass rendered, when a rewrite took the request there. */
+  rewrittenTo?: string;
+}
+
+/**
+ * Run the request pass by pass until one produces a response. A `Rewrite`
+ * that unwinds a pass moves the context to its target and runs the next;
+ * a loop answers 508; a rewrite the request cannot take is reported and
+ * becomes `refuse`'s response, or is thrown.
+ */
+export async function runRewritePasses(
+  opts: RewritePassesOptions,
+): Promise<RewritePassesResult> {
+  let request = opts.request;
+  let url = opts.url;
+  let rewrittenTo: string | undefined;
+  for (;;) {
+    let rewrite: Rewrite;
+    try {
+      return { response: await opts.runPass(request, url), rewrittenTo };
+    } catch (error) {
+      if (!isRewrite(error)) throw error;
+      rewrite = error;
+    }
+    let pass: RewritePass;
+    try {
+      pass = applyRewrite(
+        rewrite,
+        request,
+        opts.reqCtx,
+        opts.routeMap(),
+        opts.basename,
+      );
+    } catch (error) {
+      opts.report(error, { request, url });
+      if (error instanceof RewriteLoopError) {
+        return { response: loopDetectedResponse() };
+      }
+      const refused = opts.refuse?.(error, rewrite);
+      if (refused) return { response: refused };
+      throw error;
+    }
+    request = pass.request;
+    url = pass.url;
+    rewrittenTo = pass.target.pathname;
+    opts.onHop?.(pass);
+  }
+}

package/src/rsc/rsc-rendering.ts

@@ -51,7 +51,7 @@ import {
 import type { HandlerContext } from "./handler-context.js";
 import { attachTransitionWhen } from "./attach-transition-when.js";
 import { publicRouteName } from "../route-name.js";
-import { buildFullPayload } from "./full-payload.js";
+import { buildFullPayload, renderedLocation } from "./full-payload.js";
 import {
   capShellWindow,
   lastStoredCaptureSeq,
@@ -845,7 +845,7 @@ function* preparePayloadPlan<TEnv>(
       kind: "payload",
       payload: {
         metadata: {
-          pathname: url.pathname,
+          pathname: renderedLocation(reqCtx, url).pathname,
           // routerId is serialized on every payload (including within-session
           // ones) so the frontend can read the current app/router identity. It
           // always equals the current app's id: a cross-app navigation is
@@ -1867,6 +1867,8 @@ function serveShellHit(
       payload.metadata.initialTheme = entry.initialTheme as
         | import("../theme/types.js").Theme
         | undefined;
+      // Same for the location: the capture rendered the target's.
+      payload.metadata.pathname = url.pathname;
     }
     // Full Flight render per request: hydration needs the whole payload (there
     // is no Flight-side resume — a React limitation, not ours).

package/src/rsc/ssr-setup.ts

@@ -22,6 +22,7 @@ import {
   RSC_WIRE_MIME,
 } from "../router/content-negotiation.js";
 import { _getRequestContext } from "../server/request-context.js";
+import { renderedLocation } from "./full-payload.js";
 
 export type SSRSetup = readonly [SSRModule, SSRStreamMode];
 
@@ -38,6 +39,8 @@ export const SSR_SETUP_VAR = "__ssrSetup";
  * lazily so stores created after kickoff are still captured). Without a
  * getter the promises run bare — no `.then()` microtasks, no
  * `performance.now()` calls — keeping the non-debug hot path lean.
+ * `ssrModule` reuses a load already started (a rewritten request's earlier
+ * pass).
  */
 export function startSSRSetup<TEnv>(
   ctx: HandlerContext<TEnv>,
@@ -45,16 +48,17 @@ export function startSSRSetup<TEnv>(
   env: TEnv,
   url: URL,
   getMetricsStore?: () => MetricsStore | undefined,
+  ssrModule?: Promise<SSRModule>,
 ): Promise<SSRSetup> {
   if (!getMetricsStore) {
     return Promise.all([
-      ctx.loadSSRModule(),
+      ssrModule ?? ctx.loadSSRModule(),
       ctx.resolveStreamMode(request, env, url),
     ]);
   }
   const start = performance.now();
   return Promise.all([
-    ctx.loadSSRModule().then((mod) => {
+    (ssrModule ?? ctx.loadSSRModule()).then((mod) => {
       appendMetric(
         getMetricsStore(),
         "ssr:module-load",
@@ -110,7 +114,9 @@ export function createSsrHtmlStage<TEnv>(
       options.url,
       options.metricsStore,
     );
-    const renderErrors = _getRequestContext()?._renderErrors;
+    const reqCtx = _getRequestContext();
+    const renderErrors = reqCtx?._renderErrors;
+    const location = renderedLocation(reqCtx, options.url);
     return {
       render: () =>
         // search: the LIVE request's query string, threaded out-of-band into
@@ -121,11 +127,11 @@ export function createSsrHtmlStage<TEnv>(
         ssrModule.renderHTML(flight.stream, {
           ...options.render,
           streamMode,
-          search: options.url.search,
+          search: location.search,
           // origin: same out-of-band channel — seeds the SSR store location
           // so origin-dependent markup (Link's data-external) agrees with the
           // browser's window.location across hydration.
-          origin: options.url.origin,
+          origin: location.origin,
           // A component that throws inside a Suspense boundary leaves an
           // errored boundary in a completed document; the document cache
           // reads the list before storing it.

package/src/server/cookie-parse.ts

@@ -10,23 +10,47 @@
 export function parseCookiesFromHeader(
   cookieHeader: string | null,
 ): Record<string, string> {
-  if (!cookieHeader) return {};
-
   const cookies: Record<string, string> = {};
-  const pairs = cookieHeader.split(";");
 
-  for (const pair of pairs) {
-    const [name, ...rest] = pair.trim().split("=");
-    if (name) {
-      const raw = rest.join("=");
-      try {
-        cookies[name] = decodeURIComponent(raw);
-      } catch {
-        // Malformed percent-encoding: fall back to raw value
-        cookies[name] = raw;
+  if (cookieHeader) {
+    for (const pair of cookieHeader.split(";")) {
+      const [name, ...rest] = pair.trim().split("=");
+      if (name) {
+        const raw = rest.join("=");
+        let value: string;
+        try {
+          value = decodeURIComponent(raw);
+        } catch {
+          // Malformed percent-encoding: fall back to raw value
+          value = raw;
+        }
+        setCookie(cookies, name, value);
       }
     }
   }
 
+  // Null prototype (#1109): cookie names come from the request, so a lookup
+  // must never answer `constructor` or `toString` with an inherited member.
+  // Set once at the end: Object.create(null) starts in dictionary mode, which
+  // makes a spread of the jar several times slower.
+  Object.setPrototypeOf(cookies, null);
   return cookies;
 }
+
+/** `cookies[name] = value`, a cookie named `__proto__` as an own key too. */
+function setCookie(
+  cookies: Record<string, string>,
+  name: string,
+  value: string,
+): void {
+  if (name === "__proto__") {
+    Object.defineProperty(cookies, name, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    });
+  } else {
+    cookies[name] = value;
+  }
+}

package/src/server/cookie-store.ts

@@ -367,12 +367,16 @@ function createCookieStore(
 
     getAll(name?: string): Cookie[] {
       recordLoaderIdentityRead("cookies()");
-      const all = ctx._readCookies();
       if (name !== undefined) {
-        const value = all[name];
+        // The single-name read, not an index into the plain object
+        // _readCookies() returns: that would answer an inherited member.
+        const value = ctx._readCookie(name);
         return value !== undefined ? [{ name, value }] : [];
       }
-      return Object.entries(all).map(([n, v]) => ({ name: n, value: v }));
+      return Object.entries(ctx._readCookies()).map(([n, v]) => ({
+        name: n,
+        value: v,
+      }));
     },
 
     has(name: string): boolean {

package/src/server/handle-store.ts

@@ -5,6 +5,7 @@ import {
 } from "./context.js";
 import { holdsThenable } from "../router/segment-resolution/mask-nested.js";
 import { pushedByKey } from "../handles/pushed-by.js";
+import { defineSlot } from "./slot-accessors.js";
 
 /**
  * Handle data structure: handleName -> segmentId -> entries[]
@@ -394,6 +395,34 @@ export interface HandleStore {
   ): void;
 }
 
+/**
+ * settled and fullySettled: shared descriptors (slot-accessors.ts) that call
+ * the store's closure in SETTLEMENT_SLOT with the lane they wait for.
+ */
+const SETTLEMENT_SLOT: unique symbol = Symbol("rango.handleStore.settlement");
+
+type SettlementSlot = { [SETTLEMENT_SLOT]: (full: boolean) => Promise<void> };
+
+const SETTLEMENT_ACCESSORS: Record<
+  "settled" | "fullySettled",
+  PropertyDescriptor
+> = {
+  settled: {
+    get(this: SettlementSlot): Promise<void> {
+      return this[SETTLEMENT_SLOT](false);
+    },
+    enumerable: true,
+    configurable: true,
+  },
+  fullySettled: {
+    get(this: SettlementSlot): Promise<void> {
+      return this[SETTLEMENT_SLOT](true);
+    },
+    enumerable: true,
+    configurable: true,
+  },
+};
+
 /**
  * Create a new HandleStore instance.
  *
@@ -774,7 +803,9 @@ export function createHandleStore(): HandleStore {
     });
   }
 
-  return {
+  // Data members only: the accessors are SETTLEMENT_ACCESSORS.
+  const store: Omit<HandleStore, "settled" | "fullySettled"> &
+    ThisType<HandleStore> = {
     track<T>(promise: Promise<T>): Promise<T> {
       inflightCount++;
       return trackSettlement(promise, () => {
@@ -793,22 +824,6 @@ export function createHandleStore(): HandleStore {
       sealInternal();
     },
 
-    get settled(): Promise<void> {
-      if (sealed && inflightCount === 0) return Promise.resolve();
-      return new Promise<void>((resolve) => {
-        drainWaiters.push(resolve);
-      });
-    },
-
-    get fullySettled(): Promise<void> {
-      if (sealed && inflightCount === 0 && auxInflightCount === 0) {
-        return Promise.resolve();
-      }
-      return new Promise<void>((resolve) => {
-        fullDrainWaiters.push(resolve);
-      });
-    },
-
     push(
       handleName: string,
       segmentId: string,
@@ -1213,4 +1228,20 @@ export function createHandleStore(): HandleStore {
       signalEmission();
     },
   };
+  // settled: the handler lane drained; fullySettled: the auxiliary lane too.
+  defineSlot(store, SETTLEMENT_SLOT, (full: boolean): Promise<void> => {
+    if (sealed && inflightCount === 0 && (!full || auxInflightCount === 0)) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      (full ? fullDrainWaiters : drainWaiters).push(resolve);
+    });
+  });
+  Object.defineProperty(store, "settled", SETTLEMENT_ACCESSORS.settled);
+  Object.defineProperty(
+    store,
+    "fullySettled",
+    SETTLEMENT_ACCESSORS.fullySettled,
+  );
+  return store as HandleStore;
 }