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

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

@@ -0,0 +1,88 @@
+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/runtime/rsc/payloadErrors.mjs

@@ -0,0 +1,49 @@
+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/runtime/rsc/payloadFetch.mjs

@@ -0,0 +1,61 @@
+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/runtime/rsc/payloadRouter.mjs

@@ -1,76 +1,8 @@
-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 = [];
@@ -80,7 +12,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);
         }
     }
@@ -89,14 +21,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');
@@ -108,69 +43,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();
@@ -189,8 +72,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/runtime/rsc/payloadRoutes.mjs

@@ -0,0 +1,50 @@
+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/runtime/rsc/payloadStorage.mjs

@@ -0,0 +1,14 @@
+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/runtime/rsc/server.mjs

@@ -1,26 +1,11 @@
 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({}, {
@@ -44,6 +29,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
@@ -57,7 +53,7 @@ async function renderServerComponent(node) {
     const streamWrapper = {
         createReplayStream: ()=>stream.createReplayStream()
     };
-    return createRscProxy(createTreeGetter(streamWrapper), {
+    return createServerRscValue({
         renderable: true,
         stream: streamWrapper
     });
@@ -86,7 +82,7 @@ async function createCompositeComponent(component) {
     const streamWrapper = {
         createReplayStream: ()=>flightStream.createReplayStream()
     };
-    return createRscProxy(createTreeGetter(streamWrapper), {
+    return createServerRscValue({
         renderable: false,
         slotUsagesStream: slotUsagesEmitter?.stream,
         stream: streamWrapper

package/dist/esm/runtime/rsc/shared.mjs

@@ -0,0 +1,21 @@
+import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
+const TANSTACK_RSC_FLIGHT_VALUE = '__modernTanstackRsc';
+function isSerializedTanstackRscFlightValue(value) {
+    return Boolean(value) && 'object' == typeof value && true === value[TANSTACK_RSC_FLIGHT_VALUE] && ('renderable' === value.kind || 'composite' === value.kind) && value.stream instanceof ReadableStream;
+}
+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;
+}
+function renderSelectedTree(src, { getTree = src[RSC_PROXY_GET_TREE], missingTreeError }) {
+    if (!getTree) throw new Error(missingTreeError);
+    return selectTreePath(getTree(), src[RSC_PROXY_PATH] || []);
+}
+export { EmptyFallback, TANSTACK_RSC_FLIGHT_VALUE, isSerializedTanstackRscFlightValue, renderSelectedTree, selectTreePath };

package/dist/esm/runtime/rsc/treeGetter.mjs

@@ -0,0 +1,34 @@
+"use client";
+import { use } from "react";
+let modernRscClientRuntimePromise;
+function loadModernRscClientRuntime() {
+    modernRscClientRuntimePromise ??= import("@modern-js/runtime/rsc/client").then((runtime)=>{
+        runtime.setServerCallback(runtime.callServer);
+        return runtime;
+    });
+    return modernRscClientRuntimePromise;
+}
+async function createFromFlightStream(stream) {
+    if ("u" < typeof window) {
+        const runtime = await import("react-server-dom-rspack/client.edge");
+        return runtime.createFromReadableStream(stream);
+    }
+    const runtime = await loadModernRscClientRuntime();
+    return runtime.createFromReadableStream(stream, {
+        callServer: runtime.callServer
+    });
+}
+function createTreeGetterFromFlightStream(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = createFromFlightStream(stream).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return use(treePromise);
+    };
+}
+export { createTreeGetterFromFlightStream };

package/dist/esm/runtime/ssrManagedTags.mjs

@@ -0,0 +1,53 @@
+async function waitForRouterSerialization(tanstackRouter) {
+    const serverSsr = tanstackRouter.serverSsr;
+    if (!serverSsr || 'function' != typeof serverSsr.onSerializationFinished || serverSsr.isSerializationFinished?.()) return;
+    await new Promise((resolve)=>{
+        serverSsr.onSerializationFinished?.(resolve);
+    });
+}
+function htmlEscapeAttr(value) {
+    return value.replace(/&/g, '&').replace(/"/g, '"');
+}
+function routerManagedTagToHtml(tag) {
+    if (!tag || 'object' != typeof tag) return '';
+    const managedTag = tag;
+    if (!managedTag || "script" !== managedTag.tag) return '';
+    const attrs = managedTag.attrs || {};
+    const attrsStr = Object.entries(attrs).filter(([, v])=>null != v && false !== v).map(([k, v])=>{
+        const name = 'className' === k ? 'class' : k;
+        if (true === v) return name;
+        return `${name}="${htmlEscapeAttr(String(v))}"`;
+    }).join(' ');
+    const open = attrsStr.length ? `<script ${attrsStr}>` : "<script>";
+    const children = 'string' == typeof managedTag.children ? managedTag.children : '';
+    return `${open}${children}</script>`;
+}
+function routerManagedTagsToHtml(tags) {
+    const normalizedTags = Array.isArray(tags) ? tags : [
+        tags
+    ];
+    return normalizedTags.map(routerManagedTagToHtml).filter(Boolean);
+}
+function createGetSsrHref(request) {
+    const url = new URL(request.url);
+    return `${url.pathname}${url.search}${url.hash}`;
+}
+function collectRouterErrors(tanstackRouter) {
+    const state = tanstackRouter.state;
+    const matches = Array.isArray(state.matches) ? state.matches : [];
+    const errors = matches.reduce((acc, match)=>{
+        if (!match.error) return acc;
+        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : `match-${Object.keys(acc).length}`;
+        acc[routeId] = match.error;
+        return acc;
+    }, {});
+    return Object.keys(errors).length > 0 ? errors : void 0;
+}
+async function attachServerSsrUtils(router) {
+    const { attachRouterServerSsrUtils } = await import("@tanstack/router-core/ssr/server");
+    attachRouterServerSsrUtils({
+        router,
+        manifest: void 0
+    });
+}
+export { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization };