@octanejs/tanstack-start 0.1.0

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

@@ -0,0 +1,17 @@
+import {
+	parseStartConfig as parseStartConfig$1,
+	tanstackStartOptionsObjectSchema,
+} from '../schema.js';
+import { z } from 'zod';
+//#region src/vite/schema.ts
+var tanstackStartViteOptionsSchema = tanstackStartOptionsObjectSchema
+	.extend({ vite: z.object({ installDevServerMiddleware: z.boolean().optional() }).optional() })
+	.optional()
+	.prefault({});
+function parseStartConfig(opts, corePluginOpts, root) {
+	tanstackStartViteOptionsSchema.parse(opts);
+	const { vite: _vite, ...coreOptions } = opts ?? {};
+	return parseStartConfig$1(coreOptions, corePluginOpts, root);
+}
+//#endregion
+export { parseStartConfig };

package/src/internal/start-plugin-core/vite/serialization-adapters-plugin.d.ts

@@ -0,0 +1,5 @@
+import { SerializationAdapterConfig } from '../types.js';
+import { PluginOption } from 'vite';
+export declare function serializationAdaptersPlugin(opts: {
+	adapters: Array<SerializationAdapterConfig> | undefined;
+}): PluginOption;

package/src/internal/start-plugin-core/vite/serialization-adapters-plugin.js

@@ -0,0 +1,63 @@
+import { START_ENVIRONMENT_NAMES } from '../constants.js';
+import { createIdFilter } from '../utils.js';
+import { generateSerializationAdaptersModule } from '../serialization-adapters-module.js';
+import { VIRTUAL_MODULES } from '@tanstack/start-server-core';
+//#region src/vite/serialization-adapters-plugin.ts
+var CLIENT_MODULE_ID = 'virtual:tanstack-start-plugin-adapters/client';
+var SERVER_MODULE_ID = 'virtual:tanstack-start-plugin-adapters/server';
+var BUILD_CLIENT_MODULE_ID = `\0${CLIENT_MODULE_ID}`;
+var BUILD_SERVER_MODULE_ID = `\0${SERVER_MODULE_ID}`;
+var MODULE_IDS = [
+	CLIENT_MODULE_ID,
+	SERVER_MODULE_ID,
+	BUILD_CLIENT_MODULE_ID,
+	BUILD_SERVER_MODULE_ID,
+];
+var moduleIdFilter = createIdFilter(MODULE_IDS);
+var resolveIdFilter = createIdFilter([VIRTUAL_MODULES.pluginAdapters, ...MODULE_IDS]);
+function serializationAdaptersPlugin(opts) {
+	return {
+		name: 'tanstack-start:plugin-adapters',
+		enforce: 'pre',
+		resolveId: {
+			filter: { id: resolveIdFilter },
+			handler(id) {
+				if (getRuntime(id)) return id;
+				if (id !== VIRTUAL_MODULES.pluginAdapters) return;
+				return getModuleId(
+					this.environment.name === START_ENVIRONMENT_NAMES.client ? 'client' : 'server',
+					this.environment.config.command,
+				);
+			},
+		},
+		load: {
+			filter: { id: moduleIdFilter },
+			handler(id) {
+				const runtime = getRuntime(id);
+				if (!runtime) return;
+				return generateSerializationAdaptersModule({
+					adapters: opts.adapters,
+					runtime,
+				});
+			},
+		},
+	};
+}
+function getModuleId(runtime, command) {
+	if (runtime === 'client') return command === 'serve' ? CLIENT_MODULE_ID : BUILD_CLIENT_MODULE_ID;
+	return command === 'serve' ? SERVER_MODULE_ID : BUILD_SERVER_MODULE_ID;
+}
+function getRuntime(id) {
+	switch (id) {
+		case CLIENT_MODULE_ID:
+		case BUILD_CLIENT_MODULE_ID:
+			return 'client';
+		case SERVER_MODULE_ID:
+		case BUILD_SERVER_MODULE_ID:
+			return 'server';
+		default:
+			return;
+	}
+}
+//#endregion
+export { serializationAdaptersPlugin };

package/src/internal/start-plugin-core/vite/start-compiler-plugin/hot-update.d.ts

@@ -0,0 +1,5 @@
+import { EnvironmentModuleNode } from 'vite';
+export declare function mergeHotUpdateModules(
+	currentModules: Array<EnvironmentModuleNode>,
+	additionalModules: Array<EnvironmentModuleNode>,
+): Array<EnvironmentModuleNode> | undefined;

package/src/internal/start-plugin-core/vite/start-compiler-plugin/hot-update.js

@@ -0,0 +1,14 @@
+//#region src/vite/start-compiler-plugin/hot-update.ts
+function mergeHotUpdateModules(currentModules, additionalModules) {
+	if (additionalModules.length === 0) return;
+	const mergedModules = currentModules.slice();
+	const seenModules = new Set(currentModules);
+	for (const mod of additionalModules) {
+		if (seenModules.has(mod)) continue;
+		seenModules.add(mod);
+		mergedModules.push(mod);
+	}
+	return mergedModules;
+}
+//#endregion
+export { mergeHotUpdateModules };

package/src/internal/start-plugin-core/vite/start-compiler-plugin/module-specifier.d.ts

@@ -0,0 +1,5 @@
+import { DevServerFnModuleSpecifierEncoder } from '../../start-compiler/types.js';
+export declare function createViteDevServerFnModuleSpecifierEncoder(
+	root: string,
+): DevServerFnModuleSpecifierEncoder;
+export declare function decodeViteDevServerModuleSpecifier(moduleSpecifier: string): string;

package/src/internal/start-plugin-core/vite/start-compiler-plugin/module-specifier.js

@@ -0,0 +1,25 @@
+//#region src/vite/start-compiler-plugin/module-specifier.ts
+function createViteDevServerFnModuleSpecifierEncoder(root) {
+	const normalizedRoot = root.replace(/\\/g, '/');
+	const rootWithTrailingSlash = normalizedRoot.endsWith('/')
+		? normalizedRoot
+		: `${normalizedRoot}/`;
+	return ({ extractedFilename }) => {
+		const normalizedFile = extractedFilename.replace(/\\/g, '/');
+		if (normalizedFile.startsWith(rootWithTrailingSlash))
+			return `/${normalizedFile.slice(rootWithTrailingSlash.length)}`;
+		return normalizedFile.startsWith('/') ? `/@fs${normalizedFile}` : `/@fs/${normalizedFile}`;
+	};
+}
+function decodeViteDevServerModuleSpecifier(moduleSpecifier) {
+	let sourceFile = moduleSpecifier;
+	if (sourceFile.startsWith('/@id/')) sourceFile = sourceFile.slice(5);
+	else if (sourceFile.startsWith('/@fs/')) {
+		sourceFile = sourceFile.slice(4);
+		sourceFile = sourceFile.replace(/^\/([A-Za-z]:\/)/, '$1');
+	} else if (sourceFile.startsWith('/')) sourceFile = sourceFile.slice(1);
+	const queryIndex = sourceFile.indexOf('?');
+	return queryIndex === -1 ? sourceFile : sourceFile.slice(0, queryIndex);
+}
+//#endregion
+export { createViteDevServerFnModuleSpecifierEncoder, decodeViteDevServerModuleSpecifier };

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

@@ -0,0 +1,29 @@
+import { SERVER_FN_LOOKUP } from '../../constants.js';
+import {
+	CompileStartFrameworkOptions,
+	StartCompilerImportTransform,
+	StartCompilerPlugin,
+} from '../../types.js';
+import { GenerateFunctionIdFnOptional } from '../../start-compiler/types.js';
+import { PluginOption } from 'vite';
+export { SERVER_FN_LOOKUP };
+export interface StartCompilerPluginOptions {
+	framework: CompileStartFrameworkOptions;
+	environments: Array<{
+		name: string;
+		type: 'client' | 'server';
+		getServerFnById?: string;
+	}>;
+	/**
+	 * Custom function ID generator (optional).
+	 */
+	generateFunctionId?: GenerateFunctionIdFnOptional;
+	compilerTransforms?: Array<StartCompilerImportTransform> | undefined;
+	compilerPlugins?: Array<StartCompilerPlugin> | undefined;
+	serverFnProviderModuleDirectives?: ReadonlyArray<string> | undefined;
+	/**
+	 * The Vite environment name for the server function provider.
+	 */
+	providerEnvName: string;
+}
+export declare function startCompilerPlugin(opts: StartCompilerPluginOptions): PluginOption;

package/src/internal/start-plugin-core/vite/start-compiler-plugin/plugin.js

@@ -0,0 +1,380 @@
+import { SERVER_FN_LOOKUP, TRANSFORM_ID_REGEX, VITE_ENVIRONMENT_NAMES } from '../../constants.js';
+import { resolveViteId } from '../../utils.js';
+import { createVirtualModule } from '../createVirtualModule.js';
+import { cleanId } from '../../start-compiler/utils.js';
+import { detectKindsInCode } from '../../start-compiler/compiler.js';
+import { getTransformCodeFilterForEnv } from '../../start-compiler/config.js';
+import {
+	createCompilerVirtualModuleIdPattern,
+	createStartCompiler,
+	loadCompilerVirtualModule,
+	mergeServerFnsById,
+} from '../../start-compiler/host.js';
+import { generateServerFnResolverModule } from '../../start-compiler/server-fn-resolver-module.js';
+import {
+	MissingHydrateSourceError,
+	createHydrateCompilerPlugin,
+} from '../../hydrate-when-transform.js';
+import {
+	createViteDevServerFnModuleSpecifierEncoder,
+	decodeViteDevServerModuleSpecifier,
+} from './module-specifier.js';
+import { mergeHotUpdateModules } from './hot-update.js';
+import { resolve } from 'pathe';
+import { VIRTUAL_MODULES } from '@tanstack/start-server-core';
+//#region src/vite/start-compiler-plugin/plugin.ts
+var validateServerFnIdVirtualModule = `virtual:tanstack-start-validate-server-fn-id`;
+var TSS_SERVERFN_SPLIT_PARAM = 'tss-serverfn-split';
+async function loadViteModuleFromEnvironment(environment, id, opts) {
+	if (environment.mode === 'build') return (await opts.load({ id }))?.code ?? '';
+	if (environment.mode === 'dev') {
+		await environment.transformRequest(opts.devId ?? id);
+		return;
+	}
+	opts.error(`could not load module ${id}: unknown environment mode ${environment.mode}`);
+}
+function invalidateMatchingFileModules(environment, ids, shouldInvalidate) {
+	const seen = /* @__PURE__ */ new Set();
+	const invalidatedModules = [];
+	for (const id of ids) {
+		const fileModules = environment.moduleGraph.getModulesByFile(cleanId(id));
+		if (!fileModules) continue;
+		for (const fileModule of fileModules) {
+			if (!shouldInvalidate(fileModule)) continue;
+			environment.moduleGraph.invalidateModule(fileModule, seen);
+			invalidatedModules.push(fileModule);
+		}
+	}
+	return invalidatedModules;
+}
+function invalidateServerFnProviderModules(environment, ids) {
+	return invalidateMatchingFileModules(
+		environment,
+		ids,
+		(fileModule) => fileModule.id?.includes(TSS_SERVERFN_SPLIT_PARAM) ?? false,
+	);
+}
+function invalidateServerFnLookupModules(environment, ids) {
+	invalidateMatchingFileModules(
+		environment,
+		ids,
+		(fileModule) => fileModule.id?.includes('server-fn-module-lookup') ?? false,
+	);
+}
+function invalidateCompilerVirtualModules(environment, ids, pattern) {
+	if (!pattern) return [];
+	return invalidateMatchingFileModules(environment, ids, (fileModule) => {
+		if (!fileModule.id) return false;
+		pattern.lastIndex = 0;
+		return pattern.test(fileModule.id);
+	});
+}
+function getServerFnProviderIds(ids) {
+	const providerIds = /* @__PURE__ */ new Set();
+	for (const id of ids) {
+		const cleanedId = cleanId(id);
+		providerIds.add(`${cleanedId}?${TSS_SERVERFN_SPLIT_PARAM}`);
+	}
+	return providerIds;
+}
+function invalidateModuleNodes(environment, modules) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const mod of modules) environment.moduleGraph.invalidateModule(mod, seen);
+}
+function getDevServerFnValidatorModule() {
+	return `
+export async function getServerFnById(id, _access) {
+  const validateIdImport = ${JSON.stringify(validateServerFnIdVirtualModule)} + '?id=' + id
+  await import(/* @vite-ignore */ '/@id/__x00__' + validateIdImport)
+  const decoded = Buffer.from(id, 'base64url').toString('utf8')
+  const devServerFn = JSON.parse(decoded)
+  const mod = await import(/* @vite-ignore */ devServerFn.file)
+  return mod[devServerFn.export]
+}
+`;
+}
+function parseIdQuery(id) {
+	if (!id.includes('?'))
+		return {
+			filename: id,
+			query: {},
+		};
+	const [filename, rawQuery] = id.split(`?`, 2);
+	return {
+		filename,
+		query: Object.fromEntries(new URLSearchParams(rawQuery)),
+	};
+}
+function startCompilerPlugin(opts) {
+	const compilers = /* @__PURE__ */ new Map();
+	const compilerPlugins = [createHydrateCompilerPlugin(), ...(opts.compilerPlugins ?? [])];
+	const compilerVirtualModuleIdPattern = createCompilerVirtualModuleIdPattern(compilerPlugins);
+	const environmentByName = new Map(
+		opts.environments.map((environment) => [environment.name, environment]),
+	);
+	const serverFnsById = {};
+	const onServerFnsById = (d) => {
+		mergeServerFnsById(serverFnsById, d);
+	};
+	let root = process.cwd();
+	let bundledDev = false;
+	const ssrEnvName = VITE_ENVIRONMENT_NAMES.server;
+	const ssrIsProvider = opts.providerEnvName === ssrEnvName;
+	const appliedResolverEnvironments = new Set(
+		ssrIsProvider ? [opts.providerEnvName] : [ssrEnvName, opts.providerEnvName],
+	);
+	function perEnvServerFnPlugin(environment) {
+		const compilerTransforms =
+			environment.name === opts.providerEnvName ? opts.compilerTransforms : void 0;
+		const serverFnProviderModuleDirectives =
+			environment.name === opts.providerEnvName ? opts.serverFnProviderModuleDirectives : void 0;
+		const transformCodeFilter = getTransformCodeFilterForEnv(environment.type, {
+			compilerTransforms,
+			compilerPlugins,
+		});
+		return {
+			name: `tanstack-start-core::server-fn:${environment.name}`,
+			enforce: 'pre',
+			applyToEnvironment(env) {
+				return env.name === environment.name;
+			},
+			configResolved(config) {
+				root = config.root;
+				bundledDev = !!config.experimental.bundledDev;
+			},
+			buildStart() {
+				if (
+					this.environment.mode === 'build' ||
+					(bundledDev && this.environment.name === VITE_ENVIRONMENT_NAMES.client)
+				)
+					compilers.delete(this.environment.name);
+			},
+			watchChange(id) {
+				if (bundledDev && this.environment.mode === 'dev')
+					compilers.get(this.environment.name)?.invalidateModule(id);
+			},
+			transform: {
+				filter: {
+					id: {
+						exclude: new RegExp(`${SERVER_FN_LOOKUP}$`),
+						include: TRANSFORM_ID_REGEX,
+					},
+					code: { include: transformCodeFilter },
+				},
+				async handler(code, id) {
+					let compiler = compilers.get(this.environment.name);
+					if (!compiler) {
+						const mode = this.environment.mode === 'build' ? 'build' : 'dev';
+						compiler = createStartCompiler({
+							env: environment.type,
+							envName: environment.name,
+							root,
+							mode,
+							framework: opts.framework,
+							providerEnvName: opts.providerEnvName,
+							generateFunctionId: opts.generateFunctionId,
+							compilerTransforms,
+							compilerPlugins,
+							serverFnProviderModuleDirectives,
+							onServerFnsById,
+							getKnownServerFns: () => serverFnsById,
+							encodeModuleSpecifierInDev:
+								mode === 'dev' ? createViteDevServerFnModuleSpecifierEncoder(root) : void 0,
+							loadModule: async (id) => {
+								const code = await loadViteModuleFromEnvironment(this.environment, id, {
+									load: (options) => this.load(options),
+									error: (message) => this.error(message),
+									devId: `${id}?${SERVER_FN_LOOKUP}`,
+								});
+								if (code !== void 0)
+									compiler.ingestModule({
+										code,
+										id,
+									});
+							},
+							resolveId: async (source, importer) => {
+								const r = await this.resolve(source, importer);
+								if (r) {
+									if (!r.external) return cleanId(r.id);
+								}
+								return null;
+							},
+						});
+						compilers.set(this.environment.name, compiler);
+					}
+					const detectedKinds = detectKindsInCode(code, environment.type, { compilerTransforms });
+					return await compiler.compile({
+						id,
+						code,
+						detectedKinds,
+						warn: (message) => this.warn(message),
+					});
+				},
+			},
+			hotUpdate(ctx) {
+				const compiler = compilers.get(this.environment.name);
+				const idsToInvalidate = /* @__PURE__ */ new Set();
+				const transitiveCompilerImportersToInvalidate = /* @__PURE__ */ new Set();
+				const importerModulesToInvalidate = /* @__PURE__ */ new Set();
+				const changedIds = [];
+				ctx.modules.forEach((m) => {
+					if (m.id) {
+						idsToInvalidate.add(m.id);
+						changedIds.push(m.id);
+					}
+				});
+				const deletedIds = compiler?.invalidateModules(changedIds) ?? /* @__PURE__ */ new Set();
+				ctx.modules.forEach((m) => {
+					if (m.id) {
+						if (deletedIds.has(cleanId(m.id))) {
+							transitiveCompilerImportersToInvalidate.add(cleanId(m.id));
+							m.importers.forEach((importer) => {
+								if (importer.id) {
+									idsToInvalidate.add(importer.id);
+									importerModulesToInvalidate.add(importer);
+									transitiveCompilerImportersToInvalidate.add(cleanId(importer.id));
+								}
+							});
+						}
+					}
+				});
+				const finishHotUpdate = async () => {
+					if (
+						environment.type === 'server' &&
+						compiler &&
+						transitiveCompilerImportersToInvalidate.size > 0
+					) {
+						const seenImporters = new Set(transitiveCompilerImportersToInvalidate);
+						const nestedImporters = await compiler.getTransitiveImporters(seenImporters);
+						for (const nestedImporterId of nestedImporters) seenImporters.add(nestedImporterId);
+						for (const importerId of seenImporters) idsToInvalidate.add(importerId);
+						compiler.invalidateModules(seenImporters);
+					}
+					invalidateModuleNodes(this.environment, importerModulesToInvalidate);
+					invalidateServerFnLookupModules(this.environment, idsToInvalidate);
+					const compilerVirtualModules = invalidateCompilerVirtualModules(
+						this.environment,
+						idsToInvalidate,
+						compilerVirtualModuleIdPattern,
+					);
+					if (environment.type !== 'server')
+						return mergeHotUpdateModules(ctx.modules, compilerVirtualModules);
+					invalidateModuleNodes(this.environment, ctx.modules);
+					const providerIdsToInvalidate = getServerFnProviderIds(idsToInvalidate);
+					compiler?.invalidateModules(providerIdsToInvalidate);
+					const providerModules = invalidateServerFnProviderModules(this.environment, [
+						...idsToInvalidate,
+						...providerIdsToInvalidate,
+					]);
+					return mergeHotUpdateModules(ctx.modules, [
+						...compilerVirtualModules,
+						...providerModules,
+					]);
+				};
+				return finishHotUpdate();
+			},
+		};
+	}
+	return [
+		...opts.environments.map(perEnvServerFnPlugin),
+		{
+			name: 'tanstack-start-core:capture-server-fn-module-lookup',
+			apply: 'serve',
+			applyToEnvironment(env) {
+				return !!opts.environments.find((e) => e.name === env.name);
+			},
+			transform: {
+				filter: { id: new RegExp(`${SERVER_FN_LOOKUP}$`) },
+				handler(code, id) {
+					compilers.get(this.environment.name)?.ingestModule({
+						code,
+						id: cleanId(id),
+					});
+				},
+			},
+		},
+		{
+			name: 'tanstack-start-core:compiler-virtual-module',
+			enforce: 'pre',
+			load: {
+				filter: { id: compilerVirtualModuleIdPattern ?? /$^/ },
+				async handler(id) {
+					const environment = environmentByName.get(this.environment.name);
+					if (!environment || !compilerVirtualModuleIdPattern) return null;
+					const loadVirtualModule = () =>
+						loadCompilerVirtualModule(compilerPlugins, {
+							id,
+							root,
+							env: environment.type,
+							envName: this.environment.name,
+						});
+					try {
+						return loadVirtualModule();
+					} catch (error) {
+						if (!(error instanceof MissingHydrateSourceError)) throw error;
+					}
+					const sourceId = cleanId(id);
+					await loadViteModuleFromEnvironment(this.environment, sourceId, {
+						load: (options) => this.load(options),
+						error: (message) => this.error(message),
+					});
+					return loadVirtualModule();
+				},
+			},
+		},
+		{
+			name: 'tanstack-start-core:validate-server-fn-id',
+			apply: 'serve',
+			load: {
+				filter: { id: new RegExp(resolveViteId(validateServerFnIdVirtualModule)) },
+				async handler(id) {
+					const fnId = parseIdQuery(id).query.id;
+					if (fnId && serverFnsById[fnId]) return `export {}`;
+					if (fnId)
+						try {
+							const decoded = JSON.parse(Buffer.from(fnId, 'base64url').toString('utf8'));
+							if (typeof decoded.file === 'string' && typeof decoded.export === 'string') {
+								const sourceFile = decodeViteDevServerModuleSpecifier(decoded.file);
+								if (sourceFile) {
+									const absPath = resolve(root, sourceFile);
+									if (this.environment.mode !== 'dev')
+										this.error(
+											`could not validate server function ID ${fnId}: unknown environment mode ${this.environment.mode}`,
+										);
+									await this.environment.transformRequest(`${absPath}?${SERVER_FN_LOOKUP}`);
+									if (serverFnsById[fnId]) return `export {}`;
+								}
+							}
+						} catch {}
+					this.error(`Invalid server function ID: ${fnId}`);
+				},
+			},
+		},
+		createVirtualModule({
+			name: 'tanstack-start-core:server-fn-resolver',
+			moduleId: VIRTUAL_MODULES.serverFnResolver,
+			enforce: 'pre',
+			applyToEnvironment: (env) => {
+				return appliedResolverEnvironments.has(env.name);
+			},
+			load() {
+				if (this.environment.name !== opts.providerEnvName) {
+					const mod = opts.environments.find(
+						(e) => e.name === this.environment.name,
+					)?.getServerFnById;
+					if (mod) return mod;
+					this.error(
+						`No getServerFnById implementation found for caller environment: ${this.environment.name}`,
+					);
+				}
+				if (this.environment.mode !== 'build') return getDevServerFnValidatorModule();
+				return generateServerFnResolverModule({
+					serverFnsById,
+					includeClientReferencedCheck: !ssrIsProvider,
+				});
+			},
+		}),
+	];
+}
+//#endregion
+export { startCompilerPlugin };

package/src/internal/start-plugin-core/vite/start-manifest-plugin/normalized-client-build.d.ts

@@ -0,0 +1,11 @@
+import { Rollup } from 'vite';
+import { NormalizedClientBuild, NormalizedClientChunk } from '../../types.js';
+export declare function normalizeViteClientChunk(chunk: Rollup.OutputChunk): NormalizedClientChunk;
+export declare function normalizeViteClientChunks(
+	clientBundle: Rollup.OutputBundle,
+): ReadonlyMap<string, NormalizedClientChunk>;
+export declare function normalizeViteClientBuild(
+	clientBundle: Rollup.OutputBundle,
+): NormalizedClientBuild;
+export declare function getRouteFilePathsFromModuleIds(moduleIds: Array<string>): string[];
+export declare function getHydrationIdsFromModuleIds(moduleIds: Array<string>): string[];

package/src/internal/start-plugin-core/vite/start-manifest-plugin/normalized-client-build.js

@@ -0,0 +1,114 @@
+import { tssHydrate } from '../../hydration-constants.js';
+import { getCssAssetSource } from '../../start-manifest-plugin/inlineCss.js';
+import { tsrSplit } from '#tanstack-start/router-plugin';
+//#region src/vite/start-manifest-plugin/normalized-client-build.ts
+function normalizeViteClientChunk(chunk) {
+	return {
+		fileName: chunk.fileName,
+		isEntry: chunk.isEntry,
+		imports: chunk.imports,
+		dynamicImports: chunk.dynamicImports,
+		css: Array.from(chunk.viteMetadata?.importedCss ?? []),
+		routeFilePaths: getRouteFilePathsFromModuleIds(chunk.moduleIds),
+		hydrationIds: getHydrationIdsFromModuleIds(chunk.moduleIds),
+	};
+}
+function normalizeViteClientChunks(clientBundle) {
+	const chunksByFileName = /* @__PURE__ */ new Map();
+	for (const fileName in clientBundle) {
+		const bundleEntry = clientBundle[fileName];
+		if (bundleEntry.type !== 'chunk') continue;
+		const normalizedChunk = normalizeViteClientChunk(bundleEntry);
+		chunksByFileName.set(normalizedChunk.fileName, normalizedChunk);
+	}
+	return chunksByFileName;
+}
+function normalizeViteClientBuild(clientBundle) {
+	let entryChunkFileName;
+	const chunksByFileName = normalizeViteClientChunks(clientBundle);
+	const chunkFileNamesByRouteFilePath = /* @__PURE__ */ new Map();
+	const cssFilesBySourcePath = /* @__PURE__ */ new Map();
+	const cssContentByFileName = /* @__PURE__ */ new Map();
+	for (const chunk of chunksByFileName.values()) {
+		const bundleEntry = clientBundle[chunk.fileName];
+		if (chunk.isEntry) {
+			if (entryChunkFileName)
+				throw new Error(`multiple entries detected: ${entryChunkFileName} ${chunk.fileName}`);
+			entryChunkFileName = chunk.fileName;
+		}
+		for (const routeFilePath of chunk.routeFilePaths) {
+			let chunkFileNames = chunkFileNamesByRouteFilePath.get(routeFilePath);
+			if (chunkFileNames === void 0) {
+				chunkFileNames = [];
+				chunkFileNamesByRouteFilePath.set(routeFilePath, chunkFileNames);
+			}
+			chunkFileNames.push(chunk.fileName);
+		}
+		for (const moduleId of bundleEntry.moduleIds) {
+			const queryIndex = moduleId.indexOf('?');
+			const sourcePath = queryIndex >= 0 ? moduleId.slice(0, queryIndex) : moduleId;
+			if (!sourcePath) continue;
+			const existing = cssFilesBySourcePath.get(sourcePath);
+			cssFilesBySourcePath.set(
+				sourcePath,
+				existing ? Array.from(new Set([...existing, ...chunk.css])) : chunk.css.slice(),
+			);
+		}
+	}
+	for (const fileName in clientBundle) {
+		if (!fileName.endsWith('.css')) continue;
+		const bundleEntry = clientBundle[fileName];
+		if (bundleEntry.type !== 'asset') continue;
+		const css = getCssAssetSource(bundleEntry.source);
+		if (css !== void 0) cssContentByFileName.set(fileName, css);
+	}
+	if (!entryChunkFileName) throw new Error('No entry file found');
+	return {
+		entryChunkFileName,
+		chunksByFileName,
+		chunkFileNamesByRouteFilePath,
+		cssFilesBySourcePath,
+		cssContentByFileName,
+	};
+}
+function getRouteFilePathsFromModuleIds(moduleIds) {
+	let routeFilePaths;
+	let seenRouteFilePaths;
+	for (const moduleId of moduleIds) {
+		const queryIndex = moduleId.indexOf('?');
+		if (queryIndex < 0) continue;
+		const query = moduleId.slice(queryIndex + 1);
+		if (!query.includes(tsrSplit)) continue;
+		if (!new URLSearchParams(query).has(tsrSplit)) continue;
+		const routeFilePath = moduleId.slice(0, queryIndex);
+		if (seenRouteFilePaths?.has(routeFilePath)) continue;
+		if (routeFilePaths === void 0 || seenRouteFilePaths === void 0) {
+			routeFilePaths = [];
+			seenRouteFilePaths = /* @__PURE__ */ new Set();
+		}
+		routeFilePaths.push(routeFilePath);
+		seenRouteFilePaths.add(routeFilePath);
+	}
+	return routeFilePaths ?? [];
+}
+function getHydrationIdsFromModuleIds(moduleIds) {
+	let hydrationIds;
+	let seen;
+	for (const moduleId of moduleIds) {
+		const queryIndex = moduleId.indexOf('?');
+		if (queryIndex < 0) continue;
+		const query = moduleId.slice(queryIndex + 1);
+		if (!query.includes('tss-hydrate')) continue;
+		const hydrationId = new URLSearchParams(query).get(tssHydrate);
+		if (!hydrationId || seen?.has(hydrationId)) continue;
+		if (hydrationIds === void 0 || seen === void 0) {
+			hydrationIds = [];
+			seen = /* @__PURE__ */ new Set();
+		}
+		hydrationIds.push(hydrationId);
+		seen.add(hydrationId);
+	}
+	return hydrationIds ?? [];
+}
+//#endregion
+export { normalizeViteClientBuild };

package/src/internal/start-plugin-core/vite/start-manifest-plugin/plugin.d.ts

@@ -0,0 +1,3 @@
+import { GetConfigFn } from '../../types.js';
+import { PluginOption } from 'vite';
+export declare function startManifestPlugin(opts: { getConfig: GetConfigFn }): PluginOption;