@octanejs/tanstack-start 0.1.0

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

@@ -0,0 +1,20 @@
+import { LookupConfig } from './compiler.js';
+import {
+	CompileStartFrameworkOptions,
+	StartCompilerImportTransform,
+	StartCompilerPlugin,
+} from '../types.js';
+export declare function getTransformCodeFilterForEnv(
+	env: 'client' | 'server',
+	opts?: {
+		compilerTransforms?: Array<StartCompilerImportTransform> | undefined;
+		compilerPlugins?: Array<StartCompilerPlugin> | undefined;
+	},
+): Array<RegExp>;
+export declare function getLookupConfigurationsForEnv(
+	env: 'client' | 'server',
+	framework: CompileStartFrameworkOptions,
+	opts?: {
+		compilerTransforms?: Array<StartCompilerImportTransform> | undefined;
+	},
+): Array<LookupConfig>;

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

@@ -0,0 +1,84 @@
+import {
+	KindDetectionPatterns,
+	getExternalLookupKind,
+	getLookupKindsForEnv,
+	isCompilerTransformEnabledForEnv,
+	isStartCompilerPluginEnabledForEnv,
+} from './compiler.js';
+import { getRouterPackage, getStartPackage } from '#tanstack-start/package-names';
+//#region src/start-compiler/config.ts
+function getTransformCodeFilterForEnv(env, opts) {
+	const validKinds = getLookupKindsForEnv(env, opts);
+	const patterns = [];
+	for (const [kind, pattern] of Object.entries(KindDetectionPatterns))
+		if (validKinds.has(kind)) patterns.push(pattern);
+	for (const transform of opts?.compilerTransforms ?? [])
+		if (isCompilerTransformEnabledForEnv(transform, env)) patterns.push(transform.detect);
+	for (const plugin of opts?.compilerPlugins ?? [])
+		if (plugin.detect && isStartCompilerPluginEnabledForEnv(plugin, env))
+			patterns.push(plugin.detect);
+	return patterns;
+}
+function getLookupConfigurationsForEnv(env, framework, opts) {
+	const commonConfigs = [
+		{
+			libName: getStartPackage(framework),
+			rootExport: 'createServerFn',
+			kind: 'Root',
+		},
+		{
+			libName: getStartPackage(framework),
+			rootExport: 'createIsomorphicFn',
+			kind: 'IsomorphicFn',
+		},
+		{
+			libName: getStartPackage(framework),
+			rootExport: 'createServerOnlyFn',
+			kind: 'ServerOnlyFn',
+		},
+		{
+			libName: getStartPackage(framework),
+			rootExport: 'createClientOnlyFn',
+			kind: 'ClientOnlyFn',
+		},
+	];
+	const externalConfigs = [];
+	for (const transform of opts?.compilerTransforms ?? []) {
+		if (!isCompilerTransformEnabledForEnv(transform, env)) continue;
+		const kind = getExternalLookupKind(transform);
+		for (const imported of transform.imports)
+			externalConfigs.push({
+				libName: imported.libName,
+				rootExport: imported.rootExport,
+				kind,
+			});
+	}
+	if (env === 'client')
+		return [
+			{
+				libName: getStartPackage(framework),
+				rootExport: 'createMiddleware',
+				kind: 'Root',
+			},
+			{
+				libName: getStartPackage(framework),
+				rootExport: 'createStart',
+				kind: 'Root',
+			},
+			...commonConfigs,
+			...externalConfigs,
+		];
+	return [
+		...[
+			...commonConfigs,
+			{
+				libName: getRouterPackage(framework),
+				rootExport: 'ClientOnly',
+				kind: 'ClientOnlyJSX',
+			},
+		],
+		...externalConfigs,
+	];
+}
+//#endregion
+export { getLookupConfigurationsForEnv, getTransformCodeFilterForEnv };

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

@@ -0,0 +1,24 @@
+import type * as t from '@babel/types';
+import type * as babel from '@babel/core';
+/**
+ * Handles <ClientOnly> JSX elements on the server side.
+ *
+ * On the server, the children of <ClientOnly> should be removed since they
+ * are client-only code. Only the fallback prop (if present) will be rendered.
+ *
+ * Transform:
+ *   <ClientOnly fallback={<Loading />}>{clientOnlyContent}</ClientOnly>
+ * Into:
+ *   <ClientOnly fallback={<Loading />} />
+ *
+ * Or if no fallback:
+ *   <ClientOnly>{clientOnlyContent}</ClientOnly>
+ * Into:
+ *   <ClientOnly />
+ */
+export declare function handleClientOnlyJSX(
+	path: babel.NodePath<t.JSXElement>,
+	_opts: {
+		env: 'server';
+	},
+): void;

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

@@ -0,0 +1,25 @@
+//#region src/start-compiler/handleClientOnlyJSX.ts
+/**
+ * Handles <ClientOnly> JSX elements on the server side.
+ *
+ * On the server, the children of <ClientOnly> should be removed since they
+ * are client-only code. Only the fallback prop (if present) will be rendered.
+ *
+ * Transform:
+ *   <ClientOnly fallback={<Loading />}>{clientOnlyContent}</ClientOnly>
+ * Into:
+ *   <ClientOnly fallback={<Loading />} />
+ *
+ * Or if no fallback:
+ *   <ClientOnly>{clientOnlyContent}</ClientOnly>
+ * Into:
+ *   <ClientOnly />
+ */
+function handleClientOnlyJSX(path, _opts) {
+	const element = path.node;
+	element.children = [];
+	element.openingElement.selfClosing = true;
+	element.closingElement = null;
+}
+//#endregion
+export { handleClientOnlyJSX };

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

@@ -0,0 +1,11 @@
+import { CompilationContext, RewriteCandidate } from './types.js';
+/**
+ * Handles createIsomorphicFn transformations for a batch of candidates.
+ *
+ * @param candidates - All IsomorphicFn candidates to process
+ * @param context - The compilation context
+ */
+export declare function handleCreateIsomorphicFn(
+	candidates: Array<RewriteCandidate>,
+	context: CompilationContext,
+): void;

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

@@ -0,0 +1,24 @@
+import * as t from '@babel/types';
+//#region src/start-compiler/handleCreateIsomorphicFn.ts
+/**
+ * Handles createIsomorphicFn transformations for a batch of candidates.
+ *
+ * @param candidates - All IsomorphicFn candidates to process
+ * @param context - The compilation context
+ */
+function handleCreateIsomorphicFn(candidates, context) {
+	for (const candidate of candidates) {
+		const { path, methodChain } = candidate;
+		const envCallInfo = context.env === 'client' ? methodChain.client : methodChain.server;
+		if (!envCallInfo) {
+			path.replaceWith(t.arrowFunctionExpression([], t.blockStatement([])));
+			continue;
+		}
+		const innerFn = envCallInfo.firstArgPath?.node;
+		if (!t.isExpression(innerFn))
+			throw new Error(`createIsomorphicFn().${context.env}(func) must be called with a function!`);
+		path.replaceWith(innerFn);
+	}
+}
+//#endregion
+export { handleCreateIsomorphicFn };

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

@@ -0,0 +1,11 @@
+import { CompilationContext, RewriteCandidate } from './types.js';
+/**
+ * Handles createMiddleware transformations for a batch of candidates.
+ *
+ * @param candidates - All Middleware candidates to process
+ * @param context - The compilation context
+ */
+export declare function handleCreateMiddleware(
+	candidates: Array<RewriteCandidate>,
+	context: CompilationContext,
+): void;

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

@@ -0,0 +1,35 @@
+import { stripMethodCall } from './utils.js';
+//#region src/start-compiler/handleCreateMiddleware.ts
+function warnInputValidatorDeprecation(context, inputValidator) {
+	const loc = inputValidator.callPath.node.loc?.start;
+	const location = loc ? `${context.id}:${loc.line}:${loc.column + 1} ` : `${context.id} `;
+	context.warn?.(
+		`${location}createMiddleware().inputValidator() is deprecated. Use createMiddleware().validator() instead.`,
+	);
+}
+/**
+ * Handles createMiddleware transformations for a batch of candidates.
+ *
+ * @param candidates - All Middleware candidates to process
+ * @param context - The compilation context
+ */
+function handleCreateMiddleware(candidates, context) {
+	if (context.env === 'server')
+		throw new Error('handleCreateMiddleware should not be called on the server');
+	for (const candidate of candidates) {
+		const { validator, inputValidator, server } = candidate.methodChain;
+		if (inputValidator) warnInputValidatorDeprecation(context, inputValidator);
+		for (const [methodName, methodCall] of [
+			['validator', validator],
+			['inputValidator', inputValidator],
+		]) {
+			if (!methodCall) continue;
+			if (!methodCall.callPath.node.arguments[0])
+				throw new Error(`createMiddleware().${methodName}() must be called with a validator!`);
+			stripMethodCall(methodCall.callPath);
+		}
+		if (server) stripMethodCall(server.callPath);
+	}
+}
+//#endregion
+export { handleCreateMiddleware };

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

@@ -0,0 +1,22 @@
+import { CompilationContext, RewriteCandidate } from './types.js';
+/**
+ * Handles createServerFn transformations for a batch of candidates.
+ *
+ * This function performs extraction and replacement of server functions
+ *
+ * For caller files (non-provider):
+ * - Replaces the server function with an RPC stub
+ * - Does not include the handler function body
+ *
+ * For provider files:
+ * - Creates an extractedFn that calls __executeServer
+ * - Modifies .handler() to pass (extractedFn, serverFn) - two arguments
+ *
+ * @param candidates - All ServerFn candidates to process
+ * @param context - The compilation context with helpers and mutable state
+ * @returns Result containing runtime code to add, or null if no candidates processed
+ */
+export declare function handleCreateServerFn(
+	candidates: Array<RewriteCandidate>,
+	context: CompilationContext,
+): void;

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

@@ -0,0 +1,292 @@
+import { cleanId, codeFrameError, stripMethodCall } from './utils.js';
+import { hasKeys } from '@tanstack/router-core';
+import path from 'pathe';
+import * as t from '@babel/types';
+import { getVariableDeclaratorForExpressionPath } from '@tanstack/router-utils';
+import babel from '@babel/core';
+import { getStartPackage } from '#tanstack-start/package-names';
+//#region src/start-compiler/handleCreateServerFn.ts
+var TSS_SERVERFN_SPLIT_PARAM = 'tss-serverfn-split';
+var providerHmrAcceptTemplate = babel.template.statements(
+	`
+if (import.meta.hot) {
+  import.meta.hot.accept(() => {})
+}
+if (import.meta.webpackHot) {
+  import.meta.webpackHot.accept(() => {})
+}
+`,
+	{ placeholderPattern: false },
+);
+var serverRpcTemplate = babel.template.expression(`createServerRpc(%%serverFnMeta%%, %%fn%%)`);
+var clientRpcTemplate = babel.template.expression(`createClientRpc(%%functionId%%)`);
+var ssrRpcManifestTemplate = babel.template.expression(`createSsrRpc(%%functionId%%)`);
+function warnInputValidatorDeprecation(context, inputValidator) {
+	const loc = inputValidator.callPath.node.loc?.start;
+	const location = loc ? `${context.id}:${loc.line}:${loc.column + 1} ` : `${context.id} `;
+	context.warn?.(
+		`${location}createServerFn().inputValidator() is deprecated. Use createServerFn().validator() instead.`,
+	);
+}
+var RuntimeCodeCache = /* @__PURE__ */ new Map();
+function getCachedRuntimeCode(framework, type) {
+	let cache = RuntimeCodeCache.get(framework);
+	if (!cache) {
+		const startPackage = getStartPackage(framework);
+		cache = {
+			provider: babel.template.ast(`import { createServerRpc } from '${startPackage}/server-rpc'`, {
+				placeholderPattern: false,
+			}),
+			client: babel.template.ast(`import { createClientRpc } from '${startPackage}/client-rpc'`, {
+				placeholderPattern: false,
+			}),
+			ssr: babel.template.ast(`import { createSsrRpc } from '${startPackage}/ssr-rpc'`, {
+				placeholderPattern: false,
+			}),
+		};
+		RuntimeCodeCache.set(framework, cache);
+	}
+	return cache[type];
+}
+/**
+ * Gets the environment configuration for the current compilation context.
+ */
+function getEnvConfig(context, isProviderFile) {
+	const { env } = context;
+	if (isProviderFile)
+		return {
+			isClientEnvironment: false,
+			runtimeCodeType: 'provider',
+		};
+	if (env === 'client')
+		return {
+			isClientEnvironment: true,
+			runtimeCodeType: 'client',
+		};
+	return {
+		isClientEnvironment: false,
+		runtimeCodeType: 'ssr',
+	};
+}
+/**
+ * Builds the serverFnMeta object literal AST node.
+ * The object contains: { id, name, filename }
+ */
+function buildServerFnMetaObject(functionId, variableName, filename) {
+	return t.objectExpression([
+		t.objectProperty(t.identifier('id'), t.stringLiteral(functionId)),
+		t.objectProperty(t.identifier('name'), t.stringLiteral(variableName)),
+		t.objectProperty(t.identifier('filename'), t.stringLiteral(filename)),
+	]);
+}
+/**
+ * Generates the RPC stub expression for provider files.
+ * Uses pre-compiled template for performance.
+ */
+function generateProviderRpcStub(serverFnMeta, fn) {
+	return serverRpcTemplate({
+		serverFnMeta,
+		fn,
+	});
+}
+/**
+ * Generates the RPC stub expression for caller files.
+ * Uses pre-compiled templates for performance.
+ * Note: Client and SSR callers only receive the functionId string, not the full metadata.
+ */
+function generateCallerRpcStub(functionId, envConfig) {
+	const functionIdLiteral = t.stringLiteral(functionId);
+	if (envConfig.runtimeCodeType === 'client')
+		return clientRpcTemplate({ functionId: functionIdLiteral });
+	return ssrRpcManifestTemplate({ functionId: functionIdLiteral });
+}
+/**
+ * Handles createServerFn transformations for a batch of candidates.
+ *
+ * This function performs extraction and replacement of server functions
+ *
+ * For caller files (non-provider):
+ * - Replaces the server function with an RPC stub
+ * - Does not include the handler function body
+ *
+ * For provider files:
+ * - Creates an extractedFn that calls __executeServer
+ * - Modifies .handler() to pass (extractedFn, serverFn) - two arguments
+ *
+ * @param candidates - All ServerFn candidates to process
+ * @param context - The compilation context with helpers and mutable state
+ * @returns Result containing runtime code to add, or null if no candidates processed
+ */
+function handleCreateServerFn(candidates, context) {
+	if (candidates.length === 0) return;
+	const isProviderFile = context.id.includes(TSS_SERVERFN_SPLIT_PARAM);
+	if (isProviderFile && context.serverFnProviderModuleDirectives)
+		ensureDirectivePrologue(context.ast, context.serverFnProviderModuleDirectives);
+	const envConfig = getEnvConfig(context, isProviderFile);
+	const functionNameSet = /* @__PURE__ */ new Set();
+	const exportNames = /* @__PURE__ */ new Set();
+	const serverFnsById = {};
+	const [baseFilename] = context.id.split('?');
+	const extractedFilename = `${baseFilename}?${TSS_SERVERFN_SPLIT_PARAM}`;
+	const relativeFilename = path.relative(context.root, baseFilename);
+	const knownFns = context.getKnownServerFns();
+	const cleanedContextId = cleanId(context.id);
+	for (const candidate of candidates) {
+		const { path: candidatePath, methodChain } = candidate;
+		const { validator, inputValidator, handler } = methodChain;
+		const candidateVariableDeclarator = getVariableDeclaratorForExpressionPath(candidatePath);
+		if (!candidateVariableDeclarator)
+			throw new Error('createServerFn must be assigned to a variable!');
+		const variableDeclarator = candidateVariableDeclarator.node;
+		if (!t.isIdentifier(variableDeclarator.id))
+			throw codeFrameError(
+				context.code,
+				variableDeclarator.id.loc,
+				'createServerFn must be assigned to a simple identifier, not a destructuring pattern',
+			);
+		const existingVariableName = variableDeclarator.id.name;
+		let functionName = `${existingVariableName}_createServerFn_handler`;
+		while (functionNameSet.has(functionName))
+			functionName = incrementFunctionNameVersion(functionName);
+		functionNameSet.add(functionName);
+		const functionId = context.generateFunctionId({
+			filename: relativeFilename,
+			functionName,
+			extractedFilename,
+		});
+		const knownFn = knownFns[functionId];
+		const isClientReferenced =
+			envConfig.isClientEnvironment || !!knownFn || envConfig.runtimeCodeType === 'ssr';
+		const canonicalExtractedFilename = knownFn?.extractedFilename ?? extractedFilename;
+		if (inputValidator) warnInputValidatorDeprecation(context, inputValidator);
+		for (const [methodName, methodCall] of [
+			['validator', validator],
+			['inputValidator', inputValidator],
+		]) {
+			if (!methodCall) continue;
+			if (!methodCall.callPath.node.arguments[0])
+				throw new Error(`createServerFn().${methodName}() must be called with a validator!`);
+			if (context.env === 'client') stripMethodCall(methodCall.callPath);
+		}
+		const handlerFnPath = handler?.firstArgPath;
+		if (!handler || !handlerFnPath?.node)
+			throw codeFrameError(
+				context.code,
+				candidatePath.node.callee.loc,
+				`createServerFn must be called with a "handler" property!`,
+			);
+		if (!t.isExpression(handlerFnPath.node))
+			throw codeFrameError(
+				context.code,
+				handlerFnPath.node.loc,
+				`handler() must be called with an expression, not a ${handlerFnPath.node.type}`,
+			);
+		const handlerFn = handlerFnPath.node;
+		if (!isProviderFile)
+			serverFnsById[functionId] = {
+				functionName,
+				functionId,
+				filename: cleanedContextId,
+				extractedFilename: canonicalExtractedFilename,
+				isClientReferenced,
+			};
+		if (isProviderFile) {
+			const executeServerArrowFn = t.arrowFunctionExpression(
+				[t.identifier('opts')],
+				t.callExpression(
+					t.memberExpression(t.identifier(existingVariableName), t.identifier('__executeServer')),
+					[t.identifier('opts')],
+				),
+			);
+			const extractedFnInit = generateProviderRpcStub(
+				buildServerFnMetaObject(functionId, existingVariableName, relativeFilename),
+				executeServerArrowFn,
+			);
+			const extractedFnStatement = t.variableDeclaration('const', [
+				t.variableDeclarator(t.identifier(functionName), extractedFnInit),
+			]);
+			const variableDeclaration = candidateVariableDeclarator.parentPath;
+			if (!variableDeclaration.isVariableDeclaration())
+				throw new Error('Expected createServerFn to be in a VariableDeclaration');
+			variableDeclaration.insertBefore(extractedFnStatement);
+			const extractedFnIdentifier = t.identifier(functionName);
+			const serverFnNode = t.cloneNode(handlerFn, true);
+			handler.callPath.node.arguments = [extractedFnIdentifier, serverFnNode];
+			exportNames.add(functionName);
+		} else {
+			const rpcStub = generateCallerRpcStub(functionId, envConfig);
+			handlerFnPath.replaceWith(rpcStub);
+		}
+	}
+	if (isProviderFile) {
+		safeRemoveExports(context.ast);
+		if (exportNames.size > 0)
+			context.ast.program.body.push(
+				t.exportNamedDeclaration(
+					void 0,
+					Array.from(exportNames).map((name) =>
+						t.exportSpecifier(t.identifier(name), t.identifier(name)),
+					),
+				),
+			);
+		if (context.mode === 'dev') context.ast.program.body.push(...providerHmrAcceptTemplate());
+	}
+	if (!isProviderFile && hasKeys(serverFnsById) && context.onServerFnsById)
+		context.onServerFnsById(serverFnsById);
+	const runtimeCode = getCachedRuntimeCode(context.framework, envConfig.runtimeCodeType);
+	context.ast.program.body.unshift(t.cloneNode(runtimeCode));
+}
+/**
+ * Makes an identifier safe for use as a JavaScript identifier.
+ */
+function makeIdentifierSafe(identifier) {
+	return identifier
+		.replace(/[^a-zA-Z0-9_$]/g, '_')
+		.replace(/^[0-9]/, '_$&')
+		.replace(/^\$/, '_$')
+		.replace(/_{2,}/g, '_')
+		.replace(/^_|_$/g, '');
+}
+/**
+ * Increments the version number suffix on a function name.
+ */
+function incrementFunctionNameVersion(functionName) {
+	const [realReferenceName, count] = functionName.split(/_(\d+)$/);
+	const suffix = `_${Number(count || '0') + 1}`;
+	return makeIdentifierSafe(realReferenceName) + suffix;
+}
+/**
+ * Removes all exports from the AST while preserving the declarations.
+ * Used for provider files where we want to re-export only the server functions.
+ */
+function safeRemoveExports(ast) {
+	ast.program.body = ast.program.body.flatMap((node) => {
+		if (t.isExportNamedDeclaration(node) || t.isExportDefaultDeclaration(node)) {
+			if (
+				t.isFunctionDeclaration(node.declaration) ||
+				t.isClassDeclaration(node.declaration) ||
+				t.isVariableDeclaration(node.declaration)
+			) {
+				if (t.isFunctionDeclaration(node.declaration) || t.isClassDeclaration(node.declaration)) {
+					if (!node.declaration.id) return node;
+				}
+				return node.declaration;
+			} else if (node.declaration === null) return [];
+		}
+		return node;
+	});
+}
+function ensureDirectivePrologue(ast, directiveValues) {
+	const directives = ast.program.directives;
+	const existingDirectives = new Set(directives.map((directive) => directive.value.value));
+	const missingDirectives = [];
+	for (const directiveValue of directiveValues) {
+		if (!directiveValue || existingDirectives.has(directiveValue)) continue;
+		existingDirectives.add(directiveValue);
+		missingDirectives.push(directiveValue);
+	}
+	for (let i = missingDirectives.length - 1; i >= 0; i--)
+		directives.unshift(t.directive(t.directiveLiteral(missingDirectives[i])));
+}
+//#endregion
+export { handleCreateServerFn };

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

@@ -0,0 +1,14 @@
+import { CompilationContext, RewriteCandidate } from './types.js';
+import { LookupKind } from './compiler.js';
+/**
+ * Handles serverOnly/clientOnly function transformations for a batch of candidates.
+ *
+ * @param candidates - All EnvOnly candidates to process (all same kind)
+ * @param context - The compilation context
+ * @param kind - The specific kind (ServerOnlyFn or ClientOnlyFn)
+ */
+export declare function handleEnvOnlyFn(
+	candidates: Array<RewriteCandidate>,
+	context: CompilationContext,
+	kind: LookupKind,
+): void;

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

@@ -0,0 +1,41 @@
+import * as t from '@babel/types';
+//#region src/start-compiler/handleEnvOnly.ts
+function capitalize(str) {
+	if (!str) return '';
+	return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+/**
+ * Handles serverOnly/clientOnly function transformations for a batch of candidates.
+ *
+ * @param candidates - All EnvOnly candidates to process (all same kind)
+ * @param context - The compilation context
+ * @param kind - The specific kind (ServerOnlyFn or ClientOnlyFn)
+ */
+function handleEnvOnlyFn(candidates, context, kind) {
+	const targetEnv = kind === 'ClientOnlyFn' ? 'client' : 'server';
+	for (const candidate of candidates) {
+		const { path } = candidate;
+		if (context.env === targetEnv) {
+			const innerFn = path.node.arguments[0];
+			if (!t.isExpression(innerFn))
+				throw new Error(`create${capitalize(targetEnv)}OnlyFn() must be called with a function!`);
+			path.replaceWith(innerFn);
+		} else
+			path.replaceWith(
+				t.arrowFunctionExpression(
+					[],
+					t.blockStatement([
+						t.throwStatement(
+							t.newExpression(t.identifier('Error'), [
+								t.stringLiteral(
+									`create${capitalize(targetEnv)}OnlyFn() functions can only be called on the ${targetEnv}!`,
+								),
+							]),
+						),
+					]),
+				),
+			);
+	}
+}
+//#endregion
+export { handleEnvOnlyFn };

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

@@ -0,0 +1,44 @@
+import { StartCompiler } from './compiler.js';
+import {
+	CompileStartFrameworkOptions,
+	StartCompilerImportTransform,
+	StartCompilerPlugin,
+	StartCompilerTransformResult,
+	StartCompilerVirtualModuleContext,
+} from '../types.js';
+import {
+	DevServerFnModuleSpecifierEncoder,
+	GenerateFunctionIdFnOptional,
+	ServerFn,
+} from './types.js';
+export interface CreateStartCompilerOptions {
+	env: 'client' | 'server';
+	envName: string;
+	root: string;
+	framework: CompileStartFrameworkOptions;
+	providerEnvName: string;
+	mode: 'dev' | 'build';
+	generateFunctionId?: GenerateFunctionIdFnOptional;
+	compilerTransforms?: Array<StartCompilerImportTransform> | undefined;
+	compilerPlugins?: Array<StartCompilerPlugin> | undefined;
+	serverFnProviderModuleDirectives?: ReadonlyArray<string> | undefined;
+	warn?: (message: string) => void;
+	onServerFnsById?: (d: Record<string, ServerFn>) => void;
+	getKnownServerFns: () => Record<string, ServerFn>;
+	encodeModuleSpecifierInDev?: DevServerFnModuleSpecifierEncoder;
+	loadModule: (id: string) => Promise<void>;
+	resolveId: (id: string, importer?: string) => Promise<string | null>;
+}
+export declare function createStartCompiler(options: CreateStartCompilerOptions): StartCompiler;
+export declare function mergeServerFnsById(
+	current: Record<string, ServerFn>,
+	next: Record<string, ServerFn>,
+): void;
+export declare function matchesCodeFilters(code: string, filters: ReadonlyArray<RegExp>): boolean;
+export declare function createCompilerVirtualModuleIdPattern(
+	compilerPlugins: ReadonlyArray<StartCompilerPlugin>,
+): RegExp | undefined;
+export declare function loadCompilerVirtualModule(
+	compilerPlugins: ReadonlyArray<StartCompilerPlugin>,
+	context: StartCompilerVirtualModuleContext,
+): StartCompilerTransformResult | null;