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

package/src/host/errors.ts

@@ -64,6 +64,21 @@ export class NoRouteMatchError extends HostRouterError {
   }
 }
 
+/**
+ * True when `err` is a NoRouteMatchError — including one thrown by a
+ * DUPLICATED @rangojs/router copy in the module graph (a workspace pinning a
+ * second version), whose class identity differs so a bare `instanceof` misses
+ * it and an unmatched-host 404 becomes an opaque 500. Use this in worker
+ * catch blocks instead of `instanceof`; it also matches by the stable `name`
+ * the constructor stamps.
+ */
+export function isNoRouteMatchError(err: unknown): err is NoRouteMatchError {
+  return (
+    err instanceof NoRouteMatchError ||
+    (err instanceof Error && err.name === "NoRouteMatchError")
+  );
+}
+
 export class InvalidHandlerError extends HostRouterError {
   constructor(handler: unknown, options?: ErrorOptions) {
     super(`Invalid handler type: ${typeof handler}`, options);

package/src/host/index.ts

@@ -42,6 +42,7 @@ export {
   InvalidHostnameError,
   HostValidationError,
   NoRouteMatchError,
+  isNoRouteMatchError,
   InvalidHandlerError,
 } from "./errors.js";
 

package/src/index.rsc.ts

@@ -65,6 +65,12 @@ export type {
   ErrorPhase,
   OnErrorContext,
   OnErrorCallback,
+  // View transition types (also exported from the default entry; route
+  // definitions resolve to this react-server entry, so they must be here too)
+  TransitionConfig,
+  TransitionWhenFn,
+  TransitionWhenContext,
+  ViewTransitionClass,
 } from "./types.js";
 
 // Router options type (server-only, so import directly)
@@ -97,7 +103,6 @@ export {
   loading,
   parallel,
   intercept,
-  when,
   errorBoundary,
   notFoundBoundary,
   transition,
@@ -117,7 +122,6 @@ export { createHandle, isHandle, type Handle } from "./handle.js";
 export {
   DEFAULT_DEFER_TIMEOUT_MS,
   type DeferOptions,
-  type DeferredHandleEntry,
   type HandlePush,
   type HandlePushFn,
 } from "./defer.js";
@@ -153,6 +157,7 @@ export {
   urls,
   type PathHelpers,
   type PathOptions,
+  type PartialPrerenderProps,
   type UrlPatterns,
   type IncludeOptions,
   type IncludeItem,
@@ -303,6 +308,7 @@ export type {
   RouterTracingConfig,
   TracePhase,
   TracePhaseToggles,
+  TracingToggleOptions,
 } from "./router/tracing.js";
 
 // Timeout types and error class

package/src/index.ts

@@ -82,7 +82,12 @@ export { createLoader } from "./loader.js";
 
 // Route definition types (safe to import anywhere)
 export type { RouteHelpers, RouteHandlers } from "./route-definition.js";
-export type { TransitionConfig, ViewTransitionClass } from "./types.js";
+export type {
+  TransitionConfig,
+  TransitionWhenFn,
+  TransitionWhenContext,
+  ViewTransitionClass,
+} from "./types.js";
 
 // Composition types for reusable callback factories
 export type {
@@ -105,6 +110,7 @@ export type {
   TextResponsePathFn,
   RouteResponse,
   ProblemDetails,
+  PartialPrerenderProps,
 } from "./urls.js";
 
 // Middleware context types
@@ -143,7 +149,6 @@ export { createHandle, isHandle, type Handle } from "./handle.js";
 export {
   DEFAULT_DEFER_TIMEOUT_MS,
   type DeferOptions,
-  type DeferredHandleEntry,
   type HandlePush,
   type HandlePushFn,
 } from "./defer.js";
@@ -279,9 +284,6 @@ export function parallel(): never {
 export function intercept(): never {
   throw serverOnlyStubError("intercept");
 }
-export function when(): never {
-  throw serverOnlyStubError("when");
-}
 export function errorBoundary(): never {
   throw serverOnlyStubError("errorBoundary");
 }
@@ -341,14 +343,17 @@ export {
 // Path and response types are ambient on the `Rango` namespace (`Rango.Path`,
 // `Rango.PathResponse`, declared in href-client.ts) — no import needed.
 
-// Telemetry types only — the createConsoleSink/createOTelSink values are
-// server-only and live in index.rsc.ts (the `react-server` condition of the
-// bare `@rangojs/router` import). Re-exporting them as values from this
-// (default/client) entry would pull telemetry.ts and telemetry-otel.ts into
-// the client module graph; both tree-shake to zero bytes but still appear in
-// bundle analysis output and slow build-time module resolution. Consumers
-// who need the values in non-RSC contexts can import from
-// `@rangojs/router/server`.
+// Telemetry types only — the createConsoleSink / createOTelSink /
+// createOTelTracing VALUES are server-only and live in index.rsc.ts (the
+// `react-server` condition of the bare `@rangojs/router` import). Re-exporting
+// them as values from this (default/client) entry would pull telemetry.ts and
+// telemetry-otel.ts into the client module graph; both tree-shake to zero bytes
+// but still appear in bundle analysis output and slow build-time module
+// resolution. The factory values are NOT re-exported from `@rangojs/router/server`
+// either — that subpath is internal, not user-facing (see server.ts header).
+// Non-RSC server code imports these TYPES from the root and obtains the factory
+// VALUES from its own router definition module, which resolves to index.rsc.ts
+// under the `react-server` condition.
 export type {
   OTelTracer,
   OTelActiveSpanTracer,
@@ -384,6 +389,7 @@ export type {
   RouterTracingConfig,
   TracePhase,
   TracePhaseToggles,
+  TracingToggleOptions,
 } from "./router/tracing.js";
 
 // Timeout types and error class

package/src/internal-debug.ts

@@ -1,9 +1,12 @@
-// Vite define for compile-time injection; falls back to process.env (tests, Node).
-// Works in all runtimes including Cloudflare Workers where process.env is unavailable.
+// Runtime fallback for non-Vite contexts (Node, tests, raw imports). In the Vite
+// pipeline -- dev and build, every environment -- the router discovery plugin's
+// transform replaces this module with the build-time-resolved flag (see
+// vite/inject-client-debug.ts), so the CLIENT debug flag no longer depends on a
+// `__RANGO_DEBUG__` define being delivered to the browser (which dev did only as
+// an injected global whose presence varied across consumer setups).
+//
+// Keep this module to the single INTERNAL_RANGO_DEBUG export: the transform
+// replaces the whole file, so a second export would be dropped from the bundle.
 export const INTERNAL_RANGO_DEBUG: boolean =
-  typeof __RANGO_DEBUG__ !== "undefined"
-    ? __RANGO_DEBUG__
-    : typeof process !== "undefined" &&
-      Boolean((process as any).env?.INTERNAL_RANGO_DEBUG);
-
-declare const __RANGO_DEBUG__: boolean;
+  typeof process !== "undefined" &&
+  Boolean((process as any).env?.INTERNAL_RANGO_DEBUG);

package/src/prerender.ts

@@ -33,6 +33,7 @@ import type {
   ExtractParams,
 } from "./types.js";
 import type { Handle } from "./handle.js";
+import type { HandlePush } from "./defer.js";
 import type { ContextVar } from "./context-var.js";
 import type { ReverseFunction } from "./reverse.js";
 import type { DefaultReverseRouteMap } from "./types/global-namespace.js";
@@ -165,8 +166,14 @@ export interface BuildContext<TParams> {
     (key: string, value: any): void;
   };
 
-  /** Push handle data (frozen into pre-rendered output at build time). */
-  use: <T>(handle: Handle<T>) => (data: T) => void;
+  /**
+   * Push handle data (frozen into pre-rendered output at build time). Returns
+   * the full push function, including `.defer()` — a deferred slot resolved by
+   * a deep async component during the prerender render is awaited before the
+   * artifact is baked (resolve-by-default), so the baked output holds the
+   * resolved value.
+   */
+  use: <T>(handle: Handle<T>) => HandlePush<T>;
 
   /** Synthetic URL built from pattern + params (no real request). */
   url: URL;
@@ -222,8 +229,14 @@ export interface StaticBuildContext {
     (key: string, value: any): void;
   };
 
-  /** Push handle data (frozen into pre-rendered output at build time). */
-  use: <T>(handle: Handle<T>) => (data: T) => void;
+  /**
+   * Push handle data (frozen into pre-rendered output at build time). Returns
+   * the full push function, including `.defer()` — a deferred slot resolved by
+   * a deep async component during the prerender render is awaited before the
+   * artifact is baked (resolve-by-default), so the baked output holds the
+   * resolved value.
+   */
+  use: <T>(handle: Handle<T>) => HandlePush<T>;
 
   /** URL generation by route name. */
   reverse: BuildReverseFunction;

package/src/redirect-origin.ts

@@ -60,6 +60,20 @@ export function resolveExternalRedirect(
   }
 }
 
+/**
+ * The safe same-origin landing for a blocked redirect.
+ *
+ * Every guard that neutralizes a cross-origin/unsafe redirect target sends the
+ * browser here instead: the app's basename root, or `"/"` when unset. Kept
+ * beside the resolvers so the "where does a blocked redirect go" answer lives
+ * in ONE place -- the server 3xx guard (`rsc/redirect-guard.ts`) and the
+ * shell-HIT degradation path (`rsc/rsc-rendering.ts`) must agree, or a blocked
+ * redirect lands differently depending on which exit it took.
+ */
+export function safeSameOriginLanding(basename: string | undefined): string {
+  return basename && basename !== "/" ? basename : "/";
+}
+
 /**
  * Out-of-band brand for `redirect(url, { external: true })`.
  *

package/src/render-error-thrower.tsx

@@ -0,0 +1,20 @@
+"use client";
+
+import type { ReactNode } from "react";
+
+interface RenderErrorThrowerProps {
+  error: unknown;
+}
+
+/**
+ * Client component that throws the given error during render, so the nearest
+ * error boundary catches it. Errors thrown during render are caught by error
+ * boundaries; async errors (rejected promises) are not -- which is why the
+ * navigation bridge funnels processing failures through this component instead
+ * of letting them surface as uncaught rejections.
+ */
+export function RenderErrorThrower({
+  error,
+}: RenderErrorThrowerProps): ReactNode {
+  throw error;
+}

package/src/route-content-wrapper.tsx

@@ -1,7 +1,6 @@
 "use client";
 import type { ReactNode } from "react";
 import { Suspense, use } from "react";
-import { invariant } from "./errors";
 import { OutletProvider } from "./outlet-provider.js";
 import type { ResolvedSegment } from "./types.js";
 import { decodeLoaderResults } from "./decode-loader-results.js";
@@ -22,7 +21,9 @@ export function RouteContentWrapper({
   fallback,
   segmentId,
 }: {
-  content: Promise<ReactNode>;
+  // Normally a pending promise (use() suspends -> fallback). forceAwait paths
+  // pass an already-resolved node so Suspender renders it without suspending.
+  content: Promise<ReactNode> | ReactNode;
   fallback?: ReactNode;
   segmentId?: string;
 }): ReactNode {
@@ -41,9 +42,15 @@ const Suspender = ({
 }: {
   content: Promise<ReactNode> | ReactNode;
 }): ReactNode => {
-  invariant(content instanceof Promise, "Suspender expects a Promise content");
-
-  return use(content);
+  // Normally content is a pending promise -> use() suspends and the wrapping
+  // Suspense shows the loading() fallback. forceAwait paths (popstate,
+  // stale-revalidation, fully-prefetched nav) instead pass the ALREADY-RESOLVED
+  // node so first render does not suspend for a microtask and flash the loading()
+  // fallback on a NORMAL (non-transition) commit. The wrapper tree
+  // (RouteContentWrapper > Suspense > Suspender) is identical either way, so this
+  // preserves tree structure (see docs/tree-structure.md) — only whether use()
+  // suspends differs, exactly like LoaderResolver's resolved-data branch.
+  return content instanceof Promise ? use(content) : content;
 };
 
 /**

package/src/route-definition/dsl-helpers.ts

@@ -17,6 +17,7 @@ import {
   type EntryPropSegments,
   type HelperContext,
   type InterceptEntry,
+  type InterceptConfig,
 } from "../server/context";
 import { invariant } from "../errors";
 import { validateUserRouteName } from "../route-name.js";
@@ -36,7 +37,6 @@ import type {
   ErrorBoundaryItem,
   NotFoundBoundaryItem,
   LayoutItem,
-  WhenItem,
   CacheItem,
   TransitionItem,
   UseItems,
@@ -265,34 +265,6 @@ const notFoundBoundary: RouteHelpers<any, any>["notFoundBoundary"] = (
   return { name, type: "notFoundBoundary" } as NotFoundBoundaryItem;
 };
 
-/**
- * When helper - defines a condition for intercept activation
- *
- * Only valid inside intercept() use() callback. The when() function
- * is captured by the intercept and stored in its `when` array.
- * During soft navigation, all when() conditions must return true
- * for the intercept to activate.
- */
-const when: RouteHelpers<any, any>["when"] = (fn) => {
-  const { store, ctx } = requireDslContext(
-    "when() must be called inside intercept()",
-  );
-
-  // The when() function needs to be captured by the intercept's tempParent
-  // which should have a `when` array. If not present, we're not inside intercept()
-  const parent = ctx.parent as any;
-  if (!parent || !("when" in parent)) {
-    invariant(
-      false,
-      "when() can only be used inside intercept() use() callback",
-    );
-  }
-
-  const name = `$${store.getNextIndex("when")}`;
-  parent.when.push(fn);
-  return { name, type: "when" } as WhenItem;
-};
-
 /**
  * Cache helper - defines caching configuration for segments
  *
@@ -701,8 +673,19 @@ const intercept = (
   slotName: `@${string}`,
   routeName: string,
   handler: any,
+  configOrUse?: InterceptConfig | (() => any[]),
   use?: () => any[],
 ) => {
+  // arg4 discrimination: a function is the use() callback (no config); an object
+  // is the config carrying `when`. With config given, the use() callback is
+  // arg5. Keeps the no-config form intercept(slot, route, handler, () => [...])
+  // working unchanged.
+  const config: InterceptConfig | undefined =
+    typeof configOrUse === "function" || configOrUse == null
+      ? undefined
+      : configOrUse;
+  const useFn = typeof configOrUse === "function" ? configOrUse : use;
+
   const { store, ctx } = requireDslContext(
     "intercept() must be called inside urls()",
   );
@@ -740,9 +723,17 @@ const intercept = (
     when: [], // Selector conditions for conditional interception
   };
 
+  // Conditional interception: `when` from the config object — a single selector
+  // or an array (ALL must return true to activate). Replaces the former when()
+  // use-item captured inside the callback.
+  if (config?.when) {
+    const selectors = Array.isArray(config.when) ? config.when : [config.when];
+    entry.when.push(...selectors);
+  }
+
   // Merge handler.use defaults with explicit use
   const handlerUseFn = resolveHandlerUse(handler);
-  const mergedUse = mergeHandlerUse(handlerUseFn, use, "intercept");
+  const mergedUse = mergeHandlerUse(handlerUseFn, useFn, "intercept");
 
   // Run merged use callback to collect loaders, revalidate, middleware, etc.
   if (mergedUse) {
@@ -759,7 +750,6 @@ const intercept = (
       notFoundBoundary: entry.notFoundBoundary,
       loader: entry.loader,
       layout: capturedLayouts, // Capture layout() calls
-      when: entry.when, // Capture when() conditions
       get loading() {
         return entry.loading;
       },
@@ -1114,7 +1104,6 @@ export {
   revalidate,
   parallel,
   intercept,
-  when,
   errorBoundary,
   notFoundBoundary,
   route,

package/src/route-definition/helper-factories.ts

@@ -8,7 +8,6 @@ import {
   revalidate,
   parallel,
   intercept,
-  when,
   errorBoundary,
   notFoundBoundary,
   route,
@@ -40,7 +39,6 @@ function buildRouteHelpers<T extends RouteDefinition, TEnv>(): RouteHelpers<
     loading,
     errorBoundary,
     notFoundBoundary,
-    when,
     cache,
     transition,
   } as unknown as RouteHelpers<T, TEnv>;

package/src/route-definition/helpers-types.ts

@@ -29,12 +29,10 @@ import type {
   ParallelUseItem,
   InterceptUseItem,
   LoaderUseItem,
-  WhenItem,
   CacheItem,
   TransitionItem,
   UseItems,
 } from "../route-types.js";
-import type { InterceptWhenFn } from "../server/context";
 
 // Re-export route item types for backward compatibility
 export type {
@@ -52,12 +50,12 @@ export type {
   RouteUseItem,
   ParallelUseItem,
   InterceptUseItem,
-  WhenItem,
   CacheItem,
 } from "../route-types.js";
 
 // Re-export intercept selector types for use in handlers
 export type {
+  InterceptConfig,
   InterceptSelectorContext,
   InterceptSegmentsState,
   InterceptWhenFn,
@@ -151,8 +149,11 @@ export type RouteHelpers<T extends RouteDefinition, TEnv> = {
    *              so they take precedence on `loading()` and other last-write-wins
    *              fields.
    */
-  parallel: <
-    TSlots extends Record<
+  // Not generic over the slots record: an inferred type parameter makes the
+  // object literal an inference site, which suppresses contextual typing of
+  // arrow slot handlers (`(ctx) => ...` was implicit any).
+  parallel: (
+    slots: Record<
       `@${string}`,
       | Handler<any, any, TEnv>
       | ReactNode
@@ -161,8 +162,6 @@ export type RouteHelpers<T extends RouteDefinition, TEnv> = {
           use?: () => UseItems<ParallelUseItem>;
         }
     >,
-  >(
-    slots: TSlots,
     use?: () => UseItems<ParallelUseItem>,
   ) => ParallelItem;
   /**
@@ -183,10 +182,26 @@ export type RouteHelpers<T extends RouteDefinition, TEnv> = {
    *   loader(CardModalLoader),
    *   revalidate(() => false),
    * ])
+   *
+   * // Conditional activation via the config object's `when` selector
+   * intercept("@modal", "card", <CardModal />, {
+   *   when: ({ from }) => from.pathname.startsWith("/board"),
+   * })
+   *
+   * // Config + other use-items: config is arg 4, use is arg 5
+   * intercept(
+   *   "@modal",
+   *   "card",
+   *   <CardModal />,
+   *   { when: ({ from }) => from.pathname.startsWith("/board") },
+   *   () => [loader(CardDetailLoader)],
+   * )
    * ```
    * @param slotName - Named slot (prefixed with @) where intercept renders
    * @param routeName - Route name to intercept
    * @param handler - Component or handler for intercepted render
+   * @param config - Optional InterceptConfig (e.g. `{ when }`), or the use
+   *   callback directly when there is no config
    * @param use - Optional callback for loaders, middleware, revalidate, etc.
    */
   intercept: {
@@ -195,6 +210,9 @@ export type RouteHelpers<T extends RouteDefinition, TEnv> = {
       slotName: `@${string}`,
       routeName: `.${K}`,
       handler: ReactNode | Handler<ExtractRouteParams<T, K>, {}, TEnv>,
+      config?:
+        | import("../server/context.js").InterceptConfig<TEnv>
+        | (() => UseItems<InterceptUseItem>),
       use?: () => UseItems<InterceptUseItem>,
     ): InterceptItem;
     // Global: unprefixed, params inferred from global route map
@@ -202,6 +220,9 @@ export type RouteHelpers<T extends RouteDefinition, TEnv> = {
       slotName: `@${string}`,
       routeName: K,
       handler: ReactNode | Handler<K, Rango.GeneratedRouteMap, TEnv>,
+      config?:
+        | import("../server/context.js").InterceptConfig<TEnv>
+        | (() => UseItems<InterceptUseItem>),
       use?: () => UseItems<InterceptUseItem>,
     ): InterceptItem;
   };
@@ -347,40 +368,6 @@ export type RouteHelpers<T extends RouteDefinition, TEnv> = {
   notFoundBoundary: (
     fallback: ReactNode | NotFoundBoundaryHandler,
   ) => NotFoundBoundaryItem;
-  /**
-   * Define a condition for when an intercept should activate
-   *
-   * Only valid inside intercept() use() callback. When multiple when() calls
-   * are present, ALL must return true for the intercept to activate.
-   * If no when() is defined, the intercept always activates on soft navigation.
-   *
-   * Context properties:
-   * - `from` - Source URL (where user is navigating from)
-   * - `to` - Destination URL (where user is navigating to)
-   * - `params` - Matched route params
-   * - `segments` - Client's current segments with `path` and `ids`
-   *
-   * ```typescript
-   * // Only intercept when coming from the board page
-   * intercept("@modal", "card", <CardModal />, () => [
-   *   when(({ from }) => from.pathname.startsWith("/board")),
-   *   loader(CardDetailLoader),
-   * ])
-   *
-   * // Use segments to check current route context
-   * intercept("@modal", "card", <CardModal />, () => [
-   *   when(({ segments }) => segments.path[0] === "kanban"),
-   * ])
-   *
-   * // Multiple conditions (AND logic)
-   * intercept("@modal", "card", <CardModal />, () => [
-   *   when(({ from }) => from.pathname.startsWith("/board")),
-   *   when(({ segments }) => segments.ids.includes("kanban-layout")),
-   * ])
-   * ```
-   * @param fn - Selector function receiving navigation context, returns boolean
-   */
-  when: (fn: InterceptWhenFn) => WhenItem;
   /**
    * Define cache configuration for segments
    *
@@ -472,6 +459,13 @@ export type RouteHelpers<T extends RouteDefinition, TEnv> = {
    * transition({}) is startTransition + ViewTransition under the default and
    * startTransition only when the router sets viewTransition: false.
    *
+   * Conditional hold: pass `when: (ctx) => boolean` to gate the transition per
+   * request. It runs server-side AFTER the route handler (so it can read state
+   * the handler set via `ctx.get(...)`); returning false drops this transition
+   * for the request, so the navigation streams its loading() skeleton instead of
+   * holding. This is a post-handler predicate — distinct from intercept()'s
+   * match-time `when` config selector (`intercept(slot, route, Comp, { when })`).
+   *
    * ```typescript
    * // Attach to a single route
    * path("/about", AboutPage, { name: "about" }, () => [
@@ -488,10 +482,16 @@ export type RouteHelpers<T extends RouteDefinition, TEnv> = {
    * path("/product/:id", ProductPage, { name: "product" }, () => [
    *   transition({ viewTransition: false }),
    * ])
+   *
+   * // Hold only when the handler decided to (post-handler predicate):
+   * path("/product/:id", ProductPage, { name: "product" }, () => [
+   *   transition({ when: (ctx) => ctx.get(KeepScroll) === true }),
+   * ])
    * ```
    * @param config - ViewTransition configuration (enter, exit, update, share,
-   *   default, name) plus `viewTransition: "auto" | false` to toggle the router
-   *   boundary (createRouter({ viewTransition }) sets the app-wide default)
+   *   default, name), `viewTransition: "auto" | false` to toggle the router
+   *   boundary (createRouter({ viewTransition }) sets the app-wide default), and
+   *   `when: (ctx) => boolean` to gate the transition per request post-handler
    * @param children - Optional callback returning child routes to wrap
    */
   transition: {

package/src/route-definition/index.ts

@@ -15,8 +15,8 @@ export type {
   RouteUseItem,
   ParallelUseItem,
   InterceptUseItem,
-  WhenItem,
   CacheItem,
+  InterceptConfig,
   InterceptSelectorContext,
   InterceptSegmentsState,
   InterceptWhenFn,
@@ -30,7 +30,6 @@ export {
   revalidate,
   parallel,
   intercept,
-  when,
   errorBoundary,
   notFoundBoundary,
   loader,

package/src/route-definition/resolve-handler-use.ts

@@ -100,7 +100,6 @@ const MOUNT_SITE_ALLOWED_TYPES: Record<string, Set<string>> = {
     "notFoundBoundary",
     "layout",
     "route",
-    "when",
     "transition",
   ]),
   // LoaderUseItem — only revalidate + cache can attach to a loader entry

package/src/route-definition/use-item-types.ts

@@ -1,16 +1,14 @@
-import type { AllUseItems, WhenItem } from "../route-types.js";
+import type { AllUseItems } from "../route-types.js";
 
 /**
  * The set of valid use-item `type` discriminants — the single runtime source of
  * truth for "is this a well-formed use item?" shape validation.
  *
  * Declared via a `Record<...>` so that adding a member to the union without
- * updating this map is a compile error. `when` is included because when() items
- * are valid inside intercept() even though WhenItem is not part of AllUseItems
- * (it lives only in InterceptUseItem). This is shape validation only; per-mount-
+ * updating this map is a compile error. This is shape validation only; per-mount-
  * site rules remain the narrower hand-written tables in resolve-handler-use.ts.
  */
-const USE_ITEM_TYPES: Record<AllUseItems["type"] | WhenItem["type"], true> = {
+const USE_ITEM_TYPES: Record<AllUseItems["type"], true> = {
   layout: true,
   route: true,
   middleware: true,
@@ -21,7 +19,6 @@ const USE_ITEM_TYPES: Record<AllUseItems["type"] | WhenItem["type"], true> = {
   loading: true,
   errorBoundary: true,
   notFoundBoundary: true,
-  when: true,
   cache: true,
   transition: true,
   include: true,