@rangojs/router 0.0.0-experimental.131 → 0.0.0-experimental.132

package/src/router/loader-resolution.ts

@@ -109,16 +109,40 @@ export function wrapLoaderWithErrorHandling<T>(
         };
       }
 
-      // Render fallback on server
+      // Render fallback on server. The user ErrorBoundaryHandler may throw
+      // synchronously; if it does we must NOT let that rejection escape — the
+      // wrapped LoaderDataResult promise is contracted to never reject (see
+      // segment-resolution/fresh.ts `await Promise.all(...wrapped)`), and a
+      // rejection here would collapse the whole entry and discard healthy
+      // sibling loader data. On a fallback-render throw, fall back to the
+      // no-boundary result (fallback: null) so the client throws the ORIGINAL
+      // error, and the wrapped promise still resolves to a LoaderDataResult.
       let renderedFallback: ReactNode;
-      if (typeof fallback === "function") {
-        // ErrorBoundaryHandler - call with error info
-        const props: ErrorBoundaryFallbackProps = {
+      try {
+        if (typeof fallback === "function") {
+          // ErrorBoundaryHandler - call with error info
+          const props: ErrorBoundaryFallbackProps = {
+            error: errorInfo,
+          };
+          renderedFallback = fallback(props);
+        } else {
+          renderedFallback = fallback;
+        }
+      } catch (fallbackError) {
+        debugLog("loader", "error boundary fallback render threw", {
+          segmentId,
+          message: errorInfo.message,
+          fallbackError:
+            fallbackError instanceof Error
+              ? fallbackError.message
+              : String(fallbackError),
+        });
+        return {
+          __loaderResult: true,
+          ok: false,
           error: errorInfo,
+          fallback: null,
         };
-        renderedFallback = fallback(props);
-      } else {
-        renderedFallback = fallback;
       }
 
       debugLog("loader", "loader error wrapped with boundary fallback", {
@@ -542,18 +566,21 @@ export function setupBuildUse<TEnv>(ctx: HandlerContext<any, TEnv>): void {
         );
       }
 
-      return (
-        dataOrFn: unknown | Promise<unknown> | (() => Promise<unknown>),
-      ) => {
-        if (!store) return;
+      // Wrap with withDefer so ctx.use(Handle).defer(...) works on the build /
+      // prerender path, matching production setupLoaderAccess. Without it a
+      // prerender handler calling .defer() throws "defer is not a function".
+      return withDefer(
+        (dataOrFn: unknown | Promise<unknown> | (() => Promise<unknown>)) => {
+          if (!store) return;
 
-        const valueOrPromise =
-          typeof dataOrFn === "function"
-            ? (dataOrFn as () => Promise<unknown>)()
-            : dataOrFn;
+          const valueOrPromise =
+            typeof dataOrFn === "function"
+              ? (dataOrFn as () => Promise<unknown>)()
+              : dataOrFn;
 
-        store.push(handle.$$id, segmentId, valueOrPromise);
-      };
+          store.push(handle.$$id, segmentId, valueOrPromise);
+        },
+      );
     }
 
     // Loader case: not available during pre-rendering
@@ -581,8 +608,11 @@ export function setupLoaderAccessSilent<TEnv>(
 
   ctx.use = ((item: LoaderDefinition<any, any> | Handle<any, any>) => {
     if (isHandle(item)) {
-      // Silent mode - return a no-op so handle data is not pushed during caching
-      return (_dataOrFn: unknown) => {};
+      // Silent mode - return a no-op so handle data is not pushed during caching.
+      // Wrap with withDefer so ctx.use(Handle).defer(...) still resolves to a
+      // callable resolver (also a no-op here), matching production's push shape
+      // instead of throwing "defer is not a function".
+      return withDefer((_dataOrFn: unknown) => {});
     }
 
     return useLoader(item as LoaderDefinition<any, any>, null);

package/src/router/match-middleware/background-revalidation.ts

@@ -203,6 +203,12 @@ export function withBackgroundRevalidation<TEnv>(
               ctx.matched.params,
               freshHandlerContext,
               true,
+              undefined,
+              // Skip intercept middleware: this is a post-response background
+              // re-render to refresh a stale cached route. The foreground
+              // already ran the middleware; re-running it would double its side
+              // effects and a short-circuit Response would abort the write.
+              { skipMiddleware: true },
             ),
           );
         }

package/src/router/match-middleware/cache-store.ts

@@ -243,6 +243,12 @@ export function withCacheStore<TEnv>(
                   proactiveHandlerContext,
                   true, // belongsToRoute
                   // No revalidationContext = render fresh
+                  undefined,
+                  // Skip intercept middleware: the foreground already ran it
+                  // before the response was sent. Re-running here (post-response,
+                  // background) would fire side effects twice and a short-circuit
+                  // Response would silently abort this cache write.
+                  { skipMiddleware: true },
                 ),
               );
             }

package/src/router/middleware.ts

@@ -1,6 +1,8 @@
 /// <reference types="vite/types/importMeta.d.ts" />
 
 import { contextGet, contextSet } from "../context-var.js";
+import { escapeRegExp } from "../regex-escape.js";
+import { parsePattern as parseRoutePattern } from "./pattern-matching.js";
 import { safeDecodeURIComponent } from "./url-params.js";
 import { fireAndForgetWaitUntil } from "../types/request-scope.js";
 import type {
@@ -48,7 +50,43 @@ function getMiddlewareMetricLabel<TEnv>(
   return `middleware:${scope}#${ordinal + 1}`;
 }
 
-export function parsePattern(pattern: string): {
+/**
+ * Compile a middleware scope pattern to a regex + param names.
+ *
+ * Middleware scopes reuse the route pattern parser (`parsePattern` from
+ * pattern-matching.ts), so they support the same param forms as routes —
+ * optional (`:x?`), constrained (`:x(en|gb)`), and suffix (`:x.html`) — in
+ * addition to the trailing-`*` wildcard middleware relies on. Before this
+ * unification the middleware-side parser handled only static, bare `:param`,
+ * and trailing `*`, so e.g. `router.use("/:locale(en|gb)/*", mw)` silently
+ * named the param "locale(en|gb)" and never enforced the constraint.
+ *
+ * Middleware matching semantics deliberately differ from route matching, so we
+ * emit the regex here rather than route through `compilePattern`:
+ * - `*` alone matches every path (`/^.*$/`).
+ * - A trailing `*` segment is an OPTIONAL subtree match (`(?:/.*)?`): `/admin/*`
+ *   matches `/admin`, `/admin/`, and `/admin/users`. It contributes no param
+ *   name (unlike route wildcards, which capture `*`).
+ * - A NON-trailing `*` is also OPTIONAL (`(?:/.*)?`), matching zero-or-more
+ *   intermediate segments: `/a/<star>/b` matches both `/a/b` and `/a/x/b`. This
+ *   mirrors the pre-unification parser, which compiled every `*` part as
+ *   optional regardless of position.
+ * - A pattern without a trailing `*` tolerates a trailing slash (`/?$`).
+ * - Constraints are baked into the regex as an alternation so `matchMiddleware`
+ *   (a bare `regex.test`) enforces them without extra validation. Constraint
+ *   values are matched against the raw (still URL-encoded) path segment, which
+ *   matches the pre-unification middleware behavior (it never decoded for
+ *   matching); the constraint string is regex-escaped so values like `en.gb`
+ *   are treated literally.
+ *
+ * The route segment parser only recognizes `/`-prefixed segments, but the
+ * pre-unification middleware parser split on `/` and dropped empty parts, so a
+ * leading slash was irrelevant: `use("admin/*")` and `use("/admin/*")` scoped
+ * identically. Normalize a non-`*` pattern to have a leading slash before
+ * parsing so that behavior is preserved (without it, `parseRoutePattern("admin/*")`
+ * drops the static `admin` and the scope explodes to every path).
+ */
+export function compileMiddlewarePattern(pattern: string): {
   regex: RegExp;
   paramNames: string[];
 } {
@@ -56,45 +94,47 @@ export function parsePattern(pattern: string): {
     return { regex: /^.*$/, paramNames: [] };
   }
 
+  const normalizedPattern = pattern.startsWith("/") ? pattern : `/${pattern}`;
+  const segments = parseRoutePattern(normalizedPattern);
   const paramNames: string[] = [];
   let regexStr = "^";
+  let hasTrailingWildcard = false;
 
-  const parts = pattern.split("/").filter(Boolean);
-
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
 
-    if (part === "*") {
-      // Wildcard - match rest of path
+    if (segment.type === "wildcard") {
+      // Optional subtree match (parity with the original middleware parser,
+      // which compiled every `*` as `(?:/.*)?`). A trailing `*` matches the
+      // subtree; a non-trailing `*` matches zero-or-more intermediate segments,
+      // so `/a/<star>/b` still matches `/a/b`.
       regexStr += "(?:/.*)?";
-    } else if (part.startsWith(":")) {
-      // Param
-      const paramName = part.slice(1);
-      paramNames.push(paramName);
-      regexStr += "/([^/]+)";
+      if (i === segments.length - 1) {
+        hasTrailingWildcard = true;
+      }
+    } else if (segment.type === "param") {
+      paramNames.push(segment.value);
+      const suffixPattern = segment.suffix ? escapeRegExp(segment.suffix) : "";
+      const valuePattern = segment.constraint
+        ? `(${segment.constraint.map(escapeRegExp).join("|")})`
+        : "([^/]+)";
+      if (segment.optional) {
+        regexStr += `(?:/${valuePattern}${suffixPattern})?`;
+      } else {
+        regexStr += `/${valuePattern}${suffixPattern}`;
+      }
     } else {
-      // Literal
-      regexStr += "/" + escapeRegex(part);
+      // Static literal
+      regexStr += "/" + escapeRegExp(segment.value);
     }
   }
 
-  // If pattern doesn't end with *, match exact or with trailing segments
-  if (!pattern.endsWith("*")) {
-    regexStr += "/?$";
-  } else {
-    regexStr += "$";
-  }
+  // Without a trailing `*`, match exactly with an optional trailing slash.
+  regexStr += hasTrailingWildcard ? "$" : "/?$";
 
   return { regex: new RegExp(regexStr), paramNames };
 }
 
-/**
- * Escape special regex characters
- */
-function escapeRegex(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 /**
  * Extract params from a pathname using a pattern's regex and param names.
  *

package/src/router/pattern-matching.ts

@@ -7,6 +7,7 @@
 import type { RouteEntry, TrailingSlashMode } from "../types";
 import type { EntryData } from "../server/context";
 import { debugLog, isRouterDebugEnabled } from "./logging.js";
+import { escapeRegExp } from "../regex-escape.js";
 import { safeDecodeURIComponent } from "./url-params.js";
 
 /**
@@ -151,7 +152,7 @@ export function compilePattern(pattern: string): CompiledPattern {
       regexPattern += "/(.*)";
     } else if (segment.type === "param") {
       paramNames.push(segment.value);
-      const suffixPattern = segment.suffix ? escapeRegex(segment.suffix) : "";
+      const suffixPattern = segment.suffix ? escapeRegExp(segment.suffix) : "";
       // Constrained params capture anything here; the allowed values are
       // checked post-decode in findMatch so URL-encoded constraint values
       // (e.g. `:lang(en GB)` via `/en%20GB`) still match.
@@ -169,7 +170,7 @@ export function compilePattern(pattern: string): CompiledPattern {
       }
     } else {
       // Static segment
-      regexPattern += `/${escapeRegex(segment.value)}`;
+      regexPattern += `/${escapeRegExp(segment.value)}`;
     }
   }
 
@@ -229,13 +230,6 @@ function satisfiesConstraints(
   return true;
 }
 
-/**
- * Escape special regex characters in a string
- */
-function escapeRegex(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 /**
  * Build the named-params record from a regex match. Optional segments that
  * didn't capture leave the corresponding group `undefined`; we skip those

package/src/router/revalidation.ts

@@ -231,29 +231,71 @@ export async function evaluateRevalidation<TEnv>(
       : undefined;
 
   for (const { name, fn } of revalidations) {
-    const result = fn({
-      currentParams: prevSegment?.params || prevParams, // Use segment params if available, else route params
-      currentUrl: prevUrl,
-      nextParams,
-      nextUrl,
-      defaultShouldRevalidate: currentSuggestion,
-      context,
-      // Segment metadata (which segment is being evaluated)
-      segmentType: segment.type,
-      layoutName: segment.layoutName,
-      slotName: segment.slot,
-      // Action context (only populated when triggered by server action)
-      actionId: actionContext?.actionId,
-      isAction: makeIsAction(actionContext?.actionId),
-      actionUrl: actionContext?.actionUrl,
-      actionResult: actionContext?.actionResult,
-      formData: actionContext?.formData,
-      method: request.method,
-      routeName: toRouteName,
-      fromRouteName,
-      toRouteName,
-      stale,
-    });
+    let result: any;
+    try {
+      result = fn({
+        currentParams: prevSegment?.params || prevParams, // Use segment params if available, else route params
+        currentUrl: prevUrl,
+        nextParams,
+        nextUrl,
+        defaultShouldRevalidate: currentSuggestion,
+        context,
+        // Segment metadata (which segment is being evaluated)
+        segmentType: segment.type,
+        layoutName: segment.layoutName,
+        slotName: segment.slot,
+        // Action context (only populated when triggered by server action)
+        actionId: actionContext?.actionId,
+        isAction: makeIsAction(actionContext?.actionId),
+        actionUrl: actionContext?.actionUrl,
+        actionResult: actionContext?.actionResult,
+        formData: actionContext?.formData,
+        method: request.method,
+        routeName: toRouteName,
+        fromRouteName,
+        toRouteName,
+        stale,
+      });
+    } catch (error) {
+      // A thrown Response is control flow (e.g. `throw redirect(...)`), not a
+      // failure: re-throw it so the handler chokepoint (match-handlers.ts)
+      // turns it into the intended redirect/response. This mirrors how that
+      // catch special-cases `error instanceof Response`.
+      if (error instanceof Response) throw error;
+      // Fail open for genuine errors: a buggy user revalidate fn must not
+      // collapse the whole entry's loader batch into a failed partial render.
+      // Mirror the dynamic-tags fail-open in cache/cache-policy.ts: log and
+      // defer to the current default decision, leaving currentSuggestion
+      // unchanged. TODO: route through callOnError(phase "revalidation") once
+      // evaluateRevalidation is given the onError seam (today the error only
+      // reaches onError via the entry-collapse path in match-handlers.ts).
+      console.error(
+        `[revalidate] "${name}" threw for segment "${segment.id}"; using default decision:`,
+        error,
+      );
+      continue;
+    }
+
+    // The revalidate fn contract (handler-context.ts) is SYNCHRONOUS: it must
+    // return a boolean, a { defaultShouldRevalidate } object, or null/undefined.
+    // A Promise-returning (async) fn matches none of the decision branches below
+    // and silently falls through keeping the current default — a hard-to-find
+    // misuse. We do NOT await it (that would change the sync contract); instead
+    // we surface it as a dev-mode warning so the silent drop is diagnosable.
+    // Mirrors defer.ts: gated to dev, stripped from production builds.
+    if (
+      process.env.NODE_ENV !== "production" &&
+      result != null &&
+      typeof (result as { then?: unknown }).then === "function"
+    ) {
+      console.warn(
+        `[rango] revalidate fn "${name}" returned a Promise; revalidate ` +
+          `functions must be synchronous (return a boolean, ` +
+          `{ defaultShouldRevalidate }, or null/undefined). The async result ` +
+          `was IGNORED and the default (${currentSuggestion}) was kept. ` +
+          `Move async work into a loader instead.`,
+      );
+    }
 
     if (typeof result === "boolean") {
       debugLog("revalidation", "hard decision", {

package/src/router/router-context.ts

@@ -154,6 +154,7 @@ export interface RouterContext<TEnv = any> {
     handlerContext: HandlerContext<any, TEnv>,
     belongsToRoute: boolean,
     revalidationContext?: RevalidationContext,
+    options?: { skipMiddleware?: boolean },
   ) => Promise<ResolvedSegment[]>;
 
   collectWithMarkers?: <T>(

package/src/router/router-options.ts

@@ -579,9 +579,9 @@ export interface RangoOptions<TEnv = any> {
    * start/end/error, loader start/end/error, handler errors, cache decisions,
    * revalidation decisions, timeouts, origin rejections.
    *
-   * This is the EVENT surface. Phase-duration SPANS (request/loader/render/ssr
-   * timing wired into a tracing backend) come from the separate `tracing`
-   * option below — a sink does not emit them, because async-context nesting
+   * This is the EVENT surface. Phase-duration SPANS (request/middleware/action/
+   * handler/loader/render/ssr timing wired into a tracing backend) come from the
+   * separate `tracing` option below — a sink does not emit them, because async-context nesting
    * cannot be faithfully reconstructed from after-the-fact start/end events.
    *
    * No-op when not configured (zero overhead).

package/src/router/segment-resolution/loader-cache.ts

@@ -175,6 +175,19 @@ export function resolveLoaderData<TEnv>(
   }
   const runMiss = internal._loaderCacheOriginalUse!;
 
+  // Dedup the cache read-through across repeated resolutions of the SAME
+  // loaderId in one request. An orphan layout with parallel slots inherits its
+  // parent route's loaders, so resolveOrphanLayout (fresh.ts) re-resolves the
+  // parent's loaders under a different shortCode — calling resolveLoaderData
+  // again for the same loaderId. The cache key (loader:{loaderId}:{host}
+  // {pathname}:{sortedParams}) does not include the shortCode and ctx/params
+  // are identical, so both resolutions produce the same data. Reuse the already
+  // in-flight dataPromise instead of issuing a second getItem/setItem (e.g. a
+  // second KV round-trip) for one logical cached loader. The shortCode only
+  // affects the emitted segmentId in resolveLoaders, not the cached value.
+  const existing = overrides.get(loaderId);
+  if (existing) return existing;
+
   const dataPromise = (async () => {
     const codec = await getCodec();
     const key = await resolveLoaderKey(

package/src/router/segment-wrappers.ts

@@ -94,6 +94,7 @@ export interface SegmentWrappers<TEnv = any> {
     context: HandlerContext<any, TEnv>,
     belongsToRoute?: boolean,
     revalidationContext?: any,
+    options?: { skipMiddleware?: boolean },
   ) => Promise<ResolvedSegment[]>;
   resolveInterceptLoadersOnly: (
     interceptEntry: InterceptEntry,
@@ -245,6 +246,7 @@ export function createSegmentWrappers<TEnv = any>(
     context: HandlerContext<any, TEnv>,
     belongsToRoute: boolean = true,
     revalidationContext?: any,
+    options?: { skipMiddleware?: boolean },
   ): ReturnType<typeof _resolveInterceptEntry> {
     return _resolveInterceptEntry(
       interceptEntry,
@@ -254,6 +256,7 @@ export function createSegmentWrappers<TEnv = any>(
       belongsToRoute,
       segmentDeps,
       revalidationContext,
+      options,
     );
   }
 

package/src/router/trie-matching.ts

@@ -81,6 +81,7 @@ export function tryTrieMatch(
       result.wildcardValue,
       pathname,
       pathnameHasTrailingSlash,
+      result.validatedParams,
     );
   }
 
@@ -91,6 +92,14 @@ interface WalkResult {
   leaf: TrieLeaf;
   paramValues: string[];
   wildcardValue?: string;
+  /**
+   * For a constraint-bearing leaf (leaf.cv set), the params map that
+   * leafConstraintsPass already decoded AND validated during the walk. Carried
+   * forward so validateAndBuild reuses it instead of re-decoding paramValues and
+   * re-running constraintsSatisfied a second time on the winning leaf. Undefined
+   * for unconstrained leaves (no decode/validate happened in the walk).
+   */
+  validatedParams?: Record<string, string>;
 }
 
 /**
@@ -115,17 +124,23 @@ function constraintsSatisfied(
 /**
  * Constraint check for a candidate terminal DURING the walk. Builds the named
  * params from positional walk values (decoded the same way validateAndBuild
- * does) and validates leaf.cv. Returning false lets walkTrie unwind to a
+ * does) and validates leaf.cv. Returning null lets walkTrie unwind to a
  * lower-priority sibling instead of committing to a leaf that would only be
  * rejected post-walk — that post-walk rejection is what forced the regex
  * fallback (and its false "trie gap" R3 warning) for perfectly valid configs.
+ *
+ * On success returns the built+validated params for a constraint-bearing leaf so
+ * walkTrie can carry them to validateAndBuild (avoiding a second decode + a
+ * second constraintsSatisfied pass on the winner); returns the shared EMPTY_PASS
+ * sentinel for an unconstrained leaf (no work was done, nothing to carry).
  */
+const EMPTY_PASS: Record<string, string> = {};
 function leafConstraintsPass(
   leaf: TrieLeaf,
   paramValues: string[],
   wildcardValue: string | undefined,
-): boolean {
-  if (!leaf.cv) return true;
+): Record<string, string> | null {
+  if (!leaf.cv) return EMPTY_PASS;
   const params: Record<string, string> = {};
   if (leaf.pa) {
     for (let i = 0; i < leaf.pa.length && i < paramValues.length; i++) {
@@ -136,7 +151,7 @@ function leafConstraintsPass(
     params[(leaf as TrieLeaf & { pn: string }).pn] =
       safeDecodeURIComponent(wildcardValue);
   }
-  return constraintsSatisfied(leaf, params);
+  return constraintsSatisfied(leaf, params) ? params : null;
 }
 
 /**
@@ -154,8 +169,19 @@ function walkTrie(
   paramValues: string[],
 ): WalkResult | null {
   if (index === segments.length) {
-    if (node.r && leafConstraintsPass(node.r, paramValues, undefined)) {
-      return { leaf: node.r, paramValues: [...paramValues] };
+    if (node.r) {
+      const validatedParams = leafConstraintsPass(
+        node.r,
+        paramValues,
+        undefined,
+      );
+      if (validatedParams) {
+        return {
+          leaf: node.r,
+          paramValues: [...paramValues],
+          validatedParams,
+        };
+      }
     }
     // A wildcard at this node matches the bare prefix with an empty remainder
     // (e.g. "/files" against "/files/*"), mirroring the regex matcher's `*=""`.
@@ -163,8 +189,16 @@ function walkTrie(
     // so without this a request to the wildcard's own prefix misses the trie
     // and the regex fallback emits a corrupt redirect. A static terminal
     // (node.r) still wins.
-    if (node.w && leafConstraintsPass(node.w, paramValues, "")) {
-      return { leaf: node.w, paramValues: [...paramValues], wildcardValue: "" };
+    if (node.w) {
+      const validatedParams = leafConstraintsPass(node.w, paramValues, "");
+      if (validatedParams) {
+        return {
+          leaf: node.w,
+          paramValues: [...paramValues],
+          wildcardValue: "",
+          validatedParams,
+        };
+      }
     }
     return null;
   }
@@ -206,11 +240,13 @@ function walkTrie(
 
   if (node.w) {
     const rest = joinRemainingSegments(segments, index);
-    if (leafConstraintsPass(node.w, paramValues, rest)) {
+    const validatedParams = leafConstraintsPass(node.w, paramValues, rest);
+    if (validatedParams) {
       return {
         leaf: node.w,
         paramValues: [...paramValues],
         wildcardValue: rest,
+        validatedParams,
       };
     }
   }
@@ -230,6 +266,15 @@ function joinRemainingSegments(segments: string[], start: number): string {
 
 /**
  * Post-match: validate constraints and handle trailing slash logic.
+ *
+ * `validatedParams` is the params map walkTrie already decoded AND validated via
+ * leafConstraintsPass for a constraint-bearing winning leaf. When present (and
+ * non-empty) we reuse it verbatim and SKIP the second decode + the second
+ * constraintsSatisfied pass — both are byte-identical to the walk-time work.
+ * When absent (unconstrained leaf, or the root-path call sites that never walk)
+ * we still BUILD the params here (that is not redundant — they must be returned)
+ * and run constraintsSatisfied for safety; an unconstrained leaf's check is a
+ * cheap early `!leaf.cv` return.
  */
 function validateAndBuild(
   leaf: TrieLeaf,
@@ -237,21 +282,30 @@ function validateAndBuild(
   wildcardValue: string | undefined,
   originalPathname: string,
   pathnameHasTrailingSlash: boolean,
+  validatedParams?: Record<string, string>,
 ): TrieMatchResult | null {
-  const params: Record<string, string> = {};
-  if (leaf.pa) {
-    for (let i = 0; i < leaf.pa.length && i < paramValues.length; i++) {
-      params[leaf.pa[i]] = safeDecodeURIComponent(paramValues[i]);
+  let params: Record<string, string>;
+  // EMPTY_PASS (the unconstrained sentinel) and undefined both mean "nothing was
+  // pre-validated"; only a populated map carried from a constraint-bearing leaf
+  // lets us skip the rebuild + re-check.
+  if (validatedParams && validatedParams !== EMPTY_PASS) {
+    params = validatedParams;
+  } else {
+    params = {};
+    if (leaf.pa) {
+      for (let i = 0; i < leaf.pa.length && i < paramValues.length; i++) {
+        params[leaf.pa[i]] = safeDecodeURIComponent(paramValues[i]);
+      }
     }
-  }
 
-  if (wildcardValue !== undefined && "pn" in leaf) {
-    params[(leaf as TrieLeaf & { pn: string }).pn] =
-      safeDecodeURIComponent(wildcardValue);
-  }
+    if (wildcardValue !== undefined && "pn" in leaf) {
+      params[(leaf as TrieLeaf & { pn: string }).pn] =
+        safeDecodeURIComponent(wildcardValue);
+    }
 
-  if (!constraintsSatisfied(leaf, params)) {
-    return null;
+    if (!constraintsSatisfied(leaf, params)) {
+      return null;
+    }
   }
 
   const tsMode = leaf.ts as "never" | "always" | "ignore" | undefined;

package/src/router.ts

@@ -63,7 +63,7 @@ import {
 import { loadManifest } from "./router/manifest.js";
 import { createMetricsStore } from "./router/metrics.js";
 import {
-  parsePattern,
+  compileMiddlewarePattern,
   type MiddlewareEntry,
   type MiddlewareFn,
 } from "./router/middleware.js";
@@ -347,7 +347,7 @@ export function createRouter<TEnv = any>(
     let regex: RegExp | null = null;
     let paramNames: string[] = [];
     if (fullPattern) {
-      const parsed = parsePattern(fullPattern);
+      const parsed = compileMiddlewarePattern(fullPattern);
       regex = parsed.regex;
       paramNames = parsed.paramNames;
     }