@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/dist/esm-node/runtime/rsc/CompositeComponent.mjs

@@ -3,22 +3,27 @@ import "node:module";
 import { jsx } from "react/jsx-runtime";
 import { Suspense } from "react";
 import { SlotProvider } from "./SlotContext.mjs";
-import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
-function EmptyFallback() {
-    return null;
-}
-function selectTreePath(tree, path) {
-    let current = tree;
-    for (const key of path){
-        if (null === current || 'object' != typeof current) return null;
-        current = current[key];
+import { EmptyFallback, renderSelectedTree } from "./shared.mjs";
+import { RSC_PROXY_GET_TREE, SERVER_COMPONENT_STREAM } from "./symbols.mjs";
+import { createTreeGetterFromFlightStream } from "./treeGetter.mjs";
+const rawServerValueGetters = new WeakMap();
+function getRawServerTreeGetter(src) {
+    if (!src || 'object' != typeof src && 'function' != typeof src) return;
+    const source = src;
+    const stream = source[SERVER_COMPONENT_STREAM];
+    if ('function' != typeof stream?.createReplayStream) return;
+    let getTree = rawServerValueGetters.get(src);
+    if (!getTree) {
+        getTree = createTreeGetterFromFlightStream(stream.createReplayStream());
+        rawServerValueGetters.set(src, getTree);
     }
-    return current;
+    return getTree;
 }
 function CompositeInner({ slotProps, src, strict }) {
-    const getTree = src[RSC_PROXY_GET_TREE];
-    if (!getTree) throw new Error('CompositeComponent src must come from createCompositeComponent().');
-    const tree = selectTreePath(getTree(), src[RSC_PROXY_PATH] || []);
+    const tree = renderSelectedTree(src, {
+        getTree: src[RSC_PROXY_GET_TREE] || getRawServerTreeGetter(src),
+        missingTreeError: 'CompositeComponent src must come from createCompositeComponent().'
+    });
     return /*#__PURE__*/ jsx(SlotProvider, {
         implementations: slotProps,
         strict: strict,

package/dist/esm-node/runtime/rsc/RscNodeRenderer.mjs

@@ -2,23 +2,12 @@ import "node:module";
 "use client";
 import { Fragment, jsx } from "react/jsx-runtime";
 import { Suspense } from "react";
-import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
-function EmptyFallback() {
-    return null;
-}
-function selectTreePath(tree, path) {
-    let current = tree;
-    for (const key of path){
-        if (null === current || 'object' != typeof current) return null;
-        current = current[key];
-    }
-    return current;
-}
+import { EmptyFallback, renderSelectedTree } from "./shared.mjs";
 function RscNodeRenderInner({ data }) {
-    const getTree = data[RSC_PROXY_GET_TREE];
-    if (!getTree) throw new Error('Renderable RSC is missing its decoded tree getter.');
     return /*#__PURE__*/ jsx(Fragment, {
-        children: selectTreePath(getTree(), data[RSC_PROXY_PATH] || [])
+        children: renderSelectedTree(data, {
+            missingTreeError: 'Renderable RSC is missing its decoded tree getter.'
+        })
     });
 }
 function RscNodeRenderer({ data }) {

package/dist/esm-node/runtime/rsc/client.mjs

@@ -1,41 +1,21 @@
 import "node:module";
 "use client";
 import { createSerializationAdapter } from "@tanstack/react-router";
-import { use } from "react";
+import { createTreeGetterFromFlightStream } from "./treeGetter.mjs";
 import { createRscProxy } from "./createRscProxy.mjs";
-let modernRscClientRuntimePromise;
-function loadModernRscClientRuntime() {
-    modernRscClientRuntimePromise ??= import("@modern-js/runtime/rsc/client").then((runtime)=>{
-        runtime.setServerCallback(runtime.callServer);
-        return runtime;
-    });
-    return modernRscClientRuntimePromise;
-}
-function createTreeGetter(stream) {
-    let ready = false;
-    let tree;
-    const treePromise = loadModernRscClientRuntime().then((runtime)=>runtime.createFromReadableStream(stream, {
-            callServer: runtime.callServer
-        })).then((value)=>{
-        tree = value;
-        ready = true;
-        return value;
-    });
-    return ()=>{
-        if (ready) return tree;
-        return use(treePromise);
-    };
-}
 function createFromFlightStream(serialized) {
     const streamWrapper = {
         createReplayStream: ()=>serialized.stream
     };
-    return createRscProxy(createTreeGetter(serialized.stream), {
+    return createRscProxy(createTreeGetterFromFlightStream(serialized.stream), {
         renderable: 'renderable' === serialized.kind,
         slotUsagesStream: serialized.slotUsagesStream,
         stream: streamWrapper
     });
 }
+function createTanstackRscValueFromFlight(serialized) {
+    return createFromFlightStream(serialized);
+}
 const adapter = createSerializationAdapter({
     key: '$MODERN_TANSTACK_RSC',
     test: (_value)=>false,
@@ -51,4 +31,4 @@ function getTanstackRscSerializationAdapters() {
 }
 const rscSerializationAdapter = getTanstackRscSerializationAdapters;
 export { CompositeComponent } from "./CompositeComponent.mjs";
-export { getTanstackRscSerializationAdapters, rscSerializationAdapter };
+export { createTanstackRscValueFromFlight, getTanstackRscSerializationAdapters, rscSerializationAdapter };

package/dist/esm-node/runtime/rsc/flightSerialization.mjs

@@ -0,0 +1,89 @@
+import "node:module";
+import { TANSTACK_RSC_FLIGHT_VALUE, isSerializedTanstackRscFlightValue } from "./shared.mjs";
+import { RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent } from "./symbols.mjs";
+function isPlainObject(value) {
+    if (!value || 'object' != typeof value) return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || null === prototype;
+}
+function serializeTanstackRscFlightValues(value, seen = new WeakMap()) {
+    if (isServerComponent(value)) {
+        const streamWrapper = value[SERVER_COMPONENT_STREAM];
+        if (!streamWrapper) throw new Error('Cannot serialize TanStack RSC without a Flight stream.');
+        const kind = isRenderableServerComponent(value) ? 'renderable' : 'composite';
+        const slotUsagesStream = 'development' === process.env.NODE_ENV && 'composite' === kind ? value[RSC_SLOT_USAGES_STREAM] : void 0;
+        return {
+            [TANSTACK_RSC_FLIGHT_VALUE]: true,
+            kind,
+            stream: streamWrapper.createReplayStream(),
+            ...slotUsagesStream ? {
+                slotUsagesStream
+            } : {}
+        };
+    }
+    if (!value || 'object' != typeof value) return value;
+    if (seen.has(value)) return seen.get(value);
+    if (value instanceof Map) {
+        const result = new Map();
+        seen.set(value, result);
+        for (const [key, item] of value)result.set(serializeTanstackRscFlightValues(key, seen), serializeTanstackRscFlightValues(item, seen));
+        return result;
+    }
+    if (value instanceof Set) {
+        const result = new Set();
+        seen.set(value, result);
+        for (const item of value)result.add(serializeTanstackRscFlightValues(item, seen));
+        return result;
+    }
+    if (Array.isArray(value)) {
+        const result = [];
+        seen.set(value, result);
+        for (const item of value)result.push(serializeTanstackRscFlightValues(item, seen));
+        return result;
+    }
+    if (!isPlainObject(value)) return value;
+    const result = {};
+    seen.set(value, result);
+    for (const [key, item] of Object.entries(value))result[key] = serializeTanstackRscFlightValues(item, seen);
+    return result;
+}
+async function reviveTanstackRscFlightValues(value, seen = new WeakMap()) {
+    let reviver;
+    const getReviver = async ()=>{
+        if (!reviver) {
+            const client = await import("./client.mjs");
+            reviver = client.createTanstackRscValueFromFlight;
+        }
+        return reviver;
+    };
+    const visit = async (current)=>{
+        if (isSerializedTanstackRscFlightValue(current)) return (await getReviver())(current);
+        if (!current || 'object' != typeof current) return current;
+        if (seen.has(current)) return seen.get(current);
+        if (current instanceof Map) {
+            const result = new Map();
+            seen.set(current, result);
+            for (const [key, item] of current)result.set(await visit(key), await visit(item));
+            return result;
+        }
+        if (current instanceof Set) {
+            const result = new Set();
+            seen.set(current, result);
+            for (const item of current)result.add(await visit(item));
+            return result;
+        }
+        if (Array.isArray(current)) {
+            const result = [];
+            seen.set(current, result);
+            for (const item of current)result.push(await visit(item));
+            return result;
+        }
+        if (!isPlainObject(current)) return current;
+        const result = {};
+        seen.set(current, result);
+        for (const [key, item] of Object.entries(current))result[key] = await visit(item);
+        return result;
+    };
+    return visit(value);
+}
+export { isPlainObject, reviveTanstackRscFlightValues, serializeTanstackRscFlightValues };

package/dist/esm-node/runtime/rsc/payloadErrors.mjs

@@ -0,0 +1,50 @@
+import "node:module";
+import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+function shouldRedactServerError(status = 500) {
+    return status >= 500 && 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV;
+}
+function serializePayloadError(error) {
+    if (isRouteErrorResponse(error)) {
+        if (shouldRedactServerError(error.status)) return {
+            status: error.status,
+            statusText: 'Internal Server Error',
+            data: 'Unexpected Server Error',
+            __type: 'RouteErrorResponse'
+        };
+        return {
+            ...error,
+            __type: 'RouteErrorResponse'
+        };
+    }
+    if (error instanceof Error) {
+        if (shouldRedactServerError()) return {
+            message: 'Unexpected Server Error',
+            stack: void 0,
+            __type: 'Error'
+        };
+        return {
+            message: error.message,
+            stack: error.stack,
+            __type: 'Error',
+            ...'Error' !== error.name ? {
+                __subType: error.name
+            } : {}
+        };
+    }
+    if (shouldRedactServerError()) return {
+        message: 'Unexpected Server Error',
+        stack: void 0,
+        __type: 'Error'
+    };
+    return error;
+}
+function isSerializedNotFound(value) {
+    return Boolean(value) && 'object' == typeof value && true === value.isNotFound;
+}
+function toRouteErrors(payload) {
+    return payload.errors && 'object' == typeof payload.errors ? payload.errors : {};
+}
+function toRouteLoaderData(payload) {
+    return payload.loaderData && 'object' == typeof payload.loaderData ? payload.loaderData : {};
+}
+export { isSerializedNotFound, serializePayloadError, shouldRedactServerError, toRouteErrors, toRouteLoaderData };

package/dist/esm-node/runtime/rsc/payloadFetch.mjs

@@ -0,0 +1,62 @@
+import "node:module";
+import { notFound, redirect } from "@tanstack/react-router";
+import { reviveTanstackRscFlightValues } from "./flightSerialization.mjs";
+const payloadFetchCache = new Map();
+let payloadDecoder;
+async function decodePayload(stream) {
+    if (payloadDecoder) return reviveTanstackRscFlightValues(await payloadDecoder(stream));
+    const runtime = await import("@modern-js/runtime/rsc/client");
+    return reviveTanstackRscFlightValues(await runtime.createFromReadableStream(stream));
+}
+function isServerPayload(value) {
+    return Boolean(value) && 'object' == typeof value && 'render' === value.type && Array.isArray(value.routes);
+}
+function createPayloadFetchKey(request) {
+    return JSON.stringify([
+        request.url,
+        [
+            ...request.headers.entries()
+        ].sort(([left], [right])=>left.localeCompare(right))
+    ]);
+}
+function isAbsoluteUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function fetchTanstackRscPayload(request) {
+    const headers = new Headers(request.headers);
+    headers.set('x-rsc-tree', 'true');
+    const response = await fetch(request.url, {
+        credentials: 'same-origin',
+        headers,
+        method: 'GET',
+        signal: request.signal
+    });
+    const redirectLocation = response.headers.get('X-Modernjs-Redirect');
+    if (redirectLocation) {
+        if (isAbsoluteUrl(redirectLocation)) throw redirect({
+            headers: response.headers,
+            href: redirectLocation,
+            statusCode: response.status
+        });
+        throw redirect({
+            headers: response.headers,
+            statusCode: response.status,
+            to: redirectLocation || '/'
+        });
+    }
+    if (404 === response.status && !response.body) throw notFound();
+    if (!response.body) throw new Error('TanStack RSC payload response body is null.');
+    const payload = await decodePayload(response.body);
+    if (!isServerPayload(payload)) throw new Error('Unexpected TanStack RSC payload type.');
+    return payload;
+}
+function __setTanstackRscPayloadDecoderForTests(decoder) {
+    payloadDecoder = decoder;
+    payloadFetchCache.clear();
+}
+export { __setTanstackRscPayloadDecoderForTests, createPayloadFetchKey, decodePayload, fetchTanstackRscPayload, isAbsoluteUrl, isServerPayload, payloadFetchCache };

package/dist/esm-node/runtime/rsc/payloadRouter.mjs

@@ -1,77 +1,9 @@
 import "node:module";
-import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
-import { notFound, redirect } from "@tanstack/react-router";
-const payloadFetchCache = new Map();
-let payloadDecoder;
-function getRouteId(match) {
-    const routeId = match.routeId ?? match.route?.id ?? match.id;
-    return 'string' == typeof routeId ? routeId : void 0;
-}
-function getRouteStaticData(match) {
-    return match.route?.options?.staticData || {};
-}
-function getRouteParentId(match) {
-    const parentId = match.route?.parentRoute?.id;
-    return 'string' == typeof parentId ? parentId : void 0;
-}
-function toRoutePath(match) {
-    const path = match.route?.options?.path;
-    return 'string' == typeof path ? path : void 0;
-}
-function toPayloadRoute(match) {
-    const routeId = getRouteId(match);
-    if (!routeId) return;
-    const staticData = getRouteStaticData(match);
-    const params = match.params && 'object' == typeof match.params ? match.params : {};
-    const pathname = 'string' == typeof match.pathname ? match.pathname : '';
-    return {
-        handle: staticData.modernRouteHandle,
-        hasAction: Boolean(staticData.modernRouteHasAction || staticData.modernRouteAction),
-        hasErrorBoundary: false,
-        hasLoader: Boolean(staticData.modernRouteHasLoader),
-        hasClientLoader: Boolean(staticData.modernRouteHasClientLoader),
-        id: routeId,
-        index: Boolean(match.route?.options?.index) || void 0,
-        params,
-        parentId: getRouteParentId(match),
-        path: toRoutePath(match),
-        pathname,
-        pathnameBase: 'string' == typeof match.pathnameBase ? match.pathnameBase : pathname
-    };
-}
-function shouldRedactServerError(status = 500) {
-    return status >= 500 && 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV;
-}
-function serializePayloadError(error) {
-    if (isRouteErrorResponse(error)) {
-        if (shouldRedactServerError(error.status)) return {
-            status: error.status,
-            statusText: 'Internal Server Error',
-            data: 'Unexpected Server Error',
-            __type: 'RouteErrorResponse'
-        };
-        return {
-            ...error,
-            __type: 'RouteErrorResponse'
-        };
-    }
-    if (error instanceof Error) {
-        if (shouldRedactServerError()) return {
-            message: 'Unexpected Server Error',
-            stack: void 0,
-            __type: 'Error'
-        };
-        return {
-            message: error.message,
-            stack: error.stack,
-            __type: 'Error',
-            ...'Error' !== error.name ? {
-                __subType: error.name
-            } : {}
-        };
-    }
-    return error;
-}
+import { notFound } from "@tanstack/react-router";
+import { serializeTanstackRscFlightValues } from "./flightSerialization.mjs";
+import { isSerializedNotFound, serializePayloadError, toRouteErrors, toRouteLoaderData } from "./payloadErrors.mjs";
+import { __setTanstackRscPayloadDecoderForTests, createPayloadFetchKey, fetchTanstackRscPayload, payloadFetchCache } from "./payloadFetch.mjs";
+import { toPayloadRoute, toPlainLocation } from "./payloadRoutes.mjs";
 function createTanstackRscServerPayload(router, options = {}) {
     const matches = Array.isArray(router.state?.matches) ? router.state.matches : [];
     const routes = [];
@@ -81,7 +13,7 @@ function createTanstackRscServerPayload(router, options = {}) {
         const payloadRoute = toPayloadRoute(match);
         if (payloadRoute) {
             routes.push(payloadRoute);
-            if ('loaderData' in match && void 0 !== match.loaderData && !(options.omitClientLoaderData && payloadRoute.hasClientLoader)) loaderData[payloadRoute.id] = match.loaderData;
+            if ('loaderData' in match && void 0 !== match.loaderData && !(options.omitClientLoaderData && payloadRoute.hasClientLoader)) loaderData[payloadRoute.id] = serializeTanstackRscFlightValues(match.loaderData);
             if (void 0 !== match.error) errors[payloadRoute.id] = serializePayloadError(match.error);
         }
     }
@@ -90,14 +22,17 @@ function createTanstackRscServerPayload(router, options = {}) {
         actionData: null,
         errors: Object.keys(errors).length > 0 ? errors : null,
         loaderData,
-        location: router.state?.location,
+        location: toPlainLocation(router.state?.location),
         routes
     };
 }
 function handleTanstackRscRedirect(headers, basename, status) {
     const newHeaders = new Headers(headers);
     let redirectUrl = headers.get('Location') || '/';
-    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '') || '/';
+    if ('/' !== basename) {
+        if (redirectUrl === basename) redirectUrl = '/';
+        else if (redirectUrl.startsWith(`${basename}/`)) redirectUrl = redirectUrl.slice(basename.length);
+    }
     newHeaders.set('X-Modernjs-Redirect', redirectUrl);
     newHeaders.set('X-Modernjs-BaseUrl', basename);
     newHeaders.delete('Location');
@@ -109,69 +44,17 @@ function handleTanstackRscRedirect(headers, basename, status) {
 function isTanstackRscPayloadNavigationEnabled() {
     return "u" > typeof window;
 }
-async function decodePayload(stream) {
-    if (payloadDecoder) return payloadDecoder(stream);
-    const runtime = await import("@modern-js/runtime/rsc/client");
-    return runtime.createFromReadableStream(stream);
-}
-function isServerPayload(value) {
-    return Boolean(value) && 'object' == typeof value && 'render' === value.type && Array.isArray(value.routes);
-}
-function createPayloadFetchKey(request) {
-    return request.url;
-}
-function isAbsoluteUrl(value) {
-    try {
-        new URL(value);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-async function fetchTanstackRscPayload(request) {
-    const headers = new Headers(request.headers);
-    headers.set('x-rsc-tree', 'true');
-    const response = await fetch(request.url, {
-        credentials: 'same-origin',
-        headers,
-        method: 'GET',
-        signal: request.signal
-    });
-    const redirectLocation = response.headers.get('X-Modernjs-Redirect');
-    if (redirectLocation) {
-        if (isAbsoluteUrl(redirectLocation)) throw redirect({
-            href: redirectLocation
-        });
-        throw redirect({
-            to: redirectLocation || '/'
-        });
-    }
-    if (404 === response.status && !response.body) throw notFound();
-    if (!response.body) throw new Error('TanStack RSC payload response body is null.');
-    const payload = await decodePayload(response.body);
-    if (!isServerPayload(payload)) throw new Error('Unexpected TanStack RSC payload type.');
-    return payload;
-}
 function loadTanstackRscPayload(request) {
     const key = createPayloadFetchKey(request);
     let payloadPromise = payloadFetchCache.get(key);
     if (!payloadPromise) {
         payloadPromise = fetchTanstackRscPayload(request).finally(()=>{
-            payloadFetchCache.delete(key);
+            payloadFetchCache["delete"](key);
         });
         payloadFetchCache.set(key, payloadPromise);
     }
     return payloadPromise;
 }
-function isSerializedNotFound(value) {
-    return Boolean(value) && 'object' == typeof value && true === value.isNotFound;
-}
-function toRouteErrors(payload) {
-    return payload.errors && 'object' == typeof payload.errors ? payload.errors : {};
-}
-function toRouteLoaderData(payload) {
-    return payload.loaderData && 'object' == typeof payload.loaderData ? payload.loaderData : {};
-}
 async function loadTanstackRscRouteData({ hasClientLoader, loadClientData, request, routeId }) {
     if (hasClientLoader) return loadClientData();
     if (!routeId) return loadClientData();
@@ -190,8 +73,4 @@ async function loadTanstackRscRouteData({ hasClientLoader, loadClientData, reque
     const payloadRoute = payload.routes.find((route)=>route.id === routeId);
     if (payloadRoute && payloadRoute.hasClientLoader) return loadClientData();
 }
-function __setTanstackRscPayloadDecoderForTests(decoder) {
-    payloadDecoder = decoder;
-    payloadFetchCache.clear();
-}
 export { __setTanstackRscPayloadDecoderForTests, createTanstackRscServerPayload, handleTanstackRscRedirect, isTanstackRscPayloadNavigationEnabled, loadTanstackRscPayload, loadTanstackRscRouteData };

package/dist/esm-node/runtime/rsc/payloadRoutes.mjs

@@ -0,0 +1,51 @@
+import "node:module";
+function toPlainRecord(value) {
+    if (!value || 'object' != typeof value) return {};
+    return Object.fromEntries(Object.entries(value));
+}
+function toPlainLocation(location) {
+    if (!location || 'object' != typeof location) return location;
+    const plainLocation = toPlainRecord(location);
+    for (const key of [
+        'search',
+        'state'
+    ])if (plainLocation[key] && 'object' == typeof plainLocation[key] && !Array.isArray(plainLocation[key])) plainLocation[key] = toPlainRecord(plainLocation[key]);
+    return plainLocation;
+}
+function getRouteId(match) {
+    const routeId = match.routeId ?? match.route?.id ?? match.id;
+    return 'string' == typeof routeId ? routeId : void 0;
+}
+function getRouteStaticData(match) {
+    return match.route?.options?.staticData || {};
+}
+function getRouteParentId(match) {
+    const parentId = match.route?.parentRoute?.id;
+    return 'string' == typeof parentId ? parentId : void 0;
+}
+function toRoutePath(match) {
+    const path = match.route?.options?.path;
+    return 'string' == typeof path ? path : void 0;
+}
+function toPayloadRoute(match) {
+    const routeId = getRouteId(match);
+    if (!routeId) return;
+    const staticData = getRouteStaticData(match);
+    const params = match.params && 'object' == typeof match.params ? toPlainRecord(match.params) : {};
+    const pathname = 'string' == typeof match.pathname ? match.pathname : '';
+    return {
+        handle: staticData.modernRouteHandle,
+        hasAction: Boolean(staticData.modernRouteHasAction || staticData.modernRouteAction),
+        hasErrorBoundary: false,
+        hasLoader: Boolean(staticData.modernRouteHasLoader),
+        hasClientLoader: Boolean(staticData.modernRouteHasClientLoader),
+        id: routeId,
+        index: Boolean(match.route?.options?.index) || void 0,
+        params,
+        parentId: getRouteParentId(match),
+        path: toRoutePath(match),
+        pathname,
+        pathnameBase: 'string' == typeof match.pathnameBase ? match.pathnameBase : pathname
+    };
+}
+export { getRouteId, getRouteParentId, getRouteStaticData, toPayloadRoute, toPlainLocation, toPlainRecord, toRoutePath };

package/dist/esm-node/runtime/rsc/payloadStorage.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+import { storage } from "@modern-js/runtime-utils/node";
+const setTanstackRscServerPayload = (payload)=>{
+    const storageContext = storage.useContext?.();
+    if (storageContext) storageContext.serverPayload = payload;
+};
+const setTanstackRscRouter = (router)=>{
+    const storageContext = storage.useContext?.();
+    if (storageContext) storageContext.tanstackRscRouter = router;
+};
+const getTanstackRscRouter = ()=>{
+    const storageContext = storage.useContext?.();
+    return storageContext?.tanstackRscRouter;
+};
+export { getTanstackRscRouter, setTanstackRscRouter, setTanstackRscServerPayload };

package/dist/esm-node/runtime/rsc/server.mjs

@@ -1,27 +1,12 @@
 import "node:module";
 import { Fragment, jsx } from "react/jsx-runtime";
-import { createFromReadableStream, renderRsc } from "@modern-js/runtime/rsc/server";
-import { createSerializationAdapter } from "@tanstack/react-router";
-import { RawStream } from "@tanstack/router-core";
-import { createElement, use } from "react";
+import { renderRsc } from "@modern-js/runtime/rsc/server";
+import { RawStream, createSerializationAdapter } from "@tanstack/router-core";
+import { createElement } from "react";
 import { ClientSlot } from "./ClientSlot.mjs";
-import { createRscProxy } from "./createRscProxy.mjs";
 import { ReplayableStream } from "./ReplayableStream.mjs";
 import { sanitizeSlotArgs } from "./slotUsageSanitizer.mjs";
-import { RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent } from "./symbols.mjs";
-function createTreeGetter(stream) {
-    let ready = false;
-    let tree;
-    const treePromise = Promise.resolve(createFromReadableStream(stream.createReplayStream())).then((value)=>{
-        tree = value;
-        ready = true;
-        return value;
-    });
-    return ()=>{
-        if (ready) return tree;
-        return use(treePromise);
-    };
-}
+import { RENDERABLE_RSC, RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent } from "./symbols.mjs";
 function createSlotProxy(options) {
     const cache = new Map();
     return new Proxy({}, {
@@ -45,6 +30,17 @@ function createSlotProxy(options) {
         }
     });
 }
+function createServerRscValue(options) {
+    return {
+        [SERVER_COMPONENT_STREAM]: options.stream,
+        ...options.renderable ? {
+            [RENDERABLE_RSC]: true
+        } : {},
+        ...options.slotUsagesStream ? {
+            [RSC_SLOT_USAGES_STREAM]: options.slotUsagesStream
+        } : {}
+    };
+}
 function toReplayableFlightStream(node, handlers) {
     const flightStream = renderRsc({
         element: node
@@ -58,7 +54,7 @@ async function renderServerComponent(node) {
     const streamWrapper = {
         createReplayStream: ()=>stream.createReplayStream()
     };
-    return createRscProxy(createTreeGetter(streamWrapper), {
+    return createServerRscValue({
         renderable: true,
         stream: streamWrapper
     });
@@ -87,7 +83,7 @@ async function createCompositeComponent(component) {
     const streamWrapper = {
         createReplayStream: ()=>flightStream.createReplayStream()
     };
-    return createRscProxy(createTreeGetter(streamWrapper), {
+    return createServerRscValue({
         renderable: false,
         slotUsagesStream: slotUsagesEmitter?.stream,
         stream: streamWrapper