@bleedingdev/modern-js-renderer-solid 0.0.0-bootstrap → 3.9.3-ultramodern.1

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

@@ -0,0 +1,161 @@
+import { memo } 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";
+var _m$ = Symbol(), _m$2 = Symbol();
+var _d$ = {
+    get () {
+        return [
+            Transitioner({}),
+            MatchesInner(),
+            Rendered({})
+        ];
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$() {
+    Object.defineProperty(this, "children", _d$);
+}
+_P$.prototype = Object.prototype;
+var _d$2 = {
+    get () {
+        const routeId = this[_m$];
+        return routeId();
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$2(_p, _p2, _p3) {
+    this[_m$] = _p;
+    Object.defineProperty(this, "when", _d$2);
+    this.keyed = _p2;
+    this.children = _p3;
+}
+_P$2.prototype = Object.prototype;
+var _d$3 = {
+    get () {
+        const matchContent = this[_m$];
+        return matchContent();
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$3(_p4, _p5) {
+    this[_m$] = _p4;
+    this.value = _p5;
+    Object.defineProperty(this, "children", _d$3);
+}
+_P$3.prototype = Object.prototype;
+var _d$4 = {
+    get () {
+        return "production" !== process.env.NODE_ENV ? (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()}`);
+        } : void 0;
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$4(_p6, _p7, _p8) {
+    this.getResetKey = _p6;
+    this.render = _p7;
+    this.errorComponent = _p8;
+    Object.defineProperty(this, "onCatch", _d$4);
+}
+_P$4.prototype = Object.prototype;
+var _d$5 = {
+    get () {
+        const router = this[_m$];
+        const matchContent = this[_m$2];
+        return CatchBoundary(new _P$4(()=>router.stores.matches.get(), matchContent, ErrorComponent));
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$5(_p9, _p0, _p1) {
+    this[_m$] = _p9;
+    this[_m$2] = _p0;
+    this.value = _p1;
+    Object.defineProperty(this, "children", _d$5);
+}
+_P$5.prototype = Object.prototype;
+const NearestMatchContext = nearestMatchContext;
+function Matches() {
+    const router = useRouter();
+    const OptionalWrapper = router.options.InnerWrap || SafeFragment;
+    return OptionalWrapper(new _P$());
+}
+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 = ()=>__rspack_external_solid_js_0ac0db99.Show(new _P$2(routeId, true, (currentRouteId)=>Match({
+                routeId: currentRouteId
+            })));
+    if (router.options.disableGlobalCatchBoundary) return NearestMatchContext(new _P$3(matchContent, nearestMatch));
+    return NearestMatchContext(new _P$5(router, matchContent, nearestMatch));
+}
+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, {
+                pending,
+                caseSensitive,
+                fuzzy,
+                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-node/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.34",
+      "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.34 no longer exports. SSR options use the current top-level serializationAdapters contract and the public Solid 2 option types without legacy fallbacks or type assertions.",
+    "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.13 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-node/router-binding/RouterProvider.js

@@ -0,0 +1,87 @@
+import { mergeProps } from "@solidjs/web";
+import { isServer } from "@tanstack/router-core/isServer";
+import { setupFlightDataConsumer } from "./flightData.js";
+import { Matches } from "./Matches.js";
+import { 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";
+var _m$ = Symbol(), _m$2 = Symbol(), _m$3 = Symbol();
+var _d$ = {
+    get () {
+        const ready = this[_m$];
+        return ready();
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$(_p, _p2) {
+    this[_m$] = _p;
+    Object.defineProperty(this, "when", _d$);
+    this.children = _p2;
+}
+_P$.prototype = Object.prototype;
+var _d$2 = {
+    get () {
+        const ready = this[_m$];
+        const router = this[_m$2];
+        const children = this[_m$3];
+        return __rspack_external_solid_js_0ac0db99.Show(new _P$(ready, (_)=>{
+            if (isServer ?? router.isServer) serializeMatchTransfer(router);
+            return children();
+        }));
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$2(_p3, _p4, _p5, _p6) {
+    this[_m$] = _p3;
+    this[_m$2] = _p4;
+    this[_m$3] = _p5;
+    this.value = _p6;
+    Object.defineProperty(this, "children", _d$2);
+}
+_P$2.prototype = Object.prototype;
+var _d$3 = {
+    get () {
+        const ready = this[_m$];
+        const router = this[_m$2];
+        const children = this[_m$3];
+        return RouterContext(new _P$2(ready, router, children, router));
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$3(_p7, _p8, _p9) {
+    this[_m$] = _p7;
+    this[_m$2] = _p8;
+    this[_m$3] = _p9;
+    Object.defineProperty(this, "children", _d$3);
+}
+_P$3.prototype = Object.prototype;
+const RouterContext = routerContext;
+function RouterContextProvider({ router, children, ...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 OptionalWrapper(new _P$3(ready, router, children));
+}
+function RouterProvider({ router, ...rest }) {
+    return RouterContextProvider(mergeProps({
+        router
+    }, rest, {
+        children: ()=>Matches({})
+    }));
+}
+export { RouterContextProvider, RouterProvider };

package/dist/esm-node/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-node/router-binding/ScriptOnce.js

@@ -0,0 +1,16 @@
+import { escape as web_escape, ssr, ssrAttribute, ssrHydrationKey } from "@solidjs/web";
+import { isServer } from "@tanstack/router-core/isServer";
+import { useRouter } from "./useRouter.js";
+var _tmpl$ = [
+    "<script",
+    "",
+    " class=\"$tsr\">",
+    "<\/script>"
+];
+function ScriptOnce({ children }) {
+    const router = useRouter();
+    if (!(isServer ?? router.isServer)) return null;
+    var _v$ = ssrHydrationKey(), _v$2 = ()=>ssrAttribute("nonce", web_escape(router.options.ssr?.nonce, true)), _v$3 = children + ";document.currentScript.remove()";
+    return ssr(_tmpl$, _v$, _v$2, _v$3);
+}
+export { ScriptOnce };

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

@@ -0,0 +1,49 @@
+import { NoHydration } 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";
+var _m$ = Symbol();
+var _d$ = {
+    get () {
+        const tags = this[_m$];
+        return tags();
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$(_p, _p2) {
+    this[_m$] = _p;
+    Object.defineProperty(this, "each", _d$);
+    this.children = _p2;
+}
+_P$.prototype = Object.prototype;
+var _d$2 = {
+    get () {
+        const tags = this[_m$];
+        return __rspack_external_solid_js_0ac0db99.For(new _P$(tags, (asset)=>Asset(asset)));
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$2(_p3) {
+    this[_m$] = _p3;
+    Object.defineProperty(this, "children", _d$2);
+}
+_P$2.prototype = Object.prototype;
+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 NoHydration(new _P$2(tags));
+};
+export { Scripts };

package/dist/esm-node/router-binding/ScrollRestoration.js

@@ -0,0 +1,16 @@
+import { getElementScrollRestorationEntry, setupScrollRestoration } from "@tanstack/router-core";
+import { useRouter } from "./useRouter.js";
+function useScrollRestoration() {
+    const router = useRouter();
+    setupScrollRestoration(router, true);
+}
+function ScrollRestoration(_props) {
+    useScrollRestoration();
+    if ("development" === process.env.NODE_ENV) console.warn("The ScrollRestoration component is deprecated. Use createRouter's `scrollRestoration` option instead.");
+    return null;
+}
+function useElementScrollRestoration(options) {
+    useScrollRestoration();
+    return getElementScrollRestorationEntry(useRouter(), options);
+}
+export { ScrollRestoration, useElementScrollRestoration };

package/dist/esm-node/router-binding/Transitioner.js

@@ -0,0 +1,103 @@
+import { getLocationChangeInfo, trimPathRight } from "@tanstack/router-core";
+import { isServer } from "@tanstack/router-core/isServer";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function describeNavigation(router, expected, at) {
+    if (expected.some((match)=>"pending" === match.status)) return;
+    const to = router.latestLocation;
+    const from = router.stores.resolvedLocation.get();
+    if (!from || from.href === to.href) return;
+    const leaf = expected[expected.length - 1];
+    const ref = {
+        kind: "navigation",
+        name: leaf?.fullPath || to.pathname,
+        to: to.pathname,
+        from: from.pathname
+    };
+    if (leaf && Object.keys(leaf.params).length) ref.params = leaf.params;
+    if (void 0 !== at) ref.at = at;
+    return ref;
+}
+function getResolvedLocation(router) {
+    const resolvedLocation = router.stores.resolvedLocation.get();
+    if (resolvedLocation?.href === router.latestLocation.href && resolvedLocation.state.__TSR_key === router.latestLocation.state.__TSR_key) return resolvedLocation;
+}
+function Transitioner() {
+    const router = useRouter();
+    const acks = [];
+    let committed;
+    const isCommitted = (expected)=>!!committed && committed.length === expected.length && expected.every((match, index)=>committed[index] === match);
+    let requestedAt;
+    router.startTransition = (fn, expectedMatches)=>{
+        if (isServer ?? router.isServer) {
+            fn();
+            return Promise.resolve(true);
+        }
+        return new Promise((resolve)=>{
+            const ack = [
+                expectedMatches,
+                resolve
+            ];
+            acks.push(ack);
+            let publish = fn;
+            if (void 0 !== __rspack_external_solid_js_0ac0db99.OBSERVE) {
+                const ref = describeNavigation(router, expectedMatches, requestedAt);
+                if (void 0 !== ref) {
+                    requestedAt = void 0;
+                    const observe = __rspack_external_solid_js_0ac0db99.OBSERVE;
+                    publish = ()=>observe.attribution.withOrigin(ref, fn);
+                }
+            }
+            __rspack_external_solid_js_0ac0db99.runWithOwner(null, publish);
+            try {
+                __rspack_external_solid_js_0ac0db99.flush();
+            } catch  {}
+            if (acks.includes(ack) && isCommitted(expectedMatches)) {
+                acks.splice(acks.indexOf(ack), 1);
+                resolve(true);
+            }
+        });
+    };
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>router.stores.matches.get(), (current)=>{
+        committed = current;
+        if (acks.length) for (const [expected, resolve] of acks.splice(0))resolve(isCommitted(expected));
+    });
+    __rspack_external_solid_js_0ac0db99.onSettled(()=>{
+        const unsub = router.history.subscribe(()=>{
+            requestedAt ??= performance.now();
+            queueMicrotask(()=>router.load().catch(console.error));
+        });
+        router.updateLatestLocation();
+        const nextLocation = router.buildLocation({
+            to: router.latestLocation.pathname,
+            search: true,
+            params: true,
+            hash: true,
+            state: true,
+            _includeValidateSearch: true
+        });
+        if (trimPathRight(router.latestLocation.publicHref) !== trimPathRight(nextLocation.publicHref)) {
+            router.commitLocation({
+                ...nextLocation,
+                replace: true,
+                ignoreBlocker: true
+            });
+            return unsub;
+        }
+        if (!getResolvedLocation(router) && !router._tx) queueMicrotask(()=>router.load().catch(console.error));
+        return unsub;
+    });
+    return null;
+}
+function Rendered() {
+    const router = useRouter();
+    __rspack_external_solid_js_0ac0db99.onSettled(()=>{
+        const resolvedLocation = getResolvedLocation(router);
+        if (resolvedLocation) router.emit({
+            type: "onRendered",
+            ...getLocationChangeInfo(resolvedLocation, resolvedLocation)
+        });
+    });
+    return null;
+}
+export { Rendered, Transitioner };

package/dist/esm-node/router-binding/awaited.js

@@ -0,0 +1,75 @@
+import { TSR_DEFERRED_PROMISE, defer } from "@tanstack/router-core";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+var _m$ = Symbol();
+var _d$ = {
+    get () {
+        const props = this[_m$];
+        return props.ready();
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$(_p, _p2) {
+    this[_m$] = _p;
+    Object.defineProperty(this, "when", _d$);
+    this.children = _p2;
+}
+_P$.prototype = Object.prototype;
+var _d$2 = {
+    get () {
+        const props = this[_m$];
+        return props.children;
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$2(_p3, _p4, _p5) {
+    this[_m$] = _p3;
+    this.deferred = _p4;
+    this.ready = _p5;
+    Object.defineProperty(this, "children", _d$2);
+}
+_P$2.prototype = Object.prototype;
+var _d$3 = {
+    get () {
+        const props = this[_m$];
+        return props.fallback;
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$3(_p6, _p7) {
+    this[_m$] = _p6;
+    Object.defineProperty(this, "fallback", _d$3);
+    this.children = _p7;
+}
+_P$3.prototype = Object.prototype;
+function track(promise) {
+    return defer(Object.isExtensible(promise) ? promise : promise.then((v)=>v));
+}
+function useAwaited({ promise: _promise }) {
+    const promise = track(_promise);
+    const data = __rspack_external_solid_js_0ac0db99.createMemo(async ()=>await promise);
+    return [
+        data(),
+        promise
+    ];
+}
+function InnerAwait(props) {
+    return __rspack_external_solid_js_0ac0db99.Show(new _P$(props, (_)=>{
+        const state = props.deferred[TSR_DEFERRED_PROMISE];
+        if ("error" === state.status) throw state.error;
+        return props.children(state.data);
+    }));
+}
+function Await(props) {
+    const deferred = track(props.promise);
+    const ready = __rspack_external_solid_js_0ac0db99.createMemo(async ()=>{
+        await deferred;
+        return true;
+    });
+    const inner = InnerAwait(new _P$2(props, deferred, ready));
+    if (void 0 === props.fallback) return inner;
+    return __rspack_external_solid_js_0ac0db99.Loading(new _P$3(props, inner));
+}
+export { Await, useAwaited };