@bleedingdev/modern-js-runtime 3.2.0-ultramodern.99 → 3.4.0-ultramodern.0

package/dist/types/core/context/extensions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Fork-owned runtime-context extension mechanism.
+ *
+ * Plugins must not add ad-hoc fields to `TRuntimeContext` /
+ * `TInternalRuntimeContext`. Instead they store state in a single internal
+ * slot (a `Map` keyed by symbol) attached to the context object under a
+ * symbol property, so nothing leaks into string-key enumeration
+ * (`Object.keys`, `JSON.stringify`, `{ ...context }` rest patterns over
+ * named keys).
+ *
+ * `Symbol.for` is used for both the slot and the extension keys so that the
+ * mechanism stays coherent even if this module is instantiated twice
+ * (e.g. esm/cjs interop in test runners).
+ */
+export interface RuntimeContextExtension<T> {
+    /** Stable identity of this extension. */
+    readonly key: symbol;
+    get(context: object): T | undefined;
+    set(context: object, value: T): void;
+    remove(context: object): void;
+}
+/**
+ * Removes the extension slot from a context object.
+ *
+ * The slot is an enumerable symbol-keyed property, so object spreads copy it
+ * onto derived objects. Call this on *copies* that form the public
+ * `RuntimeContext` value to keep internal state (router instances, helmet
+ * state, ...) unreachable from the public context object.
+ */
+export declare function stripRuntimeContextExtensions(context: object): void;
+/**
+ * Creates a typed accessor pair over the shared extension slot.
+ *
+ * The `id` must be globally unique (it is interned via `Symbol.for`); use a
+ * package-prefixed name such as `@modern-js/plugin-tanstack:router-state`.
+ */
+export declare function createRuntimeContextExtension<T>(id: string): RuntimeContextExtension<T>;

package/dist/types/core/context/helmetContext.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fork-owned helmet state, stored via the runtime-context extension slot
+ * instead of an ad-hoc `_helmetContext` field on `TInternalRuntimeContext`.
+ */
+import type { HelmetServerState } from 'react-helmet-async';
+export interface HelmetContextSlot {
+    helmet?: HelmetServerState | null;
+}
+export declare function getHelmetContext(context: object): HelmetContextSlot | undefined;
+export declare function ensureHelmetContext(context: object): HelmetContextSlot;

package/dist/types/core/context/index.d.ts

@@ -3,6 +3,12 @@ import type { NestedRoute, PageRoute } from '@modern-js/types';
 import type React from 'react';
 import type { RuntimeExtends } from '../plugin/types';
 import type { ServerPayload } from './serverPayload/index';
+export { DefaultNotFound } from '../../router/runtime/DefaultNotFound';
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, type RouterExtendsHooks, } from '../../router/runtime/hooks';
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot, type RouterLifecycleContext, type RouterLifecyclePhase, } from '../../router/runtime/lifecycle';
+export { type RouterProviderFactory, type RouterProviderPlugin, registerRouterProvider, resolveRouterProvider, routerProviderRegistryHooks, } from '../../router/runtime/provider';
+export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from '../../router/runtime/types';
+export { createRuntimeContextExtension, type RuntimeContextExtension, } from './extensions';
 export { getInitialContext, InternalRuntimeContext, RuntimeContext, type TInternalRuntimeContext, type TRuntimeContext, } from './runtime';
 export type { PayloadRoute, ServerPayload } from './serverPayload/index';
 interface GlobalContext {

package/dist/types/core/context/response/index.server.d.ts

@@ -1,4 +1,7 @@
-export declare const getResponseProxy: () => any;
+export declare const getResponseProxy: () => {
+    headers: Record<string, string>;
+    status: number;
+} | undefined;
 export declare const setHeaders: (headers: Record<string, string>) => void;
 export declare const setStatus: (status: number) => void;
 export declare const redirect: (url: string, init?: number | ResponseInit) => void;

package/dist/types/core/context/runtime.d.ts

@@ -1,12 +1,10 @@
 import type { RouteObject, StaticHandlerContext } from '@modern-js/runtime-utils/router';
-import type { HelmetServerState } from 'react-helmet-async';
-import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouteManifest, RouterFramework } from '../../router/runtime/types';
+import type { RouteManifest } from '../../router/runtime/types';
 import type { RequestContext, SSRServerContext } from '../types';
 export interface TRuntimeContext {
     initialData?: Record<string, unknown>;
     isBrowser: boolean;
     routes?: RouteObject[];
-    routerFramework?: RouterFramework;
     requestContext: RequestContext;
     /**
      * @deprecated Use `requestContext` instead
@@ -19,19 +17,11 @@ export interface TRuntimeContext {
  */
 export interface TInternalRuntimeContext extends TRuntimeContext {
     routeManifest?: RouteManifest;
-    routerRuntime?: InternalRouterRuntimeState;
-    routerInstance?: unknown;
-    routerHydrationScript?: string;
-    routerMatchedRouteIds?: string[];
-    routerServerSnapshot?: InternalRouterServerSnapshot;
     routerContext?: StaticHandlerContext;
     unstable_getBlockNavState?: () => boolean;
     ssrContext?: SSRServerContext;
     _internalContext?: any;
     _internalRouterBaseName?: any;
-    _helmetContext?: {
-        helmet?: HelmetServerState | null;
-    };
 }
 export declare const InternalRuntimeContext: import("react").Context<TInternalRuntimeContext>;
 export declare const RuntimeContext: import("react").Context<TRuntimeContext>;

package/dist/types/core/plugin/index.d.ts

@@ -2,4 +2,4 @@ import type { InternalRuntimeContext } from '@modern-js/plugin/runtime';
 import type { RuntimeConfig, RuntimeExtends, RuntimePlugin } from './types';
 export type { RuntimePlugin };
 export declare function registerPlugin(internalPlugins: RuntimePlugin[], runtimeConfig?: RuntimeConfig): InternalRuntimeContext<RuntimeExtends>;
-export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): any;
+export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): Record<string, any>;

package/dist/types/core/server/routerCleanup.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Fork-owned helper for the per-request router runtime cleanup.
+ *
+ * Router providers (react-router, @modern-js/plugin-tanstack, ...) register a
+ * `cleanup` callback in the router runtime state. For streamed SSR the
+ * Response is returned at shell-ready while React is still rendering into the
+ * body, so the cleanup must not run until the body finishes — otherwise it
+ * can dispose router state that the in-flight render is still using. Cleanup
+ * failures are reported through the request's `onError` instead of being
+ * swallowed.
+ */
+import type { OnError } from '@modern-js/app-tools';
+import type { TInternalRuntimeContext } from '../context';
+export declare const ROUTER_CLEANUP_ERROR = "An error occurs during router runtime cleanup";
+export type RouterCleanup = {
+    /** True once the cleanup has been tied to a streamed response body. */
+    readonly deferred: boolean;
+    /** Runs the router cleanup at most once; reports failures via `onError`. */
+    run: () => Promise<void>;
+    /**
+     * Ties the cleanup to the completion (close, error or cancellation) of the
+     * response body when it is a stream. Responses without a streaming body are
+     * returned as-is and the caller is expected to invoke `run()` itself.
+     */
+    deferUntilBodyDone: (response: Response) => Response;
+};
+export declare function withRouterCleanup<T>(runtimeContext: TInternalRuntimeContext, onError: OnError, callback: (routerCleanup: RouterCleanup) => Promise<T>): Promise<T>;
+export declare function createRouterCleanup(runtimeContext: TInternalRuntimeContext, onError: OnError): RouterCleanup;

package/dist/types/core/server/scriptOrder.d.ts

@@ -1 +1,25 @@
+import type { TInternalRuntimeContext } from '../context';
+type RouteAssetManifest = {
+    assets?: string[];
+};
+type RouteManifestLike = {
+    routeAssets?: Record<string, RouteAssetManifest | undefined>;
+};
+type ScriptChunkLike = {
+    filename?: string;
+    url?: string;
+};
+export declare function getMatchedRouteAssets(runtimeContext: TInternalRuntimeContext, routeManifest?: RouteManifestLike): string[];
+export declare const orderHydrationScriptChunks: <T extends ScriptChunkLike>({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
+    asyncEntryChunks: T[];
+    collectedChunks: T[];
+    matchedRouteChunks: T[];
+    entryName: string;
+}) => T[];
 export declare function injectBeforeHydrationEntryScript(template: string, scripts: string, entryName?: string): string;
+export declare function replaceChunkJsPlaceholder(template: string, scripts: string, entryName?: string, placeholder?: string): string;
+export declare function createRouteHydrationScriptTags(runtimeContext: TInternalRuntimeContext, entryName: string, options?: {
+    nonce?: string;
+    template?: string;
+}): string;
+export {};

package/dist/types/core/server/string/loadable.d.ts

@@ -1,19 +1,13 @@
-import { type Chunk } from '@loadable/server';
 import type { ReactElement } from 'react';
 import type { TInternalRuntimeContext } from '../../context';
 import type { ChunkSet, Collector } from './types';
+export { orderHydrationScriptChunks } from '../scriptOrder';
 declare module '@loadable/server' {
     interface ChunkExtractor {
         chunks: string[];
         getChunkAssets: (chunks: string[]) => Chunk[];
     }
 }
-export declare const orderHydrationScriptChunks: ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
-    asyncEntryChunks: Chunk[];
-    collectedChunks: Chunk[];
-    matchedRouteChunks: Chunk[];
-    entryName: string;
-}) => Chunk[];
 export interface LoadableCollectorOptions {
     nonce?: string;
     stats?: Record<string, any>;

package/dist/types/core/server/utils.d.ts

@@ -15,5 +15,23 @@ export declare function checkIsNode(): boolean;
  * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
  */
 export declare function serializeErrors(errors: StaticHandlerContext['errors']): StaticHandlerContext['errors'];
-export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries']): any;
+export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries']): true | {
+    forceCSR?: boolean;
+    mode?: import("@modern-js/types").SSRMode;
+    preload?: boolean | {
+        [x: string]: unknown;
+    };
+    inlineScript?: boolean;
+    disablePrerender?: boolean;
+    unsafeHeaders?: string[];
+    loaderFailureMode?: 'clientRender' | 'errorBoundary';
+    moduleFederationAppSSR?: boolean;
+};
 export declare function getSSRMode(ssrConfig?: SSRConfig): 'string' | 'stream' | false;
+/**
+ * Whether the template already contains a `<link rel="stylesheet">` for `href`.
+ * Other link rels (e.g. `<link rel="prefetch">` emitted by `performance.prefetch`,
+ * or `<link rel="preload" as="style">`) may reference the same css URL but do not
+ * apply styles, so they must not block stylesheet injection during SSR.
+ */
+export declare const hasStylesheetLink: (template: string, href: string) => boolean;

package/dist/types/document/constants.d.ts

@@ -21,5 +21,7 @@ export declare const DOCUMENT_STYLE_PLACEHOLDER_END: string;
 export declare const DOCUMENT_COMMENT_PLACEHOLDER_START: string;
 export declare const DOCUMENT_COMMENT_PLACEHOLDER_END: string;
 export declare const PLACEHOLDER_REPLACER_MAP: {
-    [x: string]: string;
+    [DOCUMENT_SSR_PLACEHOLDER]: string;
+    [DOCUMENT_CHUNKSMAP_PLACEHOLDER]: string;
+    [DOCUMENT_SSRDATASCRIPT_PLACEHOLDER]: string;
 };

package/dist/types/exports/head.d.ts

@@ -1,11 +1,11 @@
 import React from 'react';
-import { Helmet as AsyncHelmet, HelmetData, type HelmetDatum, type HelmetHTMLBodyDatum, type HelmetHTMLElementDatum, type HelmetProps, HelmetProvider, type HelmetServerState, type HelmetTags } from 'react-helmet-async';
+import { Helmet as AsyncHelmet, HelmetData as AsyncHelmetData, type HelmetDatum, type HelmetHTMLBodyDatum, type HelmetHTMLElementDatum, type HelmetProps, HelmetProvider, type HelmetServerState, type HelmetTags } from 'react-helmet-async';
 export declare const Helmet: (props: React.PropsWithChildren<HelmetProps>) => React.CElement<React.PropsWithChildren<HelmetProps>, AsyncHelmet> | null;
 declare const head: {
     Helmet: (props: React.PropsWithChildren<HelmetProps>) => React.CElement<React.PropsWithChildren<HelmetProps>, AsyncHelmet> | null;
-    HelmetData: typeof HelmetData;
+    HelmetData: typeof AsyncHelmetData;
     HelmetProvider: typeof HelmetProvider;
 };
 export default head;
-export type { HelmetDatum, HelmetHTMLBodyDatum, HelmetHTMLElementDatum, HelmetProps, HelmetServerState as HelmetData, HelmetTags, };
-export { HelmetData, HelmetProvider };
+export type { HelmetDatum, HelmetHTMLBodyDatum, HelmetHTMLElementDatum, HelmetProps, HelmetServerState, HelmetTags, };
+export { AsyncHelmetData as HelmetData, HelmetProvider };

package/dist/types/exports/loadable.d.ts

@@ -1,7 +1,7 @@
 type LoadableDefault = typeof import('@loadable/component').default;
 type LoadableLazy = typeof import('@loadable/component').lazy;
 type LoadableReady = typeof import('@loadable/component').loadableReady;
-type LoadableInternals = typeof import('@loadable/component').__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+type LoadableInternals = unknown;
 declare const loadable: LoadableDefault;
 export declare const lazy: LoadableLazy;
 export declare const loadableReady: LoadableReady;

package/dist/types/exports/tanstack-router.d.ts

@@ -1,5 +1,88 @@
-export * from '@tanstack/react-router';
-export type { Fetcher, FetcherState, FetcherSubmitOptions, FormProps, SubmitOptions, } from '../router/runtime/tanstack/dataMutation';
-export { Form, RouteActionResponseError, useFetcher, } from '../router/runtime/tanstack/dataMutation';
-export type { LinkProps, NavLinkProps, PrefetchBehavior, } from '../router/runtime/tanstack/prefetchLink';
-export { Link, NavLink } from '../router/runtime/tanstack/prefetchLink';
+/**
+ * @deprecated Legacy alias kept so the published `@modern-js/runtime/tanstack-router`
+ * subpath keeps resolving. Use `@modern-js/plugin-tanstack/runtime` instead.
+ *
+ * Only the Modern.js specific `Link`, `NavLink`, `Outlet`, `Form`,
+ * `useFetcher` and `RouteActionResponseError` bindings are still exported from
+ * here for compatibility. They are thin delegates: the real implementations
+ * live in `@modern-js/plugin-tanstack` and are looked up at use time through a
+ * `Symbol.for` slot that '@modern-js/plugin-tanstack/runtime' populates on
+ * import. (`@modern-js/runtime` cannot import `@modern-js/plugin-tanstack`
+ * directly — the package dependency points the other way.)
+ */
+import type React from 'react';
+export type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+export type LinkProps<_TRouter = unknown, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & {
+    prefetch?: PrefetchBehavior;
+    from?: TFrom;
+    mask?: {
+        from?: TMaskFrom;
+        to?: TMaskTo;
+    };
+    params?: unknown;
+    search?: unknown;
+    to?: TTo;
+};
+export type NavLinkProps<TRouter = unknown, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+type LinkComponent = <TRouter = unknown, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: LinkProps<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => React.ReactElement;
+export type SubmitOptions = {
+    action?: string;
+    method?: string;
+    encType?: string;
+};
+export type FetcherState = 'idle' | 'submitting' | 'loading';
+export type FetcherSubmitOptions = SubmitOptions;
+export type FormProps = Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'action'> & {
+    action?: string;
+    onSubmit?: React.FormEventHandler<HTMLFormElement>;
+    reloadDocument?: boolean;
+};
+type SubmitTarget = HTMLFormElement | FormData | URLSearchParams | Record<string, string | number | boolean | null | undefined>;
+export type Fetcher = {
+    state: FetcherState;
+    data: unknown;
+    error: unknown;
+    Form: React.ComponentType<FormProps>;
+    submit: (target: SubmitTarget, options?: FetcherSubmitOptions) => Promise<void>;
+};
+export interface RouteActionResponseError<TData = unknown> extends Error {
+    readonly response: Response;
+    readonly data: TData;
+}
+interface RouteActionResponseErrorConstructor {
+    new <TData = unknown>(response: Response, data: TData): RouteActionResponseError<TData>;
+    readonly prototype: RouteActionResponseError<unknown>;
+}
+/**
+ * @deprecated Import `Link` from `@modern-js/plugin-tanstack/runtime` instead.
+ */
+export declare const Link: LinkComponent;
+/**
+ * @deprecated Import `NavLink` from `@modern-js/plugin-tanstack/runtime` instead.
+ */
+export declare const NavLink: LinkComponent;
+/**
+ * @deprecated Import `Outlet` from `@modern-js/plugin-tanstack/runtime` instead.
+ */
+export declare const Outlet: React.ComponentType;
+/**
+ * @deprecated Import `Form` from `@modern-js/plugin-tanstack/runtime` instead.
+ */
+export declare const Form: React.ComponentType<FormProps>;
+/**
+ * @deprecated Import `useFetcher` from `@modern-js/plugin-tanstack/runtime`
+ * instead.
+ */
+export declare function useFetcher(): Fetcher;
+/**
+ * @deprecated Import `RouteActionResponseError` from
+ * `@modern-js/plugin-tanstack/runtime` instead.
+ *
+ * Delegates to the real class registered by '@modern-js/plugin-tanstack/runtime'
+ * so that `instanceof` checks observe the same class identity. Before the
+ * registration happens no instance can exist, so `instanceof` is gracefully
+ * `false`; constructing without @modern-js/plugin-tanstack installed throws an
+ * actionable error.
+ */
+export declare const RouteActionResponseError: RouteActionResponseErrorConstructor;
+export {};

package/dist/types/module-federation/index.d.ts

@@ -0,0 +1,65 @@
+export declare const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = "modernjs:mf-runtime-fallback";
+export declare const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = "modernjs:mf-runtime-recovery";
+export declare const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = "/_modern/contract-gates/runtime-fallback";
+export declare const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = "x-modernjs-runtime-signal-token";
+export type ModuleFederationFallbackClassification = 'timeout' | 'network' | 'contract' | 'version-skew' | 'remote-unavailable';
+export type ModuleFederationFallbackStatus = 'degraded' | 'failed' | 'recovered';
+export type ModuleFederationFallbackTelemetryInput = {
+    appName: string;
+    classification: ModuleFederationFallbackClassification;
+    entry?: string;
+    error?: unknown;
+    eventName?: string;
+    exportName?: string;
+    metadata?: Record<string, unknown>;
+    phase: 'discovery' | 'load' | 'mount' | 'hydrate' | 'recover';
+    remote: string;
+    runtimeDigest?: string;
+    status?: ModuleFederationFallbackStatus;
+};
+export type ModuleFederationFallbackTelemetryPayload = {
+    appName: string;
+    entry?: string;
+    eventName: string;
+    phase: ModuleFederationFallbackTelemetryInput['phase'];
+    reason: ModuleFederationFallbackClassification;
+    runtimeDigest?: string;
+    schemaVersion: 1;
+    metadata: {
+        classification: ModuleFederationFallbackClassification;
+        errorMessage?: string;
+        errorName?: string;
+        exportName?: string;
+        remote: string;
+        runtimeDigest?: string;
+        status: ModuleFederationFallbackStatus;
+    } & Record<string, unknown>;
+};
+export type ModuleFederationFallbackTelemetryEmitOptions = {
+    authHeaderName?: string;
+    authToken?: string;
+    endpoint?: string;
+    fetchImpl?: typeof fetch;
+    postSignal?: boolean;
+};
+export type ModuleFederationFallbackTelemetryEmitResult = {
+    dispatched: boolean;
+    posted: boolean;
+    postStatus?: number;
+};
+export declare class ModuleFederationRemoteLoadTimeoutError extends Error {
+    constructor(remote: string, timeoutMs: number);
+}
+export declare class ModuleFederationRemoteLoadError extends Error {
+    readonly remote: string;
+    readonly attempts: number;
+    readonly causeError: Error;
+    constructor(remote: string, attempts: number, causeError: Error);
+}
+export declare class ModuleFederationRemoteComponentContractError extends Error {
+    constructor(remote: string, exportName: string);
+}
+export declare function classifyModuleFederationFallback(error: unknown): ModuleFederationFallbackClassification;
+export declare function createModuleFederationFallbackTelemetry(input: ModuleFederationFallbackTelemetryInput): ModuleFederationFallbackTelemetryPayload;
+export declare function toModuleFederationFallbackAttributes(payload: ModuleFederationFallbackTelemetryPayload): Record<string, string>;
+export declare function emitModuleFederationFallbackTelemetry(input: ModuleFederationFallbackTelemetryInput, options?: ModuleFederationFallbackTelemetryEmitOptions): Promise<ModuleFederationFallbackTelemetryEmitResult>;

package/dist/types/router/cli/code/index.d.ts

@@ -5,8 +5,6 @@ import type { Entrypoint, NestedRouteForCli, PageRoute } from '@modern-js/types'
  * Generate routing information for a single entry point (can be reused by the routes inspect feature)
  */
 export declare function generateRoutesForEntry(entrypoint: Entrypoint, appContext: AppToolsContext): Promise<NestedRouteForCli[]>;
-export declare const generateCode: (appContext: AppToolsContext, config: AppNormalizedConfig, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools>, options?: {
-    enableTanstackTypes?: boolean;
-}) => Promise<Record<string, (NestedRouteForCli | PageRoute)[]>>;
+export declare const generateCode: (appContext: AppToolsContext, config: AppNormalizedConfig, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools>) => Promise<Record<string, (NestedRouteForCli | PageRoute)[]>>;
 export declare function generatorRegisterCode(internalDirectory: string, entryName: string, code: string): void;
 export declare function generatorServerRegisterCode(internalDirectory: string, entryName: string, code: string): void;

package/dist/types/router/cli/code/utils.d.ts

@@ -1,6 +1,6 @@
 export declare const walkDirectory: (dir: string) => string[];
 export declare const isPageComponentFile: (filePath: string) => boolean;
-export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => any;
+export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => string;
 export declare const parseModule: ({ source, filename, }: {
     source: string;
     filename: string;

package/dist/types/router/cli/entry.d.ts

@@ -13,6 +13,6 @@ export declare const getEntrypointRoutesDir: (entrypoint: {
 export declare const getEntrypointRoutesOwner: (entrypoint: {
     [ROUTES_OWNER_META_KEY]?: string;
 }) => string | null;
-export declare const hasNestedRoutes: (dir: string, routesDir?: string) => any;
+export declare const hasNestedRoutes: (dir: string, routesDir?: string) => boolean;
 export declare const isRouteEntry: (dir: string, routesDir?: string) => string | false;
 export declare const modifyEntrypoints: (entrypoints: Entrypoint[], routesDir?: string, routesOwner?: string) => EntrypointWithRoutesMeta[];

package/dist/types/router/cli/handler.d.ts

@@ -10,9 +10,6 @@ type RegenerateRoutesFn = (params: {
 }) => Promise<void>;
 type HandleGeneratorEntryCodeOptions = {
     entrypointsKey?: string;
-    generateCodeOptions?: {
-        enableTanstackTypes?: boolean;
-    };
 };
 type HandleFileChangeOptions = {
     includeEntry?: (entrypoint: Entrypoint) => boolean;

package/dist/types/router/runtime/DeferredDataScripts.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => null;
 export default _default;
+declare function _default(): null;

package/dist/types/router/runtime/PrefetchLink.d.ts

@@ -13,14 +13,18 @@ import React from 'react';
  *
  * - "intent": Fetched when the user focuses or hovers the link
  * - "render": Fetched when the link is rendered
+ * - "viewport": Fetched when the link enters the viewport
  * - "none": Never fetched
  */
-type PrefetchBehavior = 'intent' | 'render' | 'none';
+type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+type PreloadBehavior = PrefetchBehavior | false;
 export interface LinkProps extends RouterLinkProps {
     prefetch?: PrefetchBehavior;
+    preload?: PreloadBehavior;
 }
 export interface NavLinkProps extends RouterNavLinkProps {
     prefetch?: PrefetchBehavior;
+    preload?: PreloadBehavior;
 }
 declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
 declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;

package/dist/types/router/runtime/internal.d.ts

@@ -7,5 +7,6 @@ export declare const routerPlugin: (userConfig?: Partial<RouterConfig>) => Runti
 export default routerPlugin;
 export type { RouterExtendsHooks } from './hooks';
 export { modifyRoutes } from './plugin';
+export { type RouterProviderFactory, type RouterProviderPlugin, registerRouterProvider, resolveRouterProvider, } from './provider';
 export { renderRoutes } from './utils';
 export type { RouterConfig, SingleRouteConfig };

package/dist/types/router/runtime/lifecycle.d.ts

@@ -1,6 +1,8 @@
 import type { RouteObject } from '@modern-js/runtime-utils/router';
 import type { TInternalRuntimeContext } from '../../core/context/runtime';
 import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult } from './types';
+export declare function getRouterRuntimeState(runtimeContext: object): InternalRouterRuntimeState | undefined;
+export declare function getRouterServerSnapshot(runtimeContext: object): InternalRouterServerSnapshot | undefined;
 export type RouterLifecyclePhase = 'ssr-prepare' | 'client-create' | 'hydrate';
 export type RouterLifecycleContext = {
     framework: RouterFramework;

package/dist/types/router/runtime/plugin.d.ts

@@ -1,5 +1,5 @@
 import { type RuntimePlugin } from '../../core';
-import { type RouterExtendsHooks } from './hooks';
+import type { RouterExtendsHooks } from './hooks';
 import type { RouterConfig, Routes } from './types';
 export declare let finalRouteConfig: RouterConfig['routesConfig'];
 export declare let beforeCreateRouter: boolean;

package/dist/types/router/runtime/plugin.node.d.ts

@@ -1,5 +1,5 @@
 import type { RuntimePlugin } from '../../core';
-import { type RouterExtendsHooks } from './hooks';
+import type { RouterExtendsHooks } from './hooks';
 import type { RouterConfig } from './types';
 export declare const routerPlugin: (userConfig?: Partial<RouterConfig>) => RuntimePlugin<{
     extendHooks: RouterExtendsHooks;

package/dist/types/router/runtime/provider.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Fork-owned router-provider registry.
+ *
+ * `runtime.router.framework` selects the router implementation used by the
+ * built-in router runtime plugin (`@modern-js/runtime/router/internal`).
+ * Instead of hardcoding every implementation there, providers register
+ * themselves here:
+ *
+ * - `react-router` registers itself as the default provider when the
+ *   built-in router plugin module is loaded.
+ * - `@modern-js/plugin-tanstack` registers the `tanstack` provider when its
+ *   runtime entry is imported.
+ */
+import type { RuntimePlugin } from '../../core';
+import type { RouterExtendsHooks } from './hooks';
+import type { RouterConfig } from './types';
+/**
+ * The single declaration source for the router hook registry. Every router
+ * provider (built-in react-router, @modern-js/plugin-tanstack, ...) and the
+ * framework-resolving wrapper plugin register exactly these instances, so the
+ * hook set is defined once and providers cannot drift apart.
+ */
+export declare const routerProviderRegistryHooks: RouterExtendsHooks;
+export type RouterProviderPlugin = RuntimePlugin<{
+    extendHooks: RouterExtendsHooks;
+}>;
+/**
+ * Guard for the wrapper plugin (`router/internal`): a resolved provider is
+ * only invoked through `setup`, so registry hooks outside the canonical
+ * router hook contract cannot be registered for it. Returns the offending
+ * hook names and warns once so they are surfaced instead of silently dropped.
+ */
+export declare function reportUnsupportedProviderRegistryHooks(providerPlugin: {
+    name?: string;
+    registryHooks?: Record<string, unknown>;
+}): string[];
+export type RouterProviderFactory = (userConfig: Partial<RouterConfig>) => RouterProviderPlugin;
+export declare function registerRouterProvider(name: string, factory: RouterProviderFactory, options?: {
+    isDefault?: boolean;
+}): void;
+export declare function resolveRouterProvider(framework?: RouterConfig['framework'], options?: {
+    /**
+     * The resolving module's own copy of a provider. The registry is
+     * realm-global with keep-first semantics, so in a page hosting several
+     * independent Modern.js apps (Module Federation app-level remotes) the
+     * first-loaded copy of a provider would otherwise win for *every* app —
+     * a foreign factory closes over the foreign app's global context (routes,
+     * App, runtime hooks) and renders the wrong app inside the resolving one.
+     * When the resolved name matches `localDefault.name`, the local factory
+     * is returned instead of whatever copy registered first.
+     */
+    localDefault?: {
+        name: string;
+        factory: RouterProviderFactory;
+    };
+}): RouterProviderFactory;
+/**
+ * Test-only escape hatch: the registry lives on `globalThis`, so unit tests
+ * need a way to restore a pristine state between cases.
+ */
+export declare function unsafe_resetRouterProvidersForTesting(): void;