@mionjs/devtools 0.8.0-alpha.0

package/build/vite-plugin/esm/src/pureFns/purityRules.js

@@ -0,0 +1,65 @@
+const ALLOWED_GLOBALS = /* @__PURE__ */ new Set([
+  // Value types
+  "undefined",
+  "null",
+  "NaN",
+  "Infinity",
+  "true",
+  "false",
+  // Built-in constructors/objects
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Math",
+  "JSON",
+  "Date",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Symbol",
+  "BigInt",
+  "Promise",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI",
+  // Common safe globals
+  "console",
+  "globalThis",
+  "Bun"
+]);
+const FORBIDDEN_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "eval",
+  "Function",
+  "fetch",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "process",
+  "window",
+  "document",
+  "global",
+  "require",
+  "XMLHttpRequest",
+  "WebSocket",
+  "localStorage",
+  "sessionStorage",
+  "indexedDB"
+]);
+export {
+  ALLOWED_GLOBALS,
+  FORBIDDEN_IDENTIFIERS
+};
+//# sourceMappingURL=purityRules.js.map

package/build/vite-plugin/esm/src/pureFns/purityRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"purityRules.js","sources":["../../../../../src/pureFns/purityRules.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\n/** Globals and built-ins that are allowed inside pure functions */\nexport const ALLOWED_GLOBALS = new Set([\n    // Value types\n    'undefined',\n    'null',\n    'NaN',\n    'Infinity',\n    'true',\n    'false',\n    // Built-in constructors/objects\n    'Object',\n    'Array',\n    'String',\n    'Number',\n    'Boolean',\n    'Math',\n    'JSON',\n    'Date',\n    'RegExp',\n    'Map',\n    'Set',\n    'WeakMap',\n    'WeakSet',\n    'Symbol',\n    'BigInt',\n    'Promise',\n    'Error',\n    'TypeError',\n    'RangeError',\n    'parseInt',\n    'parseFloat',\n    'isNaN',\n    'isFinite',\n    'encodeURIComponent',\n    'decodeURIComponent',\n    'encodeURI',\n    'decodeURI',\n    // Common safe globals\n    'console',\n    'globalThis',\n    'Bun',\n]);\n\n/** Forbidden identifiers that indicate impure operations in pure functions */\nexport const FORBIDDEN_IDENTIFIERS = new Set([\n    'eval',\n    'Function',\n    'fetch',\n    'setTimeout',\n    'setInterval',\n    'clearTimeout',\n    'clearInterval',\n    'process',\n    'window',\n    'document',\n    'global',\n    'require',\n    'XMLHttpRequest',\n    'WebSocket',\n    'localStorage',\n    'sessionStorage',\n    'indexedDB',\n]);\n\n/** The target function names that purity validation applies to */\nexport const PURE_FN_CALL_NAMES = ['pureServerFn', 'registerPureFnFactory', 'mapFrom'] as const;\n\n/** The packages that export the target pure function APIs */\nexport const PURE_FN_SOURCE_PACKAGES = ['@mionjs/core', '@mionjs/client'] as const;\n"],"names":[],"mappings":"AAQO,MAAM,sCAAsB,IAAI;AAAA;AAAA,EAEnC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;AAGM,MAAM,4CAA4B,IAAI;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;"}

package/build/vite-plugin/esm/src/vite-plugin/aotCacheGenerator.d.ts

@@ -0,0 +1,23 @@
+import { ChildProcess } from 'child_process';
+import { MionServerConfig } from './types.ts';
+export interface AOTCacheData {
+    jitFnsCode: string;
+    pureFnsCode: string;
+    routerCacheCode: string;
+}
+export interface AOTCacheResult {
+    data: AOTCacheData;
+    childProcess?: ChildProcess;
+}
+export declare function generateAOTCaches(serverConfig: MionServerConfig, startScriptOverride?: string): Promise<AOTCacheResult>;
+export type ModuleLoader = (url: string) => Promise<Record<string, any>>;
+export declare function loadSSRRouterAndGenerateAOTCaches(loadModule: ModuleLoader, startServerScript: string): Promise<AOTCacheData>;
+export declare function killPersistentChild(child: ChildProcess | null): Promise<void>;
+export declare function logAOTCaches(data: AOTCacheData): void;
+export declare function generateJitFnsModule(jitFnsCode: string): string;
+export declare function generatePureFnsModule(pureFnsCode: string): string;
+export declare function generateRouterCacheModule(routerCacheCode: string): string;
+export declare function generateCombinedCachesModule(): string;
+export declare function generateNoopModule(comment: string): string;
+export declare function waitForServer(port: number, timeoutMs?: number): Promise<void>;
+export declare function generateNoopCombinedModule(): string;

package/build/vite-plugin/esm/src/vite-plugin/aotCacheGenerator.js

@@ -0,0 +1,235 @@
+import { fork } from "child_process";
+import { resolve, dirname } from "path";
+import { resolveModule } from "./resolveModule.js";
+const DEFAULT_TIMEOUT = 3e4;
+async function generateAOTCaches(serverConfig, startScriptOverride) {
+  const persist = serverConfig.mode === "IPC";
+  const startScript = resolve(startScriptOverride ?? serverConfig.startServerScript);
+  const scriptDir = dirname(startScript);
+  const viteConfigArgs = serverConfig.serverViteConfig ? ["--config", resolve(serverConfig.serverViteConfig)] : [];
+  let viteNodePath;
+  try {
+    viteNodePath = await resolveModule("vite-node/cli", scriptDir);
+  } catch (err) {
+    throw new Error(
+      `Failed to resolve vite-node. Make sure vite-node is installed.
+You can install it with: npm install -D vite-node
+Original error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return new Promise((resolvePromise, reject) => {
+    let child;
+    let resolved = false;
+    let stderr = "";
+    try {
+      child = fork(viteNodePath, [...viteConfigArgs, startScript], {
+        env: { ...process.env, MION_COMPILE: persist ? "serve" : "onlyAOT" },
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+        cwd: scriptDir
+      });
+    } catch (err) {
+      reject(
+        new Error(
+          `Failed to spawn vite-node. Make sure vite-node is installed.
+You can install it with: npm install -D vite-node
+Original error: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      return;
+    }
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      if (child.connected) child.disconnect();
+      if (!persist) child.kill();
+    };
+    child.on("message", (msg) => {
+      const message = msg;
+      if (message?.type === "mion-aot-caches") {
+        resolved = true;
+        cleanup();
+        resolvePromise({
+          data: {
+            jitFnsCode: message.jitFnsCode,
+            pureFnsCode: message.pureFnsCode,
+            routerCacheCode: message.routerCacheCode
+          },
+          childProcess: persist ? child : void 0
+        });
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (!resolved) stderr += msg + "\n";
+      if (persist && msg) console.error(`[mion-server] ${msg}`);
+    });
+    child.stdout?.on("data", (data) => {
+      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.
+Make sure the startServerScript calls initMionRouter() and the router is fully initialized.
+` + (stderr ? `stderr: ${stderr}` : "")
+          )
+        );
+      }
+    });
+    const timeoutId = setTimeout(() => {
+      if (!resolved) {
+        cleanup();
+        if (persist) child.kill();
+        reject(
+          new Error(
+            `AOT cache generation timed out (${DEFAULT_TIMEOUT / 1e3}s). Make sure the server start script completes initialization.`
+          )
+        );
+      }
+    }, DEFAULT_TIMEOUT);
+  });
+}
+async function loadSSRRouterAndGenerateAOTCaches(loadModule, startServerScript) {
+  const prevCompile = process.env.MION_COMPILE;
+  process.env.MION_COMPILE = "viteSSR";
+  try {
+    const mod = await loadModule(startServerScript);
+    const promises = Object.values(mod).filter((v) => v instanceof Promise);
+    if (promises.length > 0) await Promise.all(promises);
+    const aotModule = await loadModule("@mionjs/router/aot");
+    const caches = await aotModule.getSerializedCaches();
+    return caches;
+  } finally {
+    if (prevCompile === void 0) delete process.env.MION_COMPILE;
+    else process.env.MION_COMPILE = prevCompile;
+  }
+}
+async function killPersistentChild(child) {
+  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((resolve2) => {
+    const timeout = setTimeout(() => {
+      if (child && !child.killed) {
+        if (pid) {
+          try {
+            process.kill(-pid, "SIGKILL");
+          } catch {
+            child.kill("SIGKILL");
+          }
+        } else {
+          child.kill("SIGKILL");
+        }
+      }
+      resolve2();
+    }, 5e3);
+    child.on("exit", () => {
+      clearTimeout(timeout);
+      resolve2();
+    });
+  });
+}
+function formatBytes(bytes) {
+  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`;
+}
+function logAOTCaches(data) {
+  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);
+  }
+}
+function generateJitFnsModule(jitFnsCode) {
+  return `/* Auto-generated AOT JIT functions cache - do not edit */
+export const jitFnsCache = ${jitFnsCode};
+`;
+}
+function generatePureFnsModule(pureFnsCode) {
+  return `/* Auto-generated AOT pure functions cache - do not edit */
+export const pureFnsCache = ${pureFnsCode};
+`;
+}
+function generateRouterCacheModule(routerCacheCode) {
+  return `/* Auto-generated AOT router cache - do not edit */
+export const routerCache = ${routerCacheCode};
+`;
+}
+function generateCombinedCachesModule() {
+  return `/* Auto-generated combined AOT caches - do not edit */
+import { addAOTCaches, addRoutesToCache } from '@mionjs/core';
+import { pureFnsCache } from 'virtual:mion-aot/pure-fns';
+import { jitFnsCache } from 'virtual:mion-aot/jit-fns';
+import { routerCache } from 'virtual:mion-aot/router-cache';
+
+addAOTCaches(jitFnsCache, pureFnsCache);
+addRoutesToCache(routerCache);
+
+export { jitFnsCache, pureFnsCache, routerCache };
+`;
+}
+function generateNoopModule(comment) {
+  return `/* ${comment} */
+`;
+}
+async function waitForServer(port, timeoutMs = 3e4) {
+  const startTime = Date.now();
+  const checkInterval = 100;
+  while (Date.now() - startTime < timeoutMs) {
+    try {
+      const response = await fetch(`http://localhost:${port}/`);
+      if (response.ok || response.status === 404) return;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, checkInterval));
+  }
+  throw new Error(`[mion] Server failed to become ready on port ${port} within ${timeoutMs}ms`);
+}
+function generateNoopCombinedModule() {
+  return `/* No-op: AOT caches not generated */
+export const jitFnsCache = {};
+export const pureFnsCache = {};
+export const routerCache = {};
+`;
+}
+export {
+  generateAOTCaches,
+  generateCombinedCachesModule,
+  generateJitFnsModule,
+  generateNoopCombinedModule,
+  generateNoopModule,
+  generatePureFnsModule,
+  generateRouterCacheModule,
+  killPersistentChild,
+  loadSSRRouterAndGenerateAOTCaches,
+  logAOTCaches,
+  waitForServer
+};
+//# sourceMappingURL=aotCacheGenerator.js.map

package/build/vite-plugin/esm/src/vite-plugin/aotCacheGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aotCacheGenerator.js","sources":["../../../../../src/vite-plugin/aotCacheGenerator.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {fork, ChildProcess} from 'child_process';\nimport {resolve, dirname} from 'path';\nimport {MionServerConfig} from './types.ts';\nimport {resolveModule} from './resolveModule.ts';\n\n/** AOT cache data returned from the generator */\nexport interface AOTCacheData {\n    jitFnsCode: string;\n    pureFnsCode: string;\n    routerCacheCode: string;\n}\n\n/** AOT cache result including optional persistent child process */\nexport interface AOTCacheResult {\n    data: AOTCacheData;\n    /** The child process, only present when server mode is 'IPC' (persist) */\n    childProcess?: ChildProcess;\n}\n\n/** IPC message type from the router's aotEmitter */\ninterface AOTCacheMessage {\n    type: 'mion-aot-caches';\n    jitFnsCode: string;\n    pureFnsCode: string;\n    routerCacheCode: string;\n}\n\n/** Default timeout for AOT cache generation (30 seconds) */\nconst DEFAULT_TIMEOUT = 30000;\n\n/**\n * Generates AOT caches by spawning vite-node to run the server's start script.\n *\n * vite-node is used instead of plain node/ts-node because:\n * 1. The server needs deepkit type compiler transformations\n * 2. The server's vite.config.ts has aliases and plugins that must be applied\n * 3. vite-node provides the same environment as the actual server build\n *\n * The router's emitAOTCaches() (called automatically from initMionRouter)\n * detects MION_COMPILE and sends the serialized caches via IPC.\n */\nexport async function generateAOTCaches(serverConfig: MionServerConfig, startScriptOverride?: string): Promise<AOTCacheResult> {\n    const persist = serverConfig.mode === 'IPC';\n    const startScript = resolve(startScriptOverride ?? serverConfig.startServerScript);\n    const scriptDir = dirname(startScript);\n\n    // Determine the vite config to use\n    // If serverViteConfig is provided, use it; otherwise let vite-node auto-discover\n    const viteConfigArgs = serverConfig.serverViteConfig ? ['--config', resolve(serverConfig.serverViteConfig)] : [];\n\n    // Resolve vite-node path in both CJS and ESM environments\n    let viteNodePath: string;\n    try {\n        viteNodePath = await resolveModule('vite-node/cli', scriptDir);\n    } catch (err) {\n        throw new Error(\n            `Failed to resolve vite-node. Make sure vite-node is installed.\\n` +\n                `You can install it with: npm install -D vite-node\\n` +\n                `Original error: ${err instanceof Error ? err.message : String(err)}`\n        );\n    }\n\n    return new Promise((resolvePromise, reject) => {\n        let child: ChildProcess;\n        let resolved = false;\n        let stderr = '';\n\n        try {\n            // Spawn vite-node as a child process with IPC channel\n            // 'serve' mode tells platform adapters to proceed with server.listen()\n            child = fork(viteNodePath, [...viteConfigArgs, startScript], {\n                env: {...process.env, MION_COMPILE: persist ? 'serve' : 'onlyAOT'},\n                stdio: ['pipe', 'pipe', 'pipe', 'ipc'],\n                cwd: scriptDir,\n            });\n        } catch (err) {\n            // If vite-node is not found, provide a helpful error message\n            reject(\n                new Error(\n                    `Failed to spawn vite-node. Make sure vite-node is installed.\\n` +\n                        `You can install it with: npm install -D vite-node\\n` +\n                        `Original error: ${err instanceof Error ? err.message : String(err)}`\n                )\n            );\n            return;\n        }\n\n        /** Cleanup child process: disconnect IPC, clear timeout, and optionally kill */\n        const cleanup = () => {\n            clearTimeout(timeoutId);\n            if (child.connected) child.disconnect();\n            if (!persist) child.kill();\n        };\n\n        child.on('message', (msg: unknown) => {\n            const message = msg as AOTCacheMessage;\n            if (message?.type === 'mion-aot-caches') {\n                resolved = true;\n                cleanup();\n                resolvePromise({\n                    data: {\n                        jitFnsCode: message.jitFnsCode,\n                        pureFnsCode: message.pureFnsCode,\n                        routerCacheCode: message.routerCacheCode,\n                    },\n                    childProcess: persist ? child : undefined,\n                });\n            }\n        });\n\n        // Capture stderr for error reporting (and pipe through in persist mode)\n        child.stderr?.on('data', (data: Buffer) => {\n            const msg = data.toString().trim();\n            if (!resolved) stderr += msg + '\\n';\n            if (persist && msg) console.error(`[mion-server] ${msg}`);\n        });\n\n        // Pipe stdout through (always in persist mode, only with DEBUG_AOT otherwise)\n        child.stdout?.on('data', (data: Buffer) => {\n            const msg = data.toString().trim();\n            if (persist && msg) {\n                console.log(`[mion-server] ${msg}`);\n            } else if (process.env.DEBUG_AOT && msg) {\n                console.log('[mion-aot] stdout:', msg);\n            }\n        });\n\n        child.on('error', (err) => {\n            if (!resolved) {\n                cleanup();\n                reject(new Error(`vite-node failed to start: ${err.message}`));\n            }\n        });\n\n        child.on('exit', (code) => {\n            if (!resolved) {\n                cleanup();\n                reject(\n                    new Error(\n                        `vite-node exited with code ${code} before emitting AOT caches.\\n` +\n                            `Make sure the startServerScript calls initMionRouter() and the router ` +\n                            `is fully initialized.\\n` +\n                            (stderr ? `stderr: ${stderr}` : '')\n                    )\n                );\n            }\n        });\n\n        // Timeout safety\n        const timeoutId = setTimeout(() => {\n            if (!resolved) {\n                cleanup();\n                if (persist) child.kill();\n                reject(\n                    new Error(\n                        `AOT cache generation timed out (${DEFAULT_TIMEOUT / 1000}s). ` +\n                            `Make sure the server start script completes initialization.`\n                    )\n                );\n            }\n        }, DEFAULT_TIMEOUT);\n    });\n}\n\n/** Loads a module by URL — abstracts over ssrLoadModule and Environment Runner */\nexport type ModuleLoader = (url: string) => Promise<Record<string, any>>;\n\n/**\n *  Loads the startServerScript with MION_COMPILE=SSR so platform adapters skip server.listen().\n *  Generates AOT caches via SSR using a module loader (for same-Vite-process scenarios like Nuxt).\n *  After loading, retrieves the caches directly from the router's global state via getSerializedCaches(). */\nexport async function loadSSRRouterAndGenerateAOTCaches(\n    loadModule: ModuleLoader,\n    startServerScript: string\n): Promise<AOTCacheData> {\n    const prevCompile = process.env.MION_COMPILE;\n    process.env.MION_COMPILE = 'viteSSR';\n\n    try {\n        // Load the start server script — triggers initMionRouter(), populates caches,\n        // skips process.send (SSR mode) and skips server.listen() (platform adapters)\n        const mod = await loadModule(startServerScript);\n        // Await any Promise-valued exports (e.g. initMionRouter() without top-level await)\n        const promises = Object.values(mod).filter((v): v is Promise<any> => v instanceof Promise);\n        if (promises.length > 0) await Promise.all(promises);\n\n        // Get caches directly from the router's global state\n        const aotModule = await loadModule('@mionjs/router/aot');\n        const caches: AOTCacheData = await aotModule.getSerializedCaches();\n        return caches;\n    } finally {\n        if (prevCompile === undefined) delete process.env.MION_COMPILE;\n        else process.env.MION_COMPILE = prevCompile;\n    }\n}\n\n// ============ Persistent child management ============\n\n/** Kills a persistent child process gracefully (SIGTERM then SIGKILL after 5s) */\nexport async function killPersistentChild(child: ChildProcess | null): Promise<void> {\n    if (!child || child.killed) return;\n    const pid = child.pid;\n\n    if (pid) {\n        try {\n            process.kill(-pid, 'SIGTERM');\n        } catch {\n            child.kill('SIGTERM');\n        }\n    } else {\n        child.kill('SIGTERM');\n    }\n\n    await new Promise<void>((resolve) => {\n        const timeout = setTimeout(() => {\n            if (child && !child.killed) {\n                if (pid) {\n                    try {\n                        process.kill(-pid, 'SIGKILL');\n                    } catch {\n                        child.kill('SIGKILL');\n                    }\n                } else {\n                    child.kill('SIGKILL');\n                }\n            }\n            resolve();\n        }, 5000);\n\n        child!.on('exit', () => {\n            clearTimeout(timeout);\n            resolve();\n        });\n    });\n}\n\n// ============ Logging ============\n\n/** Formats byte size to human-readable string */\nfunction formatBytes(bytes: number): string {\n    if (bytes < 1024) return `${bytes} B`;\n    const kb = bytes / 1024;\n    if (kb < 1024) return `${kb.toFixed(1)} KB`;\n    const mb = kb / 1024;\n    return `${mb.toFixed(1)} MB`;\n}\n\n/** Logs AOT cache sizes and optionally full contents in verbose mode (DEBUG_AOT) */\nexport function logAOTCaches(data: AOTCacheData): void {\n    const jitSize = formatBytes(Buffer.byteLength(data.jitFnsCode, 'utf-8'));\n    const pureSize = formatBytes(Buffer.byteLength(data.pureFnsCode, 'utf-8'));\n    const routerSize = formatBytes(Buffer.byteLength(data.routerCacheCode, 'utf-8'));\n    console.log(`[mion]   jitFns: ${jitSize}, pureFns: ${pureSize}, routerCache: ${routerSize}`);\n\n    if (process.env.DEBUG_AOT) {\n        console.log('[mion] AOT jitFns cache:\\n', data.jitFnsCode);\n        console.log('[mion] AOT pureFns cache:\\n', data.pureFnsCode);\n        console.log('[mion] AOT routerCache:\\n', data.routerCacheCode);\n    }\n}\n\n// ============ Module Generators ============\n\n/** Generates the virtual module code for JIT functions cache (exports only). */\nexport function generateJitFnsModule(jitFnsCode: string): string {\n    return `/* Auto-generated AOT JIT functions cache - do not edit */\nexport const jitFnsCache = ${jitFnsCode};\n`;\n}\n\n/** Generates the virtual module code for pure functions cache (exports only). */\nexport function generatePureFnsModule(pureFnsCode: string): string {\n    return `/* Auto-generated AOT pure functions cache - do not edit */\nexport const pureFnsCache = ${pureFnsCode};\n`;\n}\n\n/** Generates the virtual module code for router methods cache (exports only). */\nexport function generateRouterCacheModule(routerCacheCode: string): string {\n    return `/* Auto-generated AOT router cache - do not edit */\nexport const routerCache = ${routerCacheCode};\n`;\n}\n\n/** Generates the combined virtual module that imports all 3 caches, registers them, and re-exports. */\nexport function generateCombinedCachesModule(): string {\n    return `/* Auto-generated combined AOT caches - do not edit */\nimport { addAOTCaches, addRoutesToCache } from '@mionjs/core';\nimport { pureFnsCache } from 'virtual:mion-aot/pure-fns';\nimport { jitFnsCache } from 'virtual:mion-aot/jit-fns';\nimport { routerCache } from 'virtual:mion-aot/router-cache';\n\naddAOTCaches(jitFnsCache, pureFnsCache);\naddRoutesToCache(routerCache);\n\nexport { jitFnsCache, pureFnsCache, routerCache };\n`;\n}\n\n/** Generates a no-op module for when AOT caches are disabled. */\nexport function generateNoopModule(comment: string): string {\n    return `/* ${comment} */\\n`;\n}\n\n/** Poll an HTTP port until the server responds (2xx or 404). */\nexport async function waitForServer(port: number, timeoutMs = 30000): Promise<void> {\n    const startTime = Date.now();\n    const checkInterval = 100;\n    while (Date.now() - startTime < timeoutMs) {\n        try {\n            const response = await fetch(`http://localhost:${port}/`);\n            if (response.ok || response.status === 404) return;\n        } catch {\n            // Server not ready yet\n        }\n        await new Promise((r) => setTimeout(r, checkInterval));\n    }\n    throw new Error(`[mion] Server failed to become ready on port ${port} within ${timeoutMs}ms`);\n}\n\n/** Generates a no-op combined module that exports empty caches. */\nexport function generateNoopCombinedModule(): string {\n    return `/* No-op: AOT caches not generated */\nexport const jitFnsCache = {};\nexport const pureFnsCache = {};\nexport const routerCache = {};\n`;\n}\n"],"names":["resolve"],"mappings":"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"}

package/build/vite-plugin/esm/src/vite-plugin/aotDiskCache.d.ts

@@ -0,0 +1,6 @@
+import { AOTCacheOptions, MionServerConfig } from './types.ts';
+import { AOTCacheData, AOTCacheResult } from './aotCacheGenerator.ts';
+export declare function computeSourceHash(serverConfig: MionServerConfig, aotOptions?: AOTCacheOptions): string;
+export declare function resolveCacheDir(options: AOTCacheOptions, viteCacheDir?: string): string;
+export declare function getOrGenerateAOTCaches(serverConfig: MionServerConfig, aotOptions: AOTCacheOptions | undefined, cacheDir: string): Promise<AOTCacheResult>;
+export declare function updateDiskCache(serverConfig: MionServerConfig, aotOptions: AOTCacheOptions | undefined, data: AOTCacheData, cacheDir: string): void;

package/build/vite-plugin/esm/src/vite-plugin/aotDiskCache.js

@@ -0,0 +1,133 @@
+import { createHash } from "crypto";
+import { readdirSync, statSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve, join, relative } from "path";
+import { generateAOTCaches } from "./aotCacheGenerator.js";
+const AOT_DISK_CACHE_VERSION = "2";
+const CACHE_FILENAME = "mion-aot-cache.json";
+const SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".dist", "dist", ".git", ".vite", "build", "coverage", ".coverage"]);
+const SOURCE_EXTENSIONS = /\.(ts|tsx)$/;
+const TEST_FILE_PATTERN = /\.(spec|test)\.(ts|tsx)$/;
+let devtoolsVersion = null;
+function getDevtoolsVersion() {
+  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;
+}
+function collectFileStats(dir, baseDir) {
+  const entries = [];
+  let files;
+  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;
+}
+function computeSourceHash(serverConfig, aotOptions) {
+  const serverDir = dirname(resolve(serverConfig.startServerScript));
+  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())}`
+  ].join("\n");
+  return createHash("sha256").update(hashInput).digest("hex");
+}
+function readDiskCache(cacheDir) {
+  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;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeDiskCache(cacheDir, hash, data) {
+  const cachePath = join(cacheDir, CACHE_FILENAME);
+  try {
+    mkdirSync(cacheDir, { recursive: true });
+    const cacheFile = {
+      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)}`);
+  }
+}
+function resolveCacheDir(options, viteCacheDir) {
+  if (options.cache === false) return "";
+  if (typeof options.cache === "string") return resolve(options.cache);
+  return viteCacheDir || resolve(process.cwd(), "node_modules/.vite");
+}
+async function getOrGenerateAOTCaches(serverConfig, aotOptions, cacheDir) {
+  const forceRegenerate = process.env.MION_AOT_FORCE === "true";
+  const isIPCMode = serverConfig.mode === "IPC";
+  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
+        }
+      };
+    }
+  }
+  const result = await generateAOTCaches(serverConfig);
+  if (cachingEnabled) {
+    if (!hash) hash = computeSourceHash(serverConfig, aotOptions);
+    writeDiskCache(cacheDir, hash, result.data);
+    console.log("[mion] AOT caches saved to disk cache");
+  }
+  return result;
+}
+function updateDiskCache(serverConfig, aotOptions, data, cacheDir) {
+  if (!cacheDir || aotOptions?.cache === false) return;
+  const hash = computeSourceHash(serverConfig, aotOptions);
+  writeDiskCache(cacheDir, hash, data);
+}
+export {
+  computeSourceHash,
+  getOrGenerateAOTCaches,
+  resolveCacheDir,
+  updateDiskCache
+};
+//# sourceMappingURL=aotDiskCache.js.map

package/build/vite-plugin/esm/src/vite-plugin/aotDiskCache.js.map

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

package/build/vite-plugin/esm/src/vite-plugin/cjsPackageJsonPlugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'vite';
+export declare function cjsPackageJsonPlugin(...cjsDirs: string[]): Plugin;

package/build/vite-plugin/esm/src/vite-plugin/cjsPackageJsonPlugin.js

@@ -0,0 +1,15 @@
+import { writeFileSync } from "fs";
+function cjsPackageJsonPlugin(...cjsDirs) {
+  return {
+    name: "cjs-package-json",
+    closeBundle() {
+      for (const dir of cjsDirs) {
+        writeFileSync(`${dir}/package.json`, '{"type":"commonjs"}\n');
+      }
+    }
+  };
+}
+export {
+  cjsPackageJsonPlugin
+};
+//# sourceMappingURL=cjsPackageJsonPlugin.js.map

package/build/vite-plugin/esm/src/vite-plugin/cjsPackageJsonPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cjsPackageJsonPlugin.js","sources":["../../../../../src/vite-plugin/cjsPackageJsonPlugin.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {Plugin} from 'vite';\nimport {writeFileSync} from 'fs';\n\n/** Writes {\"type\": \"commonjs\"} package.json in CJS output dirs so Node.js doesn't treat .cjs files ambiguously */\nexport function cjsPackageJsonPlugin(...cjsDirs: string[]): Plugin {\n    return {\n        name: 'cjs-package-json',\n        closeBundle() {\n            for (const dir of cjsDirs) {\n                writeFileSync(`${dir}/package.json`, '{\"type\":\"commonjs\"}\\n');\n            }\n        },\n    };\n}\n"],"names":[],"mappings":";AAWO,SAAS,wBAAwB,SAA2B;AAC/D,SAAO;AAAA,IACH,MAAM;AAAA,IACN,cAAc;AACV,iBAAW,OAAO,SAAS;AACvB,sBAAc,GAAG,GAAG,iBAAiB,uBAAuB;AAAA,MAChE;AAAA,IACJ;AAAA,EAAA;AAER;"}

package/build/vite-plugin/esm/src/vite-plugin/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const BODY_HASH_LENGTH = 14;
+export declare const VIRTUAL_SERVER_PURE_FNS = "virtual:mion-server-pure-fns";
+export declare const VIRTUAL_AOT_JIT_FNS = "virtual:mion-aot/jit-fns";
+export declare const VIRTUAL_AOT_PURE_FNS = "virtual:mion-aot/pure-fns";
+export declare const VIRTUAL_AOT_ROUTER_CACHE = "virtual:mion-aot/router-cache";
+export declare const VIRTUAL_AOT_CACHES = "virtual:mion-aot/caches";
+export declare const PURE_SERVER_FN_NAMESPACE = "pureServerFn";
+export declare function resolveVirtualId(id: string): string;
+export declare const REFLECTION_MODULES: string[];
+export declare const VIRTUAL_STUB_PREFIX = "virtual:mion-stub/";

package/build/vite-plugin/esm/src/vite-plugin/constants.js

@@ -0,0 +1,25 @@
+const BODY_HASH_LENGTH = 14;
+const VIRTUAL_SERVER_PURE_FNS = "virtual:mion-server-pure-fns";
+const VIRTUAL_AOT_JIT_FNS = "virtual:mion-aot/jit-fns";
+const VIRTUAL_AOT_PURE_FNS = "virtual:mion-aot/pure-fns";
+const VIRTUAL_AOT_ROUTER_CACHE = "virtual:mion-aot/router-cache";
+const VIRTUAL_AOT_CACHES = "virtual:mion-aot/caches";
+const PURE_SERVER_FN_NAMESPACE = "pureServerFn";
+function resolveVirtualId(id) {
+  return "\0" + id + ".ts";
+}
+const REFLECTION_MODULES = ["@mionjs/run-types", "@deepkit/type", "@deepkit/core"];
+const VIRTUAL_STUB_PREFIX = "virtual:mion-stub/";
+export {
+  BODY_HASH_LENGTH,
+  PURE_SERVER_FN_NAMESPACE,
+  REFLECTION_MODULES,
+  VIRTUAL_AOT_CACHES,
+  VIRTUAL_AOT_JIT_FNS,
+  VIRTUAL_AOT_PURE_FNS,
+  VIRTUAL_AOT_ROUTER_CACHE,
+  VIRTUAL_SERVER_PURE_FNS,
+  VIRTUAL_STUB_PREFIX,
+  resolveVirtualId
+};
+//# sourceMappingURL=constants.js.map

package/build/vite-plugin/esm/src/vite-plugin/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../../src/vite-plugin/constants.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nexport const BODY_HASH_LENGTH = 14;\n\n/** Virtual module ID for the pure functions registry (client-extracted pure functions) */\nexport const VIRTUAL_SERVER_PURE_FNS = 'virtual:mion-server-pure-fns';\n\n// ============ AOT Virtual Modules ============\n\n/** Virtual module ID for JIT functions + pure functions cache (from running the router) */\nexport const VIRTUAL_AOT_JIT_FNS = 'virtual:mion-aot/jit-fns';\n\n/** Virtual module ID for pure functions cache (standalone, from client AST extraction) */\nexport const VIRTUAL_AOT_PURE_FNS = 'virtual:mion-aot/pure-fns';\n\n/** Virtual module ID for router methods cache */\nexport const VIRTUAL_AOT_ROUTER_CACHE = 'virtual:mion-aot/router-cache';\n\n/** Virtual module ID for combined AOT caches (re-exports all 3 cache modules) */\nexport const VIRTUAL_AOT_CACHES = 'virtual:mion-aot/caches';\n\n/** The namespace used for all pureServerFn functions */\nexport const PURE_SERVER_FN_NAMESPACE = 'pureServerFn';\n\n/** Resolves a virtual module ID to its internal Vite ID (\\0 prefix + .ts extension) */\nexport function resolveVirtualId(id: string): string {\n    return '\\0' + id + '.ts';\n}\n\n// ============ Reflection Stubs (for excludeReflection) ============\n\n/** Modules stubbed out when excludeReflection is enabled (not needed at runtime in AOT mode) */\nexport const REFLECTION_MODULES = ['@mionjs/run-types', '@deepkit/type', '@deepkit/core'];\n\n/** Prefix for virtual stub module IDs */\nexport const VIRTUAL_STUB_PREFIX = 'virtual:mion-stub/';\n\n// Purity validation constants (ALLOWED_GLOBALS, FORBIDDEN_IDENTIFIERS, FACTORY_FORBIDDEN_IDENTIFIERS)\n// are in ../pureFns/purityRules.ts, shared with the eslint plugin.\n"],"names":[],"mappings":"AAOO,MAAM,mBAAmB;AAGzB,MAAM,0BAA0B;AAKhC,MAAM,sBAAsB;AAG5B,MAAM,uBAAuB;AAG7B,MAAM,2BAA2B;AAGjC,MAAM,qBAAqB;AAG3B,MAAM,2BAA2B;AAGjC,SAAS,iBAAiB,IAAoB;AACjD,SAAO,OAAO,KAAK;AACvB;AAKO,MAAM,qBAAqB,CAAC,qBAAqB,iBAAiB,eAAe;AAGjF,MAAM,sBAAsB;"}

package/build/vite-plugin/esm/src/vite-plugin/extractPureFn.d.ts

@@ -0,0 +1,13 @@
+import { ExtractedPureFn, ServerPureFunctionsOptions } from './types.ts';
+export declare function extractVueScriptContent(source: string): {
+    content: string;
+    lang: string;
+} | null;
+export declare function scanClientSource(options: ServerPureFunctionsOptions): ExtractedPureFn[];
+export declare function extractPureFnsFromSource(source: string, filePath: string, fnName?: string, noViteClient?: boolean): ExtractedPureFn[];
+export declare function stripTypes(code: string, filePath?: string): string;
+export declare class PurityError extends Error {
+    readonly filePath: string;
+    readonly position: number;
+    constructor(message: string, filePath: string, position: number);
+}