@rangojs/router 0.0.0-experimental.0b82333f

package/dist/browser/server-action-bridge.js

@@ -0,0 +1,668 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { createPartialUpdater } from "./partial-update.js";
+import { createNavigationTransaction } from "./navigation-bridge.js";
+import { mergeSegmentLoaders, needsLoaderMerge, } from "./merge-segment-loaders.js";
+import { assertSegmentStructure } from "./segment-structure-assert.js";
+import { startTransition, createElement } from "react";
+import { NetworkError, isNetworkError } from "../errors.js";
+import { NetworkErrorThrower } from "../network-error-thrower.js";
+import { browserDebugLog, isBrowserDebugEnabled, startBrowserTransaction, } from "./logging.js";
+// Polyfill Symbol.dispose/asyncDispose for Safari and older browsers
+if (typeof Symbol.dispose === "undefined") {
+    Symbol.dispose = Symbol("Symbol.dispose");
+}
+if (typeof Symbol.asyncDispose === "undefined") {
+    Symbol.asyncDispose = Symbol("Symbol.asyncDispose");
+}
+/**
+ * Normalize action ID - returns the ID as-is
+ *
+ * Server actions have IDs like "hash#actionName" or "src/actions.ts#actionName".
+ * The full ID is used for tracking in the event controller. When subscribing
+ * via useAction, both exact matching (full ID) and suffix matching (action name
+ * only) are supported by the event controller.
+ */
+function normalizeActionId(actionId) {
+    return actionId;
+}
+/**
+ * Create a server action bridge for handling RSC server actions
+ *
+ * The bridge registers a callback with the RSC runtime that handles:
+ * - Encoding action arguments
+ * - Sending action requests to the server
+ * - Processing responses and updating UI
+ * - Managing concurrent action requests via event controller
+ * - HMR resilience (refetching if segments are missing)
+ *
+ * @param config - Bridge configuration
+ * @returns ServerActionBridge instance
+ */
+export function createServerActionBridge(config) {
+    const { store, client, eventController, deps, onUpdate, renderSegments, version } = config;
+    let isRegistered = false;
+    const fetchPartialUpdate = createPartialUpdater({
+        store,
+        client,
+        onUpdate,
+        renderSegments,
+        version,
+    });
+    /**
+     * Server action callback handler
+     */
+    async function handleServerAction(id, args) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tx = isBrowserDebugEnabled()
+                ? startBrowserTransaction("action")
+                : null;
+            // Normalize action ID to just the function name for store tracking
+            const locationKey = window.history.state?.key;
+            const actionId = normalizeActionId(id);
+            if (tx) {
+                browserDebugLog(tx, "action start", { id, actionId, argsCount: args.length });
+            }
+            // Start action in event controller - handles lifecycle tracking
+            const handle = __addDisposableResource(env_1, eventController.startAction(actionId, args), false);
+            const segmentState = store.getSegmentState();
+            if (tx) {
+                browserDebugLog(tx, "action args prepared");
+            }
+            // 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);
+            }
+            // Encode arguments
+            const encodedBody = await deps.encodeReply(args, { temporaryReferences });
+            if (tx) {
+                browserDebugLog(tx, "sending action request", {
+                    url: url.href,
+                    bodyType: typeof encodedBody,
+                    isFormData: encodedBody instanceof FormData,
+                    segmentCount: segmentState.currentSegmentIds.length,
+                });
+            }
+            // Track when the stream completes
+            let resolveStreamComplete;
+            const streamComplete = new Promise((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 = 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) {
+                    if (tx) {
+                        browserDebugLog(tx, "version mismatch on action, reloading", { reloadUrl });
+                    }
+                    window.location.href = reloadUrl;
+                    // Return a never-resolving promise to prevent further processing
+                    return new Promise(() => { });
+                }
+                // Start streaming immediately when response arrives
+                if (!handle.signal.aborted) {
+                    streamingToken = handle.startStreaming();
+                }
+                if (!response.body) {
+                    // No body means stream is already complete
+                    streamingToken?.end();
+                    resolveStreamComplete();
+                    return response;
+                }
+                // Tee the stream: one for RSC runtime, one for tracking completion
+                const [rscStream, trackingStream] = response.body.tee();
+                // 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();
+                        if (tx) {
+                            browserDebugLog(tx, "stream complete");
+                        }
+                        streamingToken?.end();
+                        resolveStreamComplete();
+                    }
+                })().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,
+                });
+            });
+            // Deserialize response (MUST use same temporaryReferences)
+            let payload;
+            try {
+                payload = await deps.createFromFetch(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?.end();
+                // resolveStreamComplete is assigned in the Promise constructor so it's safe to call
+                resolveStreamComplete();
+                // Convert network-level errors to NetworkError for proper handling
+                if (isNetworkError(error)) {
+                    const networkError = new NetworkError("Unable to connect to server. Please check your connection.", {
+                        cause: error,
+                        url: url.toString(),
+                        operation: "action",
+                    });
+                    // Mark action as failed
+                    handle.fail(networkError);
+                    // Emit the network error so the root error boundary can catch it
+                    // NetworkErrorThrower throws during render to trigger the error boundary
+                    startTransition(() => {
+                        onUpdate({
+                            root: createElement(NetworkErrorThrower, { error: networkError }),
+                            metadata: {
+                                pathname: segmentState.currentUrl,
+                                segments: [],
+                                isError: true,
+                            },
+                        });
+                    });
+                    throw networkError;
+                }
+                throw error;
+            }
+            if (tx) {
+                browserDebugLog(tx, "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;
+            const { matched, diff, segments, isPartial, isError } = metadata || {};
+            // Log action result
+            if (returnValue) {
+                console.log(`[Browser] Action result:`, returnValue);
+                if (!returnValue.ok) {
+                    console.error(`[Browser] Action failed:`, returnValue.data);
+                }
+            }
+            // Handle error responses with error boundary UI
+            if (isError && isPartial && segments && diff) {
+                console.log(`[Browser] Processing error boundary response`);
+                // Abort all other pending action requests - error takes precedence
+                // This prevents other actions from completing and overwriting the error UI
+                eventController.abortAllActions();
+                // 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 || [];
+                // Create lookup for error segment from server
+                const errorSegmentMap = new Map();
+                segments.forEach((s) => errorSegmentMap.set(s.id, s));
+                // For error responses, use ALL cached segments but replace the errored one
+                // This preserves sibling layouts that aren't in the parent chain
+                const fullSegments = cachedSegments.map((cached) => {
+                    // Replace the error segment with the one from server
+                    const fromServer = errorSegmentMap.get(cached.id);
+                    if (fromServer)
+                        return fromServer;
+                    return cached;
+                });
+                // INTERCEPT HANDLING: Separate intercept segments for explicit injection
+                const isInterceptSegment = (s) => s.namespace?.startsWith("intercept:") ||
+                    (s.type === "parallel" && s.id.includes(".@"));
+                const interceptSegments = fullSegments.filter(isInterceptSegment);
+                const mainSegments = fullSegments.filter((s) => !isInterceptSegment(s));
+                // Render the full tree with error segment merged with parent layouts
+                const errorRenderOptions = {
+                    isAction: true,
+                    interceptSegments: interceptSegments.length > 0 ? interceptSegments : undefined,
+                };
+                const errorTree = await renderSegments(mainSegments, errorRenderOptions);
+                // Update UI with error boundary
+                startTransition(() => {
+                    onUpdate({ root: errorTree, metadata: metadata });
+                });
+                console.log(`[Browser] Error boundary UI rendered`);
+                // 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, fullSegments, currentHandleData);
+                console.log(`[Browser] Segment IDs updated (excluding error segments):`, segmentIdsAfterError);
+                // 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) {
+                console.log(`[Browser] Processing partial update`);
+                console.log(`[Browser] Server sent ${segments?.length || 0} segments in diff:`, diff);
+                console.log(`[Browser] Server expects client to have:`, matched);
+                // 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 || [];
+                const currentSegmentMap = new Map();
+                cachedSegments.forEach((s) => currentSegmentMap.set(s.id, s));
+                // Create lookup for new segments from server
+                const newSegmentMap = new Map();
+                (segments || []).forEach((s) => newSegmentMap.set(s.id, s));
+                if (!matched) {
+                    throw new Error("No matched segments in response");
+                }
+                // Rebuild from matched: merge server segments with cached, or use cached as fallback
+                const fullSegments = matched
+                    .map((segId) => {
+                    const fromServer = newSegmentMap.get(segId);
+                    const fromCache = currentSegmentMap.get(segId);
+                    if (fromServer) {
+                        // Server returned this segment - check if we need to merge partial loaders
+                        if (needsLoaderMerge(fromServer, fromCache)) {
+                            return mergeSegmentLoaders(fromServer, fromCache);
+                        }
+                        const cached = currentSegmentMap.get(segId); // Re-fetch to avoid type narrowing issues
+                        // Dev-mode assertion: warn if tree structure would change
+                        if (cached) {
+                            assertSegmentStructure(cached, fromServer, "action-bridge");
+                        }
+                        // Preserve cached structural properties to maintain consistent React tree.
+                        // Changing these between renders alters the element nesting
+                        // (with/without RouteContentWrapper, MountContextProvider, etc.),
+                        // causing React to remount components and destroy useActionState.
+                        if (cached) {
+                            let merged = fromServer;
+                            // When server returns component: null for a layout segment, it means
+                            // "this segment doesn't need re-rendering" - preserve the cached component
+                            // to maintain the outlet chain and prevent React tree changes
+                            if (fromServer.component === null &&
+                                fromServer.type === "layout" &&
+                                cached.component != null) {
+                                merged = { ...merged, component: cached.component };
+                            }
+                            // loading: SSR may set loading=false for skipSSR routes, but actions
+                            // resolve loading=<skeleton> (isSSR=false). Preserve cached value.
+                            if (cached.loading !== undefined &&
+                                fromServer.loading !== cached.loading) {
+                                merged = { ...merged, loading: cached.loading };
+                            }
+                            // mountPath: SSR segments may lack mountPath while action-revalidated
+                            // segments include it (from include() scope). The conditional
+                            // MountContextProvider wrapper in renderSegments changes tree depth.
+                            if (fromServer.mountPath !== cached.mountPath) {
+                                merged = { ...merged, mountPath: cached.mountPath };
+                            }
+                            return merged;
+                        }
+                        return fromServer;
+                    }
+                    // Fall back to current page's cached segments
+                    if (!fromCache) {
+                        console.error(`[Browser] MISSING SEGMENT: ${segId} not in cache!`);
+                    }
+                    return fromCache;
+                })
+                    .filter(Boolean);
+                const returnData = returnValue?.data;
+                console.log(`[Browser] Action complete - UI updated (after action state committed)`);
+                if (returnValue && !returnValue.ok) {
+                    handle.fail(returnValue.data);
+                    throw returnValue.data;
+                }
+                // Check if user navigated away during the action
+                const currentPathname = window.location.pathname;
+                const currentLocationKey = window.history.state?.key;
+                const userNavigatedAway = currentPathname !== actionStartPathname ||
+                    currentLocationKey !== locationKey;
+                if (userNavigatedAway) {
+                    const env_2 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        console.log(`[Browser] User navigated away during action (${actionStartPathname} -> ${currentPathname})`);
+                        // Clear concurrent action tracking - don't consolidate for old route's segments
+                        handle.clearConsolidation();
+                        // Check if the history key changed (different cache entry)
+                        // This happens when navigating between intercept and non-intercept routes
+                        if (currentLocationKey !== locationKey) {
+                            console.log(`[Browser] History key changed (${locationKey} -> ${currentLocationKey}), triggering background revalidation`);
+                            // The action completed on the server, but the user navigated to a different route.
+                            // The navigation fetch may have gotten stale data (before action committed).
+                            // Trigger a background revalidation of the CURRENT route to get fresh data.
+                            // User navigated to a different history entry.
+                            // Check if we should do background revalidation:
+                            // - YES if user is on a non-intercept route (safe to revalidate)
+                            // - NO if user is on an intercept route (would lose background segments)
+                            const currentInterceptSource = store.getInterceptSourceUrl();
+                            if (currentInterceptSource) {
+                                // User is on an intercept route - skip revalidation to preserve background
+                                console.log(`[Browser] Skipping background revalidation - user on intercept route`);
+                            }
+                            else {
+                                // User is on a non-intercept route - safe to revalidate
+                                console.log(`[Browser] History key changed, triggering background revalidation`);
+                                store.markCacheAsStaleAndBroadcast();
+                                const navTx = createNavigationTransaction(store, eventController, window.location.href, { replace: true, skipLoadingState: true });
+                                fetchPartialUpdate(window.location.href, [], false, navTx.handle.signal, navTx.with({
+                                    url: window.location.href,
+                                    storeOnly: true,
+                                }), {
+                                    isAction: true,
+                                }).then(() => {
+                                    console.log(`[Browser] Background revalidation complete`);
+                                }).catch((error) => {
+                                    if (error instanceof DOMException &&
+                                        error.name === "AbortError") {
+                                        console.log("[Browser] Background revalidation aborted");
+                                        return;
+                                    }
+                                    if (error instanceof NetworkError || isNetworkError(error)) {
+                                        console.warn("[Browser] Background revalidation network error (action):", error.message);
+                                        return;
+                                    }
+                                    console.error("[Browser] Background revalidation failed:", error);
+                                }).finally(() => {
+                                    navTx[Symbol.dispose]();
+                                });
+                            }
+                            handle.complete(returnData);
+                            return returnData;
+                        }
+                        // Same history key but different pathname (e.g., same-page navigation)
+                        // Safe to refetch current route
+                        console.log(`[Browser] Same history key, refetching current route`);
+                        store.markCacheAsStaleAndBroadcast();
+                        const navTx = __addDisposableResource(env_2, createNavigationTransaction(store, eventController, window.location.href, { replace: true, skipLoadingState: true }), false);
+                        // Preserve intercept context
+                        const currentInterceptSource = store.getInterceptSourceUrl();
+                        await fetchPartialUpdate(window.location.href, [], // Empty array = refetch all segments for current route
+                        false, navTx.handle.signal, navTx.with({
+                            url: window.location.href,
+                            storeOnly: true,
+                            intercept: !!currentInterceptSource,
+                            interceptSourceUrl: currentInterceptSource ?? undefined,
+                        }), {
+                            isAction: true,
+                            interceptSourceUrl: currentInterceptSource ?? undefined,
+                        });
+                        console.log(`[Browser] Refetch after navigation complete`);
+                        handle.complete(returnData);
+                        return returnData;
+                    }
+                    catch (e_1) {
+                        env_2.error = e_1;
+                        env_2.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_2);
+                    }
+                }
+                // HMR resilience check - only runs if user DIDN'T navigate away
+                if (fullSegments.length < matched.length) {
+                    const env_3 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        console.warn(`[Browser] Missing segments after action (HMR detected), refetching...`);
+                        const navTx = __addDisposableResource(env_3, createNavigationTransaction(store, eventController, window.location.href, { replace: true, skipLoadingState: true }), false);
+                        await fetchPartialUpdate(window.location.href, [], false, navTx.handle.signal, navTx.with({
+                            url: window.location.href,
+                            storeOnly: true,
+                            intercept: !!interceptSourceUrl,
+                            interceptSourceUrl: interceptSourceUrl ?? undefined,
+                        }), {
+                            isAction: true,
+                            interceptSourceUrl: interceptSourceUrl ?? undefined,
+                        });
+                        console.log(`[Browser] Refetch complete (HMR), now returning action result`);
+                        // Broadcast to other tabs
+                        store.broadcastCacheInvalidation();
+                        handle.complete(returnData);
+                        return returnData;
+                    }
+                    catch (e_2) {
+                        env_3.error = e_2;
+                        env_3.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_3);
+                    }
+                }
+                // Check if we need a consolidation fetch due to concurrent actions
+                const consolidationSegments = handle.getConsolidationSegments();
+                if (consolidationSegments && consolidationSegments.length > 0) {
+                    const env_4 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        // This is the last concurrent action - do consolidation fetch
+                        console.log(`[Browser] Concurrent actions detected - consolidation fetch needed for:`, consolidationSegments);
+                        // Calculate segments to send (exclude the ones we want fresh)
+                        const currentSegmentIds = store.getSegmentState().currentSegmentIds;
+                        const segmentsToSend = currentSegmentIds.filter((id) => !consolidationSegments.includes(id));
+                        console.log(`[Browser] Sending segments (excluding revalidated):`, segmentsToSend);
+                        // Clear consolidation tracking before fetch
+                        handle.clearConsolidation();
+                        const navTx = __addDisposableResource(env_4, createNavigationTransaction(store, eventController, window.location.href, { replace: true, skipLoadingState: true }), false);
+                        console.warn("Fetch partial", id);
+                        await fetchPartialUpdate(window.location.href, segmentsToSend, false, navTx.handle.signal, navTx.with({
+                            url: window.location.href,
+                            storeOnly: true,
+                            intercept: !!interceptSourceUrl,
+                            interceptSourceUrl: interceptSourceUrl ?? undefined,
+                        }), {
+                            isAction: true,
+                            interceptSourceUrl: interceptSourceUrl ?? undefined,
+                        });
+                        console.log(`[Browser] Consolidation fetch complete`);
+                        // Broadcast to other tabs
+                        store.broadcastCacheInvalidation();
+                        console.log(`[Browser] Consolidate/Reconcile - Returning to React:`, returnData);
+                        handle.complete(returnData);
+                        return returnData;
+                    }
+                    catch (e_3) {
+                        env_4.error = e_3;
+                        env_4.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_4);
+                    }
+                }
+                // Check if there are OTHER actions still fetching (waiting for server response)
+                // Exclude the current action since we already have our response
+                // We don't need to wait for streaming to complete - just for the response to arrive
+                const otherFetchingActions = [...eventController.getInflightActions().values()].filter((a) => a.phase === "fetching" && a.id !== handle.id);
+                if (otherFetchingActions.length > 0) {
+                    console.log(`[Browser] Skipping UI update - ${otherFetchingActions.length} other action(s) still fetching`);
+                    console.log(`[Browser] Multi actions - Returning to React (no cache clear):`, returnData);
+                    // 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);
+                    }
+                    else {
+                        console.log(`[Browser] History key changed during multi-action (${currentKey} -> ${currentKeyNow}), skipping cache update`);
+                    }
+                    handle.complete(returnData);
+                    return returnData;
+                }
+                // No concurrent actions - normal flow with single action
+                // INTERCEPT HANDLING: Separate intercept segments for explicit injection
+                const isInterceptSegment = (s) => s.namespace?.startsWith("intercept:") ||
+                    (s.type === "parallel" && s.id.includes(".@"));
+                const interceptSegments = fullSegments.filter(isInterceptSegment);
+                const mainSegments = fullSegments.filter((s) => !isInterceptSegment(s));
+                // Prepare new tree (await loader data resolution)
+                const renderOptions = {
+                    isAction: true,
+                    interceptSegments: interceptSegments.length > 0 ? interceptSegments : undefined,
+                };
+                const newTree = await renderSegments(mainSegments, renderOptions);
+                // Re-check if user navigated away (could happen during async wait)
+                const currentPathnameNow = window.location.pathname;
+                if (currentPathnameNow !== actionStartPathname) {
+                    console.log(`[Browser] User navigated during UI update scheduling, skipping`);
+                    handle.complete(returnData);
+                    return returnData;
+                }
+                // 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) {
+                    console.log(`[Browser] History key changed during action (${currentKey} -> ${currentKeyNow}), skipping cache update`);
+                    handle.complete(returnData);
+                    return returnData;
+                }
+                startTransition(() => {
+                    onUpdate({ root: newTree, metadata: metadata });
+                });
+                // Update store state
+                store.setSegmentIds(matched);
+                const currentHandleData = eventController.getHandleState().data;
+                store.cacheSegmentsForHistory(currentKey, fullSegments, currentHandleData);
+                store.markCacheAsStaleAndBroadcast();
+                console.log(`[Browser] Normal - Returning to React:`, returnData);
+                handle.complete(returnData);
+                return returnData;
+            }
+            else {
+                // Full update not supported for actions
+                throw new Error(`[Browser] Full update after action is not supported yet`);
+            }
+        }
+        catch (e_4) {
+            env_1.error = e_4;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    return {
+        /**
+         * Register the server action callback with the RSC runtime
+         */
+        register() {
+            if (isRegistered) {
+                console.warn("[Browser] Server action bridge already registered");
+                return;
+            }
+            deps.setServerCallback(handleServerAction);
+            isRegistered = true;
+            console.log("[Browser] Server action callback registered");
+        },
+        /**
+         * Unregister the server action callback
+         */
+        unregister() {
+            if (!isRegistered) {
+                return;
+            }
+            isRegistered = false;
+            console.log("[Browser] Server action bridge unregistered");
+        },
+    };
+}
+export { createServerActionBridge as default };
+//# sourceMappingURL=server-action-bridge.js.map