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

package/dist/types/router-binding/fileRoute.d.ts

@@ -0,0 +1,54 @@
+import type { AnyContext, AnyRoute, AnyRouter, Constrain, ConstrainLiteral, FileBaseRouteOptions, FileRoutesByPath, LazyRouteOptions, Register, RegisteredRouter, ResolveParams, Route, RouteById, RouteConstraints, RouteIds, RouteLoaderEntry, UpdatableRouteOptions, UseNavigateResult } from '@tanstack/router-core';
+import type { UseLoaderDataRoute } from './useLoaderData.js';
+import type { UseLoaderDepsRoute } from './useLoaderDeps.js';
+import type { UseMatchRoute } from './useMatch.js';
+import type { UseParamsRoute } from './useParams.js';
+import type { UseRouteContextRoute } from './useRouteContext.js';
+import type { UseSearchRoute } from './useSearch.js';
+export declare function createFileRoute<TFilePath extends keyof FileRoutesByPath, TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'], TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'], TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'], TFullPath extends RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath']>(_path?: TFilePath): FileRoute<TFilePath, TParentRoute, TId, TPath, TFullPath>['createRoute'];
+/**
+  @deprecated It's no longer recommended to use the `FileRoute` class directly.
+  Instead, use `createFileRoute('/path/to/file')(options)` to create a file route.
+*/
+export declare class FileRoute<TFilePath extends keyof FileRoutesByPath, TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'], TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'], TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'], TFullPath extends RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath']> {
+    path?: TFilePath | undefined;
+    silent?: boolean;
+    constructor(path?: TFilePath | undefined, _opts?: {
+        silent: boolean;
+    });
+    createRoute: <TRegister = Register, TSearchValidator = undefined, TParams = ResolveParams<TPath>, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TChildren = unknown, TSSR = unknown, const TMiddlewares = unknown, THandlers = undefined>(options?: FileBaseRouteOptions<TRegister, TParentRoute, TId, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, AnyContext, TRouteContextFn, TBeforeLoadFn, AnyContext, TSSR, TMiddlewares, THandlers> & UpdatableRouteOptions<TParentRoute, TId, TFullPath, TParams, TSearchValidator, TLoaderFn, TLoaderDeps, AnyContext, TRouteContextFn, TBeforeLoadFn>) => Route<TRegister, TParentRoute, TPath, TFullPath, TFilePath, TId, TSearchValidator, TParams, AnyContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, unknown, TSSR, TMiddlewares, THandlers>;
+}
+/**
+  @deprecated It's recommended not to split loaders into separate files.
+  Instead, place the loader function in the main route file, inside the
+  `createFileRoute('/path/to/file)(options)` options.
+*/
+export declare function FileRouteLoader<TFilePath extends keyof FileRoutesByPath, TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute']>(_path: TFilePath): <TLoaderFn>(loaderFn: Constrain<TLoaderFn, RouteLoaderEntry<Register, TRoute['parentRoute'], TRoute['types']['id'], TRoute['types']['params'], TRoute['types']['loaderDeps'], TRoute['types']['routerContext'], TRoute['types']['routeContextFn'], TRoute['types']['beforeLoadFn']>>) => TLoaderFn;
+declare module '@tanstack/router-core' {
+    interface LazyRoute<in out TRoute extends AnyRoute> {
+        useMatch: UseMatchRoute<TRoute['id']>;
+        useRouteContext: UseRouteContextRoute<TRoute['id']>;
+        useSearch: UseSearchRoute<TRoute['id']>;
+        useParams: UseParamsRoute<TRoute['id']>;
+        useLoaderDeps: UseLoaderDepsRoute<TRoute['id']>;
+        useLoaderData: UseLoaderDataRoute<TRoute['id']>;
+        useNavigate: () => UseNavigateResult<TRoute['fullPath']>;
+    }
+}
+export declare class LazyRoute<TRoute extends AnyRoute> {
+    options: {
+        id: string;
+    } & LazyRouteOptions;
+    constructor(opts: {
+        id: string;
+    } & LazyRouteOptions);
+    useMatch: UseMatchRoute<TRoute['id']>;
+    useRouteContext: UseRouteContextRoute<TRoute['id']>;
+    useSearch: UseSearchRoute<TRoute['id']>;
+    useParams: UseParamsRoute<TRoute['id']>;
+    useLoaderDeps: UseLoaderDepsRoute<TRoute['id']>;
+    useLoaderData: UseLoaderDataRoute<TRoute['id']>;
+    useNavigate: () => UseNavigateResult<TRoute['fullPath']>;
+}
+export declare function createLazyRoute<TRouter extends AnyRouter = RegisteredRouter, TId extends string = string, TRoute extends AnyRoute = RouteById<TRouter['routeTree'], TId>>(id: ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>): (opts: LazyRouteOptions) => LazyRoute<TRoute>;
+export declare function createLazyFileRoute<TFilePath extends keyof FileRoutesByPath, TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute']>(id: TFilePath): (opts: LazyRouteOptions) => LazyRoute<TRoute>;

package/dist/types/router-binding/flightData.d.ts

@@ -0,0 +1,38 @@
+import type { AnyRouter } from '@tanstack/router-core';
+/**
+ * Registers the router as the unnamed single-flight consumer of Solid's
+ * server-function transport, so the response helpers a mutation returns —
+ * `redirect()`, `reload()`, `respond(value, { revalidate })` — take effect
+ * on the client without the caller wrapping the call: the transport hands
+ * the caller the plain value and the router applies the metadata. Called
+ * by `RouterContextProvider` on the client; returns the unsubscribe.
+ *
+ * Subscribing is also the single-flight opt-in: while registered, the
+ * transport tags mutation calls so the server can fold fresh data for
+ * registered collectors into the same response. The router claims no
+ * slice of that data itself — route data is reloaded through `invalidate`
+ * below, and caches that want seeding (a query client) subscribe under
+ * their own source id.
+ */
+export declare function setupFlightDataConsumer(router: AnyRouter): () => void;
+/**
+ * Applies a server-function response's integration metadata to the
+ * router. A mutation is a write, so a response carrying metadata reloads
+ * the route data the page is built on: committed and cached matches are
+ * invalidated the way `router.invalidate()` does after a mutation.
+ *
+ * `X-Revalidate` names entries in caches the router does not own, so the
+ * keys themselves are left to those caches' consumers; the router reads
+ * only the declaration's shape. Absent (a bare `redirect()`/`reload()`),
+ * named keys, or the reserved `*` all say a write happened — route data
+ * reloads. An EMPTY declaration (`revalidate: []`) is the author narrowing
+ * the scope to nothing, and the router honors that too: a redirect still
+ * navigates, but nothing is reloaded on the way.
+ *
+ * The redirect carrier delivers the target RESOLVED to an absolute url, so
+ * the soft/hard split is a real origin comparison: a same-origin target
+ * navigates under the router (`replace`, matching what HTTP gives a form
+ * post — the destination takes the submission's place in history), and any
+ * other origin leaves the app through a document navigation.
+ */
+export declare function applyResponseMetadata(router: AnyRouter, response: Response): void;

package/dist/types/router-binding/headContentUtils.d.ts

@@ -0,0 +1,15 @@
+import type { HeadTag } from '@solidjs/web';
+import type { AssetCrossOriginConfig, RouterManagedTag } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+/**
+ * Build the head/link/meta/script tags from the renderable presented prefix.
+ * Used internally by `HeadContent`.
+ */
+export declare const useTags: (assetCrossOrigin?: AssetCrossOriginConfig) => Solid.SourceAccessor<RouterManagedTag[]>;
+/**
+ * Convert the router-managed tags into head registry descriptors for
+ * `useHead`. Pure data mapping — it is evaluated inside the registry's own
+ * flush boundary (server) / effect (client), so it must not allocate
+ * reactive owners.
+ */
+export declare function toHeadTags(tags: Array<RouterManagedTag>): Array<HeadTag>;

package/dist/types/router-binding/history.d.ts

@@ -0,0 +1,8 @@
+declare module '@tanstack/history' {
+    interface HistoryState {
+        __tempLocation?: HistoryLocation;
+        __tempKey?: string;
+        __hashScrollIntoViewOptions?: boolean | ScrollIntoViewOptions;
+    }
+}
+export {};

package/dist/types/router-binding/index.d.ts

@@ -0,0 +1,46 @@
+export type { BlockerFn, HistoryLocation, HistoryState, ParsedPath, RouterHistory, } from '@tanstack/history';
+export { createBrowserHistory, createHashHistory, createHistory, createMemoryHistory, } from '@tanstack/history';
+export type { AbsoluteToPath, ActiveOptions, AllContext, AllLoaderData, AllParams, AnyContext, AnyPathParams, AnyRedirect, AnyRoute, AnyRouteMatch, AnyRouter, AnyRouterWithContext, AnyRouteWithContext, AnySchema, AnyValidator, AnyValidatorAdapter, AnyValidatorFn, AnyValidatorObj, Assign, BaseRouteOptions, BeforeLoadContextOptions, BeforeLoadContextParameter, BuildLocationFn, BuildNextOptions, CommitLocationOptions, Constrain, ContextAsyncReturnType, ContextOptions, ContextReturnType, ControllablePromise, ControlledPromise, CreateFileRoute, CreateLazyFileRoute, DefaultValidator, DeferredPromise, DeferredPromiseState, ErrorComponentProps, ErrorRouteProps, Expand, FileBaseRouteOptions, FileRoutesByPath, FileRouteTypes, FullSearchSchema, FullSearchSchemaInput, FullSearchSchemaOption, InferAllContext, InferAllParams, InferDescendantToPaths, InferFrom, InferFullSearchSchema, InferFullSearchSchemaInput, InferMaskFrom, InferMaskTo, InferSelected, InferShouldThrow, InferStrict, InferTo, IntersectAssign, LazyRouteOptions, LinkOptions, ListenerFn, LoaderFnContext, LocationRewrite, LocationRewriteFunction, LooseAsyncReturnType, LooseReturnType, MakeOptionalPathParams, MakeRemountDepsOptionsUnion, MakeRouteMatch, MakeRouteMatchUnion, Manifest, MatchLocation, MatchRouteOptions, MergeAll, MetaDescriptor, NavigateFn, NavigateOptions, NotFoundError, NotFoundRouteProps, ParamsOptions, ParsedLocation, ParseParamsFn, ParseRoute, PathParamOptions, PreloadableObj, Redirect, RedirectOptions, Register, RegisteredRouter, RelativeToCurrentPath, RelativeToParentPath, RelativeToPath, RelativeToPathAutoComplete, RemountDepsOptions, RemoveLeadingSlashes, RemoveTrailingSlashes, ResolveAllContext, ResolveAllParamsFromParent, ResolvedRedirect, ResolveFullPath, ResolveFullSearchSchema, ResolveFullSearchSchemaInput, ResolveId, ResolveLoaderData, ResolveOptionalParams, ResolveParams, ResolveRelativePath, ResolveRequiredParams, ResolveRoute, ResolveRouteContext, ResolveSearchValidatorInput, ResolveSearchValidatorInputFn, ResolveValidatorInput, ResolveValidatorInputFn, ResolveValidatorOutput, ResolveValidatorOutputFn, RootRouteId, RootRouteOptions, RouteById, RouteByPath, RouteConstraints, RouteContext, RouteContextFn, RouteContextOptions, RouteContextParameter, RouteIds, RouteLinkEntry, RouteLoaderFn, RouteMask, RouteMatch, RouteOptions, RoutePathOptions, RoutePathOptionsIntersection, RoutePaths, RouterConstructorOptions, RouterContextOptions, RouterEvent, RouterEvents, RouterListener, RouterManagedTag, RouterState, RoutesById, RoutesByPath, SearchFilter, SearchParamOptions, SearchParser, SearchSchemaInput, SearchSerializer, SerializableExtensions, StaticDataRouteOption, StringifyParamsFn, ToMaskOptions, ToOptions, ToPathOption, ToSubOptions, TrailingSlashOption, TrimPath, TrimPathLeft, TrimPathRight, UpdatableRouteOptions, UpdatableStaticRouteOption, UseNavigateResult, ValidateFromPath, ValidateId, ValidateNavigateOptions, ValidateNavigateOptionsArray, ValidateParams, ValidateRedirectOptions, ValidateRedirectOptionsArray, ValidateSearch, ValidateToPath, ValidateUseParamsResult, ValidateUseSearchResult, Validator, ValidatorAdapter, ValidatorFn, ValidatorObj, } from '@tanstack/router-core';
+export { cleanPath, composeRewrites, createControlledPromise, DEFAULT_PROTOCOL_ALLOWLIST, deepEqual, defaultParseSearch, defaultStringifySearch, defer, functionalUpdate, interpolatePath, isMatch, isNotFound, isRedirect, joinPaths, lazyFn, notFound, parseSearchWith, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, SearchParamError, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight, } from '@tanstack/router-core';
+export { Asset } from './Asset.js';
+export type { AwaitOptions } from './awaited.js';
+export { Await, useAwaited } from './awaited.js';
+export { CatchBoundary, ErrorComponent } from './CatchBoundary.js';
+export { ClientOnly, useHydrated } from './ClientOnly.js';
+export { createFileRoute, createLazyFileRoute, createLazyRoute, FileRoute, FileRouteLoader, LazyRoute, } from './fileRoute.js';
+export { HeadContent } from './HeadContent.js';
+export { useTags } from './headContentUtils.js';
+export * from './history.js';
+export { lazyRouteComponent } from './lazyRouteComponent.js';
+export type { ActiveLinkOptions, CreateLinkProps, LinkComponent, LinkComponentProps, LinkProps, UseLinkPropsOptions, } from './link.js';
+export { createLink, Link, linkOptions, useLinkProps } from './link.js';
+export { Match, Outlet } from './Match.js';
+export type { MakeMatchRouteOptions, UseMatchRouteOptions } from './Matches.js';
+export { Matches, MatchRoute, useChildMatches, useMatches, useMatchRoute, useParentMatches, } from './Matches.js';
+export { CatchNotFound, DefaultGlobalNotFound } from './not-found.js';
+export type { PublicMatchError, PublicSnapshotOwner } from './publicMatchData.js';
+export { preparePublicContextData, preparePublicLoaderData, preparePublicMatchError, } from './publicMatchData.js';
+export type { RouterProps } from './RouterProvider.js';
+export { RouterContextProvider, RouterProvider } from './RouterProvider.js';
+export { prepareRouterMatchTransfer } from './registryTransfer.js';
+export type { AnyRootRoute, AsyncRouteComponent, ErrorRouteComponent, NotFoundRouteComponent, RouteComponent, SolidNode, } from './route.js';
+export { createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, getRouteApi, NotFoundRoute, RootRoute, Route, RouteApi, rootRouteWithContext, } from './route.js';
+export { createRouter, Router } from './router.js';
+export type { RouterOptions } from './routerOptions.js';
+export { ScriptOnce } from './ScriptOnce.js';
+export { Scripts } from './Scripts.js';
+export { ScrollRestoration, useElementScrollRestoration, } from './ScrollRestoration.js';
+export type { ValidateLinkOptions, ValidateLinkOptionsArray, ValidateUseParamsOptions, ValidateUseSearchOptions, } from './typePrimitives.js';
+export type { ShouldBlockFn, UseBlockerOpts } from './useBlocker.js';
+export { Block, useBlocker } from './useBlocker.js';
+export { useCanGoBack } from './useCanGoBack.js';
+export { useLoaderData } from './useLoaderData.js';
+export { useLoaderDeps } from './useLoaderDeps.js';
+export { useLocation } from './useLocation.js';
+export { useMatch } from './useMatch.js';
+export { Navigate, useNavigate } from './useNavigate.js';
+export { useParams } from './useParams.js';
+export { useRouteContext } from './useRouteContext.js';
+export { useRouter } from './useRouter.js';
+export { useRouterState } from './useRouterState.js';
+export { useSearch } from './useSearch.js';

package/dist/types/router-binding/lazyRouteComponent.d.ts

@@ -0,0 +1,2 @@
+import type { AsyncRouteComponent } from './route.js';
+export declare function lazyRouteComponent<T extends Record<string, any>, TKey extends keyof T = 'default'>(importer: () => Promise<T>, exportName?: TKey): T[TKey] extends (props: infer TProps) => any ? AsyncRouteComponent<TProps> : never;

package/dist/types/router-binding/link.d.ts

@@ -0,0 +1,43 @@
+import type { ComponentProps, JSX, ValidComponent } from '@solidjs/web';
+import type { AnyRouter, Constrain, LinkOptions, RegisteredRouter, RoutePaths } from '@tanstack/router-core';
+import type { ValidateLinkOptions, ValidateLinkOptionsArray } from './typePrimitives.js';
+export declare function useLinkProps<TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TTo extends string = '', TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = ''>(options: UseLinkPropsOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): ComponentProps<'a'>;
+export type UseLinkPropsOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TTo extends string | undefined = '.', TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = '.'> = ActiveLinkOptions<'a', TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & Omit<ComponentProps<'a'>, 'style'> & {
+    style?: JSX.CSSProperties;
+};
+export type ActiveLinkOptions<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & ActiveLinkOptionProps<TComp>;
+type ActiveLinkProps<TComp> = Partial<LinkComponentSolidProps<TComp> & {
+    [key: `data-${string}`]: unknown;
+}>;
+export interface ActiveLinkOptionProps<TComp = 'a'> {
+    /**
+     * A function that returns additional props for the `active` state of this link.
+     * These props override other props passed to the link (`style`'s are merged, `class`'s are concatenated)
+     */
+    activeProps?: ActiveLinkProps<TComp> | (() => ActiveLinkProps<TComp>);
+    /**
+     * A function that returns additional props for the `inactive` state of this link.
+     * These props override other props passed to the link (`style`'s are merged, `class`'s are concatenated)
+     */
+    inactiveProps?: ActiveLinkProps<TComp> | (() => ActiveLinkProps<TComp>);
+}
+export type LinkProps<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = ActiveLinkOptions<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & LinkPropsChildren;
+export interface LinkPropsChildren {
+    children?: JSX.Element | ((state: {
+        isActive: boolean;
+    }) => JSX.Element);
+}
+type LinkComponentSolidProps<TComp> = TComp extends ValidComponent ? Omit<ComponentProps<TComp>, keyof CreateLinkProps> : never;
+export type LinkComponentProps<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkComponentSolidProps<TComp> & LinkProps<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+export type CreateLinkProps = LinkProps<any, any, string, string, string, string>;
+export type LinkComponent<in out TComp, in out TDefaultFrom extends string = string> = <TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = TDefaultFrom, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: LinkComponentProps<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => JSX.Element;
+export interface LinkComponentRoute<in out TDefaultFrom extends string = string> {
+    defaultFrom: TDefaultFrom;
+    <TRouter extends AnyRouter = RegisteredRouter, const TTo extends string | undefined = undefined, const TMaskTo extends string = ''>(props: LinkComponentProps<'a', TRouter, this['defaultFrom'], TTo, this['defaultFrom'], TMaskTo>): JSX.Element;
+}
+export declare function createLink<const TComp>(Comp: Constrain<TComp, any, (props: CreateLinkProps) => JSX.Element>): LinkComponent<TComp>;
+export declare const Link: LinkComponent<'a'>;
+export type LinkOptionsFnOptions<TOptions, TComp, TRouter extends AnyRouter = RegisteredRouter> = TOptions extends ReadonlyArray<any> ? ValidateLinkOptionsArray<TRouter, TOptions, string, TComp> : ValidateLinkOptions<TRouter, TOptions, string, TComp>;
+export type LinkOptionsFn<TComp> = <const TOptions, TRouter extends AnyRouter = RegisteredRouter>(options: LinkOptionsFnOptions<TOptions, TComp, TRouter>) => TOptions;
+export declare const linkOptions: LinkOptionsFn<'a'>;
+export {};

package/dist/types/router-binding/matchContext.d.ts

@@ -0,0 +1,7 @@
+import type { AnyRouteMatch } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+export type NearestMatchContextValue = readonly [
+    routeId: Solid.Accessor<string | undefined>,
+    match: Solid.Accessor<AnyRouteMatch | undefined>
+];
+export declare const nearestMatchContext: Solid.Context<NearestMatchContextValue>;

package/dist/types/router-binding/nonRouteComponentContext.d.ts

@@ -0,0 +1,5 @@
+import type { JSX } from '@solidjs/web';
+import * as Solid from 'solid-js';
+export type NonRouteComponent = 'pendingComponent' | 'errorComponent' | 'notFoundComponent';
+export declare const nonRouteComponentContext: Solid.Context<NonRouteComponent | null> | undefined;
+export declare function renderInNonRouteComponentContext(render: () => JSX.Element, component: NonRouteComponent): JSX.Element;

package/dist/types/router-binding/not-found.d.ts

@@ -0,0 +1,11 @@
+import type { JSX } from '@solidjs/web';
+import type { NotFoundError } from '@tanstack/router-core';
+export declare function getNotFound(error: unknown): (NotFoundError & {
+    isNotFound: true;
+}) | undefined;
+export declare function CatchNotFound(props: {
+    fallback?: (error: NotFoundError) => JSX.Element;
+    onCatch?: (error: NotFoundError) => void;
+    children: JSX.Element;
+}): JSX.Element;
+export declare function DefaultGlobalNotFound(): JSX.Element;

package/dist/types/router-binding/publicMatchData.d.ts

@@ -0,0 +1,19 @@
+import type { RequestSession } from '@modern-js/renderer-core/session';
+import type { RouteDataErrorSnapshot } from '../route-data-error.js';
+export type PublicSnapshotOwner = Pick<RequestSession, 'fail' | 'signal'>;
+/** A stable transfer snapshot; the renderer retains its original values and Promises. */
+export declare function preparePublicLoaderData(value: unknown, owner?: PublicSnapshotOwner, privateContexts?: readonly unknown[]): unknown;
+/** Only the native keyed receiver admits Seroval's checked s/v data metadata. */
+export declare function prepareHydratedLoaderData(value: unknown, owner?: PublicSnapshotOwner, privateContexts?: readonly unknown[]): unknown;
+/** Native beforeLoad context is an explicit pure public return value. */
+export declare function preparePublicContextData(value: unknown, owner?: PublicSnapshotOwner, privateContexts?: readonly unknown[]): unknown;
+/** Preserve the native composed root while replacing authored nested values. */
+export declare function preparePublishedRouteContext(context: Record<string, unknown>, owner: PublicSnapshotOwner, privateContexts?: readonly unknown[]): void;
+export interface PublicMatchError {
+    name: string;
+    message: string;
+    stack?: string;
+    cause?: unknown;
+}
+/** Error diagnostics are a fixed public projection, never a raw Error object. */
+export declare function preparePublicMatchError(error: unknown, owner?: PublicSnapshotOwner, privateContexts?: readonly unknown[]): PublicMatchError | RouteDataErrorSnapshot | Record<string, unknown>;

package/dist/types/router-binding/registryTransfer.d.ts

@@ -0,0 +1,49 @@
+import type { RequestSession } from '@modern-js/renderer-core/session';
+import type { AnyRouter } from '@tanstack/router-core';
+import { type PublicSnapshotOwner } from './publicMatchData.js';
+/**
+ * Match-state transfer over Solid's hydration registry — the bare pairing's
+ * native SSR channel (no `__TSR_SSR__` script injection, no router-owned
+ * stream protocol). Entries are content-addressed (`tsr:<matchId>`; match
+ * ids are deterministic route-id + interpolated params, so both sides
+ * derive the same key from the same URL), the identical mechanism
+ * solid-query v6 ships query payloads through (`sq:<queryHash>`).
+ *
+ * Server half: while the render's serialization context is live, the
+ * provider writes each settled match's transferable state. Client half: the
+ * hydration-claiming boot — matching is synchronous, so the provider primes
+ * match state from the registry and commits before rendering, without
+ * running loaders or resolving route chunks up front. Route components
+ * resolve at the read point under the boundaries the server actually
+ * rendered (Solid `lazy` semantics), and staleness rules own any
+ * post-hydration refetching.
+ *
+ * Both halves no-op under TanStack Start: `router.serverSsr` marks the
+ * Start contract (`attachRouterServerSsrUtils` / `dehydrate` / `hydrate`),
+ * which owns transfer there — and a Start-hydrated router reaches the
+ * client boot with matches already committed, which skips it.
+ */
+export declare const MATCH_KEY_PREFIX = "tsr:";
+/** Bind the managed public-data scope before native router construction claims hydration. */
+export declare function registerPublicRouteDataOwner(routeTree: object, owner: PublicSnapshotOwner, privateContexts?: readonly object[]): void;
+/** Managed match transfer uses the immutable public-data contract, not custom adapters. */
+export declare function assertNativeSerializationOptions(options: object): void;
+/** Framework SSR accepts only routers that passed its public-data factory boundary. */
+export declare function requireManagedPublicRouter(router: AnyRouter): void;
+/** Project composed public context before every native match-store publication. */
+export declare function installPublicContextPublication(router: AnyRouter): void;
+/** Validate and capture native settled match state before a response is committed. */
+export declare function prepareRouterMatchTransfer(router: AnyRouter, owner: RequestSession, privateContexts?: readonly unknown[]): void;
+export declare function serializeMatchTransfer(router: AnyRouter): void;
+/**
+ * The hydration-claiming boot. Returns true when every synchronously
+ * matched route found its registry entry and the matches were committed;
+ * false falls back to the caller's existing behavior (no entries — a
+ * non-registry server, `noHydrate`, or a pending match the server skipped).
+ *
+ * Entries arrive as inline scripts that execute at document parse, so they
+ * are readable through Solid's keyed value channel before client rendering.
+ * The boot commits before hydration; store writes inside the claim would
+ * change the owner tree being claimed.
+ */
+export declare function primeRouterFromRegistry(router: AnyRouter): boolean;

package/dist/types/router-binding/renderRouteNotFound.d.ts

@@ -0,0 +1,11 @@
+import type { JSX } from '@solidjs/web';
+import type { AnyRoute, AnyRouter } from '@tanstack/router-core';
+/**
+ * Renders a not found component for a route when no matching route is found.
+ *
+ * @param router - The router instance containing the route configuration
+ * @param route - The route that triggered the not found state
+ * @param data - Additional data to pass to the not found component
+ * @returns The rendered not found component or a default fallback component
+ */
+export declare function renderRouteNotFound(router: AnyRouter, route: AnyRoute, data: any): JSX.Element;

package/dist/types/router-binding/route.d.ts

@@ -0,0 +1,105 @@
+import type { JSX } from '@solidjs/web';
+import type { AnyContext, AnyRoute, AnyRouter, ConstrainLiteral, ErrorComponentProps, NotFoundError, NotFoundRouteProps, Register, RegisteredRouter, ResolveFullPath, ResolveId, ResolveParams, RootRoute as RootRouteCore, RootRouteId, RootRouteOptions, RouteConstraints, Route as RouteCore, RouteIds, RouteMask, RouteOptions, RouterCore, RouteTypesById, ToMaskOptions, UseNavigateResult } from '@tanstack/router-core';
+import { BaseRootRoute, BaseRoute, BaseRouteApi } from '@tanstack/router-core';
+import type { LinkComponentRoute } from './link.js';
+import type { UseLoaderDataRoute } from './useLoaderData.js';
+import type { UseLoaderDepsRoute } from './useLoaderDeps.js';
+import type { UseMatchRoute } from './useMatch.js';
+import type { UseParamsRoute } from './useParams.js';
+import type { UseRouteContextRoute } from './useRouteContext.js';
+import type { UseSearchRoute } from './useSearch.js';
+declare module '@tanstack/router-core' {
+    interface UpdatableRouteOptionsExtensions {
+        component?: RouteComponent;
+        errorComponent?: false | null | undefined | ErrorRouteComponent;
+        notFoundComponent?: NotFoundRouteComponent;
+        pendingComponent?: RouteComponent;
+    }
+    interface RootRouteOptionsExtensions {
+        shellComponent?: ({ children }: {
+            children: JSX.Element;
+        }) => JSX.Element;
+    }
+    interface RouteExtensions<in out TId extends string, in out TFullPath extends string> {
+        useMatch: UseMatchRoute<TId>;
+        useRouteContext: UseRouteContextRoute<TId>;
+        useSearch: UseSearchRoute<TId>;
+        useParams: UseParamsRoute<TId>;
+        useLoaderDeps: UseLoaderDepsRoute<TId>;
+        useLoaderData: UseLoaderDataRoute<TId>;
+        useNavigate: () => UseNavigateResult<TFullPath>;
+        Link: LinkComponentRoute<TFullPath>;
+    }
+}
+export declare function getRouteApi<const TId, TRouter extends AnyRouter = RegisteredRouter>(id: ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>): RouteApi<TId, TRouter>;
+export declare class RouteApi<TId, TRouter extends AnyRouter = RegisteredRouter> extends BaseRouteApi<TId, TRouter> {
+    /**
+     * @deprecated Use the `getRouteApi` function instead.
+     */
+    constructor({ id }: {
+        id: TId;
+    });
+    useMatch: UseMatchRoute<TId>;
+    useRouteContext: UseRouteContextRoute<TId>;
+    useSearch: UseSearchRoute<TId>;
+    useParams: UseParamsRoute<TId>;
+    useLoaderDeps: UseLoaderDepsRoute<TId>;
+    useLoaderData: UseLoaderDataRoute<TId>;
+    useNavigate: () => UseNavigateResult<RouteTypesById<TRouter, TId>['fullPath']>;
+    notFound: (opts?: NotFoundError) => NotFoundError;
+    Link: LinkComponentRoute<RouteTypesById<TRouter, TId>['fullPath']>;
+}
+export declare class Route<in out TRegister = unknown, in out TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, in out TPath extends RouteConstraints['TPath'] = '/', in out TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, in out TCustomId extends RouteConstraints['TCustomId'] = string, in out TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, in out TSearchValidator = undefined, in out TParams = ResolveParams<TPath>, in out TRouterContext = AnyContext, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TLoaderDeps extends Record<string, any> = {}, in out TLoaderFn = undefined, in out TChildren = unknown, in out TFileRouteTypes = unknown, in out TSSR = unknown, in out TMiddlewares = unknown, in out THandlers = undefined> extends BaseRoute<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, TMiddlewares, THandlers> implements RouteCore<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, TMiddlewares, THandlers> {
+    /**
+     * @deprecated Use the `createRoute` function instead.
+     */
+    constructor(options?: RouteOptions<TRegister, TParentRoute, TId, TCustomId, TFullPath, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TSSR, TMiddlewares, THandlers>);
+    useMatch: UseMatchRoute<TId>;
+    useRouteContext: UseRouteContextRoute<TId>;
+    useSearch: UseSearchRoute<TId>;
+    useParams: UseParamsRoute<TId>;
+    useLoaderDeps: UseLoaderDepsRoute<TId>;
+    useLoaderData: UseLoaderDataRoute<TId>;
+    useNavigate: () => UseNavigateResult<TFullPath>;
+    Link: LinkComponentRoute<TFullPath>;
+}
+export declare function createRoute<TRegister = unknown, TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, TPath extends RouteConstraints['TPath'] = '/', TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, TCustomId extends RouteConstraints['TCustomId'] = string, TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, TSearchValidator = undefined, TParams = ResolveParams<TPath>, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TChildren = unknown, TSSR = unknown, THandlers = undefined>(options: RouteOptions<TRegister, TParentRoute, TId, TCustomId, TFullPath, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, AnyContext, TRouteContextFn, TBeforeLoadFn, TSSR, THandlers>): Route<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, AnyContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, unknown, TSSR, THandlers>;
+export type AnyRootRoute = RootRoute<any, any, any, any, any, any, any, any, any, any>;
+export declare function createRootRouteWithContext<TRouterContext extends {}>(): <TRegister = Register, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TSearchValidator = undefined, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TSSR = unknown, THandlers = undefined>(options?: RootRouteOptions<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TSSR, THandlers>) => RootRoute<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, unknown, unknown, TSSR, THandlers>;
+/**
+ * @deprecated Use the `createRootRouteWithContext` function instead.
+ */
+export declare const rootRouteWithContext: typeof createRootRouteWithContext;
+export declare class RootRoute<in out TRegister = Register, in out TSearchValidator = undefined, in out TRouterContext = {}, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TLoaderDeps extends Record<string, any> = {}, in out TLoaderFn = undefined, in out TChildren = unknown, in out TFileRouteTypes = unknown, in out TSSR = unknown, in out THandlers = undefined> extends BaseRootRoute<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, THandlers> implements RootRouteCore<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, THandlers> {
+    /**
+     * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
+     */
+    constructor(options?: RootRouteOptions<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TSSR, THandlers>);
+    useMatch: UseMatchRoute<RootRouteId>;
+    useRouteContext: UseRouteContextRoute<RootRouteId>;
+    useSearch: UseSearchRoute<RootRouteId>;
+    useParams: UseParamsRoute<RootRouteId>;
+    useLoaderDeps: UseLoaderDepsRoute<RootRouteId>;
+    useLoaderData: UseLoaderDataRoute<RootRouteId>;
+    useNavigate: () => UseNavigateResult<'/'>;
+    Link: LinkComponentRoute<'/'>;
+}
+export declare function createRouteMask<TRouteTree extends AnyRoute, TFrom extends string, TTo extends string>(opts: {
+    routeTree: TRouteTree;
+} & ToMaskOptions<RouterCore<TRouteTree, 'never', false>, TFrom, TTo>): RouteMask<TRouteTree>;
+export type SolidNode = JSX.Element;
+export interface DefaultRouteTypes<TProps> {
+    component: (props: TProps) => any;
+}
+export interface RouteTypes<TProps> extends DefaultRouteTypes<TProps> {
+}
+export type AsyncRouteComponent<TProps> = RouteTypes<TProps>['component'] & {
+    preload?: () => Promise<void>;
+};
+export type RouteComponent = AsyncRouteComponent<{}>;
+export type ErrorRouteComponent = AsyncRouteComponent<ErrorComponentProps>;
+export type NotFoundRouteComponent = RouteTypes<NotFoundRouteProps>['component'];
+export declare class NotFoundRoute<TRegister, TParentRoute extends AnyRootRoute, TRouterContext = AnyContext, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TSearchValidator = undefined, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TChildren = unknown, TSSR = unknown, THandlers = undefined> extends Route<TRegister, TParentRoute, '/404', '/404', '404', '404', TSearchValidator, {}, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TSSR, THandlers> {
+    constructor(options: Omit<RouteOptions<TRegister, TParentRoute, string, string, string, string, TSearchValidator, {}, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TSSR, THandlers>, 'caseSensitive' | 'parseParams' | 'stringifyParams' | 'path' | 'id' | 'params'>);
+}
+export declare function createRootRoute<TRegister = Register, TSearchValidator = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TSSR = unknown, THandlers = undefined>(options?: RootRouteOptions<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TSSR, THandlers>): RootRoute<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, unknown, unknown, TSSR, THandlers>;

package/dist/types/router-binding/router.d.ts

@@ -0,0 +1,70 @@
+import type { JSX } from '@solidjs/web';
+import type { RouterHistory } from '@tanstack/history';
+import type { AnyRoute, CreateRouterFn, RouterConstructorOptions, TrailingSlashOption } from '@tanstack/router-core';
+import { RouterCore } from '@tanstack/router-core';
+import type { ErrorRouteComponent, NotFoundRouteComponent, RouteComponent } from './route.js';
+declare module '@tanstack/router-core' {
+    interface RouterOptionsExtensions {
+        /**
+         * The default `component` a route should use if no component is provided.
+         *
+         * @default Outlet
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#defaultcomponent-property)
+         */
+        defaultComponent?: RouteComponent;
+        /**
+         * The default `errorComponent` a route should use if no error component is provided.
+         *
+         * @default ErrorComponent
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#defaulterrorcomponent-property)
+         * @link [Guide](https://tanstack.com/router/latest/docs/framework/solid/guide/data-loading#handling-errors-with-routeoptionserrorcomponent)
+         */
+        defaultErrorComponent?: ErrorRouteComponent;
+        /**
+         * The default `pendingComponent` a route should use if no pending component is provided.
+         *
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#defaultpendingcomponent-property)
+         * @link [Guide](https://tanstack.com/router/latest/docs/framework/solid/guide/data-loading#showing-a-pending-component)
+         */
+        defaultPendingComponent?: RouteComponent;
+        /**
+         * The default `notFoundComponent` a route should use if no notFound component is provided.
+         *
+         * @default NotFound
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#defaultnotfoundcomponent-property)
+         * @link [Guide](https://tanstack.com/router/latest/docs/framework/solid/guide/not-found-errors#default-router-wide-not-found-handling)
+         */
+        defaultNotFoundComponent?: NotFoundRouteComponent;
+        /**
+         * A component that will be used to wrap the entire router.
+         *
+         * This is useful for providing a context to the entire router.
+         *
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#wrap-property)
+         */
+        Wrap?: (props: {
+            children: any;
+        }) => JSX.Element;
+        /**
+         * A component that will be used to wrap the inner contents of the router.
+         *
+         * This is useful for providing a context to the inner contents of the router where you also need access to the router context and hooks.
+         *
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#innerwrap-property)
+         */
+        InnerWrap?: (props: {
+            children: any;
+        }) => JSX.Element;
+        /**
+         * The default `onCatch` handler for errors caught by the Router ErrorBoundary
+         *
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultoncatch-property)
+         * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#handling-errors-with-routeoptionsoncatch)
+         */
+        defaultOnCatch?: (error: Error) => void;
+    }
+}
+export declare const createRouter: CreateRouterFn;
+export declare class Router<in out TRouteTree extends AnyRoute, in out TTrailingSlashOption extends TrailingSlashOption = 'never', in out TDefaultStructuralSharingOption extends boolean = false, in out TRouterHistory extends RouterHistory = RouterHistory, in out TDehydrated extends Record<string, any> = Record<string, any>> extends RouterCore<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated> {
+    constructor(options: RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>);
+}

package/dist/types/router-binding/routerContext.d.ts

@@ -0,0 +1,3 @@
+import type { AnyRouter } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+export declare const routerContext: Solid.Context<AnyRouter>;

package/dist/types/router-binding/routerOptions.d.ts

@@ -0,0 +1,6 @@
+import type { RouterHistory } from '@tanstack/history';
+import type { AnyRoute, RouterOptions as CoreRouterOptions, TrailingSlashOption } from '@tanstack/router-core';
+/** Native managed hydration transfers immutable public data only. */
+export type RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean = false, TRouterHistory extends RouterHistory = RouterHistory, TDehydrated = undefined> = Omit<CoreRouterOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>, 'serializationAdapters'> & {
+    serializationAdapters?: never;
+};

package/dist/types/router-binding/routerStores.d.ts

@@ -0,0 +1,2 @@
+import type { GetStoreConfig } from '@tanstack/router-core';
+export declare const getStoreFactory: GetStoreConfig;

package/dist/types/router-binding/scroll-restoration.d.ts

@@ -0,0 +1,2 @@
+import type { JSX } from '@solidjs/web';
+export declare function ScrollRestoration(): JSX.Element;

package/dist/types/router-binding/typePrimitives.d.ts

@@ -0,0 +1,10 @@
+import type { AnyRouter, Constrain, InferFrom, InferMaskFrom, InferMaskTo, InferSelected, InferShouldThrow, InferStrict, InferTo, RegisteredRouter } from '@tanstack/router-core';
+import type { LinkComponentProps } from './link.js';
+import type { UseParamsOptions } from './useParams.js';
+import type { UseSearchOptions } from './useSearch.js';
+export type ValidateLinkOptions<TRouter extends AnyRouter = RegisteredRouter, TOptions = unknown, TDefaultFrom extends string = string, TComp = 'a'> = Constrain<TOptions, LinkComponentProps<TComp, TRouter, InferFrom<TOptions, TDefaultFrom>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
+export type ValidateLinkOptionsArray<TRouter extends AnyRouter = RegisteredRouter, TOptions extends ReadonlyArray<any> = ReadonlyArray<unknown>, TDefaultFrom extends string = string, TComp = 'a'> = {
+    [K in keyof TOptions]: ValidateLinkOptions<TRouter, TOptions[K], TDefaultFrom, TComp>;
+};
+export type ValidateUseSearchOptions<TOptions, TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, UseSearchOptions<TRouter, InferFrom<TOptions>, InferStrict<TOptions>, InferShouldThrow<TOptions>, InferSelected<TOptions>>>;
+export type ValidateUseParamsOptions<TOptions, TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, UseParamsOptions<TRouter, InferFrom<TOptions>, InferStrict<TOptions>, InferShouldThrow<TOptions>, InferSelected<TOptions>>>;