@rangojs/router 0.10.1 → 0.12.0

package/dist/testing/vitest.js

@@ -14,7 +14,7 @@ function rangoTestAliases(opts = {}) {
       replacement: here("src/testing/vitest-stubs/version.ts")
     },
     {
-      find: /^@vitejs\/plugin-rsc\/rsc$/,
+      find: /^@vitejs\/plugin-rsc\/rsc(\/(server|client))?$/,
       replacement: here("src/testing/vitest-stubs/plugin-rsc.ts")
     }
   ];

package/dist/types/browser/partial-update.d.ts

@@ -52,6 +52,7 @@ export type UpdateMode = {
 } | {
     type: "action";
     interceptSourceUrl?: string;
+    actionId?: string;
 };
 /**
  * Type for the fetchPartialUpdate function

package/dist/types/client-urls/navigation.d.ts

@@ -31,6 +31,17 @@ export declare function beginClientUrlNavigation(targetUrl: URL, signal: AbortSi
 export declare function collectClientRevalidationDecisions(options: {
     currentUrl: URL;
     nextUrl: URL;
+    /**
+     * True only when the decisions ride the action POST itself — the one
+     * request the server evaluates with actionContext (locked default true).
+     * Action-triggered refetch GETs (partial-update terminals) pass false:
+     * the server gives those navigation defaults, and the delta gate below
+     * must diff against the default the SERVER will use, or a force decision
+     * on the refetch would be silently swallowed as "equals default".
+     */
+    actionRequest: boolean;
+    /** Action TRUTH for the predicates' isAction() matcher; may be true on
+     * refetch GETs where actionRequest is false. */
     isAction: boolean;
     actionId?: string;
     stale: boolean;

package/dist/types/client-urls/revalidate-chain.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The clientUrls revalidate() chain evaluator, shared by the browser
+ * collector (navigation.ts) and the public testing primitive
+ * (testing/run-client-revalidate.ts) so the two can never drift.
+ *
+ * Semantics mirror the server's evaluateRevalidation
+ * (src/router/revalidation.ts): a boolean verdict is a hard decision and
+ * short-circuits the rest of the chain; a `{ defaultShouldRevalidate }`
+ * object updates the running suggestion, which later predicates receive as
+ * their `defaultShouldRevalidate`; null/undefined defers; a throwing
+ * predicate fails open to the current suggestion (logged). One deliberate
+ * divergence: the object form is accepted only with a boolean value — the
+ * server is laxer, but never re-compares the value, while this decision
+ * feeds a strict-equality delta gate and the wire encoding
+ * (navigation.ts), where a truthy non-boolean would invert intent.
+ */
+import type { ClientRevalidateArgs, ClientRevalidateFn } from "./types.js";
+/**
+ * The locked default the server will apply to the request these decisions
+ * ride on. `actionRequest` is about the REQUEST, not the user gesture: only
+ * the action POST itself is evaluated server-side with actionContext
+ * (default `true`); the follow-up refetch GETs an action can trigger carry
+ * no actionContext and get navigation defaults — even though their
+ * predicates still see `isAction()` as true.
+ */
+export declare function lockedClientDefault(options: {
+    actionRequest: boolean;
+    currentParams: Record<string, string>;
+    nextParams: Record<string, string>;
+    currentUrl: URL;
+    nextUrl: URL;
+}): boolean;
+export declare function runClientRevalidateChain(fns: readonly ClientRevalidateFn[], baseArgs: Omit<ClientRevalidateArgs, "defaultShouldRevalidate">, lockedDefault: boolean, label: string): boolean;

package/dist/types/client-urls/types.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentType, ReactNode } from "react";
-import type { LoaderDefinition, LoaderOptions, TransitionConfig } from "../types.js";
+import type { IsActionFn, LoaderDefinition, LoaderOptions, TransitionConfig } from "../types.js";
 import type { TrieMatchResult } from "../router/trie-matching.js";
 import type { PathOptions } from "../urls/pattern-types.js";
 import type { SearchSchema } from "../search-params.js";
@@ -23,7 +23,8 @@ export type ClientLayoutFn = <const TItems extends ClientUrlItems>(component: Co
  * subset of the server ShouldRevalidateFn args — the predicate RUNS IN THE
  * BROWSER (it is declared in a "use client" module and never crosses the
  * projection boundary); only its decision is sent to the server. There is no
- * `context` — no server handler context exists where this executes.
+ * `context` — no server handler context exists where this executes. `isAction`
+ * is the same callable matcher as on the server, not a boolean.
  */
 export interface ClientRevalidateArgs {
     /** Full URL of the page being navigated away from (current location). */
@@ -35,20 +36,45 @@ export interface ClientRevalidateArgs {
     /** Route params for the navigation target (definition-local match). */
     readonly nextParams: Record<string, string>;
     /**
-     * The locked default decision for this loader, computed client-side with
-     * the same rules the server would apply: `true` on actions and when
-     * params/search changed, `false` otherwise. Return it for default behavior
-     * plus your own conditions.
+     * The current default decision for this loader, computed client-side with
+     * the same rules the server applies to the request the decisions ride on:
+     * `true` when they ride the action POST itself, otherwise `true` when
+     * params/search changed. (An action-triggered refetch GET gets navigation
+     * defaults — matching the server — even though `isAction()` is true.)
+     * Earlier predicates' `{ defaultShouldRevalidate }` verdicts thread into
+     * this value, exactly like the server chain. Return it for default
+     * behavior plus your own conditions.
      */
     readonly defaultShouldRevalidate: boolean;
     /** True when this is a stale history-entry background revalidation. */
     readonly stale: boolean;
-    /** True when revalidation is triggered by a server action. */
-    readonly isAction: boolean;
-    /** The triggering server action's id, when isAction. */
+    /**
+     * Same {@link IsActionFn} the server `revalidate()` predicate receives.
+     * In the browser the match is against the action stub's hashed `$$id`
+     * (the id the action request carries) — not the RSC file-path `$id`.
+     */
+    readonly isAction: IsActionFn;
+    /**
+     * The triggering server action's id, when this is an action. In the
+     * browser this is the hashed `hash#export` form (`$$id`), not the RSC
+     * file-path `src/...#export`. Prefer `isAction(ref)` — a substring of
+     * `path#export` will not match here in production.
+     */
     readonly actionId?: string;
 }
-export type ClientRevalidateFn = (args: ClientRevalidateArgs) => boolean;
+/**
+ * Client-run per-loader predicate, with the same chain semantics as the
+ * server's `revalidate()` (src/router/revalidation.ts): a boolean is a HARD
+ * decision that short-circuits the rest of the chain; a
+ * `{ defaultShouldRevalidate }` object updates the running suggestion, which
+ * later predicates receive as their `defaultShouldRevalidate`; `void` /
+ * `null` / `undefined` defers to the current suggestion — so
+ * `isAction(CartActions) || undefined` defers to the locked default.
+ * Predicates must be synchronous; the object form requires a boolean value.
+ */
+export type ClientRevalidateFn = (args: ClientRevalidateArgs) => boolean | {
+    defaultShouldRevalidate: boolean;
+} | null | void;
 export interface ClientUrlLoaderRecord {
     readonly loader: LoaderDefinition<any, any>;
     /** Client-run per-loader revalidation predicates; empty = locked defaults. */
@@ -114,10 +140,11 @@ export interface ClientUrlHelpers {
     readonly loading: (component: ReactNode) => ClientUrlItem;
     /**
      * Per-loader revalidation predicate, valid inside a loader() use callback
-     * only. Runs IN THE BROWSER with client-computable args; return true to
-     * re-run the loader, false to keep held data. Absent predicates (and
-     * requests that carry no decisions: no-JS, PE, prefetch, document loads)
-     * follow the locked server defaults.
+     * only. Runs IN THE BROWSER with client-computable args (including the
+     * callable `isAction(...refs)` matcher); return true to re-run the loader,
+     * false to keep held data. Absent predicates (and requests that carry no
+     * decisions: no-JS, PE, prefetch, document loads) follow the locked server
+     * defaults.
      */
     readonly revalidate: (fn: ClientRevalidateFn) => ClientUrlItem;
     /**

package/dist/types/client.d.ts

@@ -190,3 +190,5 @@ export { useHref } from "./browser/react/use-href.js";
 export { useReverse } from "./browser/react/use-reverse.js";
 export type { ScopedReverseFunction, LocalReverseFunction } from "./reverse.js";
 export type { LoaderDefinition } from "./types.js";
+export type { ActionRef, IsActionFn } from "./types.js";
+export type { ClientRevalidateArgs, ClientRevalidateFn, } from "./client-urls/types.js";

package/dist/types/deps/rsc-client.d.ts

@@ -0,0 +1 @@
+export { createFromReadableStream, encodeReply, createClientTemporaryReferenceSet, } from "@vitejs/plugin-rsc/rsc/client";

package/dist/types/deps/rsc.d.ts

@@ -1 +1 @@
-export { renderToReadableStream, decodeReply, createTemporaryReferenceSet, loadServerAction, decodeAction, decodeFormState, } from "@vitejs/plugin-rsc/rsc";
+export { renderToReadableStream, decodeReply, createTemporaryReferenceSet, loadServerAction, decodeAction, decodeFormState, } from "@vitejs/plugin-rsc/rsc/server";

package/dist/types/deps/ssr.d.ts

@@ -1 +1 @@
-export { createFromReadableStream, setOnClientReference, } from "@vitejs/plugin-rsc/ssr";
+export { createFromReadableStream, setOnClientReference, getClientEntryUrl, } from "@vitejs/plugin-rsc/ssr";

package/dist/types/index.d.ts

@@ -11,7 +11,7 @@
  */
 export { RouteNotFoundError, DataNotFoundError, notFound, MiddlewareError, HandlerError, BuildError, DslContextError, InvalidHandlerError, RouterError, Skip, isSkip, } from "./errors.js";
 export type { DocumentProps, DefaultEnv, RouteDefinition, RouteConfig, RouteDefinitionOptions, TrailingSlashMode, Handler, // Supports params object, path pattern, or route name
-HandlerContext, ExtractParams, GenericParams, Middleware, RevalidateParams, Revalidate, ActionRef, RouteKeys, LoaderDefinition, LoaderFn, LoaderContext, LoaderOptions, FetchableLoaderOptions, LoadOptions, ErrorInfo, ErrorBoundaryFallbackProps, ErrorBoundaryHandler, ClientErrorBoundaryFallbackProps, NotFoundInfo, NotFoundBoundaryFallbackProps, NotFoundBoundaryHandler, ErrorPhase, OnErrorContext, OnErrorCallback, } from "./types.js";
+HandlerContext, ExtractParams, GenericParams, Middleware, RevalidateParams, Revalidate, ActionRef, IsActionFn, RouteKeys, LoaderDefinition, LoaderFn, LoaderContext, LoaderOptions, FetchableLoaderOptions, LoadOptions, ErrorInfo, ErrorBoundaryFallbackProps, ErrorBoundaryHandler, ClientErrorBoundaryFallbackProps, NotFoundInfo, NotFoundBoundaryFallbackProps, NotFoundBoundaryHandler, ErrorPhase, OnErrorContext, OnErrorCallback, } from "./types.js";
 export type { SearchSchema, SearchSchemaValue, ResolveSearchSchema, RouteSearchParams, RouteParams, } from "./search-params.js";
 export { TRACKING_SEARCH_PARAMS, type CacheSearchParams, } from "./cache/search-params-filter.js";
 export { createLoader } from "./loader.js";

package/dist/types/index.rsc.d.ts

@@ -9,7 +9,7 @@
  * in RSC context, while the regular index.ts is used in client components.
  */
 export { RouteNotFoundError, DataNotFoundError, notFound, MiddlewareError, HandlerError, BuildError, DslContextError, InvalidHandlerError, RouterError, Skip, isSkip, } from "./index.js";
-export type { DocumentProps, DefaultEnv, RouteDefinition, RouteConfig, RouteDefinitionOptions, TrailingSlashMode, Handler, HandlerContext, ExtractParams, GenericParams, Middleware, RevalidateParams, Revalidate, ActionRef, RouteKeys, LoaderDefinition, LoaderFn, LoaderContext, FetchableLoaderOptions, LoadOptions, ErrorInfo, ErrorBoundaryFallbackProps, ErrorBoundaryHandler, ClientErrorBoundaryFallbackProps, NotFoundInfo, NotFoundBoundaryFallbackProps, NotFoundBoundaryHandler, ErrorPhase, OnErrorContext, OnErrorCallback, TransitionConfig, TransitionWhenFn, TransitionWhenContext, ViewTransitionClass, } from "./types.js";
+export type { DocumentProps, DefaultEnv, RouteDefinition, RouteConfig, RouteDefinitionOptions, TrailingSlashMode, Handler, HandlerContext, ExtractParams, GenericParams, Middleware, RevalidateParams, Revalidate, ActionRef, IsActionFn, RouteKeys, LoaderDefinition, LoaderFn, LoaderContext, FetchableLoaderOptions, LoadOptions, ErrorInfo, ErrorBoundaryFallbackProps, ErrorBoundaryHandler, ClientErrorBoundaryFallbackProps, NotFoundInfo, NotFoundBoundaryFallbackProps, NotFoundBoundaryHandler, ErrorPhase, OnErrorContext, OnErrorCallback, TransitionConfig, TransitionWhenFn, TransitionWhenContext, ViewTransitionClass, } from "./types.js";
 export type { RangoOptions, SSRStreamMode, SSROptions, ResolveStreamingContext, } from "./router.js";
 export type { OriginCheckConfig, OriginCheckContext, OriginCheckPhase, } from "./rsc/origin-guard.js";
 export type { ShellCaptureDebug, ShellCaptureDebugEvent, } from "./rsc/shell-capture.js";

package/dist/types/router/is-action.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared `isAction()` matcher for revalidate predicates (server + clientUrls).
+ *
+ * Action identity is `actionId`. The helper resolves an imported reference the
+ * same way the action boundary derives that id (`$id ?? $$id`), so a
+ * rename-safe `isAction(fn)` / `isAction(namespace)` match works in both the
+ * RSC environment (file-path `$id`) and the browser (hashed `$$id`).
+ */
+import type { IsActionFn } from "../types.js";
+/**
+ * Resolve a server-action reference's stable id, mirroring how the action
+ * boundary derives `actionContext.actionId` in `rsc/server-action.ts`
+ * (`$id ?? $$id`): the file-path `$id` set by the expose-action-id plugin in a
+ * production RSC build when present, otherwise React's `$$id`. Resolving both
+ * the incoming `actionId` and the reference with the same precedence makes
+ * `isAction()` form-agnostic across dev and production.
+ */
+export declare function resolveActionRefId(ref: unknown): string | undefined;
+/**
+ * Build the `isAction()` helper bound to the current action. Called with no
+ * arguments it answers "is this request an action at all?" — `true` during
+ * action handling (including action-triggered refetches that carry no id
+ * yet), `false` on plain navigation. Called with one or more action
+ * references it narrows to those: a single imported action, several
+ * (variadic), a namespace import (`import * as Mod`), an object literal of
+ * actions (`{ addToCart, removeFromCart }`), or a grouped namespace object.
+ * Returns `false` when there is no action or nothing matches.
+ *
+ * `inAction` is the request kind. It defaults to "an id is present" so
+ * existing server call sites stay a single argument. The client passes the
+ * explicit flag so a refetch terminal with `isAction: true` still answers
+ * bare `isAction()` even if `actionId` was not threaded.
+ */
+export declare function makeIsAction(currentActionId: string | undefined, inAction?: boolean): IsActionFn;

package/dist/types/rsc/types.d.ts

@@ -107,37 +107,37 @@ export interface RscPayload {
  */
 export type ReactFormState = unknown;
 /**
- * RSC dependencies from @vitejs/plugin-rsc/rsc
+ * RSC dependencies from @vitejs/plugin-rsc/rsc/server
  */
 export interface RSCDependencies {
     /**
-     * renderToReadableStream from @vitejs/plugin-rsc/rsc
+     * renderToReadableStream from @vitejs/plugin-rsc/rsc/server
      */
     renderToReadableStream: <T>(payload: T, options?: {
         temporaryReferences?: unknown;
         onError?: (error: unknown) => string | void;
     }) => ReadableStream<Uint8Array>;
     /**
-     * decodeReply from @vitejs/plugin-rsc/rsc
+     * decodeReply from @vitejs/plugin-rsc/rsc/server
      */
     decodeReply: (body: FormData | string, options?: {
         temporaryReferences?: unknown;
     }) => Promise<unknown[]>;
     /**
-     * createTemporaryReferenceSet from @vitejs/plugin-rsc/rsc
+     * createTemporaryReferenceSet from @vitejs/plugin-rsc/rsc/server
      */
     createTemporaryReferenceSet: () => unknown;
     /**
-     * loadServerAction from @vitejs/plugin-rsc/rsc
+     * loadServerAction from @vitejs/plugin-rsc/rsc/server
      */
     loadServerAction: (actionId: string) => Promise<Function>;
     /**
-     * decodeAction from @vitejs/plugin-rsc/rsc
+     * decodeAction from @vitejs/plugin-rsc/rsc/server
      * Decodes a FormData into a bound action function (for useActionState forms)
      */
     decodeAction: (body: FormData) => Promise<() => Promise<unknown>>;
     /**
-     * decodeFormState from @vitejs/plugin-rsc/rsc
+     * decodeFormState from @vitejs/plugin-rsc/rsc/server
      * Decodes the action result into a ReactFormState for useActionState progressive enhancement
      */
     decodeFormState: (actionResult: unknown, body: FormData) => Promise<ReactFormState | null>;
@@ -268,8 +268,8 @@ export interface CreateRSCHandlerOptions<TEnv = unknown, TRoutes extends Record<
      */
     router: RangoInternal<TEnv, TRoutes>;
     /**
-     * RSC dependencies from @vitejs/plugin-rsc/rsc.
-     * Defaults to the exports from @vitejs/plugin-rsc/rsc.
+     * RSC dependencies from @vitejs/plugin-rsc/rsc/server.
+     * Defaults to the exports from @vitejs/plugin-rsc/rsc/server.
      */
     deps?: RSCDependencies;
     /**

package/dist/types/ssr/index.d.ts

@@ -117,10 +117,19 @@ export interface SSRDependencies<TEnv = unknown> {
      */
     injectRSCPayload: (rscStream: ReadableStream<Uint8Array>, options?: InjectRSCPayloadOptions) => TransformStream<Uint8Array, Uint8Array>;
     /**
-     * Function to load bootstrap script content
-     * Typically: () => import.meta.viteRsc.loadBootstrapScriptContent("index")
+     * Function to load bootstrap script content.
+     * Required unless `getClientEntryUrl` is provided with `headScripts: "preinit"`.
+     * Custom SSR entries typically: `() => import.meta.viteRsc.loadBootstrapScriptContent("index")`
+     * (deprecated in `@vitejs/plugin-rsc` 0.5.33 in favor of `getClientEntryUrl`).
      */
-    loadBootstrapScriptContent: () => Promise<string>;
+    loadBootstrapScriptContent?: () => Promise<string>;
+    /**
+     * Client entry URL from `@vitejs/plugin-rsc/ssr` `getClientEntryUrl()`.
+     * Preferred when `headScripts` is `"preinit"`: Fizz receives `bootstrapModules`
+     * without the deprecated `loadBootstrapScriptContent` round-trip. Custom SSR
+     * entries can omit this and keep the inline bootstrap path.
+     */
+    getClientEntryUrl?: () => string;
     /**
      * Document script strategy; the generated virtual SSR entry threads the
      * `rango({ headScripts })` plugin option here (canonical docs on
@@ -251,7 +260,10 @@ interface ShellResumeOptions {
  * @example
  * ```tsx
  * import { createSSRHandler } from "@rangojs/router/ssr";
- * import { createFromReadableStream } from "@rangojs/router/internal/deps/ssr";
+ * import {
+ *   createFromReadableStream,
+ *   getClientEntryUrl,
+ * } from "@rangojs/router/internal/deps/ssr";
  * import { renderToReadableStream } from "react-dom/server.edge";
  * import { injectRSCPayload } from "@rangojs/router/internal/deps/html-stream-server";
  *
@@ -259,6 +271,17 @@ interface ShellResumeOptions {
  *   createFromReadableStream,
  *   renderToReadableStream,
  *   injectRSCPayload,
+ *   getClientEntryUrl,
+ *   headScripts: "preinit", // getClientEntryUrl is only used under "preinit"
+ * });
+ * ```
+ *
+ * Custom SSR entries that still use the deprecated bootstrap helper:
+ * ```tsx
+ * export const renderHTML = createSSRHandler({
+ *   createFromReadableStream,
+ *   renderToReadableStream,
+ *   injectRSCPayload,
  *   loadBootstrapScriptContent: () =>
  *     import.meta.viteRsc.loadBootstrapScriptContent("index"),
  * });

package/dist/types/testing/flight.d.ts

@@ -6,14 +6,15 @@
  * the same react-server-dom serializer the router uses at runtime. It runs in
  * plain node (no Vite, no browser), but ONLY under the `react-server` export
  * condition. The serializer is the VENDORED build shipped with
- * @vitejs/plugin-rsc — the public `@vitejs/plugin-rsc/rsc` entry top-level
- * imports Vite virtual modules and is not usable outside a Vite build.
+ * @vitejs/plugin-rsc — the public `@vitejs/plugin-rsc/rsc/server` entry
+ * top-level imports Vite virtual modules and is not usable outside a Vite
+ * build.
  *
  * Run the example/tests for this module via the dedicated rsc vitest project
  * (vitest.rsc.config.ts), which forces `--conditions=react-server` on the
  * worker. The main vitest project must NOT use that condition (it would flip
  * React to the no-hooks server build and break the ~50 tests that mock
- * @vitejs/plugin-rsc/rsc).
+ * @vitejs/plugin-rsc/rsc/server).
  *
  * Scope / limitations (v1):
  * - Server-only / leaf trees. A tree containing a CLIENT component emits an

package/dist/types/testing/index.d.ts

@@ -26,7 +26,7 @@
  *   condition and would throw if pulled into this barrel.
  *
  * Layers:
- * - Unit:        runMiddleware, runLoader
+ * - Unit:        runMiddleware, runLoader, runClientRevalidate
  * - Integration: dispatch (request -> Response)
  * - Cross-cut:   assertCacheStatus, assertShellStatus, assertGeneratedRoutesMatch
  * - Component:   see @rangojs/router/testing/dom (renderRoute)
@@ -39,6 +39,8 @@ export { runLoader, runLoaderResult } from "./run-loader.js";
 export type { RunLoaderOptions, RunLoaderResult, UseResolver, TestLoaderContext, } from "./run-loader.js";
 export { runTransitionWhen } from "./run-transition-when.js";
 export type { RunTransitionWhenOptions, RunTransitionWhenResult, } from "./run-transition-when.js";
+export { runClientRevalidate } from "./run-client-revalidate.js";
+export type { RunClientRevalidateOptions } from "./run-client-revalidate.js";
 export { dispatch } from "./dispatch.js";
 export type { DispatchOptions } from "./dispatch.js";
 export { assertCacheStatus, assertCacheDecision, parseCacheHeader, createCacheSink, filterCacheDecisions, } from "./cache-status.js";

package/dist/types/testing/run-client-revalidate.d.ts

@@ -0,0 +1,43 @@
+/**
+ * runClientRevalidate — unit-test clientUrls() revalidate() predicates.
+ *
+ * Builds the same {@link ClientRevalidateArgs} the browser collector passes
+ * and evaluates the predicate(s) through the SAME chain evaluator production
+ * uses (client-urls/revalidate-chain.ts) — locked default, boolean
+ * short-circuit, soft-verdict threading, and fail-open are the production
+ * code paths, not a re-implementation. Pass an array to test a chain.
+ *
+ * Synchronous: client revalidate functions must be sync.
+ */
+import type { ClientRevalidateFn } from "../client-urls/types.js";
+/**
+ * Options for {@link runClientRevalidate}. Defaults model a same-URL
+ * navigation with no action (locked default `false`).
+ */
+export interface RunClientRevalidateOptions {
+    currentUrl?: string | URL;
+    nextUrl?: string | URL;
+    currentParams?: Record<string, string>;
+    nextParams?: Record<string, string>;
+    stale?: boolean;
+    /**
+     * The triggering action: a single imported reference (id resolved via
+     * `$id ?? $$id`; throws if the function carries neither) or a raw actionId
+     * string. A namespace/object is rejected — it cannot identify the ONE
+     * action that triggered the request. Omit for a plain navigation.
+     */
+    action?: ((...args: never[]) => unknown) | string;
+    /**
+     * Model an action-triggered refetch GET: predicates see `isAction()` as
+     * true, but the locked default stays the navigation default, matching how
+     * the server evaluates that request (no actionContext). Defaults to
+     * treating a provided `action` as the action POST itself.
+     */
+    actionRequest?: boolean;
+}
+/**
+ * Run one clientUrls `revalidate()` predicate — or a chain, in declaration
+ * order — against production-built args. Returns the final boolean decision
+ * (locked default if every predicate defers or throws).
+ */
+export declare function runClientRevalidate(fn: ClientRevalidateFn | readonly ClientRevalidateFn[], opts?: RunClientRevalidateOptions): boolean;

package/dist/types/testing/to-url.d.ts

@@ -0,0 +1,2 @@
+/** Shared string|URL coercion for the testing primitives. */
+export declare function toURL(value: string | URL | undefined, fallback: URL): URL;

package/dist/types/testing/vitest-stubs/plugin-rsc.d.ts

@@ -5,3 +5,5 @@ export declare const decodeReply: () => undefined;
 export declare const decodeAction: () => undefined;
 export declare const decodeFormState: () => undefined;
 export declare const createTemporaryReferenceSet: () => Record<string, never>;
+export declare const encodeReply: () => never;
+export declare const createClientTemporaryReferenceSet: () => Record<string, never>;

package/dist/types/testing/vitest.d.ts

@@ -18,7 +18,8 @@
  *   `@rangojs/router` specifier to its react-server entry (real impls) while
  *   leaving React as the client build — which is exactly what this helper does.
  * - The build-only `@rangojs/router:version` virtual and `@vitejs/plugin-rsc/rsc`
- *   (whose real body imports unresolvable Vite virtuals) are stubbed.
+ *   plus `/rsc/server`, `/rsc/client` (whose real body imports unresolvable
+ *   Vite virtuals) are stubbed.
  * - Cloudflare apps additionally import the `cloudflare:workers` /
  *   `cloudflare:email` runtime virtuals; pass `{ preset: "cloudflare" }` to stub them.
  *

package/dist/types/types/handler-context.d.ts

@@ -418,13 +418,17 @@ export type RevalidateParams<TParams = GenericParams, TEnv = any> = Parameters<S
 /**
  * A reference to a server action, used by `isAction()` in a revalidate predicate.
  *
- * Either a directly imported action (`import { addToCart }`) or a namespace
- * import of an action module (`import * as CartActions`). Matching resolves the
+ * Either a directly imported action (`import { addToCart }`), a namespace
+ * import of an action module (`import * as CartActions`), an object
+ * literal of actions (`{ addToCart, removeFromCart }`), or a grouped
+ * namespace (`{ Cart: CartActions, Order: OrderActions }`). Matching resolves the
  * action's build-injected id (`path#export`) — the same identity the router uses
  * for `actionId` — so a renamed or moved action breaks at compile time instead
  * of silently failing to match.
  */
 export type ActionRef = ((...args: never[]) => unknown) | Record<string, unknown>;
+/** The `isAction()` matcher passed to server and client `revalidate()` predicates. */
+export type IsActionFn = (...actions: ActionRef[]) => boolean;
 /**
  * Revalidation function called during client-side navigation to decide whether
  * a segment (layout, route, parallel slot, or loader) should be re-rendered.
@@ -511,8 +515,10 @@ export type ShouldRevalidateFn<TParams = GenericParams, TEnv = any> = (args: {
     /**
      * Typed, rename-safe action matching. Returns `true` when the action that
      * triggered this revalidation is one of the given references — or, for a
-     * namespace import (`import * as CartActions`), any export of that module —
-     * and `false` otherwise (including plain navigation with no action).
+     * namespace import (`import * as CartActions`), object literal
+     * (`{ addToCart, removeFromCart }`), or grouped namespaces
+     * (`{ Cart: CartActions }`), any of those exports — and `false`
+     * otherwise (including plain navigation with no action).
      *
      * Called with NO arguments it answers "is this request an action at all?":
      * `true` for any action, `false` on plain navigation. Use the bare form when
@@ -536,9 +542,10 @@ export type ShouldRevalidateFn<TParams = GenericParams, TEnv = any> = (args: {
      * revalidate((ctx) => ctx.isAction(addToCart) || undefined); // one action
      * revalidate((ctx) => ctx.isAction(addToCart, removeFromCart) || undefined); // several
      * revalidate((ctx) => ctx.isAction(CartActions) || undefined); // any in the module
+     * revalidate((ctx) => ctx.isAction({ addToCart, removeFromCart }) || undefined); // object form
      * ```
      */
-    isAction: (...actions: ActionRef[]) => boolean;
+    isAction: IsActionFn;
     /** URL where the action was executed (the page the user was on when they triggered the action). */
     actionUrl?: URL;
     /** Return value from the action execution. Can be used to conditionally revalidate based on the action's outcome. */

package/dist/types/types/index.d.ts

@@ -3,7 +3,7 @@ import "./global-namespace.js";
 export type { DocumentProps, ExtractParams, TrailingSlashMode, RouteConfig, RouteDefinitionOptions, RouteDefinition, ResolvedRouteMap, } from "./route-config.js";
 export type { ErrorInfo, ErrorBoundaryFallbackProps, ErrorBoundaryHandler, ClientErrorBoundaryFallbackProps, LoaderDataResult, NotFoundInfo, NotFoundBoundaryFallbackProps, NotFoundBoundaryHandler, } from "./boundaries.js";
 export { isLoaderDataResult } from "./boundaries.js";
-export type { MiddlewareFn, ScopedRouteMap, Handler, HandlerContext, InternalHandlerContext, GenericParams, RevalidateParams, ShouldRevalidateFn, ActionRef, RouteKeys, ExtractRouteParams, HandlersForRouteMap, Revalidate, Middleware, } from "./handler-context.js";
+export type { MiddlewareFn, ScopedRouteMap, Handler, HandlerContext, InternalHandlerContext, GenericParams, RevalidateParams, ShouldRevalidateFn, ActionRef, IsActionFn, RouteKeys, ExtractRouteParams, HandlersForRouteMap, Revalidate, Middleware, } from "./handler-context.js";
 export type { ViewTransitionClass, TransitionConfig, TransitionWhenFn, TransitionWhenContext, ResolvedSegment, SegmentMetadata, SlotState, RootLayoutProps, MatchResult, } from "./segments.js";
 export type { LazyIncludeContext, RouteEntry } from "./route-entry.js";
 export type { LoaderContext, LoaderFn, FetchableLoaderOptions, LoaderOptions, LoadOptions, LoaderDefinition, } from "./loader-types.js";

package/dist/types/vite/plugins/expose-action-id.d.ts

@@ -1,4 +1,18 @@
 import type { Plugin } from "vite";
+/**
+ * Per-reference own `bind` injected next to `$$id`. React's client.browser
+ * build carries no server-reference metadata across `.bind()` (the
+ * edge/node/server builds install an own `bind` on each reference that
+ * does), so `isAction(boundStub)` would silently miss in the browser only.
+ * Installing the same per-reference own `bind` here — scoped to the stubs
+ * this plugin already wraps, guarded to never override an existing own
+ * `bind` — closes that without mutating the global Function.prototype
+ * (which would re-wrap once per Vite environment/HMR pass and break
+ * native-function detection for co-loaded code). The helper re-installs
+ * itself on the bound result so chained binds keep the metadata too.
+ */
+export declare const ACTION_BIND_HELPER_NAME: string;
+export declare const ACTION_BIND_HELPER_SOURCE: string;
 /**
  * Vite plugin that exposes action IDs on server reference functions.
  *

package/dist/types/vite/plugins/virtual-entries.d.ts

@@ -3,8 +3,9 @@ export declare const VIRTUAL_ENTRY_BROWSER: string;
 /**
  * Generate the virtual SSR entry. `headScripts` mirrors the rango() plugin
  * option: "preinit" (default) installs the client-reference preinit hook and
- * lets the SSR handlers convert the bootstrap to `bootstrapModules`;
- * "preload" omits the hook and pins the handlers to the hint-only strategy.
+ * threads `getClientEntryUrl` so Fizz emits `bootstrapModules`;
+ * "preload" omits the hook and uses the deprecated inline
+ * `loadBootstrapScriptContent` bootstrap.
  */
 export declare function getVirtualEntrySSR(headScripts?: HeadScriptsOption, progressiveChunkSize?: number): string;
 /**