@bleedingdev/modern-js-renderer-solid 0.0.0-stage → 3.9.3-ultramodern.10

package/dist/esm/router-binding/Match.js

@@ -0,0 +1,319 @@
+import { Dynamic, createComponent, memo, mergeProps } from "@solidjs/web";
+import { rootRouteId } from "@tanstack/router-core";
+import { isServer } from "@tanstack/router-core/isServer";
+import { CatchBoundary, ErrorComponent } from "./CatchBoundary.js";
+import { ClientOnly } from "./ClientOnly.js";
+import { nearestMatchContext } from "./matchContext.js";
+import { nonRouteComponentContext, renderInNonRouteComponentContext } from "./nonRouteComponentContext.js";
+import { CatchNotFound, getNotFound } from "./not-found.js";
+import { renderRouteNotFound } from "./renderRouteNotFound.js";
+import { SafeFragment } from "./SafeFragment.js";
+import { ScrollRestoration } from "./scroll-restoration.js";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const NearestMatchContext = nearestMatchContext;
+const renderScrollRestoration = false === isServer ? void 0 : (router, route)=>(isServer ?? router.isServer) && route.parentRoute?.id === rootRouteId && router.options.scrollRestoration ? createComponent(ScrollRestoration, {}) : null;
+const Match = (props)=>{
+    const router = useRouter();
+    const currentMatch = __rspack_external_solid_js_0ac0db99.createMemo(()=>router.stores.getMatchStore(props.routeId).get());
+    const matchState = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const match = currentMatch();
+        if (!match) return null;
+        return {
+            routeId: match.routeId,
+            ssr: match.ssr,
+            status: match.status
+        };
+    });
+    const nearestMatch = [
+        ()=>props.routeId,
+        currentMatch
+    ];
+    return createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+        get when () {
+            return matchState();
+        },
+        children: (currentMatchState)=>{
+            const route = router.routesById[props.routeId];
+            const routeOptions = ()=>{
+                currentMatchState();
+                return route.options;
+            };
+            const resolvePendingComponent = __rspack_external_solid_js_0ac0db99.createMemo(()=>routeOptions().pendingComponent ?? router.options.defaultPendingComponent);
+            const routeErrorComponent = __rspack_external_solid_js_0ac0db99.createMemo(()=>routeOptions().errorComponent ?? router.options.defaultErrorComponent);
+            const routeNotFoundComponent = __rspack_external_solid_js_0ac0db99.createMemo(()=>route.isRoot ? routeOptions().notFoundComponent ?? router.options.notFoundRoute?.options.component ?? router.options.defaultNotFoundComponent : routeOptions().notFoundComponent ?? router.options.defaultNotFoundComponent);
+            const resolvedNoSsr = __rspack_external_solid_js_0ac0db99.createMemo(()=>false === currentMatchState().ssr || "data-only" === currentMatchState().ssr);
+            const ResolvedNotFoundBoundary = __rspack_external_solid_js_0ac0db99.createMemo(()=>routeNotFoundComponent() ? CatchNotFound : SafeFragment);
+            const ShellComponent = __rspack_external_solid_js_0ac0db99.createMemo(()=>route.isRoot ? route.options.shellComponent ?? SafeFragment : SafeFragment);
+            const MatchContent = ()=>createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+                    get when () {
+                        return "pending" !== currentMatchState().status;
+                    },
+                    get fallback () {
+                        if ("production" !== process.env.NODE_ENV) return renderInNonRouteComponentContext(()=>createComponent(Dynamic, {
+                                get component () {
+                                    return resolvePendingComponent();
+                                }
+                            }), "pendingComponent");
+                        return createComponent(Dynamic, {
+                            get component () {
+                                return resolvePendingComponent();
+                            }
+                        });
+                    },
+                    get children () {
+                        return createComponent(MatchInner, {});
+                    }
+                });
+            const RouteContent = ()=>createComponent(Dynamic, {
+                    get component () {
+                        return ResolvedNotFoundBoundary();
+                    },
+                    fallback: (error)=>{
+                        const notFoundError = getNotFound(error) ?? error;
+                        notFoundError.routeId ??= currentMatchState().routeId;
+                        if (notFoundError.routeId !== currentMatchState().routeId) throw notFoundError;
+                        return "production" !== process.env.NODE_ENV ? renderInNonRouteComponentContext(()=>createComponent(Dynamic, mergeProps({
+                                get component () {
+                                    return routeNotFoundComponent();
+                                }
+                            }, notFoundError)), "notFoundComponent") : createComponent(Dynamic, mergeProps({
+                            get component () {
+                                return routeNotFoundComponent();
+                            }
+                        }, notFoundError));
+                    },
+                    get children () {
+                        return createComponent(__rspack_external_solid_js_0ac0db99.Switch, {
+                            get children () {
+                                return [
+                                    createComponent(__rspack_external_solid_js_0ac0db99.Match, {
+                                        get when () {
+                                            return resolvedNoSsr();
+                                        },
+                                        get children () {
+                                            return createComponent(ClientOnly, {
+                                                get fallback () {
+                                                    if ("production" !== process.env.NODE_ENV) return renderInNonRouteComponentContext(()=>createComponent(Dynamic, {
+                                                            get component () {
+                                                                return resolvePendingComponent();
+                                                            }
+                                                        }), "pendingComponent");
+                                                    return createComponent(Dynamic, {
+                                                        get component () {
+                                                            return resolvePendingComponent();
+                                                        }
+                                                    });
+                                                },
+                                                get children () {
+                                                    return createComponent(MatchContent, {});
+                                                }
+                                            });
+                                        }
+                                    }),
+                                    createComponent(__rspack_external_solid_js_0ac0db99.Match, {
+                                        get when () {
+                                            return !resolvedNoSsr();
+                                        },
+                                        get children () {
+                                            return createComponent(MatchContent, {});
+                                        }
+                                    })
+                                ];
+                            }
+                        });
+                    }
+                });
+            return createComponent(Dynamic, {
+                get component () {
+                    return ShellComponent();
+                },
+                get children () {
+                    return [
+                        createComponent(NearestMatchContext, {
+                            value: nearestMatch,
+                            get children () {
+                                return createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+                                    get when () {
+                                        return routeErrorComponent();
+                                    },
+                                    get fallback () {
+                                        return createComponent(RouteContent, {});
+                                    },
+                                    children: (errorComponent)=>createComponent(CatchBoundary, {
+                                            getResetKey: ()=>{
+                                                const matches = router.stores.matches.get();
+                                                const index = matches.findIndex((match)=>match.routeId === props.routeId);
+                                                if (-1 === index) return "";
+                                                let key = "";
+                                                for(let i = index; i < matches.length; i++){
+                                                    const match = matches[i];
+                                                    key += `${match.status}|${match.updatedAt},`;
+                                                }
+                                                return key;
+                                            },
+                                            get errorComponent () {
+                                                return errorComponent();
+                                            },
+                                            onCatch: (error)=>{
+                                                const notFoundError = getNotFound(error);
+                                                if (notFoundError) {
+                                                    notFoundError.routeId ??= currentMatchState().routeId;
+                                                    throw notFoundError;
+                                                }
+                                                if ("production" !== process.env.NODE_ENV) console.warn(`Warning: Error in route match: ${currentMatchState().routeId}`);
+                                                (routeOptions().onCatch ?? router.options.defaultOnCatch)?.(error);
+                                            },
+                                            render: RouteContent
+                                        })
+                                });
+                            }
+                        }),
+                        memo(()=>renderScrollRestoration?.(router, route))
+                    ];
+                }
+            });
+        }
+    });
+};
+const MatchInner = ()=>{
+    const router = useRouter();
+    const nearestMatch = __rspack_external_solid_js_0ac0db99.useContext(nearestMatchContext);
+    const match = nearestMatch[1];
+    const routeId = nearestMatch[0];
+    const matchState = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const currentMatch = match();
+        const currentRouteId = routeId();
+        if (!currentMatch || !currentRouteId) return null;
+        const route = router.routesById[currentRouteId];
+        const remount = route.options.remountDeps ?? router.options.defaultRemountDeps;
+        let componentKey;
+        if (remount) {
+            const deps = remount({
+                routeId: currentRouteId,
+                loaderDeps: currentMatch.loaderDeps,
+                params: currentMatch._strictParams,
+                search: currentMatch._strictSearch
+            });
+            componentKey = JSON.stringify(deps) ?? currentRouteId;
+        } else componentKey = currentRouteId;
+        return {
+            route,
+            routeId: currentRouteId,
+            match: {
+                id: currentMatch.id,
+                status: currentMatch.status,
+                error: currentMatch.error
+            },
+            componentKey
+        };
+    });
+    return createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+        get when () {
+            return matchState();
+        },
+        children: (currentMatchState)=>{
+            const route = __rspack_external_solid_js_0ac0db99.createMemo(()=>currentMatchState().route);
+            const currentMatch = __rspack_external_solid_js_0ac0db99.createMemo(()=>currentMatchState().match);
+            const componentKey = __rspack_external_solid_js_0ac0db99.createMemo(()=>currentMatchState().componentKey);
+            const OutComponent = __rspack_external_solid_js_0ac0db99.createMemo(()=>route().options.component ?? router.options.defaultComponent ?? Outlet);
+            const keyedOut = ()=>createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+                    get when () {
+                        return componentKey();
+                    },
+                    keyed: true,
+                    children: (_key)=>createComponent(Dynamic, {
+                            get component () {
+                                return OutComponent();
+                            }
+                        })
+                });
+            return createComponent(__rspack_external_solid_js_0ac0db99.Switch, {
+                get children () {
+                    return [
+                        createComponent(__rspack_external_solid_js_0ac0db99.Match, {
+                            get when () {
+                                return "notFound" === currentMatch().status;
+                            },
+                            children: (_)=>__rspack_external_solid_js_0ac0db99.untrack(()=>renderRouteNotFound(router, route(), currentMatch().error))
+                        }),
+                        createComponent(__rspack_external_solid_js_0ac0db99.Match, {
+                            get when () {
+                                return "error" === currentMatch().status;
+                            },
+                            children: (_)=>{
+                                const matchError = __rspack_external_solid_js_0ac0db99.untrack(()=>currentMatch().error);
+                                if (isServer ?? router.isServer) {
+                                    const RouteErrorComponent = (route().options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent;
+                                    return "production" !== process.env.NODE_ENV ? renderInNonRouteComponentContext(()=>createComponent(RouteErrorComponent, {
+                                            error: matchError,
+                                            reset: void 0,
+                                            info: {
+                                                componentStack: ""
+                                            }
+                                        }), "errorComponent") : createComponent(RouteErrorComponent, {
+                                        error: matchError,
+                                        reset: void 0,
+                                        info: {
+                                            componentStack: ""
+                                        }
+                                    });
+                                }
+                                throw matchError;
+                            }
+                        }),
+                        createComponent(__rspack_external_solid_js_0ac0db99.Match, {
+                            get when () {
+                                return "success" === currentMatch().status;
+                            },
+                            get children () {
+                                return keyedOut();
+                            }
+                        })
+                    ];
+                }
+            });
+        }
+    });
+};
+const Outlet = ()=>{
+    if ("production" !== process.env.NODE_ENV) {
+        const nonRouteComponent = __rspack_external_solid_js_0ac0db99.useContext(nonRouteComponentContext);
+        if (nonRouteComponent) console.warn(`Warning: An <Outlet /> was rendered inside a ${nonRouteComponent}. <Outlet /> should only be rendered inside a route component.`);
+    }
+    const router = useRouter();
+    const nearestParentMatch = __rspack_external_solid_js_0ac0db99.useContext(nearestMatchContext);
+    const parentMatch = nearestParentMatch[1];
+    const routeId = nearestParentMatch[0];
+    const route = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const currentRouteId = routeId();
+        return currentRouteId ? router.routesById[currentRouteId] : void 0;
+    });
+    const parentNotFound = __rspack_external_solid_js_0ac0db99.createMemo(()=>parentMatch()?._notFound);
+    const parentNotFoundError = __rspack_external_solid_js_0ac0db99.createMemo(()=>parentMatch()?.error);
+    const childRouteId = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        if (parentNotFound()) return;
+        const currentRouteId = routeId();
+        if (!currentRouteId) return;
+        const ids = router.stores.ids.get();
+        return ids[ids.indexOf(currentRouteId) + 1];
+    });
+    return createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+        get when () {
+            return childRouteId();
+        },
+        keyed: true,
+        get fallback () {
+            return createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+                get when () {
+                    return memo(()=>!!parentNotFound())() ? route() : parentNotFound();
+                },
+                children: (resolvedRoute)=>__rspack_external_solid_js_0ac0db99.untrack(()=>renderRouteNotFound(router, resolvedRoute(), parentNotFoundError()))
+            });
+        },
+        children: (currentChildRouteId)=>createComponent(Match, {
+                routeId: currentChildRouteId
+            })
+    });
+};
+export { Match, MatchInner, Outlet };

package/dist/esm/router-binding/Matches.js

@@ -0,0 +1,124 @@
+import { createComponent, memo, mergeProps } from "@solidjs/web";
+import { replaceEqualDeep } from "@tanstack/router-core";
+import { CatchBoundary, ErrorComponent } from "./CatchBoundary.js";
+import { Match } from "./Match.js";
+import { nearestMatchContext } from "./matchContext.js";
+import { SafeFragment } from "./SafeFragment.js";
+import { Rendered, Transitioner } from "./Transitioner.js";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const NearestMatchContext = nearestMatchContext;
+function Matches() {
+    const router = useRouter();
+    const OptionalWrapper = router.options.InnerWrap || SafeFragment;
+    return createComponent(OptionalWrapper, {
+        get children () {
+            return [
+                createComponent(Transitioner, {}),
+                createComponent(MatchesInner, {}),
+                createComponent(Rendered, {})
+            ];
+        }
+    });
+}
+function MatchesInner() {
+    const router = useRouter();
+    const routeId = ()=>router.stores.ids.get()[0];
+    const match = ()=>routeId() ? router.stores.byRoute.get(routeId())?.get() : void 0;
+    const nearestMatch = [
+        routeId,
+        match
+    ];
+    const matchContent = ()=>createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+            get when () {
+                return routeId();
+            },
+            keyed: true,
+            children: (currentRouteId)=>createComponent(Match, {
+                    routeId: currentRouteId
+                })
+        });
+    if (router.options.disableGlobalCatchBoundary) return createComponent(NearestMatchContext, {
+        value: nearestMatch,
+        get children () {
+            return matchContent();
+        }
+    });
+    return createComponent(NearestMatchContext, {
+        value: nearestMatch,
+        get children () {
+            return createComponent(CatchBoundary, mergeProps({
+                getResetKey: ()=>router.stores.matches.get(),
+                render: matchContent,
+                errorComponent: ErrorComponent
+            }, ()=>"production" !== process.env.NODE_ENV ? {
+                    onCatch: (error)=>{
+                        console.warn("Warning: The following error wasn't caught by any route! At the very least, consider setting an 'errorComponent' in your RootRoute!");
+                        console.warn(`Warning: ${error.message || error.toString()}`);
+                    }
+                } : {}));
+        }
+    });
+}
+function useMatchRoute() {
+    const router = useRouter();
+    return (opts)=>__rspack_external_solid_js_0ac0db99.createMemo(()=>{
+            const { pending, caseSensitive, fuzzy, includeSearch, ...rest } = opts;
+            router.stores.location.get();
+            router.stores.resolvedLocation.get();
+            router.stores.status.get();
+            return router.matchRoute(rest, {
+                ...void 0 !== pending ? {
+                    pending
+                } : {},
+                ...void 0 !== caseSensitive ? {
+                    caseSensitive
+                } : {},
+                ...void 0 !== fuzzy ? {
+                    fuzzy
+                } : {},
+                ...void 0 !== includeSearch ? {
+                    includeSearch
+                } : {}
+            });
+        });
+}
+function MatchRoute(props) {
+    const matchRoute = useMatchRoute();
+    const params = matchRoute(props);
+    const renderedChild = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const matchedParams = params();
+        const child = props.children;
+        if ("function" == typeof child) return child(matchedParams);
+        return matchedParams ? child : null;
+    });
+    return memo(renderedChild);
+}
+function useMatches(opts) {
+    const router = useRouter();
+    return __rspack_external_solid_js_0ac0db99.createMemo((prev)=>{
+        const matches = router.stores.matches.get();
+        const res = opts?.select ? opts.select(matches) : matches;
+        if (void 0 === prev) return res;
+        return replaceEqualDeep(prev, res);
+    });
+}
+function useParentMatches(opts) {
+    const contextRouteId = __rspack_external_solid_js_0ac0db99.useContext(nearestMatchContext)[0];
+    return useMatches({
+        select: (matches)=>{
+            matches = matches.slice(0, matches.findIndex((d)=>d.routeId === contextRouteId()));
+            return opts?.select ? opts.select(matches) : matches;
+        }
+    });
+}
+function useChildMatches(opts) {
+    const contextRouteId = __rspack_external_solid_js_0ac0db99.useContext(nearestMatchContext)[0];
+    return useMatches({
+        select: (matches)=>{
+            matches = matches.slice(matches.findIndex((d)=>d.routeId === contextRouteId()) + 1);
+            return opts?.select ? opts.select(matches) : matches;
+        }
+    });
+}
+export { MatchRoute, Matches, useChildMatches, useMatchRoute, useMatches, useParentMatches };

package/dist/esm/router-binding/PROVENANCE.json

@@ -0,0 +1,94 @@
+{
+  "repository": "https://github.com/TanStack/router",
+  "commit": "4fbd65c5c3b40be87a6248867c22021c1c19bba8",
+  "sourcePath": "packages/solid-router/src",
+  "upstreamPackage": "@tanstack/solid-router",
+  "upstreamVersion": "2.0.0-rc.8",
+  "license": "MIT",
+  "licenseSourcePath": "LICENSE",
+  "ownedBy": "@modern-js/renderer-solid",
+  "upstreamPorts": [
+    {
+      "repository": "https://github.com/TanStack/router",
+      "commit": "84bde660a12d82e8c74859b3240157af7566f843",
+      "sourcePath": "packages/solid-router/src",
+      "upstreamPackage": "@tanstack/solid-router",
+      "upstreamVersion": "1.170.36",
+      "routerCoreVersion": "1.171.37",
+      "files": ["Scripts.tsx", "link.tsx"],
+      "adaptation": "Native body-script composition and positional search equality are ported from the matching router-core release. The owned binding retains Solid 2 RC.13 JSX, NoHydration, keyed public match transfer and its module-keyed client-assets resolver."
+    }
+  ],
+  "upstreamFileSha256": {
+    "Asset.tsx": "78dbaa6e5ab3fabc49dc28cba20e923d7b9f7b9dcaf3729dd5479e2e5d88da56",
+    "CatchBoundary.tsx": "c79c2944e7735c76058c196693ca2ddb4bddb142fcd7a586b0672f81772486eb",
+    "ClientOnly.tsx": "e6c1ca9b4f2657696bd29d0221bd5e5f60c130f64cc694e426a7b65aaa66df74",
+    "HeadContent.tsx": "86537f4ed1ab45282444d7badfb618ba74ad19bbe547c35f3d6e8d12397c8e73",
+    "LICENSE": "a405ee70c632bb938acb7ac5f210e814409b3760ea9d2329d8ed8ffcfd11a0e7",
+    "Match.tsx": "9f83c3ab36d9eb3480b2f3b8ec10b7b77a2ff5e4ea75d79104fe628c40056af0",
+    "Matches.tsx": "5ec59438b48b7dc9bc3add8703080ee46d6dfd7b76ccaff61fe65f5ddcf02579",
+    "RouterProvider.tsx": "e5d2459328927a470e5821c7f1f68eeca51915ef885bfc45aedb2e5ee8fa4928",
+    "SafeFragment.tsx": "31a1e3445f0893abdccb3f431e97ad4e81562f09db8e0731fca37d3383641bd3",
+    "ScriptOnce.tsx": "d499a0a5cc9aa5069f9dcb38adc5de62d50db11e844f5b2bc3789589c859df51",
+    "Scripts.tsx": "c47516d07012106ebd069957970336f794ea01644c154828e7c231ac428679e1",
+    "ScrollRestoration.tsx": "947f793e1a7b1f889389fbeb24067166e65dddf19185cdc57f725d9064ca7a28",
+    "Transitioner.tsx": "ee166b4668d839fc70ccde13cb3236bfe1ec2fd6c84beab6444f312200d28046",
+    "awaited.tsx": "68185231c442451c9f97ff47b7de39803272d33e96805778231dac95fc7d1741",
+    "fileRoute.ts": "3ed7a45ea9f18566ac71bb63b0c8881b411d28bc2abe486703fe305c9fdbd01e",
+    "flightData.ts": "e19f75891f80fd220227fcc03ee17c83c7c7fb804fa0c53785daa24ebe062a4e",
+    "headContentUtils.tsx": "9dcbd62e325e7d249a79b6afff77f51388c985ac91b0f329f9ec5140bc16205c",
+    "history.ts": "1bd12c2f8ca1b44e860a17f92582596b0125c92bb577db6f07e8c3994b7a582c",
+    "index.tsx": "34248dc9c06f4e16a3a42b1256782ffe8d87bcbdbdafb1c2bffb9aef8abdbe47",
+    "lazyRouteComponent.tsx": "7bd78423c8ebac18157bacdac1c38b2fe91b98af734a2cd16b67b109e5a9fca6",
+    "link.tsx": "66ef79dcde50418e8e4b9cf5fbc15a97179283fc64b3f39a6632ebc38c11ef82",
+    "matchContext.tsx": "12bc0fabd0e9ffbab124c7270528bae8efeaf8473fd81f1e88163038d8f12e71",
+    "nonRouteComponentContext.tsx": "0c83d583a7852f76f779f7733f4e48c27148295b1f8e831cd27b26ce3ac4e5e2",
+    "not-found.tsx": "c408fce8f430c3692332dfae451b713fd17dc484809c39e6b4c9e300fedd25c8",
+    "registryTransfer.ts": "c0c989413589a384c0ad714f52d2fa622715bb15a487af1f1158ef96943c2192",
+    "renderRouteNotFound.tsx": "b504eb5b9fa6fe9998a90a0d5769ad9d5655d42b3d421e2c0dceebb8bc1831a5",
+    "route.tsx": "248922d87014821272e236cd5775c96c32d87060994db5b5f25478ffb20d86e6",
+    "router.ts": "0d8dd86241f611561d6588af0e31d194301269efe75525259eead54f95617f68",
+    "routerContext.tsx": "42f4c1179d5983224df798d2ca395b6246765cb6ec77eda2b627c8c464b5aa78",
+    "routerStores.ts": "46fb1e5d24e3d06ad798ad63b7e1ed9ec5e1f1f42e5ac1f60a9502db72da5f2f",
+    "scroll-restoration.tsx": "f029fc78c834c7271827da586b21a719d4ceebecf77f11eda75454c79608e879",
+    "typePrimitives.ts": "78d4527fe249ac871bd1696fd71f856a79cf93ccb85cedd57cf44630622d69fb",
+    "useBlocker.tsx": "ad5f4865501d628b430d15ea48dc5fabda0235b13075c688a364254183af5c95",
+    "useCanGoBack.ts": "d70495b51c4915f33158929b79352044f647d126fc5f44de08f04e219899b95b",
+    "useLoaderData.tsx": "2ffacb8e6c4bc2713f7da4db01dad0f34c9c4c9b75af66716e48ec38accf3397",
+    "useLoaderDeps.tsx": "066c52b466a0815e5f3e912e5909c8193ac039c3410ca5bb382b8d18ab1008bb",
+    "useLocation.tsx": "f65197d00b1bccd2cd7e9834a7273889706a86cf65db7636bafa41cdebb39de8",
+    "useMatch.tsx": "26c4a4c2e3d6b8b8a10b028409fca7711441b118c868a73be56209d7c38c2051",
+    "useNavigate.tsx": "83a6ec04e886b661bb38d95b12772778f79d573abd2f0c294b95d7080ef97968",
+    "useParams.tsx": "0a2a45dee679cf9df90fb1fb88e53a0d7afcfd6005c2d6cc848c350f3d33aefd",
+    "useRouteContext.ts": "2f248aeaa2fd4550dbc25b4fd78688c0aaf0d488f440546e5aeee2f055944294",
+    "useRouter.tsx": "0fe4a6a60ade5da19db72253898256486e08466a9fafd59aea3263ee5203e21d",
+    "useRouterState.tsx": "be1f97cfb4ee845cc8e7175aff5ede190e8a75c7f892faa7c914ac89c4af25f1",
+    "useSearch.tsx": "585add65de5a8633d09fa36be38666e601bfd01076e01fccef25f832792c1e1d",
+    "utils.ts": "a398c76ac378efe6f8b9aa859a5335d4f07cc692a31754fa93c8bf3e5df0b6ff"
+  },
+  "localChanges": [
+    "The public router surface omits InjectedHtmlEntry, isPlainArray and isPlainObject, which router-core 1.171.37 no longer exports. Managed SSR uses immutable public route data and native Solid 2 promise serialization. Custom serializationAdapters are unsupported and rejected before router construction or document commitment; the local public option types do not admit them.",
+    "Authored JSX types import @solidjs/web and have explicit return annotations for Solid 2 declaration generation.",
+    "Hydration state and keyed match transfer use Solid 2 RC.13 public isHydrating, isHydratable, getHydrationWriter and takeHydrationValue APIs.",
+    "Explicit public beforeLoad results transfer after canonical validation; private request context stays in owner closures. Initial hydration inherits checked server beforeLoad contributions, invokes the native client route-context callback and preserves client options context without rerunning initial beforeLoad callbacks or loaders.",
+    "Public native route/view data is projected into deeply frozen canonical plain or null-prototype records, arrays and scalars. Date, RegExp, Map and Set are unsupported at this immutable native UI boundary; the shared HTTP data codec retains its rich-data contract. Authored originals remain untouched.",
+    "Owner-scoped alias caches preserve shared critical objects and checked flat deferred transports. Promise fulfillments and rejections are freshly validated, cloned and frozen; unsupported values fail their owning scope. Request preflight captures stable public match snapshots before response commit, excluding known private request identities.",
+    "Fresh checked Promise handles are sealed with controlled nonenumerable s/v accessors matching the audited Solid RC.13 state protocol. Status accepts undefined, 0, 1 or 2; assigned values receive the same descriptor-safe immutable public/error projection and private-reference checks. Unsupported AsyncIterable state and unsafe annotations fail the owning scope. Authored Promise handles remain unchanged.",
+    "Only the native keyed hydration receiver admits decoded Promise metadata: exact native prototypes, own s/v data descriptors and documented states 0, 1 or 2. Settled states require a checked public value; symbols, accessors, extra fields and AsyncIterable metadata reject before atomic publication. A detached controlled transport adopts valid settled metadata synchronously before native views consume it. General authored Promise validation remains metadata-free and decoded originals remain untouched.",
+    "Managed route-tree owners apply the same public projection before native client hydration commits. The owning native store publisher validates the complete offered chain, rewrites composed-context fields to checked public references and freezes the same native context root before publication. Registry claiming consumes the complete matched chain and owns pending rejections before choosing atomic fallback.",
+    "Inside UltraModern request-owned SSR, the native provider and match serializer reject unregistered custom native routers before rendering or transfer; managed filesystem/application factories own the immutable public boundary and route-tree owner registration remains internal. Bare native rendering without an UltraModern request remains an ABI probe and does not claim framework privacy qualification.",
+    "Match errors use a descriptor-safe public diagnostic projection; exact DataProtocolError diagnostics remain actionable, and the exact fork-owned RouteDataError class has a fixed checked snapshot and native registry restoration.",
+    "The upstream ssr/ server-entry adapters are omitted; @modern-js/renderer-solid/server owns document rendering and the router transfer.",
+    "Source formatting follows the owning repository's Biome configuration."
+  ],
+  "nativeProtocolLimitations": [
+    {
+      "runtime": "@solidjs/web@2.0.0-rc.15 with Seroval 1.6.8",
+      "trigger": "Direct native writer injection of a rejected whole-match Promise before the client binding loads",
+      "observed": "Native inline resolver scripts reject registry Promises without a rejection handler; browser page errors occur before router construction. Binding claims cannot retroactively handle those errors.",
+      "supportedProducer": "The maintained match producer writes only settled synchronous records and excludes pending matches. Critical public-data failures are rejected before headers; unsupported deferred values fail the owning session and abort native serialization.",
+      "diagnostic": "ULTRAMODERN_SOLID_RAW_PROTOCOL_DIAGNOSTIC=1 node tests/ultramodern-renderers/solid-admission/run.mjs",
+      "qualification": "The raw injection is an opt-in unsupported native-protocol diagnostic, excluded from the maintained producer qualification; its failure remains visible and unsuppressed."
+    }
+  ]
+}

package/dist/esm/router-binding/RouterProvider.js

@@ -0,0 +1,52 @@
+import { createComponent, mergeProps } from "@solidjs/web";
+import { isServer } from "@tanstack/router-core/isServer";
+import { setupFlightDataConsumer } from "./flightData.js";
+import { Matches } from "./Matches.js";
+import { assertNativeSerializationOptions, requireManagedPublicRouter, serializeMatchTransfer } from "./registryTransfer.js";
+import { routerContext } from "./routerContext.js";
+import { SafeFragment } from "./SafeFragment.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const RouterContext = routerContext;
+function RouterContextProvider({ router, children, ...rest }) {
+    assertNativeSerializationOptions(rest);
+    requireManagedPublicRouter(router);
+    if (Object.keys(rest).length > 0) __rspack_external_solid_js_0ac0db99.runWithOwner(null, ()=>{
+        router.update({
+            ...router.options,
+            ...rest,
+            context: {
+                ...router.options.context,
+                ...rest.context
+            }
+        });
+    });
+    const ready = __rspack_external_solid_js_0ac0db99.createMemo(()=>(isServer ?? router.isServer) && !router._serverResult ? router.load().then(()=>true) : true);
+    if (!(isServer ?? router.isServer)) __rspack_external_solid_js_0ac0db99.onCleanup(setupFlightDataConsumer(router));
+    const OptionalWrapper = router.options.Wrap || SafeFragment;
+    return createComponent(OptionalWrapper, {
+        get children () {
+            return createComponent(RouterContext, {
+                value: router,
+                get children () {
+                    return createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+                        get when () {
+                            return ready();
+                        },
+                        children: (_)=>{
+                            if (isServer ?? router.isServer) serializeMatchTransfer(router);
+                            return children();
+                        }
+                    });
+                }
+            });
+        }
+    });
+}
+function RouterProvider({ router, ...rest }) {
+    return createComponent(RouterContextProvider, mergeProps({
+        router
+    }, rest, {
+        children: ()=>createComponent(Matches, {})
+    }));
+}
+export { RouterContextProvider, RouterProvider };

package/dist/esm/router-binding/SafeFragment.js

@@ -0,0 +1,5 @@
+import { memo } from "@solidjs/web";
+function SafeFragment(props) {
+    return memo(()=>props.children);
+}
+export { SafeFragment };

package/dist/esm/router-binding/ScriptOnce.js

@@ -0,0 +1,15 @@
+import { effect, getNextElement, setAttribute, setProperty, template } from "@solidjs/web";
+import { isServer } from "@tanstack/router-core/isServer";
+import { useRouter } from "./useRouter.js";
+var _tmpl$ = /* @__PURE__ */ template("<script class=$tsr>");
+function ScriptOnce({ children }) {
+    const router = useRouter();
+    if (!(isServer ?? router.isServer)) return null;
+    var _el$ = getNextElement(_tmpl$);
+    setProperty(_el$, "innerHTML", children + ";document.currentScript.remove()");
+    effect(()=>router.options.ssr?.nonce, (_v$)=>{
+        setAttribute(_el$, "nonce", _v$);
+    });
+    return _el$;
+}
+export { ScriptOnce };

package/dist/esm/router-binding/Scripts.js

@@ -0,0 +1,30 @@
+import { NoHydration, createComponent } from "@solidjs/web";
+import { composeSsrBodyScripts, getSsrBodyScriptParts, replaceEqualDeep } from "@tanstack/router-core";
+import { isServer } from "@tanstack/router-core/isServer";
+import { Asset } from "./Asset.js";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const Scripts = ()=>{
+    const router = useRouter();
+    const nonce = router.options.ssr?.nonce;
+    const scripts = __rspack_external_solid_js_0ac0db99.createMemo((previous)=>{
+        const next = composeSsrBodyScripts(getSsrBodyScriptParts(router.stores.matches.get(), router.ssr?.manifest, nonce));
+        return previous ? replaceEqualDeep(previous, next) : next;
+    });
+    const initialHydrationScripts = (isServer ?? router.isServer) && router.serverSsr ? router.serverSsr.takeInitialHydrationScriptTags() : void 0;
+    const tags = ()=>initialHydrationScripts ? composeSsrBodyScripts([
+            scripts(),
+            []
+        ], initialHydrationScripts) : scripts();
+    return createComponent(NoHydration, {
+        get children () {
+            return createComponent(__rspack_external_solid_js_0ac0db99.For, {
+                get each () {
+                    return tags();
+                },
+                children: (asset)=>createComponent(Asset, asset)
+            });
+        }
+    });
+};
+export { Scripts };