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

package/src/router-binding/Matches.tsx

@@ -0,0 +1,242 @@
+import type { JSX } from '@solidjs/web';
+import type {
+  AnyRouter,
+  DeepPartial,
+  Expand,
+  MakeOptionalPathParams,
+  MakeOptionalSearchParams,
+  MakeRouteMatchUnion,
+  MaskOptions,
+  MatchRouteOptions,
+  RegisteredRouter,
+  ResolveRoute,
+  ToSubOptionsProps,
+} from '@tanstack/router-core';
+import { replaceEqualDeep } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+import { CatchBoundary, ErrorComponent } from './CatchBoundary';
+import { Match } from './Match';
+import { nearestMatchContext } from './matchContext';
+import { SafeFragment } from './SafeFragment';
+import { Rendered, Transitioner } from './Transitioner';
+import { useRouter } from './useRouter';
+
+const NearestMatchContext = nearestMatchContext as unknown as Solid.Component<{
+  value: any;
+  children: any;
+}>;
+
+declare module '@tanstack/router-core' {
+  export interface RouteMatchExtensions {
+    meta?: Array<JSX.IntrinsicElements['meta'] | undefined>;
+    links?: Array<JSX.IntrinsicElements['link'] | undefined>;
+    scripts?: Array<JSX.IntrinsicElements['script'] | undefined>;
+    styles?: Array<JSX.IntrinsicElements['style'] | undefined>;
+    headScripts?: Array<JSX.IntrinsicElements['script'] | undefined>;
+  }
+}
+
+export function Matches() {
+  const router = useRouter();
+
+  const OptionalWrapper = router.options.InnerWrap || SafeFragment;
+
+  return (
+    <OptionalWrapper>
+      <Transitioner />
+      <MatchesInner />
+      <Rendered />
+    </OptionalWrapper>
+  );
+}
+
+function MatchesInner() {
+  const router = useRouter();
+  const routeId = () => router.stores.ids.get()[0];
+  const match = () =>
+    routeId() ? router.stores.byRoute.get(routeId()!)?.get() : undefined;
+  const nearestMatch = [routeId, match] as const;
+
+  const matchContent = () => (
+    <Solid.Show when={routeId()} keyed>
+      {currentRouteId => <Match routeId={currentRouteId} />}
+    </Solid.Show>
+  );
+
+  if (router.options.disableGlobalCatchBoundary) {
+    // When disableGlobalCatchBoundary is true, render without any internal
+    // error boundary so errors bubble up freely to an external Errored boundary.
+    return (
+      <NearestMatchContext value={nearestMatch}>
+        {matchContent()}
+      </NearestMatchContext>
+    );
+  }
+
+  return (
+    <NearestMatchContext value={nearestMatch}>
+      <CatchBoundary
+        getResetKey={() => router.stores.matches.get()}
+        render={matchContent}
+        errorComponent={ErrorComponent}
+        {...(process.env.NODE_ENV !== 'production'
+          ? {
+              onCatch: (error: 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()}`);
+              },
+            }
+          : {})}
+      />
+    </NearestMatchContext>
+  );
+}
+
+export type UseMatchRouteOptions<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TFrom extends string = string,
+  TTo extends string | undefined = undefined,
+  TMaskFrom extends string = TFrom,
+  TMaskTo extends string = '',
+> = ToSubOptionsProps<TRouter, TFrom, TTo> &
+  DeepPartial<MakeOptionalSearchParams<TRouter, TFrom, TTo>> &
+  DeepPartial<MakeOptionalPathParams<TRouter, TFrom, TTo>> &
+  MaskOptions<TRouter, TMaskFrom, TMaskTo> &
+  MatchRouteOptions;
+
+export function useMatchRoute<TRouter extends AnyRouter = RegisteredRouter>() {
+  const router = useRouter();
+
+  return <
+    const TFrom extends string = string,
+    const TTo extends string | undefined = undefined,
+    const TMaskFrom extends string = TFrom,
+    const TMaskTo extends string = '',
+  >(
+    opts: UseMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>,
+  ): Solid.Accessor<
+    false | Expand<ResolveRoute<TRouter, TFrom, TTo>['types']['allParams']>
+  > => {
+    return Solid.createMemo(() => {
+      const { pending, caseSensitive, fuzzy, includeSearch, ...rest } = opts;
+
+      router.stores.location.get();
+      router.stores.resolvedLocation.get();
+      router.stores.status.get();
+      return router.matchRoute(rest as any, {
+        ...(pending !== undefined ? { pending } : {}),
+        ...(caseSensitive !== undefined ? { caseSensitive } : {}),
+        ...(fuzzy !== undefined ? { fuzzy } : {}),
+        ...(includeSearch !== undefined ? { includeSearch } : {}),
+      });
+    });
+  };
+}
+
+export type MakeMatchRouteOptions<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TFrom extends string = string,
+  TTo extends string | undefined = undefined,
+  TMaskFrom extends string = TFrom,
+  TMaskTo extends string = '',
+> = UseMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+  // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns
+  children?:
+    | ((
+        params?: Expand<
+          ResolveRoute<TRouter, TFrom, TTo>['types']['allParams']
+        >,
+      ) => JSX.Element)
+    | JSX.Element;
+};
+
+export function MatchRoute<
+  TRouter extends AnyRouter = RegisteredRouter,
+  const TFrom extends string = string,
+  const TTo extends string | undefined = undefined,
+  const TMaskFrom extends string = TFrom,
+  const TMaskTo extends string = '',
+>(props: MakeMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): any {
+  const matchRoute = useMatchRoute();
+  const params = matchRoute(props as any);
+
+  const renderedChild = Solid.createMemo(() => {
+    const matchedParams = params();
+    const child = props.children;
+
+    if (typeof child === 'function') {
+      return (child as any)(matchedParams);
+    }
+
+    return matchedParams ? child : null;
+  });
+
+  return <>{renderedChild()}</>;
+}
+
+export interface UseMatchesBaseOptions<TRouter extends AnyRouter, TSelected> {
+  select?: (matches: Array<MakeRouteMatchUnion<TRouter>>) => TSelected;
+}
+
+export type UseMatchesResult<
+  TRouter extends AnyRouter,
+  TSelected,
+> = unknown extends TSelected ? Array<MakeRouteMatchUnion<TRouter>> : TSelected;
+
+export function useMatches<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: UseMatchesBaseOptions<TRouter, TSelected>,
+): Solid.Accessor<UseMatchesResult<TRouter, TSelected>> {
+  const router = useRouter<TRouter>();
+  return Solid.createMemo((prev: TSelected | undefined) => {
+    const matches = router.stores.matches.get() as Array<
+      MakeRouteMatchUnion<TRouter>
+    >;
+    const res = opts?.select ? opts.select(matches) : matches;
+    if (prev === undefined) return res;
+    return replaceEqualDeep(prev, res) as any;
+  }) as Solid.Accessor<UseMatchesResult<TRouter, TSelected>>;
+}
+
+export function useParentMatches<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: UseMatchesBaseOptions<TRouter, TSelected>,
+): Solid.Accessor<UseMatchesResult<TRouter, TSelected>> {
+  const contextRouteId =
+    Solid.useContext(nearestMatchContext)[0 /* route id */];
+
+  return useMatches({
+    select: (matches: Array<MakeRouteMatchUnion<TRouter>>) => {
+      matches = matches.slice(
+        0,
+        matches.findIndex(d => d.routeId === contextRouteId()),
+      );
+      return opts?.select ? opts.select(matches) : matches;
+    },
+  } as any);
+}
+
+export function useChildMatches<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: UseMatchesBaseOptions<TRouter, TSelected>,
+): Solid.Accessor<UseMatchesResult<TRouter, TSelected>> {
+  const contextRouteId =
+    Solid.useContext(nearestMatchContext)[0 /* route id */];
+
+  return useMatches({
+    select: (matches: Array<MakeRouteMatchUnion<TRouter>>) => {
+      matches = matches.slice(
+        matches.findIndex(d => d.routeId === contextRouteId()) + 1,
+      );
+      return opts?.select ? opts.select(matches) : matches;
+    },
+  } as any);
+}

package/src/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/src/router-binding/RouterProvider.tsx

@@ -0,0 +1,128 @@
+import type { JSX } from '@solidjs/web';
+import type { AnyRouter, RegisteredRouter } from '@tanstack/router-core';
+import { isServer } from '@tanstack/router-core/isServer';
+import * as Solid from 'solid-js';
+import { setupFlightDataConsumer } from './flightData';
+import { Matches } from './Matches';
+import {
+  assertNativeSerializationOptions,
+  requireManagedPublicRouter,
+  serializeMatchTransfer,
+} from './registryTransfer';
+import { routerContext } from './routerContext';
+import type { RouterOptions } from './routerOptions';
+import { SafeFragment } from './SafeFragment';
+
+const RouterContext = routerContext as unknown as Solid.Component<{
+  value: any;
+  children: any;
+}>;
+
+export function RouterContextProvider<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TDehydrated extends Record<string, any> = Record<string, any>,
+>({
+  router,
+  children,
+  ...rest
+}: RouterProps<TRouter, TDehydrated> & {
+  children: () => JSX.Element;
+}) {
+  assertNativeSerializationOptions(rest);
+  requireManagedPublicRouter(router);
+  if (Object.keys(rest).length > 0) {
+    Solid.runWithOwner(null, () => {
+      router.update({
+        ...router.options,
+        ...rest,
+        context: {
+          ...router.options.context,
+          ...rest.context,
+        },
+      } as any);
+    });
+  }
+
+  // Server-side, the provider owns the load dispatch: if the app (or a host
+  // framework like Start) hasn't already loaded the router, kick `load()`
+  // and park the render on it. Solid's SSR awaits parked reads natively, so
+  // blocking-loader semantics are preserved without a top-level
+  // `await router.load()` in the server entry. The memo exists on both
+  // environments so the component tree (and hydration keys) stay identical;
+  // on the client it resolves immediately and the boot is handled by the
+  // registry priming in the Router constructor plus Transitioner's
+  // settled-time load.
+  const ready = Solid.createMemo(() =>
+    (isServer ?? router.isServer) && !router._serverResult
+      ? router.load().then(() => true)
+      : true,
+  );
+
+  // Client-side, the provider is where the router meets Solid's
+  // server-function transport: it consumes the response metadata mutations
+  // return (`redirect()`, `reload()`, `respond(value, { revalidate })`) so
+  // a mutation's navigation and reload happen without the caller wrapping
+  // the call. Never on the server — a render has no mutations to answer.
+  if (!(isServer ?? router.isServer)) {
+    Solid.onCleanup(setupFlightDataConsumer(router));
+  }
+
+  const OptionalWrapper = router.options.Wrap || SafeFragment;
+
+  return (
+    <OptionalWrapper>
+      <RouterContext value={router as AnyRouter}>
+        <Solid.Show when={ready()}>
+          {_ => {
+            // Native SSR transfer for the bare pairing (no-op under Start —
+            // see registryTransfer): serialize settled match state into the
+            // hydration registry while the render's serialization context is
+            // live. Runs after the load gate so matches are committed. The
+            // client half — the hydration-claiming boot — runs at router
+            // creation, outside the render.
+            if (isServer ?? router.isServer) {
+              serializeMatchTransfer(router);
+            }
+            return children();
+          }}
+        </Solid.Show>
+      </RouterContext>
+    </OptionalWrapper>
+  );
+}
+
+export function RouterProvider<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TDehydrated extends Record<string, any> = Record<string, any>,
+>({ router, ...rest }: RouterProps<TRouter, TDehydrated>) {
+  return (
+    <RouterContextProvider router={router} {...rest}>
+      {() => <Matches />}
+    </RouterContextProvider>
+  );
+}
+
+export type RouterProps<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TDehydrated extends Record<string, any> = Record<string, any>,
+> = Omit<
+  RouterOptions<
+    TRouter['routeTree'],
+    NonNullable<TRouter['options']['trailingSlash']>,
+    false,
+    TRouter['history'],
+    TDehydrated
+  >,
+  'context'
+> & {
+  router: TRouter;
+  context?: Partial<
+    RouterOptions<
+      TRouter['routeTree'],
+      NonNullable<TRouter['options']['trailingSlash']>,
+      false,
+      TRouter['history'],
+      TDehydrated
+    >['context']
+  >;
+};

package/src/router-binding/SafeFragment.tsx

@@ -0,0 +1,5 @@
+import type { JSX } from '@solidjs/web';
+
+export function SafeFragment(props: any): JSX.Element {
+  return <>{props.children}</>;
+}

package/src/router-binding/ScriptOnce.tsx

@@ -0,0 +1,23 @@
+import type { JSX } from '@solidjs/web';
+import { isServer } from '@tanstack/router-core/isServer';
+import { useRouter } from './useRouter';
+
+export function ScriptOnce({
+  children,
+}: {
+  children: string;
+  log?: boolean;
+  sync?: boolean;
+}): JSX.Element {
+  const router = useRouter();
+  if (!(isServer ?? router.isServer)) {
+    return null;
+  }
+  return (
+    <script
+      nonce={router.options.ssr?.nonce}
+      class="$tsr"
+      innerHTML={children + ';document.currentScript.remove()'}
+    />
+  );
+}

package/src/router-binding/Scripts.tsx

@@ -0,0 +1,44 @@
+import type { JSX } from '@solidjs/web';
+import { NoHydration } from '@solidjs/web';
+import type { RouterManagedTag } from '@tanstack/router-core';
+import {
+  composeSsrBodyScripts,
+  getSsrBodyScriptParts,
+  replaceEqualDeep,
+} from '@tanstack/router-core';
+import { isServer } from '@tanstack/router-core/isServer';
+import * as Solid from 'solid-js';
+import { Asset } from './Asset';
+import { useRouter } from './useRouter';
+
+export const Scripts = (): JSX.Element => {
+  const router = useRouter();
+  const nonce = router.options.ssr?.nonce;
+
+  const scripts = Solid.createMemo(
+    (previous: Array<RouterManagedTag> | undefined) => {
+      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()
+      : undefined;
+  const tags = () =>
+    initialHydrationScripts
+      ? composeSsrBodyScripts([scripts(), []], initialHydrationScripts)
+      : scripts();
+
+  return (
+    <NoHydration>
+      <Solid.For each={tags()}>{asset => <Asset {...asset} />}</Solid.For>
+    </NoHydration>
+  );
+};

package/src/router-binding/ScrollRestoration.tsx

@@ -0,0 +1,49 @@
+import type {
+  ParsedLocation,
+  ScrollRestorationEntry,
+  ScrollRestorationOptions,
+} from '@tanstack/router-core';
+import {
+  getElementScrollRestorationEntry,
+  setupScrollRestoration,
+} from '@tanstack/router-core';
+import { useRouter } from './useRouter';
+
+function useScrollRestoration() {
+  const router = useRouter();
+  setupScrollRestoration(router, true);
+}
+
+/**
+ * @deprecated use createRouter's `scrollRestoration` option instead
+ */
+export function ScrollRestoration(_props: ScrollRestorationOptions) {
+  useScrollRestoration();
+
+  if (process.env.NODE_ENV === 'development') {
+    console.warn(
+      "The ScrollRestoration component is deprecated. Use createRouter's `scrollRestoration` option instead.",
+    );
+  }
+
+  return null;
+}
+
+export function useElementScrollRestoration(
+  options: (
+    | {
+        id: string;
+        getElement?: () => Window | Element | undefined | null;
+      }
+    | {
+        id?: string;
+        getElement: () => Window | Element | undefined | null;
+      }
+  ) & {
+    getKey?: (location: ParsedLocation) => string;
+  },
+): ScrollRestorationEntry | undefined {
+  useScrollRestoration();
+
+  return getElementScrollRestorationEntry(useRouter(), options);
+}