@octanejs/tanstack-start 0.1.0

package/src/internal/start-plugin-core/import-protection/utils.d.ts

@@ -0,0 +1,78 @@
+export type Pattern = string | RegExp;
+export declare function dedupePatterns(patterns: Array<Pattern>): Array<Pattern>;
+export interface FileMatchers {
+	files: Array<{
+		pattern: Pattern;
+		test: (value: string) => boolean;
+	}>;
+	excludeFiles: Array<{
+		pattern: Pattern;
+		test: (value: string) => boolean;
+	}>;
+}
+export declare function isFileExcluded(
+	relativePath: string,
+	matchers: Pick<FileMatchers, 'excludeFiles'>,
+): boolean;
+export declare function checkFileDenial(
+	relativePath: string,
+	matchers: FileMatchers,
+): FileMatchers['files'][number] | undefined;
+export declare function dedupeViolationKey(info: {
+	type: string;
+	importer: string;
+	specifier: string;
+	resolved?: string;
+}): string;
+/** Strip both `?query` and `#hash` from a module ID. */
+export declare function stripQueryAndHash(id: string): string;
+export declare function normalizeFilePath(id: string): string;
+/** Clear the memoization cache (call from buildStart to bound growth). */
+export declare function clearNormalizeFilePathCache(): void;
+/** Get a value from a Map, creating it with `factory` if absent. */
+export declare function getOrCreate<TKey, TValue>(
+	map: Map<TKey, TValue>,
+	key: TKey,
+	factory: () => TValue,
+): TValue;
+/** Make a path relative to `root`, keeping non-rooted paths as-is. */
+export declare function relativizePath(p: string, root: string): string;
+/** Log import-protection debug output when debug mode is enabled. */
+export declare function debugLog(...args: Array<unknown>): void;
+/** Check if any value matches the configured debug filter (if present). */
+export declare function matchesDebugFilter(...values: Array<string>): boolean;
+/** Strip `?query` (but not `#hash`) from a module ID. */
+export declare function stripQuery(id: string): string;
+export declare function withoutKnownExtension(id: string): string;
+/**
+ * Check whether `filePath` is contained inside `directory` using a
+ * boundary-safe comparison.  A naïve `filePath.startsWith(directory)`
+ * would incorrectly treat `/app/src2/foo.ts` as inside `/app/src`.
+ */
+export declare function isInsideDirectory(filePath: string, directory: string): boolean;
+/**
+ * Decide whether a violation should be deferred for later verification
+ * rather than reported immediately.
+ *
+ * Build mode: always defer — generateBundle checks tree-shaking.
+ * Dev mock mode: always defer — edge-survival verifies whether the Start
+ *   compiler strips the import (factory-safe pattern).  All violation
+ *   types and specifier formats are handled uniformly by the
+ *   edge-survival mechanism in processPendingViolations.
+ * Dev error mode: never defer — throw immediately (no mock fallback).
+ */
+export declare function shouldDeferViolation(opts: {
+	isBuild: boolean;
+	isDevMock: boolean;
+}): boolean;
+export declare function buildSourceCandidates(
+	source: string,
+	resolved: string | undefined,
+	root: string,
+): Set<string>;
+export declare function buildResolutionCandidates(id: string): Array<string>;
+export declare function canonicalizeResolvedId(
+	id: string,
+	root: string,
+	resolveExtensionlessAbsoluteId: (value: string) => string,
+): string;

package/src/internal/start-plugin-core/import-protection/utils.js

@@ -0,0 +1,171 @@
+import { normalizePath } from '../utils.js';
+import {
+	IMPORT_PROTECTION_DEBUG,
+	IMPORT_PROTECTION_DEBUG_FILTER,
+	KNOWN_SOURCE_EXTENSIONS,
+} from './constants.js';
+import { extname, isAbsolute, relative, resolve } from 'node:path';
+//#region src/import-protection/utils.ts
+function dedupePatterns(patterns) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const p of patterns) {
+		const key = typeof p === 'string' ? `s:${p}` : `r:${p.toString()}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(p);
+	}
+	return out;
+}
+function isFileExcluded(relativePath, matchers) {
+	return (
+		matchers.excludeFiles.length > 0 &&
+		matchers.excludeFiles.some((matcher) => matcher.test(relativePath))
+	);
+}
+function checkFileDenial(relativePath, matchers) {
+	if (isFileExcluded(relativePath, matchers)) return;
+	return matchers.files.find((matcher) => matcher.test(relativePath));
+}
+function dedupeViolationKey(info) {
+	return `${info.type}:${info.importer}:${info.specifier}:${info.resolved ?? ''}`;
+}
+/** Strip both `?query` and `#hash` from a module ID. */
+function stripQueryAndHash(id) {
+	const q = id.indexOf('?');
+	const h = id.indexOf('#');
+	if (q === -1 && h === -1) return id;
+	if (q === -1) return id.slice(0, h);
+	if (h === -1) return id.slice(0, q);
+	return id.slice(0, Math.min(q, h));
+}
+/**
+ * Strip Vite query/hash parameters and normalize the path in one step.
+ *
+ * Results are memoized because the same module IDs are processed many
+ * times across resolveId, transform, and trace-building hooks.
+ */
+var normalizeFilePathCache = /* @__PURE__ */ new Map();
+function normalizeFilePath(id) {
+	let result = normalizeFilePathCache.get(id);
+	if (result === void 0) {
+		result = normalizePath(stripQueryAndHash(id));
+		normalizeFilePathCache.set(id, result);
+	}
+	return result;
+}
+/** Clear the memoization cache (call from buildStart to bound growth). */
+function clearNormalizeFilePathCache() {
+	normalizeFilePathCache.clear();
+}
+/** Get a value from a Map, creating it with `factory` if absent. */
+function getOrCreate(map, key, factory) {
+	let value = map.get(key);
+	if (value === void 0) {
+		value = factory();
+		map.set(key, value);
+	}
+	return value;
+}
+/** Make a path relative to `root`, keeping non-rooted paths as-is. */
+function relativizePath(p, root) {
+	if (!p.startsWith(root)) return p;
+	const ch = p.charCodeAt(root.length);
+	if (ch !== 47 && !Number.isNaN(ch)) return p;
+	return ch === 47 ? p.slice(root.length + 1) : p.slice(root.length);
+}
+/** Log import-protection debug output when debug mode is enabled. */
+function debugLog(...args) {
+	if (!IMPORT_PROTECTION_DEBUG) return;
+	console.warn('[import-protection:debug]', ...args);
+}
+/** Check if any value matches the configured debug filter (if present). */
+function matchesDebugFilter(...values) {
+	const debugFilter = IMPORT_PROTECTION_DEBUG_FILTER;
+	if (!debugFilter) return true;
+	return values.some((v) => v.includes(debugFilter));
+}
+/** Strip `?query` (but not `#hash`) from a module ID. */
+function stripQuery(id) {
+	const queryIndex = id.indexOf('?');
+	return queryIndex === -1 ? id : id.slice(0, queryIndex);
+}
+function withoutKnownExtension(id) {
+	const ext = extname(id);
+	return KNOWN_SOURCE_EXTENSIONS.has(ext) ? id.slice(0, -ext.length) : id;
+}
+/**
+ * Check whether `filePath` is contained inside `directory` using a
+ * boundary-safe comparison.  A naïve `filePath.startsWith(directory)`
+ * would incorrectly treat `/app/src2/foo.ts` as inside `/app/src`.
+ */
+function isInsideDirectory(filePath, directory) {
+	const rel = relative(resolve(directory), resolve(filePath));
+	return rel.length > 0 && !rel.startsWith('..') && !isAbsolute(rel);
+}
+/**
+ * Decide whether a violation should be deferred for later verification
+ * rather than reported immediately.
+ *
+ * Build mode: always defer — generateBundle checks tree-shaking.
+ * Dev mock mode: always defer — edge-survival verifies whether the Start
+ *   compiler strips the import (factory-safe pattern).  All violation
+ *   types and specifier formats are handled uniformly by the
+ *   edge-survival mechanism in processPendingViolations.
+ * Dev error mode: never defer — throw immediately (no mock fallback).
+ */
+function shouldDeferViolation(opts) {
+	return opts.isBuild || opts.isDevMock;
+}
+function buildSourceCandidates(source, resolved, root) {
+	const candidates = /* @__PURE__ */ new Set();
+	const push = (value) => {
+		if (!value) return;
+		candidates.add(value);
+		candidates.add(stripQuery(value));
+		candidates.add(withoutKnownExtension(stripQuery(value)));
+	};
+	push(source);
+	if (resolved) {
+		push(resolved);
+		const relativeResolved = relativizePath(resolved, root);
+		push(relativeResolved);
+		push(`./${relativeResolved}`);
+		push(`/${relativeResolved}`);
+	}
+	return candidates;
+}
+function buildResolutionCandidates(id) {
+	const normalized = normalizeFilePath(id);
+	const stripped = stripQuery(normalized);
+	return [...new Set([id, normalized, stripped])];
+}
+function canonicalizeResolvedId(id, root, resolveExtensionlessAbsoluteId) {
+	let normalized = normalizeFilePath(stripQuery(id));
+	if (
+		!isAbsolute(normalized) &&
+		!normalized.startsWith('.') &&
+		!normalized.startsWith('\0') &&
+		!/^[a-zA-Z]+:/.test(normalized)
+	)
+		normalized = normalizeFilePath(resolve(root, normalized));
+	return resolveExtensionlessAbsoluteId(normalized);
+}
+//#endregion
+export {
+	buildResolutionCandidates,
+	buildSourceCandidates,
+	canonicalizeResolvedId,
+	checkFileDenial,
+	clearNormalizeFilePathCache,
+	debugLog,
+	dedupePatterns,
+	dedupeViolationKey,
+	getOrCreate,
+	isFileExcluded,
+	isInsideDirectory,
+	matchesDebugFilter,
+	normalizeFilePath,
+	relativizePath,
+	shouldDeferViolation,
+};

package/src/internal/start-plugin-core/import-protection/virtualModules.d.ts

@@ -0,0 +1,38 @@
+import {
+	MARKER_PREFIX,
+	MOCK_BUILD_PREFIX,
+	MOCK_EDGE_PREFIX,
+	MOCK_MODULE_ID,
+	MOCK_RUNTIME_PREFIX,
+} from './constants.js';
+import { ViolationInfo } from './trace.js';
+type MockAccessMode = 'error' | 'warn' | 'off';
+export declare const RUNTIME_SUGGESTION_TEXT: string;
+export declare function mockRuntimeModuleIdFromViolation(
+	info: ViolationInfo,
+	mode: MockAccessMode,
+	root: string,
+): string;
+export declare function makeMockEdgeModuleId(exports: Array<string>, runtimeId: string): string;
+export declare function loadSilentMockModule(): {
+	code: string;
+};
+export declare function generateSelfContainedMockModule(exportNames: Array<string>): {
+	code: string;
+};
+export declare function generateDevSelfDenialModule(
+	exportNames: Array<string>,
+	runtimeId: string,
+): {
+	code: string;
+};
+export declare function loadMockEdgeModule(encodedPayload: string): {
+	code: string;
+};
+export declare function loadMockRuntimeModule(encodedPayload: string): {
+	code: string;
+};
+export declare function loadMarkerModule(): {
+	code: string;
+};
+export { MARKER_PREFIX, MOCK_BUILD_PREFIX, MOCK_EDGE_PREFIX, MOCK_MODULE_ID, MOCK_RUNTIME_PREFIX };

package/src/internal/start-plugin-core/import-protection/virtualModules.js

@@ -0,0 +1,241 @@
+import { MOCK_EDGE_PREFIX, MOCK_MODULE_ID, MOCK_RUNTIME_PREFIX } from './constants.js';
+import { relativizePath } from './utils.js';
+import { CLIENT_ENV_SUGGESTIONS } from './trace.js';
+import { isValidExportName } from './analysis.js';
+//#region src/import-protection/virtualModules.ts
+function toBase64Url(input) {
+	return Buffer.from(input, 'utf8').toString('base64url');
+}
+function fromBase64Url(input) {
+	return Buffer.from(input, 'base64url').toString('utf8');
+}
+var RUNTIME_SUGGESTION_TEXT =
+	'Fix: ' +
+	CLIENT_ENV_SUGGESTIONS.join('. ') +
+	'. To disable these runtime diagnostics, set importProtection.mockAccess: "off".';
+function mockRuntimeModuleIdFromViolation(info, mode, root) {
+	if (mode === 'off') return MOCK_MODULE_ID;
+	if (info.env !== 'client') return MOCK_MODULE_ID;
+	const rel = (p) => relativizePath(p, root);
+	const trace = info.trace.map((s) => {
+		const file = rel(s.file);
+		if (s.line == null) return file;
+		return `${file}:${s.line}:${s.column ?? 1}`;
+	});
+	const payload = {
+		env: info.env,
+		importer: info.importer,
+		specifier: info.specifier,
+		trace,
+		mode,
+	};
+	return `${MOCK_RUNTIME_PREFIX}${toBase64Url(JSON.stringify(payload))}`;
+}
+function makeMockEdgeModuleId(exports, runtimeId) {
+	return `${MOCK_EDGE_PREFIX}${toBase64Url(
+		JSON.stringify({
+			exports,
+			runtimeId,
+		}),
+	)}`;
+}
+function generateMockCode(diagnostics) {
+	const fnName = diagnostics ? '__createMock' : 'createMock';
+	const hasDiag = !!diagnostics;
+	return `
+${
+	hasDiag
+		? `const __meta = ${JSON.stringify(diagnostics.meta)};
+const __mode = ${JSON.stringify(diagnostics.mode)};
+
+const __seen = new Set();
+function __report(action, accessPath) {
+  if (__mode === 'off') return;
+  const key = action + ':' + accessPath;
+  if (__seen.has(key)) return;
+  __seen.add(key);
+
+  const traceLines = Array.isArray(__meta.trace) && __meta.trace.length
+    ? "\\n\\nTrace:\\n" + __meta.trace.map((t, i) => '  ' + (i + 1) + '. ' + String(t)).join('\\n')
+    : '';
+
+  const msg =
+    '[import-protection] Mocked import used in dev client\\n\\n' +
+    'Denied import: "' + __meta.specifier + '"\\n' +
+    'Importer: ' + __meta.importer + '\\n' +
+    'Access: ' + accessPath + ' (' + action + ')' +
+    traceLines +
+    '\\n\\n' + ${JSON.stringify(RUNTIME_SUGGESTION_TEXT)};
+
+  const err = new Error(msg);
+  if (__mode === 'warn') {
+    console.warn(err);
+  } else {
+    console.error(err);
+  }
+}
+`
+		: ''
+}/* @__NO_SIDE_EFFECTS__ */
+function ${fnName}(name) {
+  const fn = function () {};
+  fn.prototype.name = name;
+  const children = Object.create(null);
+  const proxy = new Proxy(fn, {
+    get(_target, prop) {
+      if (prop === '__esModule') return true;
+      if (prop === 'default') return proxy;
+      if (prop === 'caller') return null;
+      if (prop === 'then') return (f) => Promise.resolve(f(proxy));
+      if (prop === 'catch') return () => Promise.resolve(proxy);
+      if (prop === 'finally') return (f) => { f(); return Promise.resolve(proxy); };${`
+      if (prop === Symbol.toPrimitive) {
+        return () => {
+          ${hasDiag ? `__report('toPrimitive', name);` : ''}
+          return '[import-protection mock]';
+        };
+      }
+      if (prop === 'toString' || prop === 'valueOf' || prop === 'toJSON') {
+        return () => {
+          ${hasDiag ? `__report(String(prop), name);` : ''}
+          return '[import-protection mock]';
+        };
+      }`}
+      if (typeof prop === 'symbol') return undefined;
+      if (!(prop in children)) {
+        children[prop] = ${fnName}(name + '.' + prop);
+      }
+      return children[prop];
+    },
+    apply() {
+      ${
+				hasDiag
+					? `__report('call', name + '()');
+      return ${fnName}(name + '()');`
+					: `return ${fnName}(name + '()');`
+			}
+    },
+    construct() {
+      ${
+				hasDiag
+					? `__report('construct', 'new ' + name);
+      return ${fnName}('new ' + name);`
+					: `return ${fnName}('new ' + name);`
+			}
+    },${
+			hasDiag
+				? `
+    set(_target, prop) {
+      __report('set', name + '.' + String(prop));
+      return true;
+    },`
+				: ''
+		}
+  });
+  return proxy;
+}
+const mock = /* @__PURE__ */ ${fnName}('mock');
+export default mock;
+`;
+}
+function loadSilentMockModule() {
+	return { code: generateMockCode() };
+}
+function filterExportNames(exports) {
+	return exports.filter((n) => n.length > 0 && n !== 'default');
+}
+function generateExportLines(names) {
+	const lines = [];
+	const stringExports = [];
+	for (let i = 0; i < names.length; i++) {
+		const n = names[i];
+		if (isValidExportName(n)) lines.push(`export const ${n} = mock.${n};`);
+		else {
+			const alias = `__tss_str_${i}`;
+			lines.push(`const ${alias} = mock[${JSON.stringify(n)}];`);
+			stringExports.push({
+				alias,
+				name: n,
+			});
+		}
+	}
+	if (stringExports.length > 0) {
+		const reexports = stringExports
+			.map((s) => `${s.alias} as ${JSON.stringify(s.name)}`)
+			.join(', ');
+		lines.push(`export { ${reexports} };`);
+	}
+	return lines;
+}
+function generateSelfContainedMockModule(exportNames) {
+	return {
+		code: `${generateMockCode()}
+${generateExportLines(filterExportNames(exportNames)).join('\n')}
+`,
+	};
+}
+function generateDevSelfDenialModule(exportNames, runtimeId) {
+	const exportLines = generateExportLines(filterExportNames(exportNames));
+	return {
+		code: `import mock from ${JSON.stringify(runtimeId)};
+${exportLines.join('\n')}
+export default mock;
+`,
+	};
+}
+function loadMockEdgeModule(encodedPayload) {
+	let payload;
+	try {
+		payload = JSON.parse(fromBase64Url(encodedPayload));
+	} catch {
+		payload = { exports: [] };
+	}
+	const names = filterExportNames(payload.exports ?? []);
+	const runtimeId =
+		typeof payload.runtimeId === 'string' && payload.runtimeId.length > 0
+			? payload.runtimeId
+			: MOCK_MODULE_ID;
+	const exportLines = generateExportLines(names);
+	return {
+		code: `import mock from ${JSON.stringify(runtimeId)};
+${exportLines.join('\n')}
+export default mock;
+`,
+	};
+}
+function loadMockRuntimeModule(encodedPayload) {
+	let payload;
+	try {
+		payload = JSON.parse(fromBase64Url(encodedPayload));
+	} catch {
+		payload = {};
+	}
+	const mode = payload.mode === 'warn' || payload.mode === 'off' ? payload.mode : 'error';
+	return {
+		code: generateMockCode({
+			meta: {
+				env: String(payload.env ?? ''),
+				importer: String(payload.importer ?? ''),
+				specifier: String(payload.specifier ?? ''),
+				trace: Array.isArray(payload.trace) ? payload.trace : [],
+			},
+			mode,
+		}),
+	};
+}
+var MARKER_MODULE_RESULT = { code: 'export {}' };
+function loadMarkerModule() {
+	return MARKER_MODULE_RESULT;
+}
+//#endregion
+export {
+	RUNTIME_SUGGESTION_TEXT,
+	generateDevSelfDenialModule,
+	generateSelfContainedMockModule,
+	loadMarkerModule,
+	loadMockEdgeModule,
+	loadMockRuntimeModule,
+	loadSilentMockModule,
+	makeMockEdgeModuleId,
+	mockRuntimeModuleIdFromViolation,
+};

package/src/internal/start-plugin-core/index.d.ts

@@ -0,0 +1,8 @@
+export type { TanStackStartInputConfig } from './schema.js';
+export type {
+	StartCompilerImportTransform,
+	StartCompilerTransformCandidate,
+	StartCompilerTransformContext,
+	TanStackStartCoreOptions,
+} from './types.js';
+export { START_ENVIRONMENT_NAMES } from './constants.js';

package/src/internal/start-plugin-core/index.js

@@ -0,0 +1,2 @@
+import { START_ENVIRONMENT_NAMES } from './constants.js';
+export { START_ENVIRONMENT_NAMES };

package/src/internal/start-plugin-core/planning.d.ts

@@ -0,0 +1,44 @@
+import { TanStackStartOutputConfig } from './schema.js';
+import {
+	NormalizedBasePaths,
+	NormalizedOutputDirectories,
+	TanStackStartCoreOptions,
+} from './types.js';
+export interface ResolvedStartEntryPlan {
+	srcDirectory: string;
+	startFilePath: string | undefined;
+	routerFilePath: string;
+	entryPaths: {
+		client: string;
+		server: string;
+		start: string;
+		router: string;
+	};
+}
+export declare function normalizePublicBase(base: string | undefined): string;
+export declare function deriveRouterBasepath(opts: {
+	configuredBasepath: string | undefined;
+	publicBase: string;
+}): string;
+export declare function shouldRewriteDevBasepath(opts: {
+	command: 'serve' | 'build';
+	middlewareMode: boolean | undefined;
+	routerBasepath: string;
+	publicBase: string;
+}): boolean;
+export declare function createNormalizedBasePaths(opts: {
+	publicBase: string;
+}): NormalizedBasePaths;
+export declare function createNormalizedOutputDirectories(opts: {
+	client: string;
+	server: string;
+}): NormalizedOutputDirectories;
+export declare function createServerFnBasePath(opts: {
+	routerBasepath: string;
+	serverFnBase: string;
+}): string;
+export declare function resolveStartEntryPlan(opts: {
+	root: string;
+	startConfig: TanStackStartOutputConfig;
+	defaultEntryPaths: TanStackStartCoreOptions['defaultEntryPaths'];
+}): ResolvedStartEntryPlan;

package/src/internal/start-plugin-core/planning.js

@@ -0,0 +1,98 @@
+import { resolveEntry } from './resolve-entries.js';
+import { joinPaths } from '@tanstack/router-core';
+import { join } from 'pathe';
+//#region src/planning.ts
+function normalizePublicBase(base) {
+	const resolvedBase = base ?? '/';
+	if (isFullUrl(resolvedBase)) return resolvedBase;
+	return joinPaths(['/', resolvedBase, '/']);
+}
+function deriveRouterBasepath(opts) {
+	if (opts.configuredBasepath !== void 0) return opts.configuredBasepath;
+	if (isFullUrl(opts.publicBase)) return '/';
+	return opts.publicBase.replace(/^\/|\/$/g, '');
+}
+function shouldRewriteDevBasepath(opts) {
+	if (opts.command !== 'serve' || opts.middlewareMode) return false;
+	return !joinPaths(['/', opts.routerBasepath, '/']).startsWith(
+		joinPaths(['/', opts.publicBase, '/']),
+	);
+}
+function createNormalizedBasePaths(opts) {
+	return {
+		publicBase: opts.publicBase,
+		assetBase: {
+			dev: opts.publicBase,
+			build: opts.publicBase,
+		},
+	};
+}
+function createNormalizedOutputDirectories(opts) {
+	return {
+		client: opts.client,
+		server: opts.server,
+	};
+}
+function createServerFnBasePath(opts) {
+	return joinPaths(['/', opts.routerBasepath, opts.serverFnBase, '/']);
+}
+function resolveStartEntryPlan(opts) {
+	const srcDirectory = join(opts.root, opts.startConfig.srcDirectory);
+	const startFilePath = resolveEntry({
+		type: 'start entry',
+		configuredEntry: opts.startConfig.start.entry,
+		defaultEntry: 'start',
+		resolvedSrcDirectory: srcDirectory,
+		required: false,
+	});
+	const routerFilePath = resolveEntry({
+		type: 'router entry',
+		configuredEntry: opts.startConfig.router.entry,
+		defaultEntry: 'router',
+		resolvedSrcDirectory: srcDirectory,
+		required: true,
+	});
+	const clientEntryPath = resolveEntry({
+		type: 'client entry',
+		configuredEntry: opts.startConfig.client.entry,
+		defaultEntry: 'client',
+		resolvedSrcDirectory: srcDirectory,
+		required: false,
+	});
+	const serverEntryPath = resolveEntry({
+		type: 'server entry',
+		configuredEntry: opts.startConfig.server.entry,
+		defaultEntry: 'server',
+		resolvedSrcDirectory: srcDirectory,
+		required: false,
+	});
+	return {
+		srcDirectory,
+		startFilePath,
+		routerFilePath,
+		entryPaths: {
+			client: clientEntryPath ?? opts.defaultEntryPaths.client,
+			server: serverEntryPath ?? opts.defaultEntryPaths.server,
+			start: startFilePath ?? opts.defaultEntryPaths.start,
+			router: routerFilePath,
+		},
+	};
+}
+function isFullUrl(str) {
+	try {
+		new URL(str);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export {
+	createNormalizedBasePaths,
+	createNormalizedOutputDirectories,
+	createServerFnBasePath,
+	deriveRouterBasepath,
+	normalizePublicBase,
+	resolveStartEntryPlan,
+	shouldRewriteDevBasepath,
+};

package/src/internal/start-plugin-core/post-build.d.ts

@@ -0,0 +1,12 @@
+import { TanStackStartOutputConfig } from './schema.js';
+export interface StartPostBuildAdapter {
+	getClientOutputDirectory: () => string;
+	prerender: (startConfig: TanStackStartOutputConfig) => Promise<void>;
+}
+export declare function postBuild({
+	startConfig,
+	adapter,
+}: {
+	startConfig: TanStackStartOutputConfig;
+	adapter: StartPostBuildAdapter;
+}): Promise<void>;