@octanejs/tanstack-start 0.1.28 → 0.1.30

package/src/internal/start-plugin-core/rsbuild/schema.js

@@ -0,0 +1,28 @@
+import {
+	parseStartConfig as parseStartConfig$1,
+	tanstackStartOptionsObjectSchema,
+} from '../schema.js';
+import { z } from 'zod';
+//#region src/rsbuild/schema.ts
+var rsbuildClientOutputSchema = z.enum(['module', 'iife']);
+var tanstackStartRsbuildOptionsSchema = tanstackStartOptionsObjectSchema
+	.extend({
+		rsbuild: z
+			.object({
+				installDevServerMiddleware: z.boolean().optional(),
+				client: z
+					.object({ output: rsbuildClientOutputSchema.optional().default('module') })
+					.optional()
+					.prefault({}),
+			})
+			.optional(),
+	})
+	.optional()
+	.prefault({});
+function parseStartConfig(opts, corePluginOpts, root) {
+	tanstackStartRsbuildOptionsSchema.parse(opts);
+	const { rsbuild: _rsbuild, ...coreOptions } = opts ?? {};
+	return parseStartConfig$1(coreOptions, corePluginOpts, root);
+}
+//#endregion
+export { parseStartConfig, rsbuildClientOutputSchema };

package/src/internal/start-plugin-core/rsbuild/server-middleware.d.ts

@@ -0,0 +1,32 @@
+import { RsbuildConfig } from '@rsbuild/core';
+type ServerSetupFn = Extract<
+	NonNullable<NonNullable<RsbuildConfig['server']>['setup']>,
+	(...args: Array<any>) => any
+>;
+/**
+ * Returns a `server.setup` function for rsbuild v2.
+ *
+ * Two middleware positions are used:
+ *
+ * 1. **Setup body** (BEFORE built-ins): Intercepts `/_serverFn/` URLs so
+ *    they never reach rsbuild's htmlFallback/htmlCompletion middleware,
+ *    which can swallow long base64 function IDs.
+ *
+ * 2. **Returned callback** (AFTER built-ins, BEFORE fallback): Handles
+ *    all remaining SSR requests (page navigations). This position lets
+ *    rsbuild's asset middleware serve compiled JS/CSS first.
+ *
+ * The middleware choreography is shared by dev and preview. The server entry
+ * loader differs: dev reads from Rsbuild's in-memory environment so rebuilds
+ * are reflected immediately, while preview lazy-imports the production server
+ * bundle from disk.
+ *
+ * See rsbuild source: devMiddlewares.ts `applyDefaultMiddlewares()` and
+ * previewServer.ts `startPreviewServer()`.
+ */
+export declare function createServerSetup(opts: {
+	serverFnBasePath: string;
+	serverOutputDirectory: string;
+	publicBase: string;
+}): ServerSetupFn;
+export {};

package/src/internal/start-plugin-core/rsbuild/server-middleware.js

@@ -0,0 +1,139 @@
+import { RSBUILD_ENVIRONMENT_NAMES } from './planning.js';
+import { resolve } from 'node:path';
+import { NodeRequest, sendNodeResponse } from 'srvx/node';
+import { pathToFileURL } from 'node:url';
+import { joinURL } from 'ufo';
+//#region src/rsbuild/server-middleware.ts
+function resolveFetchHandler(serverEntry) {
+	if (typeof serverEntry === 'function') return serverEntry;
+	if (typeof serverEntry.fetch === 'function') return serverEntry.fetch.bind(serverEntry);
+	throw new Error('Unable to resolve a request handler from Rsbuild server bundle');
+}
+function getPublicBasePathname(publicBase) {
+	try {
+		return new URL(publicBase, 'http://localhost').pathname;
+	} catch {
+		return publicBase;
+	}
+}
+function restorePreviewUrl(opts) {
+	if (opts.req.originalUrl) opts.req.url = opts.req.originalUrl;
+	const publicBasePathname = getPublicBasePathname(opts.publicBase);
+	if (publicBasePathname === '/') return;
+	const url = opts.req.url ?? '/';
+	if (url.startsWith(publicBasePathname)) return;
+	opts.req.url = joinURL(publicBasePathname, url);
+}
+async function loadDevFetchHandler(context) {
+	if (context.action !== 'dev')
+		throw new Error('Cannot load Rsbuild dev SSR bundle outside dev mode');
+	const ssrEnv = context.server.environments[RSBUILD_ENVIRONMENT_NAMES.server];
+	if (!ssrEnv) throw new Error(`SSR environment "${RSBUILD_ENVIRONMENT_NAMES.server}" not found`);
+	return resolveFetchHandler((await ssrEnv.loadBundle('index')).default);
+}
+/**
+ * Returns a `server.setup` function for rsbuild v2.
+ *
+ * Two middleware positions are used:
+ *
+ * 1. **Setup body** (BEFORE built-ins): Intercepts `/_serverFn/` URLs so
+ *    they never reach rsbuild's htmlFallback/htmlCompletion middleware,
+ *    which can swallow long base64 function IDs.
+ *
+ * 2. **Returned callback** (AFTER built-ins, BEFORE fallback): Handles
+ *    all remaining SSR requests (page navigations). This position lets
+ *    rsbuild's asset middleware serve compiled JS/CSS first.
+ *
+ * The middleware choreography is shared by dev and preview. The server entry
+ * loader differs: dev reads from Rsbuild's in-memory environment so rebuilds
+ * are reflected immediately, while preview lazy-imports the production server
+ * bundle from disk.
+ *
+ * See rsbuild source: devMiddlewares.ts `applyDefaultMiddlewares()` and
+ * previewServer.ts `startPreviewServer()`.
+ */
+function createServerSetup(opts) {
+	let previewFetchHandlerPromise;
+	const getPreviewFetchHandler = () => {
+		if (!previewFetchHandlerPromise)
+			previewFetchHandlerPromise = loadPreviewFetchHandler(opts.serverOutputDirectory);
+		return previewFetchHandlerPromise;
+	};
+	return (context) => {
+		const serverFnBase = opts.serverFnBasePath;
+		const handleSSR = async (req, res, next) => {
+			try {
+				const fetchHandler =
+					context.action === 'dev'
+						? await loadDevFetchHandler(context)
+						: await getPreviewFetchHandler();
+				if (context.action === 'preview')
+					restorePreviewUrl({
+						req,
+						publicBase: opts.publicBase,
+					});
+				else if (req.originalUrl) req.url = req.originalUrl;
+				return sendNodeResponse(
+					res,
+					await fetchHandler(
+						new NodeRequest({
+							req,
+							res,
+						}),
+					),
+				);
+			} catch (e) {
+				console.error('[tanstack-start] SSR error:', e);
+				if (
+					new NodeRequest({
+						req,
+						res,
+					}).headers
+						.get('content-type')
+						?.includes('application/json')
+				)
+					return sendNodeResponse(
+						res,
+						new Response(
+							JSON.stringify(
+								{
+									status: 500,
+									error: 'Internal Server Error',
+									message: 'An unexpected error occurred. Please try again later.',
+									timestamp: /* @__PURE__ */ new Date().toISOString(),
+								},
+								null,
+								2,
+							),
+							{
+								status: 500,
+								headers: { 'Content-Type': 'application/json' },
+							},
+						),
+					);
+				return next(e);
+			}
+		};
+		context.server.middlewares.use(async (req, res, next) => {
+			if ((req.url || '/').startsWith(serverFnBase)) return handleSSR(req, res, next);
+			return next();
+		});
+		return () => {
+			context.server.middlewares.use(handleSSR);
+		};
+	};
+}
+async function loadPreviewFetchHandler(serverOutputDirectory) {
+	const serverEntryPath = resolve(serverOutputDirectory, 'index.js');
+	const imported = await import(pathToFileURL(serverEntryPath).toString());
+	try {
+		return resolveFetchHandler(imported.default);
+	} catch (error) {
+		throw new Error(
+			`Unable to resolve a request handler from Rsbuild server bundle at ${serverEntryPath}`,
+			{ cause: error },
+		);
+	}
+}
+//#endregion
+export { createServerSetup };

package/src/internal/start-plugin-core/rsbuild/start-compiler-host.d.ts

@@ -0,0 +1,36 @@
+import { RsbuildPluginAPI } from '@rsbuild/core';
+import {
+	CompileStartFrameworkOptions,
+	StartCompilerImportTransform,
+	StartCompilerPlugin,
+} from '../types.js';
+import { GenerateFunctionIdFnOptional, ServerFn } from '../start-compiler/types.js';
+type StartCompilerEnvironment = {
+	name: string;
+	type: 'client' | 'server';
+};
+export interface StartCompilerHostOptions {
+	framework: CompileStartFrameworkOptions;
+	root: string | (() => string);
+	environments: Array<StartCompilerEnvironment>;
+	providerEnvName: string;
+	generateFunctionId?: GenerateFunctionIdFnOptional;
+	compilerTransforms?: Array<StartCompilerImportTransform> | undefined;
+	compilerPlugins?: Array<StartCompilerPlugin> | undefined;
+	serverFnProviderModuleDirectives?: ReadonlyArray<string> | undefined;
+	serverFnsById?: Record<string, ServerFn>;
+	onServerFnsByIdChange?: () => void;
+}
+/**
+ * Registers the shared StartCompiler as rsbuild transforms for client + ssr environments.
+ *
+ * Uses `api.transform()` to hook into the rsbuild loader pipeline, and the
+ * transform context's native `resolve()` for module resolution.
+ */
+export declare function registerStartCompilerTransforms(
+	api: RsbuildPluginAPI,
+	opts: StartCompilerHostOptions,
+): {
+	serverFnsById: Record<string, ServerFn>;
+};
+export {};

package/src/internal/start-plugin-core/rsbuild/start-compiler-host.js

@@ -0,0 +1,322 @@
+import { TRANSFORM_ID_REGEX } from '../constants.js';
+import { cleanId } from '../start-compiler/utils.js';
+import { detectKindsInCode } from '../start-compiler/compiler.js';
+import { getTransformCodeFilterForEnv } from '../start-compiler/config.js';
+import {
+	createStartCompiler,
+	loadCompilerVirtualModule,
+	matchesCodeFilters,
+	mergeServerFnsById,
+} from '../start-compiler/host.js';
+import { createHydrateCompilerPlugin } from '../hydrate-when-transform.js';
+import {
+	SERVER_FN_BUILD_INFO_CONTEXT_KEY,
+	SERVER_FN_BUILD_INFO_FIELD,
+} from './start-compiler-metadata.js';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { z } from 'zod';
+import { AsyncLocalStorage } from 'node:async_hooks';
+//#region src/rsbuild/start-compiler-host.ts
+var serverFnSchema = z.object({
+	functionName: z.string(),
+	functionId: z.string(),
+	extractedFilename: z.string(),
+	filename: z.string(),
+	isClientReferenced: z.boolean().optional(),
+});
+var serverFnBuildInfoSchema = z.object({
+	version: z.literal(1),
+	serverFnsById: z.record(z.string(), serverFnSchema),
+});
+/**
+ * In Rsbuild dev, use file:// URLs for absolute server function paths.
+ * These are directly importable by Node's ESM VM runner without any bundler
+ * path conventions (unlike Vite's /@id/ prefix).
+ */
+var rsbuildDevServerFnModuleSpecifierEncoder = ({ extractedFilename }) =>
+	pathToFileURL(extractedFilename).href;
+var currentDir = dirname(fileURLToPath(import.meta.url));
+var metadataLoaderFilename = 'start-compiler-metadata-loader.js';
+var EMPTY_SERVER_FN_BUILD_INFO = {
+	version: 1,
+	serverFnsById: {},
+};
+function resolveMetadataLoader() {
+	return resolve(currentDir, metadataLoaderFilename);
+}
+function readServerFnBuildInfo(module) {
+	const result = serverFnBuildInfoSchema.safeParse(module.buildInfo[SERVER_FN_BUILD_INFO_FIELD]);
+	if (!result.success) return null;
+	return result.data.serverFnsById;
+}
+function setServerFnBuildInfoLoaderContext(loaderContext, module) {
+	loaderContext[SERVER_FN_BUILD_INFO_CONTEXT_KEY] = (metadata) => {
+		if (metadata) module.buildInfo[SERVER_FN_BUILD_INFO_FIELD] = metadata;
+		else if (module.buildInfo['tanstack.start.serverFns'])
+			module.buildInfo[SERVER_FN_BUILD_INFO_FIELD] = EMPTY_SERVER_FN_BUILD_INFO;
+	};
+}
+function warnTransformContext(ctx, message) {
+	ctx.emitWarning?.(new Error(message));
+}
+/**
+ * Registers the shared StartCompiler as rsbuild transforms for client + ssr environments.
+ *
+ * Uses `api.transform()` to hook into the rsbuild loader pipeline, and the
+ * transform context's native `resolve()` for module resolution.
+ */
+function registerStartCompilerTransforms(api, opts) {
+	const compilers = /* @__PURE__ */ new Map();
+	const compilerQueues = /* @__PURE__ */ new Map();
+	const inputFileSystems = /* @__PURE__ */ new Map();
+	const transformContextStorage = new AsyncLocalStorage();
+	const serverFnMetadataByEnvironment = /* @__PURE__ */ new Map();
+	const serverFnsByEnvironment = /* @__PURE__ */ new Map();
+	const serverFnsById = opts.serverFnsById ?? {};
+	const getRoot = () => (typeof opts.root === 'function' ? opts.root() : opts.root);
+	const getServerFnMetadata = (environmentName) => {
+		let metadataById = serverFnMetadataByEnvironment.get(environmentName);
+		if (!metadataById) {
+			metadataById = /* @__PURE__ */ new Map();
+			serverFnMetadataByEnvironment.set(environmentName, metadataById);
+		}
+		return metadataById;
+	};
+	const runCompilerTask = async (environmentName, task) => {
+		const next = (compilerQueues.get(environmentName) ?? Promise.resolve())
+			.catch(() => void 0)
+			.then(task);
+		compilerQueues.set(
+			environmentName,
+			next.then(
+				() => void 0,
+				() => void 0,
+			),
+		);
+		return next;
+	};
+	const replaceServerFnsByIdFromEnvironmentSnapshots = () => {
+		const nextServerFnsById = {};
+		for (const snapshot of serverFnsByEnvironment.values())
+			mergeServerFnsById(nextServerFnsById, snapshot);
+		for (const key of Object.keys(serverFnsById)) delete serverFnsById[key];
+		Object.assign(serverFnsById, nextServerFnsById);
+		opts.onServerFnsByIdChange?.();
+	};
+	const compilerPlugins = [createHydrateCompilerPlugin(), ...(opts.compilerPlugins ?? [])];
+	const isDev = api.context.action === 'dev';
+	const mode = isDev ? 'dev' : 'build';
+	const metadataLoader = resolveMetadataLoader();
+	const environments = opts.environments;
+	api.modifyRspackConfig((config, utils) => {
+		if (!environments.some((env) => env.name === utils.environment.name)) return;
+		const rules = config.module.rules ?? [];
+		rules.push({
+			test: TRANSFORM_ID_REGEX[0],
+			enforce: 'post',
+			use: [
+				{
+					loader: metadataLoader,
+					options: { metadataById: getServerFnMetadata(utils.environment.name) },
+				},
+			],
+		});
+		config.module.rules = rules;
+	});
+	for (const env of environments) {
+		const compilerTransforms = env.name === opts.providerEnvName ? opts.compilerTransforms : void 0;
+		const envCodeFilters = getTransformCodeFilterForEnv(env.type, {
+			compilerTransforms,
+			compilerPlugins,
+		});
+		const serverFnProviderModuleDirectives =
+			env.name === opts.providerEnvName ? opts.serverFnProviderModuleDirectives : void 0;
+		let activeServerFnMetadata;
+		const onServerFnsById = (d) => {
+			mergeServerFnsById(serverFnsById, d);
+			if (activeServerFnMetadata) mergeServerFnsById(activeServerFnMetadata, d);
+			opts.onServerFnsByIdChange?.();
+		};
+		api.transform(
+			{
+				test: TRANSFORM_ID_REGEX[0],
+				environments: [env.name],
+				order: 'pre',
+			},
+			async (ctx) => {
+				return transformContextStorage.run(ctx, async () => {
+					const code = ctx.code;
+					let nextCode = code;
+					let previousResult = null;
+					const id = ctx.resource;
+					const root = getRoot();
+					const virtualResult = loadCompilerVirtualModule(compilerPlugins, {
+						code,
+						id,
+						root,
+						env: env.type,
+						envName: env.name,
+					});
+					if (virtualResult) {
+						nextCode = virtualResult.code;
+						previousResult = {
+							code: virtualResult.code,
+							map: virtualResult.map ?? null,
+						};
+					}
+					if (!matchesCodeFilters(nextCode, envCodeFilters)) return previousResult ?? nextCode;
+					let compiler = compilers.get(env.name);
+					if (!compiler) {
+						compiler = createStartCompiler({
+							env: env.type,
+							envName: env.name,
+							root,
+							mode,
+							framework: opts.framework,
+							providerEnvName: opts.providerEnvName,
+							generateFunctionId: opts.generateFunctionId,
+							compilerTransforms,
+							compilerPlugins,
+							serverFnProviderModuleDirectives,
+							onServerFnsById,
+							getKnownServerFns: () => serverFnsById,
+							encodeModuleSpecifierInDev: isDev ? rsbuildDevServerFnModuleSpecifierEncoder : void 0,
+							loadModule: async (moduleId) => {
+								const activeCtx = transformContextStorage.getStore();
+								if (!activeCtx)
+									throw new Error(
+										`could not load module ${moduleId}: missing active rsbuild transform context for ${env.name}`,
+									);
+								const inputFileSystem = inputFileSystems.get(env.name);
+								if (!inputFileSystem)
+									throw new Error(
+										`could not load module ${moduleId}: missing rspack input filesystem for ${env.name}`,
+									);
+								const cleanedId = cleanId(moduleId);
+								activeCtx.addDependency(cleanedId);
+								const loaded = await readFileFromInputFileSystem(inputFileSystem, cleanedId);
+								const moduleCode = Buffer.isBuffer(loaded) ? loaded.toString('utf8') : loaded;
+								compiler.ingestModule({
+									code: moduleCode,
+									id: cleanedId,
+								});
+							},
+							resolveId: async (source, importer) => {
+								const activeCtx = transformContextStorage.getStore();
+								if (!activeCtx)
+									throw new Error(
+										`could not resolve ${source}: missing active rsbuild transform context for ${env.name}`,
+									);
+								const context = importer ? importer.replace(/[/\\][^/\\]*$/, '') : getRoot();
+								return await new Promise((resolve, reject) => {
+									activeCtx.resolve(context, source, (error, resolved) => {
+										if (error) {
+											reject(error);
+											return;
+										}
+										if (!resolved) {
+											resolve(null);
+											return;
+										}
+										resolve(cleanId(resolved));
+									});
+								});
+							},
+						});
+						compilers.set(env.name, compiler);
+					}
+					const detectedKinds = detectKindsInCode(nextCode, env.type, { compilerTransforms });
+					const discoveredServerFnsById = {};
+					const result = await runCompilerTask(env.name, async () => {
+						activeServerFnMetadata = discoveredServerFnsById;
+						try {
+							return await compiler.compile({
+								id,
+								code: nextCode,
+								detectedKinds,
+								warn: (message) => warnTransformContext(ctx, message),
+							});
+						} finally {
+							activeServerFnMetadata = void 0;
+						}
+					});
+					getServerFnMetadata(env.name).set(id, {
+						version: 1,
+						serverFnsById: discoveredServerFnsById,
+					});
+					if (result)
+						return {
+							code: result.code,
+							map: result.map ?? null,
+						};
+					return previousResult ?? nextCode;
+				});
+			},
+		);
+	}
+	api.modifyRspackConfig((config, utils) => {
+		if (!environments.some((env) => env.name === utils.environment.name)) return;
+		config.plugins.push({
+			apply(compiler) {
+				if (compiler.inputFileSystem)
+					inputFileSystems.set(utils.environment.name, compiler.inputFileSystem);
+				compiler.hooks.compilation.tap(
+					'TanStackStartCompilerMetadataLoaderContext',
+					(compilation) => {
+						utils.rspack.NormalModule.getCompilationHooks(compilation).loader.tap(
+							'TanStackStartCompilerMetadataLoaderContext',
+							(loaderContext, module) => {
+								setServerFnBuildInfoLoaderContext(loaderContext, module);
+							},
+						);
+					},
+				);
+				compiler.hooks.compile.tap('TanStackStartCompilerMetadataCleanup', () =>
+					getServerFnMetadata(utils.environment.name).clear(),
+				);
+				compiler.hooks.finishMake.tap(
+					{
+						name: 'TanStackStartCompilerCachedServerFnMetadata',
+						stage: -20,
+					},
+					(compilation) => {
+						const restoredServerFnsById = {};
+						for (const module of compilation.modules) {
+							const metadata = readServerFnBuildInfo(module);
+							if (!metadata) continue;
+							mergeServerFnsById(restoredServerFnsById, metadata);
+						}
+						serverFnsByEnvironment.set(utils.environment.name, restoredServerFnsById);
+						replaceServerFnsByIdFromEnvironmentSnapshots();
+					},
+				);
+				compiler.hooks.watchRun.tap('TanStackStartCompilerModuleInvalidation', (watchCompiler) => {
+					const startCompiler = compilers.get(utils.environment.name);
+					if (!startCompiler) return;
+					for (const file of watchCompiler.modifiedFiles ?? [])
+						startCompiler.invalidateModule(file);
+					for (const file of watchCompiler.removedFiles ?? []) startCompiler.invalidateModule(file);
+				});
+			},
+		});
+	});
+	return { serverFnsById };
+}
+function readFileFromInputFileSystem(inputFileSystem, file) {
+	return new Promise((resolve, reject) => {
+		inputFileSystem.readFile(file, (error, data) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			if (data == null) {
+				reject(/* @__PURE__ */ new Error(`could not read module source for ${file}`));
+				return;
+			}
+			resolve(data);
+		});
+	});
+}
+//#endregion
+export { registerStartCompilerTransforms };

package/src/internal/start-plugin-core/rsbuild/start-compiler-metadata-loader.d.ts

@@ -0,0 +1,10 @@
+import { Rspack } from '@rsbuild/core';
+import {
+	ServerFnBuildInfoLoaderContext,
+	ServerFnMetadataLoaderOptions,
+} from './start-compiler-metadata.js';
+declare const tanStackStartCompilerMetadataLoader: Rspack.LoaderDefinition<
+	ServerFnMetadataLoaderOptions,
+	ServerFnBuildInfoLoaderContext
+>;
+export default tanStackStartCompilerMetadataLoader;

package/src/internal/start-plugin-core/rsbuild/start-compiler-metadata-loader.js

@@ -0,0 +1,12 @@
+import { SERVER_FN_BUILD_INFO_CONTEXT_KEY } from './start-compiler-metadata.js';
+//#region src/rsbuild/start-compiler-metadata-loader.ts
+var tanStackStartCompilerMetadataLoader = function (source, map) {
+	const { metadataById } = this.getOptions();
+	const id = this.resource;
+	const metadata = metadataById.get(id);
+	const setBuildInfo = this[SERVER_FN_BUILD_INFO_CONTEXT_KEY];
+	setBuildInfo?.(metadata ?? null);
+	this.callback(null, source, map);
+};
+//#endregion
+export { tanStackStartCompilerMetadataLoader as default };

package/src/internal/start-plugin-core/rsbuild/start-compiler-metadata.d.ts

@@ -0,0 +1,14 @@
+import { ServerFn } from '../start-compiler/types.js';
+export declare const SERVER_FN_BUILD_INFO_FIELD = 'tanstack.start.serverFns';
+export declare const SERVER_FN_BUILD_INFO_CONTEXT_KEY = 'tanstack.start.setServerFnBuildInfo';
+export type ServerFnBuildInfo = {
+	version: 1;
+	serverFnsById: Record<string, ServerFn>;
+};
+export type SetServerFnBuildInfo = (metadata: ServerFnBuildInfo | null) => void;
+export type ServerFnBuildInfoLoaderContext = {
+	[SERVER_FN_BUILD_INFO_CONTEXT_KEY]?: SetServerFnBuildInfo;
+};
+export type ServerFnMetadataLoaderOptions = {
+	metadataById: Map<string, ServerFnBuildInfo>;
+};

package/src/internal/start-plugin-core/rsbuild/start-compiler-metadata.js

@@ -0,0 +1,5 @@
+//#region src/rsbuild/start-compiler-metadata.ts
+var SERVER_FN_BUILD_INFO_FIELD = 'tanstack.start.serverFns';
+var SERVER_FN_BUILD_INFO_CONTEXT_KEY = 'tanstack.start.setServerFnBuildInfo';
+//#endregion
+export { SERVER_FN_BUILD_INFO_CONTEXT_KEY, SERVER_FN_BUILD_INFO_FIELD };

package/src/internal/start-plugin-core/rsbuild/start-router-plugin.d.ts

@@ -0,0 +1,19 @@
+import { RsbuildPluginAPI } from '@rsbuild/core';
+import { GetConfigFn, TanStackStartCoreOptions } from '../types.js';
+import { TanStackStartRsbuildInputConfig } from './schema.js';
+/**
+ * Registers the TanStack Router generator and code-splitter plugins
+ * as rspack plugins via `modifyRspackConfig`.
+ *
+ * The router-plugin package exports rspack-compatible unplugin wrappers:
+ * - TanStackRouterGeneratorRspack: file-based route generation
+ * - TanStackRouterCodeSplitterRspack: route code splitting
+ */
+export declare function registerRouterPlugins(
+	api: RsbuildPluginAPI,
+	opts: {
+		getConfig: GetConfigFn;
+		corePluginOpts: TanStackStartCoreOptions;
+		startPluginOpts: TanStackStartRsbuildInputConfig;
+	},
+): void;