@rangojs/router 0.0.0-experimental.tapabs3 → 0.1.1

package/src/rsc/helpers.ts

@@ -10,11 +10,15 @@ import {
 } from "../server/request-context.js";
 import type { RequestContext } from "../server/request-context.js";
 import { resolveLocationStateEntries } from "../browser/react/location-state-shared.js";
-import { isRedirectResponse } from "../response-utils.js";
+import {
+  isRedirectResponse,
+  isWebSocketUpgradeResponse,
+} from "../response-utils.js";
 import {
   EXTERNAL_REDIRECT_MARKER,
   isExternalRedirect,
   markExternalRedirect,
+  resolveSoftRedirectUrl,
 } from "../redirect-origin.js";
 import type { MiddlewareEntry, MiddlewareFn } from "../router/middleware.js";
 import { formatCacheSignalHeader } from "../router/telemetry.js";
@@ -84,6 +88,14 @@ export function drainOnResponseCallbacks(
   // Response object identity). Preserve a redirect(url, { external: true })
   // opt-in across that rebuild so a callback can't silently neutralize the
   // off-host redirect at the guard chokepoint.
+  return applyOnResponseCallbacks(callbacks, response);
+}
+
+/** Apply a saved callback batch while preserving an external-redirect brand. */
+export function applyOnResponseCallbacks(
+  callbacks: Array<(response: Response) => Response>,
+  response: Response,
+): Response {
   const wasExternal = isExternalRedirect(response);
   let result = response;
   for (const callback of callbacks) {
@@ -143,17 +155,63 @@ export function createResponseWithMergedHeaders(
   return drainOnResponseCallbacks(ctx, response);
 }
 
+/**
+ * Rebuild a Response returned or thrown by a response-route handler so request
+ * effects merge consistently in production and the public dispatch primitive.
+ */
+export function rewrapResponseRouteResponse(result: Response): Response {
+  if (isWebSocketUpgradeResponse(result)) {
+    return mergeStubHeadersAndFinalize(result);
+  }
+  const headers = new Headers();
+  result.headers.forEach((value, key) => {
+    if (key.toLowerCase() === EXTERNAL_REDIRECT_MARKER) return;
+    if (key.toLowerCase() === "set-cookie") {
+      headers.append(key, value);
+    } else {
+      headers.set(key, value);
+    }
+  });
+  const rewrapped = createResponseWithMergedHeaders(result.body, {
+    status: result.status,
+    headers,
+  });
+  if (isExternalRedirect(result)) {
+    markExternalRedirect(rewrapped);
+  }
+  return rewrapped;
+}
+
+/** Origin/basename needed to resolve soft redirect targets server-side. */
+export type SoftRedirectResolveOpts = {
+  requestOrigin: string;
+  basename?: string;
+};
+
 /**
  * Create a 204 response with X-RSC-Redirect header for stateless redirects.
  * Used during partial/action requests where fetch would auto-follow a raw
  * 3xx to a URL that renders full HTML instead of Flight data. The 204 status
  * prevents auto-follow; the client reads the header and re-navigates via
  * the router.
+ *
+ * The header value is resolved with {@link resolveSoftRedirectUrl} so a
+ * cross-origin / unsafe-scheme target is neutralized before it leaves the
+ * server (defense-in-depth; client validators still run).
  */
-export function createSimpleRedirectResponse(redirectUrl: string): Response {
+export function createSimpleRedirectResponse(
+  redirectUrl: string,
+  opts: SoftRedirectResolveOpts & { external?: boolean },
+): Response {
+  const resolved = resolveSoftRedirectUrl(
+    redirectUrl,
+    opts.requestOrigin,
+    opts.basename,
+    opts.external,
+  );
   return createResponseWithMergedHeaders(null, {
     status: 204,
-    headers: { "X-RSC-Redirect": redirectUrl },
+    headers: { "X-RSC-Redirect": resolved },
   });
 }
 
@@ -198,6 +256,10 @@ export function carryOverRedirectHeaders(
  * intercept it and return a Flight-compatible redirect instead.
  * fetch() auto-follows 3xx which would hit a URL that renders full HTML
  * the client can't parse. Returns null if the response is not a redirect.
+ *
+ * Soft redirect targets are resolved server-side (same-origin / external
+ * scheme rules) via `opts` before they are written into X-RSC-Redirect or
+ * handed to the Flight factory.
  */
 export function interceptRedirectForPartial(
   response: Response,
@@ -206,6 +268,7 @@ export function interceptRedirectForPartial(
     locationState?: Record<string, unknown>,
     external?: boolean,
   ) => Response,
+  opts: SoftRedirectResolveOpts,
 ): Response | null {
   if (!isRedirectResponse(response)) {
     return null;
@@ -228,7 +291,7 @@ export function interceptRedirectForPartial(
   } else if (external) {
     intercepted = createRedirectFlightResponse(redirectUrl, undefined, true);
   } else {
-    intercepted = createSimpleRedirectResponse(redirectUrl);
+    intercepted = createSimpleRedirectResponse(redirectUrl, opts);
   }
 
   carryOverRedirectHeaders(response, intercepted);

package/src/rsc/loader-fetch.ts

@@ -209,7 +209,7 @@ export async function handleLoaderFetch<TEnv>(
           const cleanUrl = stripInternalParams(url);
           const cleanSearchParams = cleanUrl.searchParams;
           const searchSchema = reqCtx._routeName
-            ? getSearchSchema(reqCtx._routeName)
+            ? getSearchSchema(reqCtx._routeName, reqCtx._routerId)
             : undefined;
           const loaderCtx: any = {
             ...reqCtx,
@@ -228,7 +228,7 @@ export async function handleLoaderFetch<TEnv>(
               reqCtx._routeName,
               mergedParams,
               reqCtx._routeName
-                ? isRouteRootScoped(reqCtx._routeName)
+                ? isRouteRootScoped(reqCtx._routeName, reqCtx._routerId)
                 : undefined,
             ),
             ...(loaderFormData ? { formData: loaderFormData } : {}),

package/src/rsc/manifest-init.ts

@@ -9,8 +9,6 @@ import {
   getGlobalRouteMap,
   hasCachedManifest,
   setCachedManifest,
-  getRouteTrie,
-  setRouteTrie,
   setRouterManifest,
   setRouterTrie,
   setRouterPrecomputedEntries,
@@ -32,11 +30,10 @@ export async function buildRouterTrieFromUrlpatterns(
 ): Promise<void> {
   const { generateManifestFull } =
     await import("../build/generate-manifest.js");
-  const generated = await generateManifestFull(
-    router.urlpatterns,
-    undefined,
-    router.basename ? { urlPrefix: router.basename } : undefined,
-  );
+  const generated = await generateManifestFull(router.urlpatterns, undefined, {
+    routerId: router.id,
+    ...(router.basename ? { urlPrefix: router.basename } : {}),
+  });
   // Build the trie through the SAME shared helper the production discovery uses
   // (discover-routers.ts), so the dev runtime-rebuilt trie and the prod
   // serialized trie cannot drift. buildPerRouterTrie returns null when there
@@ -45,10 +42,6 @@ export async function buildRouterTrieFromUrlpatterns(
   const trie = buildPerRouterTrie(generated);
   if (trie) {
     setRouterTrie(router.id, trie);
-    // Set global trie only if not already set by another router
-    if (!getRouteTrie()) {
-      setRouteTrie(trie);
-    }
   }
   setRouterManifest(router.id, generated.routeManifest);
 

package/src/rsc/progressive-enhancement.ts

@@ -10,7 +10,7 @@ import {
   getRequestContext,
   setRequestContextParams,
 } from "../server/request-context.js";
-import { getSSRSetup } from "./ssr-setup.js";
+import { createSsrHtmlStage } from "./ssr-setup.js";
 import type { MiddlewareFn } from "../router/middleware.js";
 import { executeMiddleware } from "../router/middleware.js";
 import { observePhase, PHASES } from "../router/instrument.js";
@@ -22,6 +22,7 @@ import {
   finalizeResponse,
   buildRouteMiddlewareEntries,
 } from "./helpers.js";
+import { renderRscResponse } from "./render-pipeline.js";
 import type { HandlerContext } from "./handler-context.js";
 import {
   extractRedirectResponse,
@@ -327,39 +328,44 @@ export async function handleProgressiveEnhancement<TEnv>(
       },
     };
 
-    const rscStream = ctx.renderToReadableStream<RscPayload>(payload, {
-      onError: (error: unknown) => {
-        ctx.callOnError(error, "rendering", { request, url, env });
+    const stageTracking = {
+      mode: "progressive-enhancement" as const,
+      routeKey: getRequestContext()._routeName,
+      actionId: directActionId ?? undefined,
+    };
+    return renderRscResponse(
+      {
+        ctx,
+        request,
+        env,
+        url,
+        payload,
+        init: {
+          // boundarylessErrorStatus is set only when the action threw and no error
+          // boundary matched; it makes the re-render carry 500 like the JS path.
+          // The redirect branch above returns before this, so a redirect re-render
+          // keeps its 308 and is never overridden.
+          ...(boundarylessErrorStatus !== undefined
+            ? { status: boundarylessErrorStatus }
+            : {}),
+          headers: { "content-type": "text/html;charset=utf-8" },
+        },
+        tracking: stageTracking,
+      },
+      {
+        // metricsStore=undefined is safe: the handler already stashed the early
+        // SSR setup promise, so this reuses it instead of starting setup again.
+        // reactFormState travels through the SSR option, not RscPayload.
+        html: createSsrHtmlStage({
+          ctx,
+          request,
+          env,
+          url,
+          metricsStore: undefined,
+          render: { formState: reactFormState, nonce },
+        }),
       },
-    });
-    // metricsStore=undefined is safe: the handler already stashed the early
-    // SSR setup promise on request variables, so getSSRSetup returns it
-    // without falling back to a fresh startSSRSetup.
-    const [ssrModule, streamMode] = await getSSRSetup(
-      ctx,
-      request,
-      env,
-      url,
-      undefined,
     );
-    // reactFormState carries the useActionState payload via the SSR-option path
-    // (renderToReadableStream({ formState })); it does NOT travel on RscPayload.
-    const htmlStream = await ssrModule.renderHTML(rscStream, {
-      formState: reactFormState,
-      nonce,
-      streamMode,
-    });
-
-    return createResponseWithMergedHeaders(htmlStream, {
-      // boundarylessErrorStatus is set only when the action threw and no error
-      // boundary matched; it makes the re-render carry 500 like the JS path.
-      // The redirect branch above returns before this, so a redirect re-render
-      // keeps its 308 and is never overridden.
-      ...(boundarylessErrorStatus !== undefined
-        ? { status: boundarylessErrorStatus }
-        : {}),
-      headers: { "content-type": "text/html;charset=utf-8" },
-    });
   };
 
   // Execute route middleware wrapping the render, if any.
@@ -475,28 +481,34 @@ async function renderPeErrorBoundary<TEnv>(
     },
   };
 
-  const rscStream = ctx.renderToReadableStream<RscPayload>(payload, {
-    onError: (error: unknown) => {
-      ctx.callOnError(error, "rendering", { request, url, env });
+  const stageTracking = {
+    mode: "progressive-enhancement-error" as const,
+    routeKey: getRequestContext()._routeName,
+    actionId: actionId ?? undefined,
+  };
+  return renderRscResponse(
+    {
+      ctx,
+      request,
+      env,
+      url,
+      payload,
+      init: {
+        status: 500,
+        headers: { "content-type": "text/html;charset=utf-8" },
+      },
+      tracking: stageTracking,
+    },
+    {
+      // Reuse the early setup promise; the driver times only renderHTML.
+      html: createSsrHtmlStage({
+        ctx,
+        request,
+        env,
+        url,
+        metricsStore: undefined,
+        render: { nonce },
+      }),
     },
-  });
-  // metricsStore=undefined is safe: the handler already stashed the early
-  // SSR setup promise on request variables, so getSSRSetup returns it
-  // without falling back to a fresh startSSRSetup.
-  const [ssrModule, streamMode] = await getSSRSetup(
-    ctx,
-    request,
-    env,
-    url,
-    undefined,
   );
-  const htmlStream = await ssrModule.renderHTML(rscStream, {
-    nonce,
-    streamMode,
-  });
-
-  return createResponseWithMergedHeaders(htmlStream, {
-    status: 500,
-    headers: { "content-type": "text/html;charset=utf-8" },
-  });
 }

package/src/rsc/redirect-guard.ts

@@ -14,7 +14,9 @@
  *
  * Soft (SPA/Flight) redirects are 200/204 responses (`X-RSC-Redirect` header or
  * `metadata.redirect` payload) and are NOT redirect Responses, so they never
- * reach this guard -- they stay validated client-side.
+ * reach this guard. They are resolved at construction time via
+ * `resolveSoftRedirectUrl` (same shared rules) so unsafe targets never leave
+ * the server; client validators remain defense-in-depth.
  *
  * Behavior on a `Location` header:
  * - same-origin / relative  -> passes through unchanged