@mionjs/devtools 0.8.10 → 0.13.0

package/src/vite-plugin/aotCacheGenerator.ts

@@ -1,397 +0,0 @@
-/* ########
- * 2026 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {fork, ChildProcess} from 'child_process';
-import {resolve, dirname} from 'path';
-import {MionServerConfig} from './types.ts';
-import {resolveModule} from './resolveModule.ts';
-
-/** AOT cache data returned from the generator */
-export interface AOTCacheData {
-    jitFnsCode: string;
-    pureFnsCode: string;
-    routerCacheCode: string;
-}
-
-/** AOT cache result including optional persistent child process */
-export interface AOTCacheResult {
-    data: AOTCacheData;
-    /** The child process, only present when runMode is 'childProcess' (persist) */
-    childProcess?: ChildProcess;
-    /** Promise that resolves when the server calls setPlatformConfig() (childProcess mode only) */
-    platformReady?: Promise<PlatformReadyData>;
-}
-
-/** IPC message type from the router's aotEmitter */
-interface AOTCacheMessage {
-    type: 'mion-aot-caches';
-    jitFnsCode: string;
-    pureFnsCode: string;
-    routerCacheCode: string;
-}
-
-/** Platform config received from the server via IPC */
-export interface PlatformReadyData {
-    routerConfig: Record<string, unknown>;
-    platformConfig: Record<string, unknown>;
-}
-
-interface PlatformReadyMessage extends PlatformReadyData {
-    type: 'mion-platform-ready';
-}
-
-/** Default timeout for AOT cache generation (30 seconds) */
-const DEFAULT_TIMEOUT = 30000;
-
-/**
- * Generates AOT caches by spawning vite-node to run the server's start script.
- *
- * vite-node is used instead of plain node/ts-node because:
- * 1. The server needs deepkit type compiler transformations
- * 2. The server's vite.config.ts has aliases and plugins that must be applied
- * 3. vite-node provides the same environment as the actual server build
- *
- * The router's emitAOTCaches() (called automatically from initMionRouter)
- * detects MION_COMPILE and sends the serialized caches via IPC.
- */
-export async function generateAOTCaches(
-    serverConfig: MionServerConfig,
-    startScriptOverride?: string,
-    isClient?: boolean
-): Promise<AOTCacheResult> {
-    const persist = serverConfig.runMode === 'childProcess';
-    const startScript = resolve(startScriptOverride ?? serverConfig.startScript);
-    const scriptDir = dirname(startScript);
-
-    // Determine the vite config to use
-    // If viteConfig is provided, use it; otherwise let vite-node auto-discover
-    const viteConfigArgs = serverConfig.viteConfig ? ['--config', resolve(serverConfig.viteConfig)] : [];
-
-    // Resolve vite-node path in both CJS and ESM environments
-    let viteNodePath: string;
-    try {
-        viteNodePath = await resolveModule('vite-node/cli', scriptDir);
-    } catch (err) {
-        throw new Error(
-            `Failed to resolve vite-node. Make sure vite-node is installed.\n` +
-                `You can install it with: npm install -D vite-node\n` +
-                `Original error: ${err instanceof Error ? err.message : String(err)}`
-        );
-    }
-
-    return new Promise((resolvePromise, reject) => {
-        let child: ChildProcess;
-        let resolved = false;
-        let stderr = '';
-
-        try {
-            // Spawn vite-node as a child process with IPC channel
-            // 'serve' mode tells platform adapters to proceed with server.listen()
-            child = fork(viteNodePath, [...viteConfigArgs, startScript, ...(serverConfig.args || [])], {
-                env: {
-                    ...process.env,
-                    ...serverConfig.env,
-                    MION_COMPILE: serverConfig.runMode,
-                    ...(isClient ? {MION_AOT_IS_CLIENT: 'true'} : {}),
-                },
-                stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-                cwd: scriptDir,
-            });
-        } catch (err) {
-            // If vite-node is not found, provide a helpful error message
-            reject(
-                new Error(
-                    `Failed to spawn vite-node. Make sure vite-node is installed.\n` +
-                        `You can install it with: npm install -D vite-node\n` +
-                        `Original error: ${err instanceof Error ? err.message : String(err)}`
-                )
-            );
-            return;
-        }
-
-        /** Cleanup child process: clear timeout, disconnect IPC (only in non-persist mode), and optionally kill.
-         *  In persist mode, IPC stays open for the mion-platform-ready message. */
-        const cleanup = () => {
-            clearTimeout(timeoutId);
-            if (!persist && child.connected) child.disconnect();
-            if (!persist) child.kill();
-        };
-
-        // Set up platform-ready listener BEFORE any messages arrive to avoid race conditions.
-        // The child may send mion-platform-ready very quickly after mion-aot-caches.
-        let platformReadyResolve: ((value: PlatformReadyData) => void) | undefined;
-        const platformReady = persist
-            ? new Promise<PlatformReadyData>((res) => {
-                  platformReadyResolve = res;
-              })
-            : undefined;
-
-        child.on('message', (msg: unknown) => {
-            const message = msg as AOTCacheMessage | PlatformReadyMessage;
-            if (message?.type === 'mion-aot-caches') {
-                resolved = true;
-                cleanup();
-                resolvePromise({
-                    data: {
-                        jitFnsCode: message.jitFnsCode,
-                        pureFnsCode: message.pureFnsCode,
-                        routerCacheCode: message.routerCacheCode,
-                    },
-                    childProcess: persist ? child : undefined,
-                    platformReady,
-                });
-            } else if (message?.type === 'mion-platform-ready' && platformReadyResolve) {
-                platformReadyResolve({routerConfig: message.routerConfig, platformConfig: message.platformConfig});
-                platformReadyResolve = undefined;
-            }
-        });
-
-        // Capture stderr for error reporting (and pipe through in persist mode)
-        child.stderr?.on('data', (data: Buffer) => {
-            const msg = data.toString().trim();
-            if (!resolved) stderr += msg + '\n';
-            if (persist && msg) console.error(`[mion-server] ${msg}`);
-        });
-
-        // Pipe stdout through (always in persist mode, only with DEBUG_AOT otherwise)
-        child.stdout?.on('data', (data: Buffer) => {
-            const msg = data.toString().trim();
-            if (persist && msg) {
-                console.log(`[mion-server] ${msg}`);
-            } else if (process.env.DEBUG_AOT && msg) {
-                console.log('[mion-aot] stdout:', msg);
-            }
-        });
-
-        child.on('error', (err) => {
-            if (!resolved) {
-                cleanup();
-                reject(new Error(`vite-node failed to start: ${err.message}`));
-            }
-        });
-
-        child.on('exit', (code) => {
-            if (!resolved) {
-                cleanup();
-                reject(
-                    new Error(
-                        `vite-node exited with code ${code} before emitting AOT caches.\n` +
-                            `Make sure the startScript calls initMionRouter() and the router ` +
-                            `is fully initialized.\n` +
-                            (stderr ? `stderr: ${stderr}` : '')
-                    )
-                );
-            }
-        });
-
-        // Timeout safety
-        const timeoutId = setTimeout(() => {
-            if (!resolved) {
-                cleanup();
-                if (persist) child.kill();
-                reject(
-                    new Error(
-                        `AOT cache generation timed out (${DEFAULT_TIMEOUT / 1000}s). ` +
-                            `Make sure the server start script completes initialization.`
-                    )
-                );
-            }
-        }, DEFAULT_TIMEOUT);
-    });
-}
-
-/** Loads a module by URL — abstracts over ssrLoadModule and Environment Runner */
-export type ModuleLoader = (url: string) => Promise<Record<string, any>>;
-
-/**
- *  Loads the startScript with MION_COMPILE=middleware so platform adapters skip server.listen().
- *  Generates AOT caches via SSR using a module loader (for same-Vite-process scenarios like Nuxt).
- *  After loading, retrieves the caches directly from the router's global state via getSerializedCaches(). */
-export async function loadSSRRouterAndGenerateAOTCaches(
-    loadModule: ModuleLoader,
-    startScript: string,
-    isClient?: boolean
-): Promise<AOTCacheData> {
-    const prevCompile = process.env.MION_COMPILE;
-    const prevIsClient = process.env.MION_AOT_IS_CLIENT;
-    process.env.MION_COMPILE = 'middleware';
-    if (isClient) process.env.MION_AOT_IS_CLIENT = 'true';
-
-    try {
-        // Load the start server script — triggers initMionRouter(), populates caches,
-        // skips process.send (SSR mode) and skips server.listen() (platform adapters)
-        const mod = await loadModule(startScript);
-        // Await any Promise-valued exports (e.g. initMionRouter() without top-level await)
-        const promises = Object.values(mod).filter((v): v is Promise<any> => v instanceof Promise);
-        if (promises.length > 0) await Promise.all(promises);
-
-        // Get caches directly from the router's global state
-        const aotModule = await loadModule('@mionjs/router/aot');
-        const caches: AOTCacheData = await aotModule.getSerializedCaches();
-        return caches;
-    } finally {
-        if (prevCompile === undefined) delete process.env.MION_COMPILE;
-        else process.env.MION_COMPILE = prevCompile;
-        if (prevIsClient === undefined) delete process.env.MION_AOT_IS_CLIENT;
-        else process.env.MION_AOT_IS_CLIENT = prevIsClient;
-    }
-}
-
-// ============ Persistent child management ============
-
-/** Kills a persistent child process gracefully (SIGTERM then SIGKILL after 5s) */
-export async function killPersistentChild(child: ChildProcess | null): Promise<void> {
-    if (!child || child.killed) return;
-    const pid = child.pid;
-
-    if (pid) {
-        try {
-            process.kill(-pid, 'SIGTERM');
-        } catch {
-            child.kill('SIGTERM');
-        }
-    } else {
-        child.kill('SIGTERM');
-    }
-
-    await new Promise<void>((resolve) => {
-        const timeout = setTimeout(() => {
-            if (child && !child.killed) {
-                if (pid) {
-                    try {
-                        process.kill(-pid, 'SIGKILL');
-                    } catch {
-                        child.kill('SIGKILL');
-                    }
-                } else {
-                    child.kill('SIGKILL');
-                }
-            }
-            resolve();
-        }, 5000);
-
-        child!.on('exit', () => {
-            clearTimeout(timeout);
-            resolve();
-        });
-    });
-}
-
-// ============ Logging ============
-
-/** Formats byte size to human-readable string */
-function formatBytes(bytes: number): string {
-    if (bytes < 1024) return `${bytes} B`;
-    const kb = bytes / 1024;
-    if (kb < 1024) return `${kb.toFixed(1)} KB`;
-    const mb = kb / 1024;
-    return `${mb.toFixed(1)} MB`;
-}
-
-/** Logs AOT cache sizes and optionally full contents in verbose mode (DEBUG_AOT) */
-export function logAOTCaches(data: AOTCacheData): void {
-    const jitSize = formatBytes(Buffer.byteLength(data.jitFnsCode, 'utf-8'));
-    const pureSize = formatBytes(Buffer.byteLength(data.pureFnsCode, 'utf-8'));
-    const routerSize = formatBytes(Buffer.byteLength(data.routerCacheCode, 'utf-8'));
-    console.log(`[mion]   jitFns: ${jitSize}, pureFns: ${pureSize}, routerCache: ${routerSize}`);
-
-    if (process.env.DEBUG_AOT) {
-        console.log('[mion] AOT jitFns cache:\n', data.jitFnsCode);
-        console.log('[mion] AOT pureFns cache:\n', data.pureFnsCode);
-        console.log('[mion] AOT routerCache:\n', data.routerCacheCode);
-    }
-}
-
-// ============ Module Generators ============
-
-/** Generates the virtual module code for JIT functions cache (exports only). */
-export function generateJitFnsModule(jitFnsCode: string): string {
-    return `/* Auto-generated AOT JIT functions cache - do not edit */
-export const jitFnsCache = ${jitFnsCode};
-`;
-}
-
-/** Generates the virtual module code for pure functions cache (exports only). */
-export function generatePureFnsModule(pureFnsCode: string): string {
-    return `/* Auto-generated AOT pure functions cache - do not edit */
-export const pureFnsCache = ${pureFnsCode};
-`;
-}
-
-/** Generates the virtual module code for router methods cache (exports only). */
-export function generateRouterCacheModule(routerCacheCode: string): string {
-    return `/* Auto-generated AOT router cache - do not edit */
-export const routerCache = ${routerCacheCode};
-`;
-}
-
-/** Generates the combined virtual module that imports all 3 caches and re-exports them. */
-export function generateCombinedCachesModule(): string {
-    return `/* Auto-generated combined AOT caches - do not edit */
-import { pureFnsCache } from 'virtual:mion-aot/pure-fns';
-import { jitFnsCache } from 'virtual:mion-aot/jit-fns';
-import { routerCache } from 'virtual:mion-aot/router-cache';
-import { addAOTCaches, addRoutesToCache } from '@mionjs/core';
-
-// Auto-register AOT caches as a side effect so they survive tree-shaking
-addAOTCaches(jitFnsCache, pureFnsCache);
-addRoutesToCache(routerCache);
-
-export { jitFnsCache, pureFnsCache, routerCache };
-
-/** Loads pre-compiled AOT caches (no-op: caches are auto-registered on import). */
-export function loadAOTCaches() {}
-
-/** Returns the raw AOT caches. */
-export function getRawAOTCaches() {
-    return { jitFnsCache, pureFnsCache, routerCache };
-}
-`;
-}
-
-/** Generates a no-op module for when AOT caches are disabled. */
-export function generateNoopModule(comment: string): string {
-    return `/* ${comment} */\n`;
-}
-
-/** Waits for the server child process to send a mion-platform-ready IPC message. */
-export function waitForPlatformReady(
-    child: ChildProcess,
-    timeoutMs = 30000
-): Promise<{routerConfig: Record<string, unknown>; platformConfig: Record<string, unknown>}> {
-    return new Promise((resolve, reject) => {
-        const onMessage = (msg: unknown) => {
-            const message = msg as PlatformReadyMessage;
-            if (message?.type === 'mion-platform-ready') {
-                clearTimeout(timeoutId);
-                child.removeListener('message', onMessage);
-                resolve({routerConfig: message.routerConfig, platformConfig: message.platformConfig});
-            }
-        };
-        child.on('message', onMessage);
-        const timeoutId = setTimeout(() => {
-            child.removeListener('message', onMessage);
-            reject(
-                new Error(
-                    `Server did not call setPlatformConfig() within ${timeoutMs / 1000}s. ` +
-                        `Ensure your platform adapter (startNodeServer, startBunServer, etc.) is called after initMionRouter().`
-                )
-            );
-        }, timeoutMs);
-    });
-}
-
-/** Generates a no-op combined module that exports empty caches. */
-export function generateNoopCombinedModule(): string {
-    return `/* No-op: AOT caches not generated */
-export const jitFnsCache = {};
-export const pureFnsCache = {};
-export const routerCache = {};
-export function loadAOTCaches() {}
-export function getRawAOTCaches() { return { jitFnsCache, pureFnsCache, routerCache }; }
-`;
-}

package/src/vite-plugin/aotDiskCache.ts

@@ -1,193 +0,0 @@
-/* ########
- * 2026 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {createHash} from 'crypto';
-import {readFileSync, writeFileSync, mkdirSync, readdirSync, statSync} from 'fs';
-import {join, resolve, dirname, relative} from 'path';
-import {AOTCacheOptions, MionServerConfig} from './types.ts';
-import {generateAOTCaches, AOTCacheData, AOTCacheResult} from './aotCacheGenerator.ts';
-
-/** Schema for the on-disk cache file */
-interface AOTDiskCacheFile {
-    cacheVersion: string;
-    hash: string;
-    jitFnsCode: string;
-    pureFnsCode: string;
-    routerCacheCode: string;
-}
-
-/** Bump when mion internals change in a way that invalidates cached output */
-const AOT_DISK_CACHE_VERSION = '2';
-
-/** Cache file name */
-const CACHE_FILENAME = 'mion-aot-cache.json';
-
-/** Directories to skip when walking the server source tree */
-const SKIP_DIRS = new Set(['node_modules', '.dist', 'dist', '.git', '.vite', 'build', 'coverage', '.coverage']);
-
-/** File extensions to include in hash computation */
-const SOURCE_EXTENSIONS = /\.(ts|tsx)$/;
-
-/** Test file patterns to exclude from hash computation */
-const TEST_FILE_PATTERN = /\.(spec|test)\.(ts|tsx)$/;
-
-/** Read the devtools package version (cached after first call) */
-let devtoolsVersion: string | null = null;
-function getDevtoolsVersion(): string {
-    if (devtoolsVersion) return devtoolsVersion;
-    try {
-        const pkgPath = resolve(dirname(new URL(import.meta.url).pathname), '../../package.json');
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-        devtoolsVersion = pkg.version || '0.0.0';
-    } catch {
-        devtoolsVersion = '0.0.0';
-    }
-    return devtoolsVersion as string;
-}
-
-/** Recursively collect file stats (relativePath:mtimeMs:size) for source files */
-function collectFileStats(dir: string, baseDir: string): string[] {
-    const entries: string[] = [];
-    let files: string[];
-    try {
-        files = readdirSync(dir);
-    } catch {
-        return entries;
-    }
-    for (const file of files) {
-        const fullPath = join(dir, file);
-        let stat;
-        try {
-            stat = statSync(fullPath);
-        } catch {
-            continue;
-        }
-        if (stat.isDirectory()) {
-            if (SKIP_DIRS.has(file)) continue;
-            entries.push(...collectFileStats(fullPath, baseDir));
-        } else if (SOURCE_EXTENSIONS.test(file) && !TEST_FILE_PATTERN.test(file)) {
-            const relativePath = relative(baseDir, fullPath);
-            entries.push(`${relativePath}:${stat.mtimeMs}:${stat.size}`);
-        }
-    }
-    return entries;
-}
-
-/** Compute a SHA-256 hash of the server source directory + options */
-export function computeSourceHash(serverConfig: MionServerConfig, aotOptions?: AOTCacheOptions): string {
-    const serverDir = dirname(resolve(serverConfig.startScript));
-    const fileStats = collectFileStats(serverDir, serverDir);
-    fileStats.sort();
-
-    const hashInput = [
-        ...fileStats,
-        `cacheVersion:${AOT_DISK_CACHE_VERSION}`,
-        `devtoolsVersion:${getDevtoolsVersion()}`,
-        `excludedFns:${JSON.stringify((aotOptions?.excludedFns || []).slice().sort())}`,
-        `excludedPureFns:${JSON.stringify((aotOptions?.excludedPureFns || []).slice().sort())}`,
-        `isClient:${!!aotOptions?.isClient}`,
-    ].join('\n');
-
-    return createHash('sha256').update(hashInput).digest('hex');
-}
-
-/** Read and validate the disk cache file. Returns null on any error. */
-function readDiskCache(cacheDir: string): AOTDiskCacheFile | null {
-    const cachePath = join(cacheDir, CACHE_FILENAME);
-    try {
-        const raw = readFileSync(cachePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (
-            typeof parsed.cacheVersion === 'string' &&
-            typeof parsed.hash === 'string' &&
-            typeof parsed.jitFnsCode === 'string' &&
-            typeof parsed.pureFnsCode === 'string' &&
-            typeof parsed.routerCacheCode === 'string'
-        ) {
-            return parsed as AOTDiskCacheFile;
-        }
-        return null;
-    } catch {
-        return null;
-    }
-}
-
-/** Write cache data to disk. Best-effort — logs warning on failure. */
-function writeDiskCache(cacheDir: string, hash: string, data: AOTCacheData): void {
-    const cachePath = join(cacheDir, CACHE_FILENAME);
-    try {
-        mkdirSync(cacheDir, {recursive: true});
-        const cacheFile: AOTDiskCacheFile = {
-            cacheVersion: AOT_DISK_CACHE_VERSION,
-            hash,
-            jitFnsCode: data.jitFnsCode,
-            pureFnsCode: data.pureFnsCode,
-            routerCacheCode: data.routerCacheCode,
-        };
-        writeFileSync(cachePath, JSON.stringify(cacheFile), 'utf-8');
-    } catch (err) {
-        console.warn(`[mion] Warning: Could not write AOT disk cache: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-
-/** Resolve the cache directory from options and Vite's cacheDir */
-export function resolveCacheDir(options: AOTCacheOptions, viteCacheDir?: string): string {
-    if (options.cache === false) return '';
-    if (typeof options.cache === 'string') return resolve(options.cache);
-    return viteCacheDir || resolve(process.cwd(), 'node_modules/.vite');
-}
-
-/** Load AOT caches from disk if valid, otherwise generate fresh and save to disk. */
-export async function getOrGenerateAOTCaches(
-    serverConfig: MionServerConfig,
-    aotOptions: AOTCacheOptions | undefined,
-    cacheDir: string
-): Promise<AOTCacheResult> {
-    const forceRegenerate = process.env.MION_AOT_FORCE === 'true';
-    // IPC mode always needs a live child process (the server), so skip disk caching entirely
-    const isIPCMode = serverConfig.runMode === 'childProcess';
-    const cachingEnabled = cacheDir !== '' && !forceRegenerate && !isIPCMode;
-
-    let hash = '';
-    if (cachingEnabled) {
-        hash = computeSourceHash(serverConfig, aotOptions);
-        const cached = readDiskCache(cacheDir);
-        if (cached && cached.cacheVersion === AOT_DISK_CACHE_VERSION && cached.hash === hash) {
-            console.log('[mion] AOT caches loaded from disk cache (source unchanged)');
-            return {
-                data: {
-                    jitFnsCode: cached.jitFnsCode,
-                    pureFnsCode: cached.pureFnsCode,
-                    routerCacheCode: cached.routerCacheCode,
-                },
-            };
-        }
-    }
-
-    // Cache miss or caching disabled — generate fresh
-    const result = await generateAOTCaches(serverConfig, undefined, aotOptions?.isClient);
-
-    if (cachingEnabled) {
-        if (!hash) hash = computeSourceHash(serverConfig, aotOptions);
-        writeDiskCache(cacheDir, hash, result.data);
-        console.log('[mion] AOT caches saved to disk cache');
-    }
-
-    return result;
-}
-
-/** Update the disk cache after HMR regeneration */
-export function updateDiskCache(
-    serverConfig: MionServerConfig,
-    aotOptions: AOTCacheOptions | undefined,
-    data: AOTCacheData,
-    cacheDir: string
-): void {
-    if (!cacheDir || aotOptions?.cache === false) return;
-    const hash = computeSourceHash(serverConfig, aotOptions);
-    writeDiskCache(cacheDir, hash, data);
-}

package/src/vite-plugin/cjsPackageJsonPlugin.ts

@@ -1,21 +0,0 @@
-/* ########
- * 2026 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import type {Plugin} from 'vite';
-import {writeFileSync} from 'fs';
-
-/** Writes {"type": "commonjs"} package.json in CJS output dirs so Node.js doesn't treat .cjs files ambiguously */
-export function cjsPackageJsonPlugin(...cjsDirs: string[]): Plugin {
-    return {
-        name: 'cjs-package-json',
-        closeBundle() {
-            for (const dir of cjsDirs) {
-                writeFileSync(`${dir}/package.json`, '{"type":"commonjs"}\n');
-            }
-        },
-    };
-}

package/src/vite-plugin/constants.ts

@@ -1,50 +0,0 @@
-/* ########
- * 2026 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-export const BODY_HASH_LENGTH = 14;
-
-/** Virtual module ID for the pure functions registry (client-extracted pure functions) */
-export const VIRTUAL_SERVER_PURE_FNS = 'virtual:mion-server-pure-fns';
-
-// ============ AOT Virtual Modules ============
-
-/** Virtual module ID for JIT functions + pure functions cache (from running the router) */
-export const VIRTUAL_AOT_JIT_FNS = 'virtual:mion-aot/jit-fns';
-
-/** Virtual module ID for pure functions cache (standalone, from client AST extraction) */
-export const VIRTUAL_AOT_PURE_FNS = 'virtual:mion-aot/pure-fns';
-
-/** Virtual module ID for router methods cache */
-export const VIRTUAL_AOT_ROUTER_CACHE = 'virtual:mion-aot/router-cache';
-
-/** Virtual module ID for combined AOT caches (re-exports all 3 cache modules) */
-export const VIRTUAL_AOT_CACHES = 'virtual:mion-aot/caches';
-
-/** The real module that acts as a shim for AOT caches (empty caches). Swapped by the plugin when AOT is enabled. */
-export const AOT_CACHES_SHIM = '@mionjs/core/aot-caches';
-
-/** The real module that acts as a shim for server pure functions (empty cache). Swapped by the plugin when serverPureFunctions is enabled. */
-export const SERVER_PURE_FNS_SHIM = '@mionjs/core/server-pure-fns';
-
-/** The namespace used for all pureServerFn functions */
-export const PURE_SERVER_FN_NAMESPACE = 'pureServerFn';
-
-/** Resolves a virtual module ID to its internal Vite ID (\0 prefix + .ts extension) */
-export function resolveVirtualId(id: string): string {
-    return '\0' + id + '.ts';
-}
-
-// ============ Reflection Stubs (for excludeReflection) ============
-
-/** Modules stubbed out when excludeReflection is enabled (not needed at runtime in AOT mode) */
-export const REFLECTION_MODULES = ['@mionjs/run-types', '@deepkit/type', '@deepkit/core'];
-
-/** Prefix for virtual stub module IDs */
-export const VIRTUAL_STUB_PREFIX = 'virtual:mion-stub/';
-
-// Purity validation constants (ALLOWED_GLOBALS, FORBIDDEN_IDENTIFIERS, FACTORY_FORBIDDEN_IDENTIFIERS)
-// are in ../pureFns/purityRules.ts, shared with the eslint plugin.