@rangojs/router 0.0.0-experimental.259 → 0.0.0-experimental.26

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

@@ -4,12 +4,11 @@ import type {
   RscPayload,
 } from "./types.js";
 import { createPartialUpdater } from "./partial-update.js";
-import { createNavigationTransaction } from "./navigation-bridge.js";
+import { createNavigationTransaction } from "./navigation-transaction.js";
 import {
   reconcileSegments,
   reconcileErrorSegments,
 } from "./segment-reconciler.js";
-import { classifyActionResponse } from "./action-response-classifier.js";
 import { startTransition } from "react";
 import type { EventController } from "./event-controller.js";
 import {
@@ -22,6 +21,14 @@ import {
   isBrowserDebugEnabled,
   startBrowserTransaction,
 } from "./logging.js";
+import { validateRedirectOrigin } from "./validate-redirect-origin.js";
+import {
+  extractRscHeaderUrl,
+  emptyResponse,
+  teeWithCompletion,
+} from "./response-adapter.js";
+import { mergeLocationState } from "./history-state.js";
+import { classifyActionOutcome } from "./action-coordinator.js";
 
 // Polyfill Symbol.dispose/asyncDispose for Safari and older browsers
 if (typeof Symbol.dispose === "undefined") {
@@ -92,27 +99,31 @@ export function createServerActionBridge(
     interceptSourceUrl?: string | null;
   }): Promise<void> {
     const src = opts?.interceptSourceUrl ?? null;
-    using navTx = createNavigationTransaction(
+    const navTx = createNavigationTransaction(
       store,
       eventController,
       window.location.href,
       { replace: true, skipLoadingState: true },
     );
-    await fetchPartialUpdate(
-      window.location.href,
-      opts?.segments ?? [],
-      false,
-      navTx.handle.signal,
-      navTx.with({
-        url: window.location.href,
-        storeOnly: true,
-        ...(src ? { intercept: true, interceptSourceUrl: src } : {}),
-      }),
-      {
-        isAction: true,
-        ...(src ? { interceptSourceUrl: src } : {}),
-      },
-    );
+    try {
+      await fetchPartialUpdate(
+        window.location.href,
+        opts?.segments ?? [],
+        false,
+        navTx.handle.signal,
+        navTx.with({
+          url: window.location.href,
+          storeOnly: true,
+          ...(src ? { intercept: true, interceptSourceUrl: src } : {}),
+        }),
+        {
+          type: "action" as const,
+          ...(src ? { interceptSourceUrl: src } : {}),
+        },
+      );
+    } finally {
+      navTx[Symbol.dispose]();
+    }
   }
 
   /**
@@ -130,406 +141,495 @@ export function createServerActionBridge(
     log("action start", { id, argsCount: args.length });
 
     // Start action in event controller - handles lifecycle tracking
-    using handle = eventController.startAction(id, args);
-
-    const segmentState = store.getSegmentState();
+    const handle = eventController.startAction(id, args);
+    try {
+      const segmentState = store.getSegmentState();
+
+      // Mark cache as stale immediately when action starts
+      // This ensures SWR pattern kicks in if user navigates away during action
+      store.markCacheAsStaleAndBroadcast();
+
+      // Create temporary references for serialization
+      const temporaryReferences = deps.createTemporaryReferenceSet();
+
+      // Capture URL pathname at action start to detect navigation during action
+      // Must use window.location (not store.path) because intercepts change URL
+      // without changing store.path (e.g., /kanban -> /kanban/card/1)
+      const actionStartPathname = window.location.pathname;
+
+      // Build action request URL with current segments
+      const url = new URL(window.location.href);
+      url.searchParams.set("_rsc_action", id);
+      url.searchParams.set(
+        "_rsc_segments",
+        segmentState.currentSegmentIds.join(","),
+      );
+      // Add version param for version mismatch detection
+      if (version) {
+        url.searchParams.set("_rsc_v", version);
+      }
 
-    // Mark cache as stale immediately when action starts
-    // This ensures SWR pattern kicks in if user navigates away during action
-    store.markCacheAsStaleAndBroadcast();
+      // Encode arguments
+      const encodedBody = await deps.encodeReply(args, { temporaryReferences });
 
-    // Create temporary references for serialization
-    const temporaryReferences = deps.createTemporaryReferenceSet();
+      log("sending action request", {
+        url: url.href,
+        bodyType: typeof encodedBody,
+        isFormData: encodedBody instanceof FormData,
+        segmentCount: segmentState.currentSegmentIds.length,
+      });
 
-    // Capture URL pathname at action start to detect navigation during action
-    // Must use window.location (not store.path) because intercepts change URL
-    // without changing store.path (e.g., /kanban -> /kanban/card/1)
-    const actionStartPathname = window.location.pathname;
+      // Track when the stream completes
+      let resolveStreamComplete: () => void;
+      const streamComplete = new Promise<void>((resolve) => {
+        resolveStreamComplete = resolve;
+      });
 
-    // Build action request URL with current segments
-    const url = new URL(window.location.href);
-    url.searchParams.set("_rsc_action", id);
-    url.searchParams.set(
-      "_rsc_segments",
-      segmentState.currentSegmentIds.join(","),
-    );
-    // Add version param for version mismatch detection
-    if (version) {
-      url.searchParams.set("_rsc_v", version);
-    }
+      // Get intercept source URL if in intercept context
+      const interceptSourceUrl = store.getInterceptSourceUrl();
+
+      // Track streaming token - will be set when response arrives
+      let streamingToken: { end(): void } | null = null;
+
+      // Use a dedicated abort controller for the fetch so we can cancel network
+      // I/O without disrupting the Flight stream once the response has arrived.
+      // Aborting a response mid-stream causes React's Flight decoder to throw
+      // asynchronous unhandled errors (BodyStreamBuffer was aborted).
+      const fetchAbort = new AbortController();
+      const onHandleAbort = () => fetchAbort.abort();
+      handle.signal.addEventListener("abort", onHandleAbort, { once: true });
+
+      // Send action request with stream tracking
+      const responsePromise = fetch(url, {
+        method: "POST",
+        headers: {
+          "rsc-action": id,
+          "X-RSC-Router-Client-Path": segmentState.currentUrl,
+          ...(tx && { "X-RSC-Router-Request-Id": tx.requestId }),
+          // Send intercept source URL so server can maintain intercept context
+          ...(interceptSourceUrl && {
+            "X-RSC-Router-Intercept-Source": interceptSourceUrl,
+          }),
+        },
+        body: encodedBody,
+        signal: fetchAbort.signal,
+      }).then(async (response) => {
+        // Response arrived — disconnect fetch abort from handle abort so
+        // abortAllActions() doesn't disrupt the in-progress Flight stream.
+        handle.signal.removeEventListener("abort", onHandleAbort);
+
+        // Check for version mismatch - server wants us to reload
+        const reload = extractRscHeaderUrl(response, "X-RSC-Reload");
+        if (reload === "blocked") {
+          resolveStreamComplete();
+          return emptyResponse();
+        }
+        if (reload) {
+          log("version mismatch on action, reloading", {
+            reloadUrl: reload.url,
+          });
+          window.location.href = reload.url;
+          return new Promise<Response>(() => {});
+        }
 
-    // Encode arguments
-    const encodedBody = await deps.encodeReply(args, { temporaryReferences });
-
-    log("sending action request", {
-      url: url.href,
-      bodyType: typeof encodedBody,
-      isFormData: encodedBody instanceof FormData,
-      segmentCount: segmentState.currentSegmentIds.length,
-    });
-
-    // Track when the stream completes
-    let resolveStreamComplete: () => void;
-    const streamComplete = new Promise<void>((resolve) => {
-      resolveStreamComplete = resolve;
-    });
-
-    // Get intercept source URL if in intercept context
-    const interceptSourceUrl = store.getInterceptSourceUrl();
-
-    // Track streaming token - will be set when response arrives
-    let streamingToken: { end(): void } | null = null;
-
-    // Send action request with stream tracking
-    const responsePromise = fetch(url, {
-      method: "POST",
-      headers: {
-        "rsc-action": id,
-        "X-RSC-Router-Client-Path": segmentState.currentUrl,
-        ...(tx && { "X-RSC-Router-Request-Id": tx.requestId }),
-        // Send intercept source URL so server can maintain intercept context
-        ...(interceptSourceUrl && {
-          "X-RSC-Router-Intercept-Source": interceptSourceUrl,
-        }),
-      },
-      body: encodedBody,
-    }).then(async (response) => {
-      // Check for version mismatch - server wants us to reload
-      const reloadUrl = response.headers.get("X-RSC-Reload");
-      if (reloadUrl) {
-        // Validate origin to prevent open redirect via crafted headers
-        try {
-          const target = new URL(reloadUrl, window.location.origin);
-          if (target.origin !== window.location.origin) {
-            throw new Error(
-              `X-RSC-Reload blocked: origin mismatch (${target.origin})`,
-            );
+        // Simple redirect from action (no state, no RSC payload).
+        // Short-circuits before createFromFetch — no Flight deserialization needed.
+        // Check handle.signal.aborted to avoid redirecting from a stale action
+        // when the user has already navigated away.
+        const redirect = extractRscHeaderUrl(response, "X-RSC-Redirect");
+        if (redirect && redirect !== "blocked" && !handle.signal.aborted) {
+          log("action simple redirect", { url: redirect.url });
+          handle.complete(undefined);
+          if (onNavigate) {
+            await onNavigate(redirect.url, {
+              replace: true,
+              _skipCache: true,
+            });
+          } else {
+            window.location.href = redirect.url;
           }
-        } catch (e) {
-          console.error("[rango]", e);
-          return response;
+          return new Promise<Response>(() => {});
         }
-        log("version mismatch on action, reloading", { reloadUrl });
-        window.location.href = reloadUrl;
-        // Return a never-resolving promise to prevent further processing
-        return new Promise<Response>(() => {});
+        if (redirect === "blocked") {
+          resolveStreamComplete();
+          return emptyResponse();
+        }
+
+        // Start streaming immediately when response arrives
+        if (!handle.signal.aborted) {
+          streamingToken = handle.startStreaming();
+        }
+
+        return teeWithCompletion(response, () => {
+          log("stream complete");
+          streamingToken?.end();
+          resolveStreamComplete();
+        });
+      });
+
+      // Deserialize response (MUST use same temporaryReferences)
+      let payload: RscPayload;
+      try {
+        payload = await deps.createFromFetch<RscPayload>(responsePromise, {
+          temporaryReferences,
+        });
+      } catch (error) {
+        // Clean up streaming token on error (may be null if fetch failed before .then() ran)
+        // The token is assigned in .then() callback which runs before this catch block,
+        // but TypeScript doesn't track cross-async assignments, so use type assertion
+        (streamingToken as { end(): void } | null)?.end();
+        // resolveStreamComplete is assigned in the Promise constructor so it's safe to call
+        resolveStreamComplete!();
+
+        // Silently swallow abort errors — the action was intentionally cancelled
+        // (e.g., user navigated away or abortAllActions was called).
+        // Return undefined instead of throwing to avoid surfacing as a page error.
+        // Check both DOMException AbortError and stream-level abort messages
+        // (BodyStreamBuffer was aborted) that propagate from the aborted fetch.
+        if (handle.signal.aborted) {
+          return undefined;
+        }
+
+        // Convert network-level errors to NetworkError for proper handling
+        const networkError = toNetworkError(error, {
+          url: url.toString(),
+          operation: "action",
+        });
+        if (networkError) {
+          handle.fail(networkError);
+          emitNetworkError(onUpdate, networkError, segmentState.currentUrl);
+          throw networkError;
+        }
+        throw error;
       }
 
-      // Simple redirect from action (no state, no RSC payload).
-      // Short-circuits before createFromFetch — no Flight deserialization needed.
+      log("action response received", {
+        isPartial: payload.metadata?.isPartial,
+        isError: payload.metadata?.isError,
+        matchedCount: payload.metadata?.matched?.length ?? 0,
+        diffCount: payload.metadata?.diff?.length ?? 0,
+      });
+
+      // Guard: if the action was aborted while streaming (e.g., user navigated
+      // away or abortAllActions fired), bail out before any reconcile/render/cache
+      // writes to avoid overwriting the current UI with stale action results.
+      if (handle.signal.aborted) {
+        log("action aborted after response, skipping reconciliation");
+        return undefined;
+      }
+
+      // Process response
+      const { metadata, returnValue } = payload;
+
+      // Handle action redirect: server converted the redirect to a Flight payload
+      // so we can perform SPA navigation instead of a full page reload.
       // Check handle.signal.aborted to avoid redirecting from a stale action
       // when the user has already navigated away.
-      const simpleRedirectUrl = response.headers.get("X-RSC-Redirect");
-      if (simpleRedirectUrl && !handle.signal.aborted) {
-        if (tx) {
-          browserDebugLog(tx, "action simple redirect", {
-            url: simpleRedirectUrl,
+      if (metadata?.redirect && !handle.signal.aborted) {
+        const redirectUrl = validateRedirectOrigin(
+          metadata.redirect.url,
+          window.location.origin,
+        );
+        if (!redirectUrl) {
+          log("blocked action redirect payload", {
+            url: metadata.redirect.url,
           });
+          handle.complete(returnValue?.data);
+          return returnValue?.data;
         }
-        handle.complete(undefined);
+        const redirectState = metadata.locationState;
+        log("action redirect", { url: redirectUrl });
+        handle.complete(returnValue?.data);
         if (onNavigate) {
-          await onNavigate(simpleRedirectUrl, {
+          await onNavigate(redirectUrl, {
+            state: redirectState,
             replace: true,
             _skipCache: true,
           });
         } else {
-          window.location.href = simpleRedirectUrl;
+          window.location.href = redirectUrl;
         }
-        return new Promise<Response>(() => {});
+        return returnValue?.data;
       }
 
-      // Start streaming immediately when response arrives
-      if (!handle.signal.aborted) {
-        streamingToken = handle.startStreaming();
+      // Bail out if the action was aborted after deserialization (e.g. user
+      // navigated away or abortAllActions was called while the Flight stream
+      // was being consumed). Without this check the code below would mutate
+      // the store / UI for a stale action.
+      if (handle.signal.aborted) {
+        log("action aborted after deserialization, skipping mutations");
+        return returnValue?.data;
       }
 
-      if (!response.body) {
-        // No body means stream is already complete
-        streamingToken?.end();
-        resolveStreamComplete();
-        return response;
+      const { matched, diff, segments, isPartial, isError } = metadata || {};
+
+      // Log action result
+      if (returnValue && !returnValue.ok) {
+        console.error(`[Browser] Action failed:`, returnValue.data);
       }
 
-      // Tee the stream: one for RSC runtime, one for tracking completion
-      const [rscStream, trackingStream] = response.body.tee();
+      // Handle error responses with error boundary UI
+      if (isError && isPartial && segments && diff) {
+        log("processing error boundary response");
 
-      // Consume the tracking stream to detect when it closes
-      (async () => {
-        const reader = trackingStream.getReader();
-        try {
-          while (true) {
-            const { done } = await reader.read();
-            if (done) break;
-          }
-        } finally {
-          reader.releaseLock();
-          log("stream complete");
-          streamingToken?.end();
-          resolveStreamComplete();
+        // Fail current handle BEFORE aborting all actions so the event controller
+        // records the error state (abortAllActions clears inflight entries)
+        if (returnValue && !returnValue.ok) {
+          handle.fail(returnValue.data);
         }
-      })().catch((error) => {
-        console.error("[STREAMING] Error reading tracking stream:", error);
-        streamingToken?.end();
-      });
 
-      // Return response with the RSC stream
-      return new Response(rscStream, {
-        headers: response.headers,
-        status: response.status,
-        statusText: response.statusText,
-      });
-    });
+        // Abort all other pending action requests - error takes precedence
+        // This prevents other actions from completing and overwriting the error UI
+        eventController.abortAllActions();
 
-    // Deserialize response (MUST use same temporaryReferences)
-    let payload: RscPayload;
-    try {
-      payload = await deps.createFromFetch<RscPayload>(responsePromise, {
-        temporaryReferences,
-      });
-    } catch (error) {
-      // Clean up streaming token on error (may be null if fetch failed before .then() ran)
-      // The token is assigned in .then() callback which runs before this catch block,
-      // but TypeScript doesn't track cross-async assignments, so use type assertion
-      (streamingToken as { end(): void } | null)?.end();
-      // resolveStreamComplete is assigned in the Promise constructor so it's safe to call
-      resolveStreamComplete!();
-
-      // Convert network-level errors to NetworkError for proper handling
-      const networkError = toNetworkError(error, {
-        url: url.toString(),
-        operation: "action",
-      });
-      if (networkError) {
-        handle.fail(networkError);
-        emitNetworkError(onUpdate, networkError, segmentState.currentUrl);
-        throw networkError;
-      }
-      throw error;
-    }
+        // Clear concurrent action tracking - no consolidation needed when showing error
+        handle.clearConsolidation();
+
+        // Get current page's cached segments
+        const currentKey = store.getHistoryKey();
+        const cached = store.getCachedSegments(currentKey);
+        const cachedSegments = cached?.segments || [];
+
+        // Reconcile error segments with cached tree
+        const errorResult = reconcileErrorSegments(cachedSegments, segments);
 
-    log("action response received", {
-      isPartial: payload.metadata?.isPartial,
-      isError: payload.metadata?.isError,
-      matchedCount: payload.metadata?.matched?.length ?? 0,
-      diffCount: payload.metadata?.diff?.length ?? 0,
-    });
-
-    // Process response
-    const { metadata, returnValue } = payload;
-
-    // Handle action redirect: server converted the redirect to a Flight payload
-    // so we can perform SPA navigation instead of a full page reload.
-    // Check handle.signal.aborted to avoid redirecting from a stale action
-    // when the user has already navigated away.
-    if (metadata?.redirect && !handle.signal.aborted) {
-      const { url: redirectUrl } = metadata.redirect;
-      const redirectState = metadata.locationState;
-      console.log(`[Browser] Action redirect to ${redirectUrl}`);
-      handle.complete(returnValue?.data);
-      if (onNavigate) {
-        await onNavigate(redirectUrl, {
-          state: redirectState,
-          replace: true,
-          _skipCache: true,
+        // Render the full tree with error segment merged with parent layouts
+        const errorTree = await renderSegments(errorResult.mainSegments, {
+          isAction: true,
+          interceptSegments:
+            errorResult.interceptSegments.length > 0
+              ? errorResult.interceptSegments
+              : undefined,
         });
-      } else {
-        window.location.href = redirectUrl;
-      }
-      return returnValue?.data;
-    }
 
-    const { matched, diff, segments, isPartial, isError } = metadata || {};
+        // Re-check route stability after async renderSegments — user may have
+        // navigated away while the error tree was being prepared.
+        if (window.location.pathname !== actionStartPathname) {
+          log("user navigated during error render, skipping");
+          if (returnValue && !returnValue.ok) {
+            throw returnValue.data;
+          }
+          handle.complete(undefined);
+          return undefined;
+        }
+        const currentKeyNow = store.getHistoryKey();
+        if (currentKeyNow !== currentKey) {
+          log("history key changed during error render, skipping cache update");
+          if (returnValue && !returnValue.ok) {
+            throw returnValue.data;
+          }
+          handle.complete(undefined);
+          return undefined;
+        }
 
-    // Log action result
-    if (returnValue && !returnValue.ok) {
-      console.error(`[Browser] Action failed:`, returnValue.data);
-    }
+        // Update UI with error boundary
+        startTransition(() => {
+          onUpdate({ root: errorTree, metadata: metadata! });
+        });
 
-    // Handle error responses with error boundary UI
-    if (isError && isPartial && segments && diff) {
-      log("processing error boundary response");
+        // Update segment tracking to exclude error segment IDs
+        const errorSegmentIds = new Set(diff);
+        const segmentIdsAfterError = segmentState.currentSegmentIds.filter(
+          (id) => !errorSegmentIds.has(id),
+        );
 
-      // Abort all other pending action requests - error takes precedence
-      // This prevents other actions from completing and overwriting the error UI
-      eventController.abortAllActions();
+        // Update store state
+        store.setSegmentIds(segmentIdsAfterError);
+        const currentHandleData = eventController.getHandleState().data;
+        store.cacheSegmentsForHistory(
+          currentKey,
+          errorResult.segments,
+          currentHandleData,
+        );
+
+        // Throw the error so the action promise rejects
+        if (returnValue && !returnValue.ok) {
+          throw returnValue.data;
+        }
 
-      // Clear concurrent action tracking - no consolidation needed when showing error
-      handle.clearConsolidation();
+        // No error in returnValue (shouldn't happen with isError: true)
+        handle.complete(undefined);
+        return undefined;
+      }
 
-      // Get current page's cached segments
+      if (!isPartial) {
+        // Protocol invariant: action revalidation responses MUST be partial.
+        // The server always sends isPartial: true for successful revalidation
+        // and isPartial: true + isError: true for error boundary responses.
+        // A non-partial payload here indicates a server-side bug.
+        throw new Error(
+          `[Browser] Action response missing isPartial — the server must ` +
+            `always send partial payloads for action revalidation.`,
+        );
+      }
+
+      log("processing partial update", {
+        serverSegments: segments?.length ?? 0,
+        diff: diff?.join(", ") ?? "",
+        matched: matched?.join(", ") ?? "",
+      });
+
+      // Record revalidated segments for concurrent action tracking
+      if (diff) {
+        handle.recordRevalidatedSegments(diff);
+      }
+
+      // Get current page's cached segments for merging
       const currentKey = store.getHistoryKey();
       const cached = store.getCachedSegments(currentKey);
       const cachedSegments = cached?.segments || [];
 
-      // Reconcile error segments with cached tree
-      const errorResult = reconcileErrorSegments(cachedSegments, segments);
-
-      // Render the full tree with error segment merged with parent layouts
-      const errorTree = await renderSegments(errorResult.mainSegments, {
-        isAction: true,
-        interceptSegments:
-          errorResult.interceptSegments.length > 0
-            ? errorResult.interceptSegments
-            : undefined,
-      });
+      if (!matched) {
+        throw new Error("No matched segments in response");
+      }
 
-      // Update UI with error boundary
-      startTransition(() => {
-        onUpdate({ root: errorTree, metadata: metadata! });
+      // Reconcile server segments with cached segments (single source of truth)
+      const reconciled = reconcileSegments({
+        actor: "action",
+        matched,
+        diff: diff || [],
+        serverSegments: segments || [],
+        cachedSegments,
       });
+      const fullSegments = reconciled.segments;
 
-      // Update segment tracking to exclude error segment IDs
-      const errorSegmentIds = new Set(diff);
-      const segmentIdsAfterError = segmentState.currentSegmentIds.filter(
-        (id) => !errorSegmentIds.has(id),
-      );
-
-      // Update store state
-      store.setSegmentIds(segmentIdsAfterError);
-      const currentHandleData = eventController.getHandleState().data;
-      store.cacheSegmentsForHistory(
-        currentKey,
-        errorResult.segments,
-        currentHandleData,
-      );
+      const returnData = returnValue?.data;
 
-      // Throw the error so the action promise rejects
       if (returnValue && !returnValue.ok) {
         handle.fail(returnValue.data);
         throw returnValue.data;
       }
 
-      // No error in returnValue (shouldn't happen with isError: true)
-      handle.complete(undefined);
-      return undefined;
-    }
-
-    if (!isPartial) {
-      // Full update not supported for actions
-      throw new Error(
-        `[Browser] Full update after action is not supported yet`,
-      );
-    }
+      // Classify the post-reconciliation scenario
+      const scenario = classifyActionOutcome({
+        handleId: handle.id,
+        inflightActions: eventController.getInflightActions(),
+        hadAnyConcurrentActions: eventController.hadAnyConcurrentActions(),
+        revalidatedSegments: handle.getRevalidatedSegments(),
+        actionStartPathname,
+        currentPathname: window.location.pathname,
+        actionStartLocationKey: locationKey,
+        currentLocationKey: window.history.state?.key,
+        reconciledSegmentCount: fullSegments.length,
+        matchedCount: matched.length,
+        currentInterceptSource: store.getInterceptSourceUrl(),
+      });
 
-    log("processing partial update", {
-      serverSegments: segments?.length ?? 0,
-      diff: diff?.join(", ") ?? "",
-      matched: matched?.join(", ") ?? "",
-    });
+      switch (scenario.type) {
+        case "navigated-away": {
+          log("user navigated away during action", {
+            from: actionStartPathname,
+            to: window.location.pathname,
+            historyKeyChanged: scenario.historyKeyChanged,
+          });
+          // Clear concurrent action tracking - don't consolidate for old route's segments
+          handle.clearConsolidation();
+
+          if (scenario.historyKeyChanged) {
+            if (!scenario.onInterceptRoute) {
+              store.markCacheAsStaleAndBroadcast();
+              refetchRoute().catch((error) => {
+                if (isBackgroundSuppressible(error)) return;
+                console.error(
+                  "[Browser] Background revalidation failed:",
+                  error,
+                );
+              });
+            }
+            break;
+          }
 
-    // Record revalidated segments for concurrent action tracking
-    if (diff) {
-      handle.recordRevalidatedSegments(diff);
-    }
+          // Same history key but different pathname - safe to refetch current route
+          store.markCacheAsStaleAndBroadcast();
+          await refetchRoute({
+            interceptSourceUrl: store.getInterceptSourceUrl(),
+          });
+          break;
+        }
 
-    // Get current page's cached segments for merging
-    const currentKey = store.getHistoryKey();
-    const cached = store.getCachedSegments(currentKey);
-    const cachedSegments = cached?.segments || [];
+        case "hmr-missing": {
+          console.warn(
+            `[Browser] Missing segments after action (HMR detected), refetching...`,
+          );
+          await refetchRoute({ interceptSourceUrl });
+          store.broadcastCacheInvalidation();
+          break;
+        }
 
-    if (!matched) {
-      throw new Error("No matched segments in response");
-    }
+        case "consolidation-needed": {
+          log("consolidation fetch needed", {
+            segmentIds: scenario.segmentIds,
+          });
+          // Calculate segments to send (exclude the ones we want fresh)
+          const currentSegmentIds = store.getSegmentState().currentSegmentIds;
+          const segmentsToSend = currentSegmentIds.filter(
+            (sid) => !scenario.segmentIds.includes(sid),
+          );
 
-    // Reconcile server segments with cached segments (single source of truth)
-    const reconciled = reconcileSegments({
-      actor: "action",
-      matched,
-      diff: diff || [],
-      serverSegments: segments || [],
-      cachedSegments,
-    });
-    const fullSegments = reconciled.segments;
-
-    const returnData = returnValue?.data;
-
-    if (returnValue && !returnValue.ok) {
-      handle.fail(returnValue.data);
-      throw returnValue.data;
-    }
+          // Clear consolidation tracking before fetch
+          handle.clearConsolidation();
 
-    // Classify the post-reconciliation scenario
-    const consolidationSegments = handle.getConsolidationSegments();
-    const otherFetchingActions = [
-      ...eventController.getInflightActions().values(),
-    ].filter((a) => a.phase === "fetching" && a.id !== handle.id);
-
-    const scenario = classifyActionResponse({
-      actionStartPathname,
-      currentPathname: window.location.pathname,
-      actionStartLocationKey: locationKey,
-      currentLocationKey: window.history.state?.key,
-      reconciledSegmentCount: fullSegments.length,
-      matchedCount: matched.length,
-      consolidationSegments: consolidationSegments || null,
-      otherFetchingActionCount: otherFetchingActions.length,
-      currentInterceptSource: store.getInterceptSourceUrl(),
-    });
-
-    switch (scenario.type) {
-      case "navigated-away": {
-        log("user navigated away during action", {
-          from: actionStartPathname,
-          to: window.location.pathname,
-          historyKeyChanged: scenario.historyKeyChanged,
-        });
-        // Clear concurrent action tracking - don't consolidate for old route's segments
-        handle.clearConsolidation();
+          await refetchRoute({
+            segments: segmentsToSend,
+            interceptSourceUrl,
+          });
+          store.broadcastCacheInvalidation();
+          break;
+        }
 
-        if (scenario.historyKeyChanged) {
-          if (!scenario.onInterceptRoute) {
-            store.markCacheAsStaleAndBroadcast();
-            refetchRoute().catch((error) => {
-              if (isBackgroundSuppressible(error)) return;
-              console.error("[Browser] Background revalidation failed:", error);
-            });
+        case "concurrent-skip": {
+          log("skipping UI update, other actions fetching", {
+            otherCount: scenario.otherFetchingCount,
+          });
+          // Only update store if history key hasn't changed (user didn't navigate away)
+          const currentKeyNow = store.getHistoryKey();
+          if (currentKeyNow === currentKey) {
+            store.setSegmentIds(matched);
+            const currentHandleData = eventController.getHandleState().data;
+            store.cacheSegmentsForHistory(
+              currentKey,
+              fullSegments,
+              currentHandleData,
+            );
           }
           break;
         }
 
-        // Same history key but different pathname - safe to refetch current route
-        store.markCacheAsStaleAndBroadcast();
-        await refetchRoute({
-          interceptSourceUrl: store.getInterceptSourceUrl(),
-        });
-        break;
-      }
+        case "normal": {
+          // Prepare new tree (await loader data resolution)
+          const newTree = await renderSegments(reconciled.mainSegments, {
+            isAction: true,
+            interceptSegments:
+              reconciled.interceptSegments.length > 0
+                ? reconciled.interceptSegments
+                : undefined,
+          });
 
-      case "hmr-missing": {
-        console.warn(
-          `[Browser] Missing segments after action (HMR detected), refetching...`,
-        );
-        await refetchRoute({ interceptSourceUrl });
-        store.broadcastCacheInvalidation();
-        break;
-      }
+          // Re-check if user navigated away (could happen during async renderSegments)
+          if (window.location.pathname !== actionStartPathname) {
+            log("user navigated during render, skipping");
+            break;
+          }
 
-      case "consolidation-needed": {
-        log("consolidation fetch needed", { segmentIds: scenario.segmentIds });
-        // Calculate segments to send (exclude the ones we want fresh)
-        const currentSegmentIds = store.getSegmentState().currentSegmentIds;
-        const segmentsToSend = currentSegmentIds.filter(
-          (sid) => !scenario.segmentIds.includes(sid),
-        );
+          // Verify the store's current key still matches what we captured at action start
+          // If they differ, user navigated away and we should NOT cache under the old key
+          const currentKeyNow = store.getHistoryKey();
+          if (currentKeyNow !== currentKey) {
+            log("history key changed during action, skipping cache update");
+            break;
+          }
 
-        // Clear consolidation tracking before fetch
-        handle.clearConsolidation();
+          startTransition(() => {
+            onUpdate({ root: newTree, metadata: metadata! });
+          });
 
-        await refetchRoute({
-          segments: segmentsToSend,
-          interceptSourceUrl,
-        });
-        store.broadcastCacheInvalidation();
-        break;
-      }
+          // Apply server-set location state to history.state (non-redirect flow)
+          const actionLocationState = metadata?.locationState;
+          if (actionLocationState) {
+            mergeLocationState(actionLocationState);
+          }
 
-      case "concurrent-skip": {
-        log("skipping UI update, other actions fetching", {
-          otherCount: scenario.otherFetchingCount,
-        });
-        // Only update store if history key hasn't changed (user didn't navigate away)
-        const currentKeyNow = store.getHistoryKey();
-        if (currentKeyNow === currentKey) {
+          // Update store state
           store.setSegmentIds(matched);
           const currentHandleData = eventController.getHandleState().data;
           store.cacheSegmentsForHistory(
@@ -537,53 +637,16 @@ export function createServerActionBridge(
             fullSegments,
             currentHandleData,
           );
-        }
-        break;
-      }
-
-      case "normal": {
-        // Prepare new tree (await loader data resolution)
-        const newTree = await renderSegments(reconciled.mainSegments, {
-          isAction: true,
-          interceptSegments:
-            reconciled.interceptSegments.length > 0
-              ? reconciled.interceptSegments
-              : undefined,
-        });
-
-        // Re-check if user navigated away (could happen during async renderSegments)
-        if (window.location.pathname !== actionStartPathname) {
-          log("user navigated during render, skipping");
+          store.markCacheAsStaleAndBroadcast();
           break;
         }
-
-        // Verify the store's current key still matches what we captured at action start
-        // If they differ, user navigated away and we should NOT cache under the old key
-        const currentKeyNow = store.getHistoryKey();
-        if (currentKeyNow !== currentKey) {
-          log("history key changed during action, skipping cache update");
-          break;
-        }
-
-        startTransition(() => {
-          onUpdate({ root: newTree, metadata: metadata! });
-        });
-
-        // Update store state
-        store.setSegmentIds(matched);
-        const currentHandleData = eventController.getHandleState().data;
-        store.cacheSegmentsForHistory(
-          currentKey,
-          fullSegments,
-          currentHandleData,
-        );
-        store.markCacheAsStaleAndBroadcast();
-        break;
       }
-    }
 
-    handle.complete(returnData);
-    return returnData;
+      handle.complete(returnData);
+      return returnData;
+    } finally {
+      handle[Symbol.dispose]();
+    }
   }
 
   return {
@@ -598,16 +661,6 @@ export function createServerActionBridge(
       deps.setServerCallback(handleServerAction);
       isRegistered = true;
     },
-
-    /**
-     * Unregister the server action callback
-     */
-    unregister(): void {
-      if (!isRegistered) {
-        return;
-      }
-      isRegistered = false;
-    },
   };
 }