@rangojs/router 0.28.0 → 0.29.0

package/src/browser/react/use-handle.ts

@@ -53,7 +53,7 @@ export function useHandle<T, A, S>(
     return selectorRef.current ? selectorRef.current(collected) : collected;
   };
 
-  const [value, setValue] = useCommitAnchoredState(collect);
+  const [value, setValue] = useCommitAnchoredState(collect, true);
 
   useEffect(() => {
     if (!ctx) return;
@@ -68,25 +68,29 @@ export function useHandle<T, A, S>(
 }
 
 /**
- * Route state the controller's handle notifications drive (useHandle,
- * useSegments) commits with the page it belongs to. NavigationProvider
- * flushes the controller inside every payload update, so a value known then
- * is set in the page's lane. A page handed over urgently (signal "release")
- * takes a value that arrives before it commits the same way: set at default
- * priority, it renders in the page's lane, and the page's effects read it.
- * A page in a transition (signal "anchor") does not: until it commits
+ * Route state the controller's handle notifications drive commits with the
+ * page it belongs to. NavigationProvider flushes the controller inside every
+ * payload update, with signal "anchor" for a page in a transition and
+ * "release" for an urgent one, so the page's own change is set in the page's
+ * lane and the page's effects read it. From the anchor until the page commits
  * (releaseRouteState() from the provider's layout effect, signal "release"),
- * a new value waits, and is applied in the commit's task, right after the
- * page's own commit. In the page's lane, a value that suspends in a revealed
- * <Suspense> (a crumb's content) would hold the page; in a lane of its own,
- * it commits over the page being left and takes the page's transition types
- * (#1165); and a transition entangled with the page misses its commit when it
- * is set after React rendered the page, before its view transition's
- * mutation, and starts a view transition of its own. A value shallow-equal to
- * the last one sets nothing, so a reader renders only when its value moves.
+ * a later change waits and is applied in the commit's task, right after the
+ * page's own commit: set in a lane of its own, it would commit over the page
+ * being left (#1165).
+ *
+ * `waitForRelease`, set by useHandle only: the anchor's own change waits too,
+ * so a handle value lands right after its page's commit, never in its lane. A
+ * handle value can carry a promise that suspends, and in the page's lane one
+ * that suspends in a revealed <Suspense> would hold the page. Nothing
+ * useSegments reads can suspend, so it leaves it off and its path and
+ * location commit with their page.
+ *
+ * A value shallow-equal to the last one sets nothing, so a reader renders only
+ * when its value moves.
  */
 export function useCommitAnchoredState<T>(
   init: () => T,
+  waitForRelease?: boolean,
 ): [T, (value: T, signal?: RouteStateSignal) => void] {
   // An app that enables the React Compiler compiles the router too; its memo
   // cache gains nothing here and cost 107 B gzip in the router chunk.
@@ -102,8 +106,8 @@ export function useCommitAnchoredState<T>(
       r.last = next;
       r.held = true;
     }
-    // The anchor's own change goes in the page's lane, with the page.
-    if (!r.held || (r.waiting && signal !== "anchor")) return;
+    if (!r.held || (r.waiting && (waitForRelease || signal !== "anchor")))
+      return;
     r.held = false;
     setValue(() => r.last);
   });

package/src/browser/react/use-link-status.ts

@@ -5,12 +5,10 @@ import {
   useContext,
   useState,
   useEffect,
-  useRef,
-  useOptimistic,
-  startTransition,
   type Context,
 } from "react";
 import { NavigationStoreContext } from "./context.js";
+import type { EventController, NavigationEntry } from "../event-controller.js";
 
 /**
  * Context for Link component to provide its destination URL
@@ -43,24 +41,45 @@ function normalizeUrl(url: string, origin: string): string {
 }
 
 /**
- * Check if this link's destination matches the pending navigation URL
+ * The navigation in flight a link can be pending for. One that shows no
+ * loading state (a background revalidation, an action's refetch) is none: it
+ * goes to no link and ends none whose page React still holds.
+ */
+function visibleNavigation(ec: EventController): NavigationEntry | null {
+  const navigation = ec.getCurrentNavigation();
+  return navigation && !navigation.options?.skipLoadingState
+    ? navigation
+    : null;
+}
+
+/**
+ * Whether `navigation` goes to `linkTo`: its URL or, after a server redirect,
+ * the URL its chain started from.
  */
 function isPendingFor(
   linkTo: string | null,
-  pendingUrl: string | null,
+  navigation: NavigationEntry | null,
   origin: string,
 ): boolean {
-  if (linkTo === null || pendingUrl === null) {
+  if (linkTo === null || !navigation) {
     return false;
   }
-  return normalizeUrl(pendingUrl, origin) === normalizeUrl(linkTo, origin);
+  const to = normalizeUrl(linkTo, origin);
+  const from = navigation.options?._redirectFrom;
+  return (
+    normalizeUrl(navigation.url, origin) === to ||
+    (from !== undefined && normalizeUrl(from, origin) === to)
+  );
 }
 
 /**
  * Hook to track the pending state of a Link component
  *
- * Must be used inside a Link component. Returns `{ pending: true }`
- * when navigation to this link's destination is in progress.
+ * Must be used inside a Link component. Returns `{ pending: true }` while a
+ * navigation to the link's destination is in flight, until the page it
+ * brings commits: under transition() while React holds that page, and
+ * through a server redirect until the target page commits. A newer
+ * navigation ends it at once.
  *
  * Useful for showing inline loading indicators on individual links.
  *
@@ -84,63 +103,32 @@ export function useLinkStatus(): LinkStatus {
 
   const origin = ctx?.origin ?? "http://localhost";
 
-  const [basePending, setBasePending] = useState<boolean>(() => {
-    if (!ctx || linkTo === null) {
-      return false;
-    }
-    const state =
-      ctx.eventController.getHydrationSnapshot()?.state ??
-      ctx.eventController.getState();
-    return isPendingFor(linkTo, state.pendingUrl, origin);
-  });
-
-  const prevPending = useRef(basePending);
-
-  // Tracks whether the most recent setOptimisticPending call pinned the value
-  // to a non-idle (loading) state. Used to decide whether to emit a release
-  // update when returning to idle, so the optimistic store doesn't stay pinned
-  // to `true` if a parent transition (e.g. the <Link> click / view transition
-  // commit) is still pending.
-  const optimisticPinnedRef = useRef(false);
-
-  const [pending, setOptimisticPending] = useOptimistic(basePending);
-
+  // The document renders no navigation in flight.
+  const [pending, setPending] = useState<boolean>(
+    () =>
+      !!ctx &&
+      !ctx.eventController.getHydrationSnapshot() &&
+      isPendingFor(linkTo, visibleNavigation(ctx.eventController), origin),
+  );
+
+  // The value commits in the lane of the notification that carries it, as
+  // useNavigation's does: at once from the click's task, and with the page
+  // when its commit clears the navigation (NavigationProvider flushes that
+  // notification inside the page's update). Set once per navigation: a
+  // repeated urgent set would commit ahead of a held page's settle. A
+  // background navigation (an action's refetch) is not a newer one, so a
+  // held link stays pending.
   useEffect(() => {
     if (!ctx || linkTo === null) {
       return;
     }
 
+    let last: NavigationEntry | null | undefined;
     const update = () => {
-      const state = ctx.eventController.getState();
-      const isPending = isPendingFor(linkTo, state.pendingUrl, origin);
-
-      if (isPending !== prevPending.current) {
-        prevPending.current = isPending;
-
-        const shouldPin = isPending && state.state !== "idle";
-
-        if (shouldPin) {
-          // Pin the optimistic value so the spinner shows immediately even if
-          // a parent transition (e.g. <Link> click) defers the urgent
-          // setBasePending commit.
-          startTransition(() => {
-            setOptimisticPending(isPending);
-          });
-          optimisticPinnedRef.current = true;
-        } else if (optimisticPinnedRef.current) {
-          // Release a previously-pinned optimistic value. Without this,
-          // useOptimistic keeps returning the stale `true` while any parent
-          // transition is still pending, even after basePending flipped to
-          // false at navigation completion — leaving the link spinner stuck.
-          startTransition(() => {
-            setOptimisticPending(isPending);
-          });
-          optimisticPinnedRef.current = false;
-        }
-
-        // Always update base state
-        setBasePending(isPending);
-      }
+      const navigation = visibleNavigation(ctx.eventController);
+      if (navigation === last) return;
+      last = navigation;
+      setPending(isPendingFor(linkTo, navigation, origin));
     };
 
     // Catch-up: re-read state synchronously on mount before subscribing, so a

package/src/browser/react/use-navigation.ts

@@ -5,13 +5,15 @@ import {
   useState,
   useEffect,
   useLayoutEffect,
-  startTransition,
   useRef,
 } from "react";
 import { NavigationStoreContext } from "./context.js";
 import { shallowEqual } from "./shallow-equal.js";
 import type { PublicNavigationState } from "../types.js";
-import type { DerivedNavigationState } from "../event-controller.js";
+import type {
+  DerivedNavigationState,
+  RouteStateSignal,
+} from "../event-controller.js";
 
 /**
  * Convert derived state to public version (strips inflightActions)
@@ -21,6 +23,32 @@ function toPublicState(state: DerivedNavigationState): PublicNavigationState {
   return publicState;
 }
 
+/** The state a value was selected from, and the value. */
+interface Snapshot<T> {
+  state: PublicNavigationState;
+  value: T;
+}
+
+/**
+ * A notification while React holds a page: work that starts shows at once
+ * (loading, streaming, a newer click's URL), what settles waits for the
+ * page's commit (rango-d152), and location moves only with the notification
+ * that moves it (the page on screen until the next one shows).
+ */
+function hold(
+  base: PublicNavigationState,
+  live: PublicNavigationState,
+  moved: boolean,
+): PublicNavigationState {
+  return {
+    state: live.state === "loading" ? live.state : base.state,
+    isStreaming: live.isStreaming || base.isStreaming,
+    isNavigating: live.isNavigating || base.isNavigating,
+    pendingUrl: live.pendingUrl ?? base.pendingUrl,
+    location: moved ? live.location : base.location,
+  };
+}
+
 /**
  * Hook to access reactive navigation state with optional selector for performance.
  *
@@ -46,18 +74,20 @@ export function useNavigation<T>(
     throw new Error("useNavigation must be used within NavigationProvider");
   }
 
-  const [value, setValue] = useState<T | PublicNavigationState>(() => {
-    const publicState = toPublicState(
-      ctx.eventController.getHydrationSnapshot()?.state ??
-        ctx.eventController.getState(),
-    );
-    return selector ? selector(publicState) : publicState;
-  });
-  const prevState = useRef(value);
-  // The value on screen: a set value that differs has not committed yet.
-  const committedRef = useRef(value);
+  const [snapshot, setSnapshot] = useState<Snapshot<T | PublicNavigationState>>(
+    () => {
+      const state = toPublicState(
+        ctx.eventController.getHydrationSnapshot()?.state ??
+          ctx.eventController.getState(),
+      );
+      return { state, value: selector ? selector(state) : state };
+    },
+  );
+  // What React ends on once every set so far commits, and what it committed.
+  const latest = useRef(snapshot);
+  const committed = useRef(snapshot);
   useLayoutEffect(() => {
-    committedRef.current = value;
+    committed.current = snapshot;
   });
 
   // Store selector in a ref so the subscription callback always uses the
@@ -74,34 +104,48 @@ export function useNavigation<T>(
   // the location hooks' values do: NavigationProvider flushes a navigation's
   // notification into the transition that commits its tree, so idle commits
   // with the destination's location (useSearchParams, usePathname,
-  // useParams). An optimistic update renders in the sync lane, ahead of that
-  // transition, and put idle on screen with the location being left (#1164).
+  // useParams). From that page's anchor to its release every other
+  // notification goes through hold(), urgently, so React rebases the same
+  // update onto the page when it commits. Never a transition of its own.
   useEffect(() => {
-    let last: DerivedNavigationState | undefined;
-    const update = () => {
-      const currentState = ctx.eventController.getState();
-      // Neither the state nor the location moved (the stream starting or
-      // ending): while a value of this hook's is held, a transition, which
-      // React entangles with it, so it never commits ahead of the location.
-      // Otherwise urgent: a transition of its own would start a view
-      // transition, and could commit ahead of a held page and take its
-      // transition types.
-      const quiet =
-        currentState.state === last?.state &&
-        currentState.location === last.location;
-      last = currentState;
-      const publicState = toPublicState(currentState);
-      const nextSelected = selectorRef.current
-        ? selectorRef.current(publicState)
-        : publicState;
-
-      // Check if selected value has changed
-      if (!shallowEqual(nextSelected, prevState.current)) {
-        const held = prevState.current !== committedRef.current;
-        prevState.current = nextSelected;
-        if (quiet && held) startTransition(() => setValue(nextSelected));
-        else setValue(nextSelected);
+    let pageHeld = false;
+    let location: PublicNavigationState["location"] | undefined;
+    const select = (state: PublicNavigationState) =>
+      selectorRef.current ? selectorRef.current(state) : state;
+    const update = (signal?: RouteStateSignal) => {
+      if (signal) pageHeld = signal === "anchor";
+      const live = toPublicState(ctx.eventController.getState());
+      const moved = live.location !== location;
+      location = live.location;
+      const held = pageHeld && !signal;
+      const next = (
+        base: Snapshot<T | PublicNavigationState>,
+      ): Snapshot<T | PublicNavigationState> => {
+        const state = held ? hold(base.state, live, moved) : live;
+        return { state, value: select(state) };
+      };
+      const target = next(latest.current);
+      // A release is compared with the state React renders it on, not
+      // `latest`: an urgent page can end the hold before React commits the
+      // anchor's set. An anchor sets inside its page's transition, which
+      // renders every set so far, so `latest` is that state. A release that
+      // finds every set committed with its value sets nothing: the updater
+      // would render the reader again only to bail out.
+      if (signal === "release") {
+        if (
+          latest.current === committed.current &&
+          shallowEqual(target.value, latest.current.value)
+        )
+          return;
+        latest.current = target;
+        setSnapshot((prev) =>
+          shallowEqual(prev.value, target.value) ? prev : target,
+        );
+        return;
       }
+      if (shallowEqual(target.value, latest.current.value)) return;
+      latest.current = target;
+      setSnapshot(held ? next : target);
     };
 
     // Catch-up: re-read state synchronously on mount before subscribing, so a
@@ -110,8 +154,15 @@ export function useNavigation<T>(
     // useSearchParams.
     update();
 
-    return ctx.eventController.subscribe(update);
+    const unsubscribe = ctx.eventController.subscribe(update);
+    // The anchor and release signals ride the handle channel. One without a
+    // signal re-reads the same state, as the state channel's own would.
+    const unsubscribeSignals = ctx.eventController.subscribeToHandles(update);
+    return () => {
+      unsubscribe();
+      unsubscribeSignals();
+    };
   }, []);
 
-  return value as T | PublicNavigationState;
+  return snapshot.value as T | PublicNavigationState;
 }

package/src/browser/segment-reconciler.ts

@@ -260,3 +260,46 @@ export function reconcileErrorSegments(
     interceptSegments: intercept,
   };
 }
+
+/**
+ * The ids a page holds once an action's error boundary `boundary` shows: the
+ * ones above it. Nothing at or below the boundary ran after the action's
+ * write (its response and the follow-up cut there), so the next request must
+ * not hold it. ShortCodes nest, so those ids start with the boundary's: the
+ * boundary, its loaders (`${id}D…`), its slots and every entry under it. A
+ * sibling with a longer index (`…R10` beside `…R1`) is kept.
+ */
+export function idsAboveBoundary(
+  ids: string[],
+  boundary: string | undefined,
+): string[] {
+  return boundary
+    ? ids.filter(
+        (id) =>
+          !id.startsWith(boundary) || /\d/.test(id.charAt(boundary.length)),
+      )
+    : ids;
+}
+
+/**
+ * The error segment of every action error boundary committed, by identity
+ * (server-action-bridge.ts adds and deletes). An entry shows one while its
+ * cached list still holds that object: a later commit on the entry replaces
+ * the list, and a refetch that holds the boundary keeps it. Weak, so a
+ * replaced boundary is not kept alive. Two routers never share a segment
+ * object. No hook reads it.
+ */
+export const actionBoundaries: WeakSet<ResolvedSegment> = new WeakSet();
+
+/**
+ * The index of the deepest action error boundary in `segments`, -1 for none.
+ * It is that action's outcome, which no GET reproduces: a background refetch
+ * of the page (the follow-up, Back/Forward's stale revalidation, the
+ * cross-tab refresh) holds it and renders what is above it. At 0 nothing is
+ * above it.
+ */
+export function actionBoundaryAt(segments: readonly ResolvedSegment[]): number {
+  let at = segments.length;
+  while (at-- && !actionBoundaries.has(segments[at]));
+  return at;
+}

package/src/browser/server-action-bridge.ts

@@ -15,6 +15,9 @@ import {
 import { KEEP_CACHE_HEADER } from "./cookie-name.js";
 import { createNavigationTransaction } from "./navigation-transaction.js";
 import {
+  actionBoundaries,
+  actionBoundaryAt,
+  idsAboveBoundary,
   reconcileSegments,
   reconcileErrorSegments,
 } from "./segment-reconciler.js";
@@ -206,6 +209,8 @@ export function createServerActionBridge(
     actionId?: string;
     /** transition({ when }) `action` fields for the refetch commit. */
     action?: TransitionWhenActionInput;
+    /** The follow-up's held error boundary (UpdateMode `action`). */
+    boundary?: string;
   };
 
   /** The follow-up's transition({ when }) fields: the last owing action's. */
@@ -255,13 +260,13 @@ export function createServerActionBridge(
   let followUpsStarted = 0;
   /** The newest follow-up, until it ends: leaveFollowUp() aborts it. */
   let followUpRunning: { handle: NavigationHandle; due: FollowUp } | undefined;
-
   /**
    * The follow-up revalidation: the rules are R1-R7 in
    * docs/internal/execution-model.md. Once the batch's last action exited,
    * the page on screen that missed a write is refetched once, whole (no
-   * segments held, so every loader re-runs), in the action lane (storeOnly,
-   * skipLoadingState: useNavigation() stays idle).
+   * segments held, so every loader re-runs; above an action's boundary, see
+   * below), in the action lane (storeOnly, skipLoadingState:
+   * useNavigation() stays idle).
    *
    * - Never over an intercept: a request holding no segments drops the page
    *   under it (match-result.ts buildMatchResult). Checked when it would run,
@@ -271,6 +276,10 @@ export function createServerActionBridge(
    *   keeps its error on screen, and the debt is dropped.
    * - Runs again when it is left before its commit (a navigation, or an action
    *   that started: leaveFollowUp), for the page then on screen.
+   * - Holds the action error boundary the page shows (actionBoundaryAt): it
+   *   is that action's outcome, which no GET reproduces, so the server
+   *   renders every segment above it and nothing at or below it. With
+   *   nothing above it (the page's first segment), the debt is dropped.
    */
   function followUp(): void {
     if (!owed || isActionFenceActive()) return;
@@ -285,8 +294,16 @@ export function createServerActionBridge(
     const due = owed;
     owed = undefined;
     if (store.getInterceptSourceUrl()) return;
+    // The deepest action boundary the page shows: none (-1) refetches the
+    // page whole, the first segment (0) leaves nothing above it.
+    const shown =
+      store.getCachedSegments(store.getHistoryKey())?.segments ?? [];
+    const at = actionBoundaryAt(shown);
+    if (at === 0) return;
+    // Not on `due`: a run owed again (owed ??= due) looks again.
+    const held = { ...due, boundary: shown[at]?.id };
     const generation = ++followUpsStarted;
-    refetchRoute(due, {
+    refetchRoute(held, {
       started: (handle) => (followUpRunning = { handle, due }),
       ended: (left) => {
         if (generation !== followUpsStarted) return;
@@ -359,6 +376,7 @@ export function createServerActionBridge(
           ...(src ? { interceptSourceUrl: src } : {}),
           ...(opts.actionId !== undefined ? { actionId: opts.actionId } : {}),
           ...(opts.action ? { action: opts.action } : {}),
+          boundary: opts.boundary,
         },
       );
       return { started: true, error };
@@ -794,11 +812,15 @@ export function createServerActionBridge(
         // Cache (and bump the nav instance) BEFORE the UI update so a deferred
         // handle pushed by the error-boundary render still applies — see the
         // "normal" case below for why caching after onUpdate dropped it. The
-        // page stops claiming the error segments only: the loaders the
-        // response re-ran above the boundary stay held.
+        // action's boundary is the last error segment: the server's cut stops
+        // there (segment-resolution/revalidation.ts resolveAllSegments). The
+        // page holds what is above it, the loaders the response re-ran
+        // included, and no error segment.
+        const errors = segments.filter((s) => s.type === "error");
+        const boundary = errors[errors.length - 1];
         store.setSegmentIds(
-          segmentState.currentSegmentIds.filter(
-            (id) => !segments.some((s) => s.id === id && s.type === "error"),
+          idsAboveBoundary(segmentState.currentSegmentIds, boundary?.id).filter(
+            (id) => !errors.some((s) => s.id === id),
           ),
         );
         const currentHandleData = liveHandleDataForCache(
@@ -812,6 +834,7 @@ export function createServerActionBridge(
           currentHandleData,
         );
         store.rememberDisplayedEntry();
+        if (boundary) actionBoundaries.add(boundary);
 
         // Update UI with error boundary.
         if (process.env.NODE_ENV !== "production") auditTreeCause("action");
@@ -912,6 +935,10 @@ export function createServerActionBridge(
           metadata?.locationState,
           eventController,
         );
+        // A success on the page supersedes the action boundary it shows
+        // (R4): a repair that stands in for this commit, direct or owed to
+        // the batch's end, holds none.
+        for (const s of cachedSegments) actionBoundaries.delete(s);
       }
       whenAction = { ...whenAction, result: returnData };
 

package/src/browser/types.ts

@@ -201,13 +201,27 @@ export interface InflightAction {
  * @internal This type is an implementation detail. Use PublicNavigationState instead.
  */
 export interface NavigationState {
-  /** Navigation lifecycle state (idle or loading during navigation) */
+  /**
+   * Lifecycle state: `"loading"` while a navigation is in flight and while a
+   * server action runs, `"idle"` otherwise
+   */
   state: "idle" | "loading";
 
-  /** Whether RSC data is currently streaming (initial load or navigation) */
+  /**
+   * Whether RSC data is currently streaming: a navigation's response, or a
+   * server action's response (initial load, navigation or action)
+   */
   isStreaming: boolean;
 
-  /** Current location */
+  /**
+   * True while a navigation is in flight (fetching or streaming, before its
+   * commit); false during a server action, whose `state` is still `"loading"`.
+   * Drive a navigation progress bar from this and an action spinner from
+   * `state`.
+   */
+  isNavigating: boolean;
+
+  /** The page on screen; moves when the next page shows (`pendingUrl` is the page being fetched) */
   location: NavigationLocation;
 
   /** URL being navigated to (null when idle) */
@@ -505,6 +519,8 @@ export interface NavigateOptionsInternal extends Omit<
   _skipCache?: boolean;
   /** Server redirects already followed by this navigation chain (0 for a user navigation) */
   _redirectHops?: number;
+  /** The URL a redirected navigation chain started from: a link to it stays pending (useLinkStatus) */
+  _redirectFrom?: string;
 }
 
 /**
@@ -718,6 +734,8 @@ export interface FetchPartialOptions {
   signal?: AbortSignal;
   /** If true, this is a stale cache revalidation request - server should force revalidators */
   staleRevalidation?: boolean;
+  /** Sent as `_rsc_boundary` (wire-params.ts WIRE.boundary). */
+  boundary?: string;
   interceptSourceUrl?: string;
   /** RSC version for cache invalidation detection */
   version?: string;
@@ -803,7 +821,8 @@ export interface ServerActionBridgeConfig {
  */
 export interface NavigationBridge {
   navigate(url: string, options?: NavigateOptionsInternal): Promise<void>;
-  refresh(): Promise<void>;
+  /** `crossTab`: another tab's write; an action's error boundary stays. */
+  refresh(crossTab?: boolean): Promise<void>;
   /** `event`: the popstate event; a traversal the browser animated itself (hasUAVisualTransition) is not animated again. */
   handlePopstate(event?: PopStateEvent): Promise<void>;
   registerLinkInterception(): () => void;

package/src/browser/wire-protocol.ts

@@ -13,6 +13,7 @@ export interface PartialRequestInit {
    */
   emptySegments: "send" | "omit";
   stale?: boolean;
+  boundary?: string;
   version?: string;
   routerId?: string;
   rewriteTarget?: string;
@@ -33,6 +34,7 @@ export function writePartialParams(url: URL, init: PartialRequestInit): URL {
     params.set(WIRE.segments, init.segmentIds.join(","));
   }
   if (init.stale) params.set(WIRE.stale, "true");
+  if (init.boundary) params.set(WIRE.boundary, init.boundary);
   if (init.version) params.set(WIRE.version, init.version);
   if (init.routerId) params.set(WIRE.routerId, init.routerId);
   if (init.rewriteTarget) params.set(WIRE.rewriteTarget, init.rewriteTarget);