@octanejs/tanstack-start 0.1.0

package/src/internal/router-plugin/core/config.d.ts

@@ -0,0 +1,294 @@
+import { z } from 'zod';
+import { CreateFileRoute, RegisteredRouter, RouteIds } from '@tanstack/router-core';
+import { CodeSplitGroupings } from './constants.js';
+export declare const splitGroupingsSchema: z.ZodArray<
+	z.ZodArray<
+		z.ZodUnion<
+			readonly [
+				z.ZodLiteral<'loader'>,
+				z.ZodLiteral<'component'>,
+				z.ZodLiteral<'pendingComponent'>,
+				z.ZodLiteral<'errorComponent'>,
+				z.ZodLiteral<'notFoundComponent'>,
+			]
+		>
+	>
+>;
+export type CodeSplittingOptions = {
+	/**
+	 * Use this function to programmatically control the code splitting behavior
+	 * based on the `routeId` for each route.
+	 *
+	 * If you just need to change the default behavior, you can use the `defaultBehavior` option.
+	 * @param params
+	 */
+	splitBehavior?: (params: {
+		routeId: RouteIds<RegisteredRouter['routeTree']>;
+	}) => CodeSplitGroupings | undefined | void;
+	/**
+	 * The default/global configuration to control your code splitting behavior per route.
+	 * @default [['component'],['pendingComponent'],['errorComponent'],['notFoundComponent']]
+	 */
+	defaultBehavior?: CodeSplitGroupings;
+	/**
+	 * The nodes that shall be deleted from the route.
+	 * @default undefined
+	 */
+	deleteNodes?: Array<DeletableNodes>;
+	/**
+	 * @default true
+	 */
+	addHmr?: boolean;
+};
+export type HmrStyle = 'vite' | 'webpack';
+export type HmrOptions = {
+	/**
+	 * Selects the HMR runtime style to emit code for.
+	 * - `'vite'` (default): ESM `import.meta.hot` with Vite accept-callback semantics.
+	 * - `'webpack'`: `import.meta.webpackHot` with webpack / Rspack `module.hot` re-execution semantics.
+	 *
+	 * Bundler-specific plugin entries (e.g. `rspack.ts`, `webpack.ts`) set this explicitly.
+	 */
+	style?: HmrStyle;
+};
+type FileRouteKeys = keyof (Parameters<CreateFileRoute<any, any, any, any, any>>[0] & {});
+export type DeletableNodes = FileRouteKeys | (string & {});
+export declare const configSchema: z.ZodObject<
+	{
+		target: z.ZodDefault<
+			z.ZodOptional<
+				z.ZodEnum<{
+					vue: 'vue';
+					react: 'react';
+					solid: 'solid';
+					octane: 'octane';
+				}>
+			>
+		>;
+		virtualRouteConfig: z.ZodOptional<
+			z.ZodUnion<
+				[
+					z.ZodType<
+						import('@tanstack/virtual-file-routes').VirtualRootRoute,
+						unknown,
+						z.core.$ZodTypeInternals<
+							import('@tanstack/virtual-file-routes').VirtualRootRoute,
+							unknown
+						>
+					>,
+					z.ZodString,
+				]
+			>
+		>;
+		routeFilePrefix: z.ZodOptional<z.ZodString>;
+		routeFileIgnorePrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+		routeFileIgnorePattern: z.ZodOptional<z.ZodString>;
+		routesDirectory: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+		quoteStyle: z.ZodDefault<
+			z.ZodOptional<
+				z.ZodEnum<{
+					single: 'single';
+					double: 'double';
+				}>
+			>
+		>;
+		semicolons: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+		disableLogging: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+		routeTreeFileHeader: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+		indexToken: z.ZodDefault<
+			z.ZodOptional<
+				z.ZodUnion<
+					readonly [
+						z.ZodString,
+						z.ZodCustom<RegExp, RegExp>,
+						z.ZodObject<
+							{
+								regex: z.ZodString;
+								flags: z.ZodOptional<z.ZodString>;
+							},
+							z.core.$strip
+						>,
+					]
+				>
+			>
+		>;
+		routeToken: z.ZodDefault<
+			z.ZodOptional<
+				z.ZodUnion<
+					readonly [
+						z.ZodString,
+						z.ZodCustom<RegExp, RegExp>,
+						z.ZodObject<
+							{
+								regex: z.ZodString;
+								flags: z.ZodOptional<z.ZodString>;
+							},
+							z.core.$strip
+						>,
+					]
+				>
+			>
+		>;
+		pathParamsAllowedCharacters: z.ZodOptional<
+			z.ZodArray<
+				z.ZodEnum<{
+					':': ':';
+					$: '$';
+					';': ';';
+					'@': '@';
+					'&': '&';
+					'=': '=';
+					'+': '+';
+					',': ',';
+				}>
+			>
+		>;
+		generatedRouteTree: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+		disableTypes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+		addExtensions: z.ZodPipe<
+			z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>>,
+			z.ZodTransform<string | boolean, string | boolean>
+		>;
+		enableRouteTreeFormatting: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+		routeTreeFileFooter: z.ZodOptional<
+			z.ZodUnion<
+				readonly [
+					z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>,
+					z.ZodCustom<() => Array<string>, () => Array<string>>,
+				]
+			>
+		>;
+		autoCodeSplitting: z.ZodOptional<z.ZodBoolean>;
+		customScaffolding: z.ZodOptional<
+			z.ZodObject<
+				{
+					routeTemplate: z.ZodOptional<z.ZodString>;
+					lazyRouteTemplate: z.ZodOptional<z.ZodString>;
+				},
+				z.core.$strip
+			>
+		>;
+		experimental: z.ZodOptional<
+			z.ZodObject<
+				{
+					enableCodeSplitting: z.ZodOptional<z.ZodBoolean>;
+				},
+				z.core.$strip
+			>
+		>;
+		plugins: z.ZodOptional<
+			z.ZodArray<
+				z.ZodCustom<
+					import('#tanstack-start/router-generator').GeneratorPlugin,
+					import('#tanstack-start/router-generator').GeneratorPlugin
+				>
+			>
+		>;
+		tmpDir: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+		importRoutesUsingAbsolutePaths: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+		enableRouteGeneration: z.ZodOptional<z.ZodBoolean>;
+		codeSplittingOptions: z.ZodOptional<z.ZodCustom<CodeSplittingOptions, CodeSplittingOptions>>;
+		plugin: z.ZodOptional<
+			z.ZodObject<
+				{
+					hmr: z.ZodOptional<
+						z.ZodObject<
+							{
+								style: z.ZodOptional<
+									z.ZodEnum<{
+										vite: 'vite';
+										webpack: 'webpack';
+									}>
+								>;
+							},
+							z.core.$strip
+						>
+					>;
+					vite: z.ZodOptional<
+						z.ZodObject<
+							{
+								environmentName: z.ZodOptional<z.ZodString>;
+							},
+							z.core.$strip
+						>
+					>;
+				},
+				z.core.$strip
+			>
+		>;
+	},
+	z.core.$strip
+>;
+export declare const getConfig: (
+	inlineConfig: Partial<Config>,
+	root: string,
+) => {
+	target: 'vue' | 'react' | 'solid' | 'octane';
+	routeFileIgnorePrefix: string;
+	routesDirectory: string;
+	quoteStyle: 'single' | 'double';
+	semicolons: boolean;
+	disableLogging: boolean;
+	routeTreeFileHeader: string[];
+	indexToken:
+		| string
+		| RegExp
+		| {
+				regex: string;
+				flags?: string | undefined;
+		  };
+	routeToken:
+		| string
+		| RegExp
+		| {
+				regex: string;
+				flags?: string | undefined;
+		  };
+	generatedRouteTree: string;
+	disableTypes: boolean;
+	addExtensions: string | boolean;
+	enableRouteTreeFormatting: boolean;
+	tmpDir: string;
+	importRoutesUsingAbsolutePaths: boolean;
+	virtualRouteConfig?:
+		| string
+		| import('@tanstack/virtual-file-routes').VirtualRootRoute
+		| undefined;
+	routeFilePrefix?: string | undefined;
+	routeFileIgnorePattern?: string | undefined;
+	pathParamsAllowedCharacters?: (':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[] | undefined;
+	routeTreeFileFooter?: string[] | (() => Array<string>) | undefined;
+	autoCodeSplitting?: boolean | undefined;
+	customScaffolding?:
+		| {
+				routeTemplate?: string | undefined;
+				lazyRouteTemplate?: string | undefined;
+		  }
+		| undefined;
+	experimental?:
+		| {
+				enableCodeSplitting?: boolean | undefined;
+		  }
+		| undefined;
+	plugins?: import('#tanstack-start/router-generator').GeneratorPlugin[] | undefined;
+	enableRouteGeneration?: boolean | undefined;
+	codeSplittingOptions?: CodeSplittingOptions | undefined;
+	plugin?:
+		| {
+				hmr?:
+					| {
+							style?: 'vite' | 'webpack' | undefined;
+					  }
+					| undefined;
+				vite?:
+					| {
+							environmentName?: string | undefined;
+					  }
+					| undefined;
+		  }
+		| undefined;
+};
+export type Config = z.infer<typeof configSchema>;
+export type ConfigInput = z.input<typeof configSchema>;
+export type ConfigOutput = z.output<typeof configSchema>;
+export {};

package/src/internal/router-plugin/core/config.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { configSchema, getConfig } from '#tanstack-start/router-generator';
+//#region src/core/config.ts
+var splitGroupingsSchema = z
+	.array(
+		z.array(
+			z.union([
+				z.literal('loader'),
+				z.literal('component'),
+				z.literal('pendingComponent'),
+				z.literal('errorComponent'),
+				z.literal('notFoundComponent'),
+			]),
+		),
+		{
+			message:
+				"  Must be an Array of Arrays containing the split groupings. i.e. [['component'], ['pendingComponent'], ['errorComponent', 'notFoundComponent']]",
+		},
+	)
+	.superRefine((val, ctx) => {
+		const flattened = val.flat();
+		if ([...new Set(flattened)].length !== flattened.length)
+			ctx.addIssue({
+				code: 'custom',
+				message: `  Split groupings must be unique and not repeated. i.e. i.e. [['component'], ['pendingComponent'], ['errorComponent', 'notFoundComponent']].\n  You input was: ${JSON.stringify(val)}.`,
+			});
+	});
+var codeSplittingOptionsSchema = z.object({
+	splitBehavior: z.custom((value) => typeof value === 'function').optional(),
+	defaultBehavior: splitGroupingsSchema.optional(),
+	deleteNodes: z.array(z.string()).optional(),
+	addHmr: z.boolean().optional().default(true),
+});
+var configSchema$1 = configSchema.extend({
+	enableRouteGeneration: z.boolean().optional(),
+	codeSplittingOptions: z
+		.custom((v) => {
+			return codeSplittingOptionsSchema.parse(v);
+		})
+		.optional(),
+	plugin: z
+		.object({
+			hmr: z.object({ style: z.enum(['vite', 'webpack']).optional() }).optional(),
+			vite: z.object({ environmentName: z.string().optional() }).optional(),
+		})
+		.optional(),
+});
+var getConfig$1 = (inlineConfig, root) => {
+	const config = getConfig(inlineConfig, root);
+	return configSchema$1.parse({
+		...inlineConfig,
+		...config,
+	});
+};
+//#endregion
+export { configSchema$1 as configSchema, getConfig$1 as getConfig, splitGroupingsSchema };

package/src/internal/router-plugin/core/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const tsrSplit = 'tsr-split';
+export declare const tsrShared = 'tsr-shared';
+export declare const splitRouteIdentNodes: readonly [
+	'loader',
+	'component',
+	'pendingComponent',
+	'errorComponent',
+	'notFoundComponent',
+];
+export type SplitRouteIdentNodes = (typeof splitRouteIdentNodes)[number];
+export type CodeSplitGroupings = Array<Array<SplitRouteIdentNodes>>;
+export declare const defaultCodeSplitGroupings: CodeSplitGroupings;

package/src/internal/router-plugin/core/constants.js

@@ -0,0 +1,13 @@
+//#region src/core/constants.ts
+var tsrSplit = 'tsr-split';
+var tsrShared = 'tsr-shared';
+var splitRouteIdentNodes = [
+	'loader',
+	'component',
+	'pendingComponent',
+	'errorComponent',
+	'notFoundComponent',
+];
+var defaultCodeSplitGroupings = [['component'], ['errorComponent'], ['notFoundComponent']];
+//#endregion
+export { defaultCodeSplitGroupings, splitRouteIdentNodes, tsrShared, tsrSplit };

package/src/internal/router-plugin/core/framework-plugin-order.d.ts

@@ -0,0 +1,8 @@
+import { Config } from './config.js';
+export declare function validateFrameworkPluginOrder(opts: {
+	framework: Config['target'];
+	plugins: ReadonlyArray<{
+		name: string;
+	}>;
+	routerPluginName: string;
+}): void;

package/src/internal/router-plugin/core/framework-plugin-order.js

@@ -0,0 +1,78 @@
+//#region src/core/framework-plugin-order.ts
+/**
+ * Framework source transformation plugins and their required ordering relative
+ * to route analysis.
+ */
+var TRANSFORMATION_PLUGINS_BY_FRAMEWORK = {
+	react: [
+		{
+			pluginNames: ['vite:react-babel', 'vite:react-refresh'],
+			pkg: '@vitejs/plugin-react',
+			usage: 'react()',
+			order: 'after-router',
+		},
+		{
+			pluginNames: ['vite:react-swc', 'vite:react-swc:resolve-runtime'],
+			pkg: '@vitejs/plugin-react-swc',
+			usage: 'reactSwc()',
+			order: 'after-router',
+		},
+		{
+			pluginNames: ['vite:react-oxc:config', 'vite:react-oxc:refresh-runtime'],
+			pkg: '@vitejs/plugin-react-oxc',
+			usage: 'reactOxc()',
+			order: 'after-router',
+		},
+	],
+	solid: [
+		{
+			pluginNames: ['solid'],
+			pkg: 'vite-plugin-solid',
+			usage: 'solid()',
+			order: 'after-router',
+		},
+	],
+	octane: [
+		{
+			pluginNames: ['octane'],
+			pkg: 'octane/compiler/vite',
+			usage: 'octane()',
+			order: 'before-router',
+			required: true,
+		},
+	],
+};
+function validateFrameworkPluginOrder(opts) {
+	const routerPluginIndex = opts.plugins.findIndex(
+		(plugin) => plugin.name === opts.routerPluginName,
+	);
+	if (routerPluginIndex === -1) return;
+	const frameworkPlugins = TRANSFORMATION_PLUGINS_BY_FRAMEWORK[opts.framework];
+	if (!frameworkPlugins) return;
+	for (const transformPlugin of frameworkPlugins) {
+		const transformPluginIndex = opts.plugins.findIndex((plugin) =>
+			transformPlugin.pluginNames.includes(plugin.name),
+		);
+		if (transformPluginIndex === -1) {
+			if (transformPlugin.required)
+				throw new Error(
+					`Plugin setup error: '${transformPlugin.pkg}' is required for the '${opts.framework}' target.\n\nPlease update your Vite config:\n\n  plugins: [\n    ${transformPlugin.usage},\n    tanstackRouter(),\n  ]\n`,
+				);
+			continue;
+		}
+		const shouldComeBeforeRouter = transformPlugin.order === 'before-router';
+		if (
+			!(shouldComeBeforeRouter
+				? transformPluginIndex > routerPluginIndex
+				: transformPluginIndex < routerPluginIndex)
+		)
+			continue;
+		const firstPlugin = shouldComeBeforeRouter ? transformPlugin.usage : 'tanstackRouter()';
+		const secondPlugin = shouldComeBeforeRouter ? 'tanstackRouter()' : transformPlugin.usage;
+		throw new Error(
+			`Plugin order error: '${transformPlugin.pkg}' is placed ${shouldComeBeforeRouter ? 'after' : 'before'} the TanStack Router integration.\n\n${shouldComeBeforeRouter ? 'This framework compiler must lower its source syntax before TanStack Router analyzes route modules.' : 'The TanStack Router integration must analyze route modules before JSX transformation plugins.'}\n\nPlease update your Vite config:\n\n  plugins: [\n    ${firstPlugin},\n    ${secondPlugin},\n  ]\n`,
+		);
+	}
+}
+//#endregion
+export { validateFrameworkPluginOrder };

package/src/internal/router-plugin/core/hmr/handle-route-update.d.ts

@@ -0,0 +1 @@
+export declare function getHandleRouteUpdateCode(stableRouteOptionKeys: Array<string>): string;

package/src/internal/router-plugin/core/hmr/handle-route-update.js

@@ -0,0 +1,126 @@
+//#region src/core/hmr/handle-route-update.ts
+function handleRouteUpdate(routeId, newRoute, shouldApplyRouteUpdate = true) {
+	const router = window.__TSR_ROUTER__;
+	const oldRoute = router.routesById[routeId];
+	if (!oldRoute) return;
+	if (!shouldApplyRouteUpdate) {
+		syncHotRouteExport(oldRoute);
+		return;
+	}
+	const generatedRouteOptionKeys = new Set(['id', 'path', 'getParentRoute']);
+	const generatedRouteOptions = {};
+	generatedRouteOptionKeys.forEach((key) => {
+		if (key in oldRoute.options) generatedRouteOptions[key] = oldRoute.options[key];
+	});
+	const removedKeys = /* @__PURE__ */ new Set();
+	Object.keys(oldRoute.options).forEach((key) => {
+		if (!generatedRouteOptionKeys.has(key) && !(key in newRoute.options)) {
+			removedKeys.add(key);
+			delete oldRoute.options[key];
+		}
+	});
+	const preserveComponentIdentity =
+		'shellComponent' in oldRoute.options === 'shellComponent' in newRoute.options;
+	const componentKeys = '__TSR_COMPONENT_TYPES__';
+	if (preserveComponentIdentity)
+		componentKeys.forEach((key) => {
+			if (key in oldRoute.options && key in newRoute.options)
+				newRoute.options[key] = oldRoute.options[key];
+		});
+	const nextOptions = {
+		...newRoute.options,
+		...generatedRouteOptions,
+	};
+	oldRoute.options = nextOptions;
+	oldRoute.update(nextOptions);
+	oldRoute._componentsPromise = void 0;
+	oldRoute._lazyPromise = void 0;
+	router.setRoutes(router.buildRouteTree());
+	syncHotRouteExport(oldRoute);
+	router.resolvePathCache.clear();
+	const filter = (m) => m.routeId === oldRoute.id;
+	const activeMatch = router.stores.matches.get().find(filter);
+	const pendingMatch = router.stores.pendingMatches.get().find(filter);
+	const cachedMatches = router.stores.cachedMatches.get().filter(filter);
+	if (activeMatch || pendingMatch || cachedMatches.length > 0) {
+		if (removedKeys.has('loader') || removedKeys.has('beforeLoad')) {
+			const matchIds = [
+				activeMatch?.id,
+				pendingMatch?.id,
+				...cachedMatches.map((match) => match.id),
+			].filter(Boolean);
+			router.batch(() => {
+				for (const matchId of matchIds) {
+					const store =
+						router.stores.pendingMatchStores.get(matchId) ||
+						router.stores.matchStores.get(matchId) ||
+						router.stores.cachedMatchStores.get(matchId);
+					if (store)
+						store.set((prev) => {
+							const next = { ...prev };
+							if (removedKeys.has('loader')) next.loaderData = void 0;
+							if (removedKeys.has('beforeLoad')) {
+								next.__beforeLoadContext = void 0;
+								next.context = rebuildMatchContextWithoutBeforeLoad(next);
+							}
+							return next;
+						});
+				}
+			});
+		}
+		router.invalidate({
+			filter,
+			sync: true,
+		});
+	}
+	function syncHotRouteExport(liveRoute) {
+		newRoute.options = liveRoute.options;
+		newRoute.parentRoute = liveRoute.parentRoute;
+		newRoute._path = liveRoute._path;
+		newRoute._id = liveRoute._id;
+		newRoute._fullPath = liveRoute._fullPath;
+		newRoute._to = liveRoute._to;
+	}
+	function getStoreMatch(matchId) {
+		return (
+			router.stores.pendingMatchStores.get(matchId)?.get() ||
+			router.stores.matchStores.get(matchId)?.get() ||
+			router.stores.cachedMatchStores.get(matchId)?.get()
+		);
+	}
+	function getMatchList(matchId) {
+		const pendingMatches = router.stores.pendingMatches.get();
+		if (pendingMatches.some((match) => match.id === matchId)) return pendingMatches;
+		const activeMatches = router.stores.matches.get();
+		if (activeMatches.some((match) => match.id === matchId)) return activeMatches;
+		const cachedMatches = router.stores.cachedMatches.get();
+		if (cachedMatches.some((match) => match.id === matchId)) return cachedMatches;
+		return [];
+	}
+	function getParentMatch(match) {
+		const matchList = getMatchList(match.id);
+		const matchIndex = matchList.findIndex((item) => item.id === match.id);
+		if (matchIndex <= 0) return;
+		const parentMatch = matchList[matchIndex - 1];
+		return getStoreMatch(parentMatch.id) || parentMatch;
+	}
+	function rebuildMatchContextWithoutBeforeLoad(match) {
+		const parentMatch = getParentMatch(match);
+		const getParentContext = router.getParentContext;
+		return {
+			...((getParentContext
+				? getParentContext.call(router, parentMatch)
+				: (parentMatch?.context ?? router.options.context)) ?? {}),
+			...(match.__routeContext ?? {}),
+		};
+	}
+}
+var handleRouteUpdateStr = handleRouteUpdate.toString();
+function getHandleRouteUpdateCode(stableRouteOptionKeys) {
+	return handleRouteUpdateStr.replace(
+		/['"]__TSR_COMPONENT_TYPES__['"]/,
+		JSON.stringify(stableRouteOptionKeys),
+	);
+}
+//#endregion
+export { getHandleRouteUpdateCode };

package/src/internal/router-plugin/core/hmr/index.d.ts

@@ -0,0 +1,5 @@
+export { createRouteHmrStatement } from './select-adapter.js';
+export type { CreateRouteHmrStatementOpts } from './select-adapter.js';
+export { createViteHmrStatement } from './vite-adapter.js';
+export { createWebpackHmrStatement } from './webpack-adapter.js';
+export { getHandleRouteUpdateCode } from './handle-route-update.js';

package/src/internal/router-plugin/core/hmr/select-adapter.d.ts

@@ -0,0 +1,17 @@
+import { Config, HmrStyle } from '../config.js';
+import type * as t from '@babel/types';
+export type CreateRouteHmrStatementOpts = {
+	hmrStyle: HmrStyle;
+	targetFramework: Config['target'];
+	routeId?: string;
+	routeSignature?: string;
+};
+/**
+ * Dispatches to the configured HMR adapter. `hmrStyle` is set explicitly by
+ * the bundler-specific plugin entry (e.g. `rspack.ts` → `'webpack'`), so there
+ * is no runtime inference based on config string shapes.
+ */
+export declare function createRouteHmrStatement(
+	stableRouteOptionKeys: Array<string>,
+	opts: CreateRouteHmrStatementOpts,
+): Array<t.Statement>;

package/src/internal/router-plugin/core/hmr/select-adapter.js

@@ -0,0 +1,24 @@
+import { createViteHmrStatement } from './vite-adapter.js';
+import { createWebpackHmrStatement } from './webpack-adapter.js';
+//#region src/core/hmr/select-adapter.ts
+/**
+ * Dispatches to the configured HMR adapter. `hmrStyle` is set explicitly by
+ * the bundler-specific plugin entry (e.g. `rspack.ts` → `'webpack'`), so there
+ * is no runtime inference based on config string shapes.
+ */
+function createRouteHmrStatement(stableRouteOptionKeys, opts) {
+	const routeId = opts.routeId === '/__root' ? '__root__' : opts.routeId;
+	if (opts.hmrStyle === 'webpack')
+		return createWebpackHmrStatement(stableRouteOptionKeys, {
+			targetFramework: opts.targetFramework,
+			routeId,
+			routeSignature: opts.routeSignature,
+		});
+	return createViteHmrStatement(stableRouteOptionKeys, {
+		targetFramework: opts.targetFramework,
+		routeId,
+		routeSignature: opts.routeSignature,
+	});
+}
+//#endregion
+export { createRouteHmrStatement };

package/src/internal/router-plugin/core/hmr/vite-adapter.d.ts

@@ -0,0 +1,18 @@
+import { Config } from '../config.js';
+import type * as t from '@babel/types';
+/**
+ * Emits HMR accept code for Vite / native ESM HMR: `import.meta.hot.accept`
+ * with a callback that receives the freshly re-imported module.
+ *
+ * Framework-specific component runtimes still own component body patching.
+ * The route signature only suppresses a redundant data invalidation when an
+ * Octane update changed extracted component code but not the route definition.
+ */
+export declare function createViteHmrStatement(
+	stableRouteOptionKeys: Array<string>,
+	opts: {
+		targetFramework: Config['target'];
+		routeId?: string;
+		routeSignature?: string;
+	},
+): Array<t.Statement>;