@rangojs/router 0.10.0 → 0.11.0

package/src/router/is-action.ts

@@ -0,0 +1,100 @@
+/**
+ * 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 { ActionRef, IsActionFn } from "../types.js";
+
+// Bind preservation is per-reference, in expose-action-id.ts. Do not patch
+// Function.prototype.bind here (rsc+ssr share a realm; global wrap stacks).
+
+/**
+ * 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 function resolveActionRefId(ref: unknown): string | undefined {
+  if (ref == null) return undefined;
+  const r = ref as { $id?: unknown; $$id?: unknown };
+  if (typeof r.$id === "string") return r.$id;
+  if (typeof r.$$id === "string") return r.$$id;
+  return undefined;
+}
+
+/**
+ * Depth cap for the object walk. The supported shapes need at most two
+ * object levels — a namespace (values are functions) and a grouped-namespace
+ * literal (`{ Cart: CartActions }`, values are namespaces). The cap keeps an
+ * accidentally passed arbitrary object (a ctx, a data blob — it type-checks
+ * as Record<string, unknown>) from triggering a full deep traversal on every
+ * predicate call.
+ */
+const MAX_ACTION_REF_DEPTH = 3;
+
+function matchesActionRef(
+  ref: unknown,
+  currentActionId: string,
+  seen: Set<object>,
+  depth: number,
+): boolean {
+  if (ref == null) return false;
+  if (typeof ref === "function") {
+    return resolveActionRefId(ref) === currentActionId;
+  }
+  if (typeof ref !== "object") return false;
+  if (depth >= MAX_ACTION_REF_DEPTH) return false;
+  if (seen.has(ref)) return false;
+  seen.add(ref);
+  // Namespace, object literal, or grouped namespaces
+  // (`{ Cart: CartActions, Order: OrderActions }`): walk every value.
+  // Object.values invokes getters; a throwing getter must not abort the
+  // predicate into the fail-open path, so treat it as "no match here".
+  let values: unknown[];
+  try {
+    values = Object.values(ref);
+  } catch {
+    return false;
+  }
+  for (const value of values) {
+    if (matchesActionRef(value, currentActionId, seen, depth + 1)) return true;
+  }
+  return false;
+}
+
+/**
+ * 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 function makeIsAction(
+  currentActionId: string | undefined,
+  inAction: boolean = currentActionId !== undefined,
+): IsActionFn {
+  return (...actions: ActionRef[]): boolean => {
+    if (!inAction) return false;
+    if (actions.length === 0) return true;
+    if (!currentActionId) return false;
+    const seen = new Set<object>();
+    for (const action of actions) {
+      if (matchesActionRef(action, currentActionId, seen, 0)) return true;
+    }
+    return false;
+  };
+}

package/src/router/revalidation.ts

@@ -4,7 +4,7 @@
  * Evaluates whether segments should revalidate based on params, actions, and custom functions.
  */
 
-import type { ResolvedSegment, HandlerContext, ActionRef } from "../types";
+import type { ResolvedSegment, HandlerContext } from "../types";
 import type { ActionContext } from "./types";
 import {
   debugLog,
@@ -15,52 +15,7 @@ import type { RevalidationTraceEntry } from "./logging.js";
 import { _getRequestContext } from "../server/request-context.js";
 import { isAutoGeneratedRouteName } from "../route-name.js";
 import { paramsEqual } from "./params-util.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.
- */
-function resolveActionRefId(ref: unknown): string | undefined {
-  if (ref == null) return undefined;
-  const r = ref as { $id?: unknown; $$id?: unknown };
-  if (typeof r.$id === "string") return r.$id;
-  if (typeof r.$$id === "string") return r.$$id;
-  return undefined;
-}
-
-/**
- * Build the `isAction()` helper bound to the current action's id. Called with no
- * arguments it answers "is this request an action at all?" (any action) — `true`
- * during action handling, `false` on plain navigation. Called with one or more
- * action references it narrows to those: a single imported action, several
- * (variadic), or any export of a namespace import (`import * as Mod`). Returns
- * `false` when there is no action (plain navigation) or nothing matches.
- */
-function makeIsAction(
-  currentActionId: string | undefined,
-): (...actions: ActionRef[]) => boolean {
-  return (...actions: ActionRef[]): boolean => {
-    if (!currentActionId) return false;
-    // Bare isAction(): an action is in flight (currentActionId is set) and the
-    // caller did not narrow to a specific action, so this is "any action".
-    if (actions.length === 0) return true;
-    for (const action of actions) {
-      if (typeof action === "function") {
-        if (resolveActionRefId(action) === currentActionId) return true;
-      } else if (action && typeof action === "object") {
-        // Namespace import: match any export of the module.
-        for (const value of Object.values(action)) {
-          if (resolveActionRefId(value) === currentActionId) return true;
-        }
-      }
-    }
-    return false;
-  };
-}
+import { makeIsAction } from "./is-action.js";
 
 /**
  * Options for revalidation evaluation
@@ -249,6 +204,8 @@ export async function evaluateRevalidation<TEnv>(
       ? prevRouteKey
       : undefined;
 
+  const isActionFn = makeIsAction(actionContext?.actionId);
+
   for (const { name, fn } of revalidations) {
     let result: any;
     try {
@@ -265,7 +222,7 @@ export async function evaluateRevalidation<TEnv>(
         slotName: segment.slot,
         // Action context (only populated when triggered by server action)
         actionId: actionContext?.actionId,
-        isAction: makeIsAction(actionContext?.actionId),
+        isAction: isActionFn,
         actionUrl: actionContext?.actionUrl,
         actionResult: actionContext?.actionResult,
         formData: actionContext?.formData,

package/src/rsc/server-action.ts

@@ -20,6 +20,7 @@ import {
   setRequestContextParams,
 } from "../server/request-context.js";
 import { observePhase, PHASES } from "../router/instrument.js";
+import { resolveActionRefId } from "../router/is-action.js";
 import type { TraceSpan } from "../router/tracing.js";
 import { gateTransitions } from "./transition-gate.js";
 import type { RscPayload } from "./types.js";
@@ -302,10 +303,7 @@ export async function executeServerAction<TEnv>(
   }
 
   // Build continuation for the revalidation phase
-  const actionMeta = loadedAction as
-    | { $id?: string; $$id?: string }
-    | undefined;
-  const resolvedActionId = actionMeta?.$id ?? actionMeta?.$$id ?? actionId;
+  const resolvedActionId = resolveActionRefId(loadedAction) ?? actionId;
 
   return {
     returnValue,

package/src/rsc/shell-capture-constants.ts

@@ -30,7 +30,7 @@ export const SHELL_CAPTURE_MAX_WAIT_MS = 15_000;
  * Hard cap on one capture TASK — runShellCapture end to end (both attempts +
  * the in-place retry delay). SHELL_CAPTURE_MAX_WAIT_MS arms only inside
  * captureShellHTML, AFTER the capture's router.match(); a handler wedged on a
- * never-settling upstream await (autobarn pilot: a 30s+ tarpitting fetch)
+ * never-settling upstream await (production pilot: a 30s+ tarpitting fetch)
  * wedges the task with no deadline in force. The task's settle path releases
  * the per-key stampede guard and the serialized capture-queue slot, so an
  * unbounded task strands BOTH for the isolate's lifetime.

package/src/rsc/shell-capture.ts

@@ -381,7 +381,7 @@ function warnNullCaptureOnce(key: string): void {
       "a <Suspense> above the consuming component.\n" +
       'See the /ppr skill (node_modules/@rangojs/router/skills/ppr/SKILL.md), "The hole ' +
       'doctrine" and "The layout-with-loaders playbook", or the design docs: ' +
-      "https://github.com/ivogt/vite-rsc/blob/main/packages/rangojs-router/docs/design/ppr-shell-resume.md",
+      "https://github.com/rangojs/rango/blob/main/packages/rangojs-router/docs/design/ppr-shell-resume.md",
   );
 }
 
@@ -1049,7 +1049,7 @@ export function scheduleShellCapture(
       // Hard-capped: SHELL_CAPTURE_MAX_WAIT_MS arms only inside
       // captureShellHTML, AFTER the capture's router.match() — a handler
       // wedged on a never-settling upstream await has no deadline in force
-      // and would strand the stampede guard and the queue slot (autobarn
+      // and would strand the stampede guard and the queue slot (production
       // pilot). The cap rejects, riding the existing catch: backoff +
       // reportCacheError + token-guarded release. The abandoned attempt keeps
       // running until its context dies; nothing awaits it.

package/src/testing/index.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)
@@ -53,6 +53,9 @@ export type {
   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";
 

package/src/testing/run-client-revalidate.ts

@@ -0,0 +1,108 @@
+/**
+ * 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 { makeIsAction, resolveActionRefId } from "../router/is-action.js";
+import {
+  lockedClientDefault,
+  runClientRevalidateChain,
+} from "../client-urls/revalidate-chain.js";
+import { toURL } from "./to-url.js";
+import type {
+  ClientRevalidateArgs,
+  ClientRevalidateFn,
+} from "../client-urls/types.js";
+
+const DEFAULT_URL = "http://localhost/";
+
+function resolveActionId(
+  action: ((...args: never[]) => unknown) | string | undefined,
+): string | undefined {
+  if (action === undefined) return undefined;
+  if (typeof action === "string") return action;
+  const id = resolveActionRefId(action);
+  if (id === undefined) {
+    throw new Error(
+      "runClientRevalidate: `action` must be a single imported server action " +
+        "(carrying its build-injected id) or an actionId string. The passed " +
+        "function has no $id/$$id — outside a built app, pass the id string " +
+        'your predicate should match (e.g. "src/actions/cart.ts#addToCart").',
+    );
+  }
+  return id;
+}
+
+/**
+ * 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 function runClientRevalidate(
+  fn: ClientRevalidateFn | readonly ClientRevalidateFn[],
+  opts: RunClientRevalidateOptions = {},
+): boolean {
+  const currentUrl = toURL(opts.currentUrl, new URL(DEFAULT_URL));
+  const nextUrl = toURL(opts.nextUrl, currentUrl);
+  const currentParams = opts.currentParams ?? {};
+  const nextParams = opts.nextParams ?? currentParams;
+  const inAction = opts.action !== undefined;
+  const actionId = resolveActionId(opts.action);
+  const defaultShouldRevalidate = lockedClientDefault({
+    actionRequest: opts.actionRequest ?? inAction,
+    currentParams,
+    nextParams,
+    currentUrl,
+    nextUrl,
+  });
+
+  const baseArgs: Omit<ClientRevalidateArgs, "defaultShouldRevalidate"> = {
+    currentUrl,
+    nextUrl,
+    currentParams,
+    nextParams,
+    stale: opts.stale ?? false,
+    isAction: makeIsAction(actionId, inAction),
+    ...(actionId !== undefined ? { actionId } : {}),
+  };
+
+  return runClientRevalidateChain(
+    Array.isArray(fn) ? fn : [fn],
+    baseArgs,
+    defaultShouldRevalidate,
+    "runClientRevalidate predicate",
+  );
+}

package/src/testing/run-transition-when.ts

@@ -35,9 +35,7 @@ import type { OnErrorCallback } from "../types/error-types.js";
 import type { EntryData } from "../server/context.js";
 import { evaluatePprTransitionWhen } from "../router/transition-when.js";
 import { invokeOnError } from "../router/error-handling.js";
-
-const toURL = (v: string | URL, base: URL): URL =>
-  typeof v === "string" ? new URL(v, base.origin) : v;
+import { toURL } from "./to-url.js";
 
 /**
  * Options for runTransitionWhen. All navigation/action fields are optional and

package/src/testing/to-url.ts

@@ -0,0 +1,5 @@
+/** Shared string|URL coercion for the testing primitives. */
+export function toURL(value: string | URL | undefined, fallback: URL): URL {
+  if (value === undefined) return fallback;
+  return typeof value === "string" ? new URL(value, fallback.origin) : value;
+}

package/src/types/handler-context.ts

@@ -541,8 +541,10 @@ export type RevalidateParams<TParams = GenericParams, TEnv = any> = Parameters<
 /**
  * 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.
@@ -551,6 +553,9 @@ 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.
@@ -643,8 +648,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
@@ -668,9 +675,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/src/types/index.ts

@@ -38,6 +38,7 @@ export type {
   RevalidateParams,
   ShouldRevalidateFn,
   ActionRef,
+  IsActionFn,
   RouteKeys,
   ExtractRouteParams,
   HandlersForRouteMap,

package/src/vite/plugins/expose-action-id.ts

@@ -92,6 +92,27 @@ function isUseServerModule(filePath: string): boolean {
   }
 }
 
+/**
+ * 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 const ACTION_BIND_HELPER_NAME: string = "__rangoActionBind";
+export const ACTION_BIND_HELPER_SOURCE: string = `var ${ACTION_BIND_HELPER_NAME} = function () {
+  var bound = Function.prototype.bind.apply(this, arguments);
+  if (typeof this.$id === "string") bound.$id = this.$id;
+  if (typeof this.$$id === "string") bound.$$id = this.$$id;
+  bound.bind = ${ACTION_BIND_HELPER_NAME};
+  return bound;
+};`;
+
 function applyServerReferenceWrapping(
   code: string,
   s: MagicString,
@@ -126,10 +147,17 @@ function applyServerReferenceWrapping(
       }
     }
 
-    const replacement = `(function(fn) { fn.$$id = ${finalIdArg}; return fn; })(${fnCall}(${idArg}${rest}))`;
+    const replacement =
+      `(function(fn) { fn.$$id = ${finalIdArg}; ` +
+      `if (!Object.prototype.hasOwnProperty.call(fn, "bind")) fn.bind = ${ACTION_BIND_HELPER_NAME}; ` +
+      `return fn; })(${fnCall}(${idArg}${rest}))`;
     s.overwrite(start, end, replacement);
   }
 
+  if (hasChanges) {
+    s.prepend(`${ACTION_BIND_HELPER_SOURCE}\n`);
+  }
+
   return hasChanges;
 }
 

package/dist/__internal.d.ts

@@ -1,83 +0,0 @@
-/**
- * Internal Types - Implementation Details
- *
- * @internal
- * These types are for internal use only and should not be relied upon by consumers.
- * They may change without notice between versions.
- *
- * If you find yourself needing these types, please open an issue to discuss
- * adding them to the public API.
- */
-/**
- * @internal
- * Internal representation of a resolved route segment.
- * Used during route matching and rendering pipeline.
- */
-export type { ResolvedSegment, SegmentMetadata } from "./types.js";
-/**
- * @internal
- * Internal match result from route resolution.
- */
-export type { MatchResult, SlotState } from "./types.js";
-/**
- * @internal
- * Context for intercept route selection.
- */
-export type { InterceptSelectorContext, InterceptSegmentsState, InterceptWhenFn, } from "./server/context.js";
-/**
- * @internal
- * RSC protocol payload structure.
- */
-export type { RscPayload, ReactFormState } from "./rsc/types.js";
-/**
- * @internal
- * Internal navigation store interface.
- */
-export type { NavigationStore, NavigationBridge, RscMetadata, ActionResult, InflightAction, NavigationState, TrackedActionState, ActionStateListener, SegmentCache, SegmentState, NavigationUpdate, } from "./browser/types.js";
-/**
- * @internal
- * Internal handle storage mechanism.
- */
-export type { HandleStore, HandleData } from "./server/handle-store.js";
-/**
- * @internal
- * Segment handle data in cache.
- */
-export type { SegmentHandleData } from "./cache/types.js";
-/**
- * @internal
- * Internal cache entry data structure.
- */
-export type { CachedEntryData, CachedEntryResult, CacheGetResult, SerializedSegmentData, CacheDefaults, } from "./cache/types.js";
-/**
- * @internal
- * Router context for AsyncLocalStorage.
- */
-export type { RouterContext, RevalidationContext, InterceptResult } from "./router/router-context.js";
-/**
- * @internal
- * Route match context during pipeline processing.
- */
-export type { MatchContext, MatchPipelineState } from "./router/match-context.js";
-/**
- * @internal
- * Pattern matching result.
- */
-export type { RouteMatchResult } from "./router/pattern-matching.js";
-/**
- * @internal
- * Entry data during route traversal.
- */
-export type { EntryData, InterceptEntry, MetricsStore, PerformanceMetric, EntryCacheConfig, EntryPropCommon, EntryPropDatas, LoaderEntry, EntryPropSegments, } from "./server/context.js";
-/**
- * @internal
- * Internal handler context with additional props for router internals.
- * Includes `_originalRequest` and `_currentSegmentId`.
- */
-export type { InternalHandlerContext } from "./types.js";
-/**
- * @internal
- * Debug utilities for manifest inspection and comparison.
- */
-export { serializeManifest, compareManifests, formatManifestDiff, type SerializedEntry, type SerializedManifest, } from "./debug.js";
-//# sourceMappingURL=__internal.d.ts.map

package/dist/__internal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"__internal.d.ts","sourceRoot":"","sources":["../src/__internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH;;;;GAIG;AACH,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEnE;;;GAGG;AACH,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAMzD;;;GAGG;AACH,YAAY,EACV,wBAAwB,EACxB,sBAAsB,EACtB,eAAe,GAChB,MAAM,qBAAqB,CAAC;AAM7B;;;GAGG;AACH,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEjE;;;GAGG;AACH,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAM5B;;;GAGG;AACH,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAExE;;;GAGG;AACH,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAM1D;;;GAGG;AACH,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,aAAa,GACd,MAAM,kBAAkB,CAAC;AAM1B;;;GAGG;AACH,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAMtG;;;GAGG;AACH,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAElF;;;GAGG;AACH,YAAY,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAMrE;;;GAGG;AACH,YAAY,EACV,SAAS,EACT,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,WAAW,EACX,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAM7B;;;;GAIG;AACH,YAAY,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAMzD;;;GAGG;AACH,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,eAAe,EACpB,KAAK,kBAAkB,GACxB,MAAM,YAAY,CAAC"}

package/dist/__internal.js

@@ -1,19 +0,0 @@
-/**
- * Internal Types - Implementation Details
- *
- * @internal
- * These types are for internal use only and should not be relied upon by consumers.
- * They may change without notice between versions.
- *
- * If you find yourself needing these types, please open an issue to discuss
- * adding them to the public API.
- */
-// ============================================================================
-// Debug Utilities (Internal)
-// ============================================================================
-/**
- * @internal
- * Debug utilities for manifest inspection and comparison.
- */
-export { serializeManifest, compareManifests, formatManifestDiff, } from "./debug.js";
-//# sourceMappingURL=__internal.js.map

package/dist/__internal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"__internal.js","sourceRoot":"","sources":["../src/__internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAsJH,+EAA+E;AAC/E,6BAA6B;AAC7B,+EAA+E;AAE/E;;;GAGG;AACH,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,GAGnB,MAAM,YAAY,CAAC"}

package/dist/__mocks__/version.d.ts

@@ -1,7 +0,0 @@
-/**
- * Mock for rsc-router:version virtual module.
- * Used by vitest since the virtual module is only available at build time.
- * Empty string disables version path in URLs for simpler test assertions.
- */
-export declare const VERSION = "";
-//# sourceMappingURL=version.d.ts.map

package/dist/__mocks__/version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/__mocks__/version.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,OAAO,KAAK,CAAC"}

package/dist/__mocks__/version.js

@@ -1,7 +0,0 @@
-/**
- * Mock for rsc-router:version virtual module.
- * Used by vitest since the virtual module is only available at build time.
- * Empty string disables version path in URLs for simpler test assertions.
- */
-export const VERSION = "";
-//# sourceMappingURL=version.js.map

package/dist/__mocks__/version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/__mocks__/version.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAC"}

package/dist/__tests__/client-href.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=client-href.test.d.ts.map

package/dist/__tests__/client-href.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client-href.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/client-href.test.ts"],"names":[],"mappings":""}