@rangojs/router 0.0.0-experimental.e9c0b2f2 → 0.0.0-experimental.ea9f40f2

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

@@ -101,7 +101,10 @@
  *   - Non-GET request (only GET requests are cacheable)
  */
 import type { ResolvedSegment } from "../../types.js";
-import { getRequestContext } from "../../server/request-context.js";
+import {
+  getRequestContext,
+  runWithRequestContext,
+} from "../../server/request-context.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
 import { getRouterContext } from "../router-context.js";
 import { debugLog, debugWarn, getOrCreateRequestId } from "../logging.js";
@@ -231,34 +234,46 @@ export function withCacheStore<TEnv>(
             setupLoaderAccess(proactiveHandlerContext, proactiveLoaderPromises);
 
             const Store = ctx.Store;
-            const freshSegments = await Store.run(() =>
-              resolveAllSegments(
-                ctx.entries,
-                ctx.routeKey,
-                ctx.matched.params,
-                proactiveHandlerContext,
-                proactiveLoaderPromises,
-                { skipLoaders: true },
+            // Re-establish the request-context ALS around the re-render. Store
+            // is a different ALS (DSL build context); on workerd a waitUntil
+            // task runs detached from the request's I/O context, so a handler/
+            // component that reads the ambient getRequestContext() during this
+            // background re-render would otherwise throw "called outside of a
+            // request context".
+            const freshSegments = await runWithRequestContext(requestCtx, () =>
+              Store.run(() =>
+                resolveAllSegments(
+                  ctx.entries,
+                  ctx.routeKey,
+                  ctx.matched.params,
+                  proactiveHandlerContext,
+                  proactiveLoaderPromises,
+                  { skipLoaders: true },
+                ),
               ),
             );
 
             let freshInterceptSegments: ResolvedSegment[] = [];
             if (ctx.interceptResult) {
-              freshInterceptSegments = await Store.run(() =>
-                resolveInterceptEntry(
-                  ctx.interceptResult!.intercept,
-                  ctx.interceptResult!.entry,
-                  ctx.matched.params,
-                  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 },
-                ),
+              freshInterceptSegments = await runWithRequestContext(
+                requestCtx,
+                () =>
+                  Store.run(() =>
+                    resolveInterceptEntry(
+                      ctx.interceptResult!.intercept,
+                      ctx.interceptResult!.entry,
+                      ctx.matched.params,
+                      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 write.
+                      { skipMiddleware: true },
+                    ),
+                  ),
               );
             }
 

package/src/router/match-result.ts

@@ -201,17 +201,23 @@ export function buildMatchResult<TEnv>(
 
   let allIds: string[];
   let segmentsToRender: ResolvedSegment[];
+  let resolvedIds: string[];
 
   if (ctx.isFullMatch) {
+    // One pass over allSegments: dedup by id (segmentsToRender + allIds) while
+    // collecting every id for resolvedIds, which keeps duplicates unlike allIds.
     const seen = new Set<string>();
     segmentsToRender = [];
+    allIds = [];
+    resolvedIds = [];
     for (const s of allSegments) {
+      resolvedIds.push(s.id);
       if (!seen.has(s.id)) {
         seen.add(s.id);
         segmentsToRender.push(s);
+        allIds.push(s.id);
       }
     }
-    allIds = segmentsToRender.map((s) => s.id);
   } else {
     allIds = ctx.interceptResult
       ? ctx.clientSegmentIds.length > 0
@@ -221,11 +227,21 @@ export function buildMatchResult<TEnv>(
 
     allIds = [...new Set(allIds)];
 
+    // One pass over allSegments: keep renderable segments and collect the
+    // handler-ran ids (resolvedIds) together.
     const clientIdSet = new Set(ctx.clientSegmentIds);
-    segmentsToRender = allSegments.filter(
-      (s) =>
-        s.component !== null || s.type === "loader" || !clientIdSet.has(s.id),
-    );
+    segmentsToRender = [];
+    resolvedIds = [];
+    for (const s of allSegments) {
+      if (s._handlerRan) resolvedIds.push(s.id);
+      if (
+        s.component !== null ||
+        s.type === "loader" ||
+        !clientIdSet.has(s.id)
+      ) {
+        segmentsToRender.push(s);
+      }
+    }
   }
 
   const { segments: dedupedSegments, removedIds } = deduplicateLoaderSegments(
@@ -236,20 +252,24 @@ export function buildMatchResult<TEnv>(
   const matchedIds =
     removedIds.size > 0 ? allIds.filter((id) => !removedIds.has(id)) : allIds;
 
-  const resolvedIds = ctx.isFullMatch
-    ? allSegments.map((s) => s.id)
-    : allSegments.filter((s) => s._handlerRan).map((s) => s.id);
-
-  const cleanedSegments = dedupedSegments.map((s) => {
-    if (s._handlerRan === undefined) return s;
-    const { _handlerRan: _drop, ...rest } = s;
-    return rest as ResolvedSegment;
-  });
+  // One pass over dedupedSegments: strip the internal _handlerRan marker and
+  // collect the diff ids (id is unchanged by the strip) together.
+  const cleanedSegments: ResolvedSegment[] = [];
+  const diff: string[] = [];
+  for (const s of dedupedSegments) {
+    if (s._handlerRan === undefined) {
+      cleanedSegments.push(s);
+    } else {
+      const { _handlerRan: _drop, ...rest } = s;
+      cleanedSegments.push(rest as ResolvedSegment);
+    }
+    diff.push(s.id);
+  }
 
   return {
     segments: cleanedSegments,
     matched: matchedIds,
-    diff: cleanedSegments.map((s) => s.id),
+    diff,
     resolvedIds,
     params: ctx.matched.params,
     routeName: ctx.routeKey,

package/src/router/middleware.ts

@@ -104,11 +104,20 @@ export function compileMiddlewarePattern(pattern: string): {
     const segment = segments[i];
 
     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 += "(?:/.*)?";
+      if (segment.value === "*") {
+        // Bare `*`: optional subtree match, no capture (parity with the original
+        // middleware parser). A trailing `*` matches the subtree; a non-trailing
+        // `*` matches zero-or-more intermediate segments, so `/a/<star>/b` still
+        // matches `/a/b`.
+        regexStr += "(?:/.*)?";
+      } else {
+        // Named catch-all `:name+` / `:name*`: capture the remainder under the
+        // name so a scoping middleware sees `ctx.params.<name>`, and respect the
+        // one-or-more arity (`+` must not match the bare prefix), mirroring the
+        // route matcher instead of collapsing to the bare-`*` subtree.
+        paramNames.push(segment.value);
+        regexStr += segment.oneOrMore ? "/(.+)" : "(?:/(.*))?";
+      }
       if (i === segments.length - 1) {
         hasTrailingWildcard = true;
       }
@@ -177,7 +186,15 @@ export function createMiddlewareContext<TEnv>(
     search?: Record<string, unknown>,
   ) => string,
 ): MiddlewareContext<TEnv> {
-  const url = stripInternalParams(new URL(request.url));
+  // Reuse the request context's clean URL when available. Each middleware still
+  // gets its OWN URL clone (a middleware may mutate ctx.url / ctx.searchParams),
+  // but cloning the already-clean URL is cheaper than re-parsing + re-stripping
+  // request.url per middleware. Fall back to parsing when no ALS context.
+  const reqCtx = _getRequestContext();
+  const ctxUrl = reqCtx?.url;
+  const url = ctxUrl
+    ? new URL(ctxUrl)
+    : stripInternalParams(new URL(request.url));
 
   // Track the initial response to detect pre/post-next() phase.
   // Before next(): responseHolder.response === initialResponse (the stub).
@@ -208,12 +225,11 @@ export function createMiddlewareContext<TEnv>(
     return responseHolder.response;
   };
 
-  // Capture reqCtx once: the request-scoped platform fields
+  // reqCtx captured once above: the request-scoped platform fields
   // (originalUrl, executionContext, waitUntil) are immutable per request,
   // so snapshotting beats re-reading ALS on every access. The lazy getters
   // below (routeName, theme, setTheme) stay lazy because those can change
   // during `await next()`.
-  const reqCtx = _getRequestContext();
   return {
     request,
     url,
@@ -296,7 +312,10 @@ export function createMiddlewareContext<TEnv>(
       const reqCtx = _getRequestContext();
       if (reqCtx) {
         reqCtx._debugPerformance = true;
-        reqCtx._metricsStore ??= createMetricsStore(true);
+        // Anchor to the true request entry (reqCtx._handlerStart) so phases that
+        // began before this opt-in report non-negative offsets; undefined falls
+        // back to performance.now() in createMetricsStore.
+        reqCtx._metricsStore ??= createMetricsStore(true, reqCtx._handlerStart);
       }
     },
   };
@@ -534,22 +553,28 @@ export async function executeMiddleware<TEnv>(
     // when neither surface is active.
     let result: Response | void;
     try {
-      result = await observePhase(PHASES.middleware(metricLabel), () =>
-        entry.handler(ctx, wrappedNext),
-      );
-    } catch (error) {
-      // Thrown Response is short-circuit control flow, not an error.
-      // Fall through to the `if (result instanceof Response)` branch below
-      // so stub headers and request-context cookies merge as they do for
-      // an explicit `return new Response(...)`. Real errors propagate.
-      if (error instanceof Response) {
-        result = error;
-      } else {
-        finishMiddleware();
-        throw error;
-      }
+      result = await observePhase(PHASES.middleware(metricLabel), async () => {
+        try {
+          return await entry.handler(ctx, wrappedNext);
+        } catch (error) {
+          // Thrown Response is short-circuit control flow, not an error —
+          // absorb it INSIDE the span so the tracing runner settles the
+          // rango.middleware span as success, not STATUS_ERROR (every auth
+          // redirect would otherwise inflate trace error rates). Returning it
+          // routes through the `if (result instanceof Response)` branch below,
+          // so stub headers and request-context cookies merge identically to an
+          // explicit `return new Response(...)`. Segment handlers already follow
+          // this convention (segment-resolution/helpers.ts keeps result handling
+          // outside the span). Real errors propagate past the span.
+          if (error instanceof Response) return error;
+          throw error;
+        }
+      });
+    } finally {
+      // Settle the middleware own-time metric once on both the success and
+      // error paths (idempotent guard in finishMiddleware).
+      finishMiddleware();
     }
-    finishMiddleware();
 
     // Record post-next() processing time when middleware did work after
     // the downstream chain resolved (e.g. adding headers, logging).
@@ -709,20 +734,21 @@ export async function executeInterceptMiddleware<TEnv>(
       ordinal,
     );
 
-    let result: Response | void;
-    try {
-      result = await observePhase(PHASES.middleware(label), () =>
-        middleware(ctx, guardedNext),
-      );
-    } catch (error) {
-      // Thrown Response is short-circuit control flow, parity with the
-      // explicit-return path below. Real errors propagate.
-      if (error instanceof Response) {
-        result = error;
-      } else {
-        throw error;
-      }
-    }
+    const result: Response | void = await observePhase(
+      PHASES.middleware(label),
+      async () => {
+        try {
+          return await middleware(ctx, guardedNext);
+        } catch (error) {
+          // Thrown Response is short-circuit control flow, parity with the
+          // explicit-return path below. Absorb it INSIDE the span so the tracing
+          // runner settles rango.middleware as success, not STATUS_ERROR (same
+          // reasoning as executeMiddleware's main chain). Real errors propagate.
+          if (error instanceof Response) return error;
+          throw error;
+        }
+      },
+    );
 
     if (result instanceof Response) {
       earlyResponse = result;

package/src/router/navigation-snapshot.ts

@@ -25,15 +25,17 @@ export interface NavigationSnapshot {
 }
 
 export interface ResolveNavigationDeps {
-  findMatch: (pathname: string) => RouteMatchResult | null;
+  findMatch: (
+    pathname: string,
+  ) => RouteMatchResult | null | Promise<RouteMatchResult | null>;
 }
 
-export function resolveNavigation(
+export async function resolveNavigation(
   request: Request,
   url: URL,
   currentRouteKey: string,
   deps: ResolveNavigationDeps,
-): NavigationSnapshot | null {
+): Promise<NavigationSnapshot | null> {
   const clientSegmentIds =
     url.searchParams.get("_rsc_segments")?.split(",").filter(Boolean) || [];
   const stale = url.searchParams.get("_rsc_stale") === "true";
@@ -65,10 +67,10 @@ export function resolveNavigation(
     interceptContextUrl = prevUrl;
   }
 
-  const prevMatch = deps.findMatch(prevUrl.pathname);
+  const prevMatch = await deps.findMatch(prevUrl.pathname);
   const prevParams = prevMatch?.params || {};
   const interceptContextMatch = interceptSourceUrl
-    ? deps.findMatch(interceptContextUrl.pathname)
+    ? await deps.findMatch(interceptContextUrl.pathname)
     : prevMatch;
 
   const isSameRouteNavigation = !!(

package/src/router/parse-pattern.ts

@@ -0,0 +1,115 @@
+/**
+ * Route pattern parsing (grammar only).
+ *
+ * Deliberately dependency-free so it is safe to bundle into the CLIENT — the
+ * reverse helper (`substitute-pattern-params.ts` -> `use-reverse`) needs it, and
+ * pulling it from `pattern-matching.ts` would drag that module's server-only
+ * transitive imports (`node:async_hooks` via `logging.ts`) into the browser.
+ * `pattern-matching.ts` re-exports these so existing importers are unaffected.
+ */
+
+/**
+ * Parsed segment info
+ */
+export interface ParsedSegment {
+  type: "static" | "param" | "wildcard";
+  value: string; // static text, param name, or "*"
+  optional: boolean;
+  constraint?: string[]; // enum values like ["en", "gb"]
+  suffix?: string; // literal text after param in same segment (e.g., ".html")
+  /**
+   * Named catch-all repeat modifier. On a `wildcard` segment whose `value` is a
+   * param name (`:name+` / `:name*`), `true` marks one-or-more (`+`, rejects the
+   * zero-segment case); absent/false marks zero-or-more (`*`, and the bare `/*`).
+   */
+  oneOrMore?: boolean;
+}
+
+/**
+ * Parse a route pattern into segments
+ *
+ * Supports:
+ * - Static: /blog, /about
+ * - Params: /:slug, /:id
+ * - Optional: /:locale?, /:page?
+ * - Constrained: /:locale(en|gb), /:type(post|page)
+ * - Optional + Constrained: /:locale(en|gb)?
+ * - Wildcard: /*
+ * - Named catch-all: /:slug* (zero-or-more), /:path+ (one-or-more)
+ */
+export function parsePattern(pattern: string): ParsedSegment[] {
+  const segments: ParsedSegment[] = [];
+  // The `([+*])?` group peels a trailing `+`/`*` off a `:name` BEFORE the
+  // literal-suffix group `([^/]*)` so it can be inspected. Whether it is a
+  // catch-all MODIFIER or a literal suffix character is decided below — a bare
+  // trailing `+`/`*` is the named catch-all of issue #634; any other combination
+  // is folded back into the literal suffix so previously-valid patterns are
+  // unaffected. It sits after `(\?)?` so `:name?*` is seen as `?` + suffix `*`.
+  const segmentRegex =
+    /\/(:([a-zA-Z_][a-zA-Z0-9_]*)(\(([^)]+)\))?(\?)?([+*])?([^/]*)|(\*)|([^/]+))/g;
+
+  let match;
+  while ((match = segmentRegex.exec(pattern)) !== null) {
+    const [
+      ,
+      ,
+      paramName,
+      ,
+      constraint,
+      optional,
+      repeat,
+      suffix,
+      wildcard,
+      staticText,
+    ] = match;
+
+    if (wildcard) {
+      // Bare `/*`: zero-or-more, captured under "*".
+      segments.push({ type: "wildcard", value: "*", optional: false });
+    } else if (paramName) {
+      // A trailing `+`/`*` is a named catch-all ONLY when it stands alone on the
+      // param — no `?`, no constraint, no literal suffix after it. In any other
+      // combination it is the start of a literal suffix, exactly as before this
+      // feature existed, so `:version+build` still matches `/…/v1+build` and
+      // never throws at registration.
+      if (repeat && !suffix && optional !== "?" && !constraint) {
+        segments.push({
+          type: "wildcard",
+          value: paramName,
+          optional: false,
+          oneOrMore: repeat === "+",
+        });
+      } else {
+        segments.push({
+          type: "param",
+          value: paramName,
+          optional: optional === "?",
+          constraint: constraint ? constraint.split("|") : undefined,
+          // Fold a non-modifier `+`/`*` back into the literal suffix.
+          suffix: (repeat ?? "") + (suffix ?? "") || undefined,
+        });
+      }
+    } else if (staticText) {
+      segments.push({ type: "static", value: staticText, optional: false });
+    }
+  }
+
+  // A named catch-all consumes the remainder, so it only makes sense as the final
+  // segment. If it isn't last, it isn't really a catch-all: restore the literal
+  // parse (`:name` + literal `+`/`*` suffix) rather than error, so a pattern like
+  // `/docs/:slug+/edit` keeps its pre-feature behavior (matches `/docs/x+/edit`).
+  // Bare `/*` keeps its historical mid-pattern leniency and is left untouched.
+  for (let i = 0; i < segments.length - 1; i++) {
+    const s = segments[i];
+    if (s.type === "wildcard" && s.value !== "*") {
+      segments[i] = {
+        type: "param",
+        value: s.value,
+        optional: false,
+        suffix: s.oneOrMore ? "+" : "*",
+      };
+    }
+  }
+
+  return segments;
+}

package/src/router/pattern-matching.ts

@@ -9,65 +9,13 @@ import type { EntryData } from "../server/context";
 import { debugLog, isRouterDebugEnabled } from "./logging.js";
 import { escapeRegExp } from "../regex-escape.js";
 import { safeDecodeURIComponent } from "./url-params.js";
+import { parsePattern, type ParsedSegment } from "./parse-pattern.js";
 
-/**
- * Parsed segment info
- */
-export interface ParsedSegment {
-  type: "static" | "param" | "wildcard";
-  value: string; // static text, param name, or "*"
-  optional: boolean;
-  constraint?: string[]; // enum values like ["en", "gb"]
-  suffix?: string; // literal text after param in same segment (e.g., ".html")
-}
-
-/**
- * Parse a route pattern into segments
- *
- * Supports:
- * - Static: /blog, /about
- * - Params: /:slug, /:id
- * - Optional: /:locale?, /:page?
- * - Constrained: /:locale(en|gb), /:type(post|page)
- * - Optional + Constrained: /:locale(en|gb)?
- * - Wildcard: /*
- */
-export function parsePattern(pattern: string): ParsedSegment[] {
-  const segments: ParsedSegment[] = [];
-  const segmentRegex =
-    /\/(:([a-zA-Z_][a-zA-Z0-9_]*)(\(([^)]+)\))?(\?)?([^/]*)|(\*)|([^/]+))/g;
-
-  let match;
-  while ((match = segmentRegex.exec(pattern)) !== null) {
-    const [
-      ,
-      ,
-      paramName,
-      ,
-      constraint,
-      optional,
-      suffix,
-      wildcard,
-      staticText,
-    ] = match;
-
-    if (wildcard) {
-      segments.push({ type: "wildcard", value: "*", optional: false });
-    } else if (paramName) {
-      segments.push({
-        type: "param",
-        value: paramName,
-        optional: optional === "?",
-        constraint: constraint ? constraint.split("|") : undefined,
-        suffix: suffix || undefined,
-      });
-    } else if (staticText) {
-      segments.push({ type: "static", value: staticText, optional: false });
-    }
-  }
-
-  return segments;
-}
+// `parsePattern`/`ParsedSegment` live in the dependency-free `parse-pattern.ts`
+// so the client reverse helper can import them without dragging this module's
+// server-only deps into the browser bundle. Re-exported here for existing
+// importers (build/route-trie, middleware, tests).
+export { parsePattern, type ParsedSegment };
 
 /**
  * Compiled pattern result containing regex, param metadata, and trailing slash info.
@@ -83,6 +31,14 @@ export interface CompiledPattern {
    * path's behavior (trie-matching.ts:validateAndBuild).
    */
   constraints?: Record<string, string[]>;
+  /**
+   * The pattern's catch-all param, if any (`*` for bare `/*`, the name for a
+   * named `:name+`/`:name*`). A zero-or-more catch-all (`oneOrMore: false`)
+   * whose optional group is absent binds "" rather than being omitted — so
+   * `/docs` matches `/docs/:slug*` with `slug === ""`. `oneOrMore` keeps the
+   * same polarity as `ParsedSegment.oneOrMore` and the trie's `w1`.
+   */
+  catchAll?: { name: string; oneOrMore: boolean };
 }
 
 // Module-level cache for compiled patterns. Route patterns are a finite set
@@ -143,13 +99,32 @@ export function compilePattern(pattern: string): CompiledPattern {
   const segments = parsePattern(normalizedPattern);
   const paramNames: string[] = [];
   let constraints: Record<string, string[]> | undefined;
+  let catchAll: { name: string; oneOrMore: boolean } | undefined;
 
   let regexPattern = "";
 
   for (const segment of segments) {
     if (segment.type === "wildcard") {
-      paramNames.push("*");
-      regexPattern += "/(.*)";
+      // Wildcards capture the remainder under `segment.value` ("*" for the bare
+      // form, the param name for a named catch-all).
+      paramNames.push(segment.value);
+      catchAll = { name: segment.value, oneOrMore: Boolean(segment.oneOrMore) };
+      if (segment.oneOrMore) {
+        // `:name+` — one-or-more, rejects the zero-segment (bare-prefix) case.
+        regexPattern += "/(.+)";
+      } else {
+        // Zero-or-more catch-all: named `:name*` OR the bare `/*` (both parse to
+        // `oneOrMore: false`). The whole `/segment` is optional so the bare
+        // prefix matches directly, aligning the regex fallback with the trie
+        // (which already matches the bare prefix binding "" — trie-matching.ts);
+        // buildParamsFromMatch binds "" when the optional group is absent.
+        //
+        // The bare `/*` previously used a required `/(.*)`, so `/files/*` failed
+        // to match `/files` and fell through to trailing-slash normalization,
+        // emitting a corrupt `/file` redirect instead of a match (issue #636,
+        // parity row C1). It is the same alignment #635 made for named `:name*`.
+        regexPattern += "(?:/(.*))?";
+      }
     } else if (segment.type === "param") {
       paramNames.push(segment.value);
       const suffixPattern = segment.suffix ? escapeRegExp(segment.suffix) : "";
@@ -202,6 +177,7 @@ export function compilePattern(pattern: string): CompiledPattern {
     paramNames,
     hasTrailingSlash,
     ...(constraints ? { constraints } : {}),
+    ...(catchAll ? { catchAll } : {}),
   };
 }
 
@@ -236,16 +212,29 @@ function satisfiesConstraints(
  * keys so `ctx.params.<name>` reads as `undefined` rather than `""`. This
  * keeps the runtime aligned with the `ExtractParams` type and matches the
  * trie matcher's contract (see `trie-matching.ts:validateAndBuild`).
+ *
+ * A zero-or-more catch-all (`compiled.catchAll`, `oneOrMore: false`) whose
+ * optional group didn't capture binds "" instead of being omitted, so `/docs`
+ * matches `/docs/:slug*` with `slug === ""`. Exported so the `renderRoute`
+ * testing harness (`matchLeaf`) shares this exact logic instead of forking it.
  */
-function buildParamsFromMatch(
+export function buildParamsFromMatch(
   match: RegExpExecArray,
   paramNames: string[],
+  catchAll?: { name: string; oneOrMore: boolean },
 ): Record<string, string> {
   const params: Record<string, string> = {};
   paramNames.forEach((name, index) => {
     const captured = match[index + 1];
     if (captured !== undefined) {
+      // A catch-all remainder decodes identically whether split-per-segment or
+      // whole-string (a literal `/` never lives inside a `%XX` escape), so a
+      // single decode is correct and cheapest.
       params[name] = safeDecodeURIComponent(captured);
+    } else if (catchAll && name === catchAll.name && !catchAll.oneOrMore) {
+      // A zero-or-more catch-all (`:name*` or the bare `/*`) whose optional
+      // group was absent binds "" rather than being omitted.
+      params[name] = "";
     }
   });
   return params;
@@ -454,7 +443,7 @@ export function findMatch<TEnv>(
         fullPattern = entry.prefix + pattern;
       }
 
-      const { regex, paramNames, hasTrailingSlash, constraints } =
+      const { regex, paramNames, hasTrailingSlash, constraints, catchAll } =
         getCompiledPattern(fullPattern);
 
       const trailingSlashMode: TrailingSlashMode | undefined =
@@ -469,7 +458,7 @@ export function findMatch<TEnv>(
 
       const match = regex.exec(pathname);
       if (match) {
-        const params = buildParamsFromMatch(match, paramNames);
+        const params = buildParamsFromMatch(match, paramNames, catchAll);
 
         if (!satisfiesConstraints(params, constraints)) {
           continue;
@@ -518,7 +507,7 @@ export function findMatch<TEnv>(
 
       const altMatch = regex.exec(alternatePathname);
       if (altMatch) {
-        const params = buildParamsFromMatch(altMatch, paramNames);
+        const params = buildParamsFromMatch(altMatch, paramNames, catchAll);
 
         if (!satisfiesConstraints(params, constraints)) {
           continue;