versacompiler 2.4.1 → 2.5.0

package/dist/compiler/compile-worker-pool.js

@@ -0,0 +1,96 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { Worker } from 'node:worker_threads';
+export class CompileWorkerPool {
+    static instance;
+    workers = [];
+    pending = new Map();
+    queue = [];
+    poolSize;
+    workerPath;
+    TASK_TIMEOUT = 60000;
+    constructor() {
+        const cpuCount = os.cpus().length;
+        const configuredMax = parseInt(process.env.COMPILE_MAX_WORKERS || '2', 10);
+        this.poolSize = Math.min(configuredMax, Math.max(1, cpuCount - 1));
+        this.workerPath = path.join(process.env.PATH_PROY || path.join(process.cwd(), 'src'), 'compiler', 'compile-worker-thread.cjs');
+        this.initWorkers();
+    }
+    static getInstance() {
+        if (!CompileWorkerPool.instance) {
+            CompileWorkerPool.instance = new CompileWorkerPool();
+        }
+        return CompileWorkerPool.instance;
+    }
+    initWorkers() {
+        for (let i = 0; i < this.poolSize; i++) {
+            const worker = new Worker(this.workerPath, {
+                env: process.env,
+            });
+            const poolWorker = { worker, busy: false };
+            worker.on('message', (response) => {
+                const pending = this.pending.get(response.id);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timeout);
+                this.pending.delete(response.id);
+                poolWorker.busy = false;
+                if (!response.success) {
+                    pending.reject(new Error(response.error || 'Worker task failed'));
+                }
+                else {
+                    pending.resolve(response.data);
+                }
+                this.drainQueue();
+            });
+            worker.on('error', error => {
+                poolWorker.busy = false;
+                for (const [id, pending] of this.pending) {
+                    clearTimeout(pending.timeout);
+                    const normalized = error instanceof Error
+                        ? error
+                        : new Error(String(error));
+                    pending.reject(normalized);
+                    this.pending.delete(id);
+                }
+                this.drainQueue();
+            });
+            this.workers.push(poolWorker);
+        }
+    }
+    async runTask(type, payload) {
+        const id = `${type}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const message = { id, type, payload };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Worker timeout: ${type}`));
+            }, this.TASK_TIMEOUT);
+            this.pending.set(id, { resolve, reject, timeout });
+            const worker = this.getAvailableWorker();
+            if (worker) {
+                worker.busy = true;
+                worker.worker.postMessage(message);
+                return;
+            }
+            this.queue.push(message);
+        });
+    }
+    getAvailableWorker() {
+        return this.workers.find(worker => !worker.busy) || null;
+    }
+    drainQueue() {
+        if (this.queue.length === 0)
+            return;
+        const worker = this.getAvailableWorker();
+        if (!worker)
+            return;
+        const message = this.queue.shift();
+        if (!message)
+            return;
+        worker.busy = true;
+        worker.worker.postMessage(message);
+    }
+}
+//# sourceMappingURL=compile-worker-pool.js.map

package/dist/compiler/compile-worker-thread.cjs

@@ -0,0 +1,72 @@
+const { parentPort } = require('node:worker_threads');
+
+let preCompileVue;
+let preCompileTS;
+let minifyJS;
+
+async function loadVue() {
+    if (!preCompileVue) {
+        const mod = await import('./vuejs.js');
+        preCompileVue = mod.preCompileVue;
+    }
+    return preCompileVue;
+}
+
+async function loadTypeScript() {
+    if (!preCompileTS) {
+        const mod = await import('./typescript-manager.js');
+        preCompileTS = mod.preCompileTS;
+    }
+    return preCompileTS;
+}
+
+async function loadMinify() {
+    if (!minifyJS) {
+        const mod = await import('./minify.js');
+        minifyJS = mod.minifyJS;
+    }
+    return minifyJS;
+}
+
+parentPort.on('message', async message => {
+    const { id, type, payload } = message;
+    try {
+        if (type === 'vue') {
+            const compileVue = await loadVue();
+            const result = await compileVue(
+                payload.source,
+                payload.fileName,
+                payload.isProd === true,
+            );
+            parentPort.postMessage({ id, success: true, data: result });
+            return;
+        }
+        if (type === 'ts') {
+            const compileTS = await loadTypeScript();
+            const result = await compileTS(
+                payload.source,
+                payload.fileName,
+                payload.scriptInfo,
+            );
+            parentPort.postMessage({ id, success: true, data: result });
+            return;
+        }
+        if (type === 'minify') {
+            const minify = await loadMinify();
+            const result = await minify(payload.source, payload.fileName, true);
+            parentPort.postMessage({ id, success: true, data: result });
+            return;
+        }
+        parentPort.postMessage({
+            id,
+            success: false,
+            error: `Tipo de tarea desconocido: ${type}`,
+        });
+    } catch (error) {
+        parentPort.postMessage({
+            id,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+});

package/dist/compiler/compile.js

@@ -6,9 +6,12 @@ import * as process from 'node:process';
 const { argv, cwd, env } = process;
 // Lazy loading optimizations - Only import lightweight modules synchronously
 import { logger, setProgressManagerGetter } from '../servicios/logger.js';
+import { getLoadedConfig } from '../servicios/readConfig.js';
 import { promptUser } from '../utils/promptUser.js';
 import { showTimingForHumans } from '../utils/utils.js';
 import { integrityValidator } from './integrity-validator.js';
+import { BuildPipeline } from './pipeline/build-pipeline.js';
+import { createCorePlugins } from './pipeline/core-plugins.js';
 // Configurar el getter del ProgressManager para el logger
 setProgressManagerGetter(() => ProgressManager.getInstance());
 /**
@@ -29,6 +32,7 @@ let generateTailwindCSS;
 let estandarizaCode;
 let preCompileTS;
 let preCompileVue;
+let pipelineInstance = null;
 // 🚀 Importar optimizador de transformaciones
 let TransformOptimizer;
 // 🚀 Importar optimizador de resolución de módulos
@@ -544,6 +548,16 @@ class SmartCompilationCache {
             catch {
                 // Ignorar si no existe package-lock.json
             }
+            // 2b. Hash de pnpm-lock.yaml si existe (pnpm)
+            try {
+                const pnpmLockPath = path.join(cwd(), 'pnpm-lock.yaml');
+                const pnpmLockContent = await readFile(pnpmLockPath, 'utf8');
+                hash.update(`pnpm-lock:${pnpmLockContent.length}`);
+                hash.update(pnpmLockContent);
+            }
+            catch {
+                // Ignorar si no existe pnpm-lock.yaml
+            }
             // 3. ✨ NUEVO: Hash de timestamps críticos de node_modules
             try {
                 const nodeModulesPath = path.join(cwd(), 'node_modules');
@@ -609,7 +623,7 @@ class SmartCompilationCache {
             return false;
         try {
             // Ejecutar todas las verificaciones independientes en paralelo
-            const [currentContentHash, currentDependencyHash, fileStat, _outputStat] = await Promise.all([
+            const [currentContentHash, currentDependencyHash, fileStat, _outputStat,] = await Promise.all([
                 this.generateContentHash(filePath),
                 this.generateDependencyHash(),
                 stat(filePath),
@@ -1406,7 +1420,8 @@ async function _displaySingleLinterError(error, filePath) {
                 }
                 else {
                     // Líneas de contexto
-                    logger.info(chalkLib.blue(` ${prefix} │ `) + chalkLib.gray(currentLine));
+                    logger.info(chalkLib.blue(` ${prefix} │ `) +
+                        chalkLib.gray(currentLine));
                 }
             }
             logger.info(chalkLib.blue('    ╰────'));
@@ -1558,6 +1573,67 @@ class WatchModeOptimizer {
         this.fileSystemCache.clear();
     }
 }
+function getBuildPipeline() {
+    if (!pipelineInstance) {
+        const basePlugins = createCorePlugins();
+        const config = getLoadedConfig();
+        const userPlugins = normalizeUserPlugins(config?.plugins);
+        pipelineInstance = new BuildPipeline([...basePlugins, ...userPlugins]);
+    }
+    return pipelineInstance;
+}
+function normalizeUserPlugins(plugins) {
+    if (!plugins || !Array.isArray(plugins))
+        return [];
+    return plugins.filter((plugin) => {
+        if (!plugin || typeof plugin !== 'object')
+            return false;
+        const candidate = plugin;
+        if (!candidate.name || typeof candidate.name !== 'string')
+            return false;
+        return Boolean(candidate.onResolve ||
+            candidate.onLoad ||
+            candidate.onTransform ||
+            candidate.onHotUpdate ||
+            candidate.onEnd);
+    });
+}
+export function getPipelineModuleGraph() {
+    if (env.PIPELINE_V2 === 'false')
+        return null;
+    return getBuildPipeline().getModuleGraph();
+}
+export async function runPipelineHotUpdate(filePath, type) {
+    if (env.PIPELINE_V2 === 'false') {
+        return { reload: 'none' };
+    }
+    return getBuildPipeline().hotUpdate({ path: filePath, type });
+}
+async function compileWithPipeline(inPath, outPath, mode = 'individual') {
+    const pipeline = getBuildPipeline();
+    const result = await pipeline.compileFile(inPath);
+    if (result.errors.length > 0) {
+        for (const message of result.errors) {
+            await handleCompilationError(new Error(message), inPath, 'pipeline', mode, env.VERBOSE === 'true');
+        }
+        throw new Error(result.errors[0]);
+    }
+    if (!result.code || result.code.trim().length === 0) {
+        await handleCompilationError(new Error('El código compilado está vacío.'), inPath, 'pipeline', mode, env.VERBOSE === 'true');
+        throw new Error('El código compilado está vacío.');
+    }
+    const destinationDir = path.dirname(outPath);
+    await mkdir(destinationDir, { recursive: true });
+    await writeFile(outPath, result.code, 'utf-8');
+    if (result.dependencies.length > 0) {
+        smartCache.registerDependencies(inPath, result.dependencies);
+    }
+    registerCompilationSuccess(inPath, 'pipeline');
+    return {
+        error: null,
+        action: 'extension',
+    };
+}
 async function compileJS(inPath, outPath, mode = 'individual') {
     const timings = {};
     // Si la ruta ya es absoluta, no la resolvamos de nuevo
@@ -1565,6 +1641,9 @@ async function compileJS(inPath, outPath, mode = 'individual') {
         ? normalizeRuta(inPath)
         : normalizeRuta(path.resolve(inPath)); // 🚀 Usar OptimizedModuleManager para carga optimizada
     const moduleManager = OptimizedModuleManager.getInstance();
+    if (env.PIPELINE_V2 !== 'false') {
+        return compileWithPipeline(inPath, outPath, mode);
+    }
     // Timing de lectura
     let start = Date.now();
     const extension = path.extname(inPath); // Asegurar que el parser esté cargado

package/dist/compiler/integrity-validator.js

@@ -48,7 +48,7 @@ export class IntegrityValidator {
         // Revisar cache
         const cacheKey = this.getCacheKey(context, processed);
         const cached = this.cache.get(cacheKey);
-        if (cached && (Date.now() - cached.timestamp) < this.CACHE_TTL) {
+        if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
             this.stats.cacheHits++;
             if (options.verbose) {
                 logger.info(`[IntegrityValidator] Cache hit for ${context}`);

package/dist/compiler/module-resolution-optimizer.js

@@ -14,6 +14,7 @@ import { dirname, join, relative } from 'node:path';
 import { cwd, env } from 'node:process';
 import { logger } from '../servicios/logger.js';
 import { EXCLUDED_MODULES } from '../utils/excluded-modules.js';
+import { parseModuleSpecifier, resolveExportValue, } from '../utils/module-resolver.js';
 /**
  * Sistema de optimización de resolución de módulos
  * Implementa indexación, caché y búsquedas O(1)
@@ -122,7 +123,7 @@ export class ModuleResolutionOptimizer {
             for (const entry of entries) {
                 const modulePath = join(nodeModulesPath, entry);
                 try {
-                    if (entry.startsWith('/dist/examples')) {
+                    if (entry.startsWith('/dist')) {
                         // Scoped packages
                         const scopedModules = readdirSync(modulePath);
                         this.metrics.filesystemAccess++;
@@ -207,10 +208,7 @@ export class ModuleResolutionOptimizer {
                     entryPoint = dotExport;
                 }
                 else if (typeof dotExport === 'object') {
-                    entryPoint =
-                        dotExport.import ||
-                            dotExport.browser ||
-                            dotExport.default;
+                    entryPoint = resolveExportValue(dotExport);
                 }
             }
         }
@@ -420,7 +418,9 @@ export class ModuleResolutionOptimizer {
             this.aliasIndex = [];
             // Convertir alias a índice con prioridad
             for (const [alias, target] of Object.entries(pathAlias)) {
-                const pattern = alias.replace('/*', '');
+                // Quitar solo el '*' final para conservar el separador '/'
+                // Ejemplo: '@/*' → '@/', así '@vueuse/core' no hace match pero '@/foo' sí
+                const pattern = alias.replace('*', '');
                 const priority = pattern.length; // Patrones más largos tienen prioridad
                 // El regex debe coincidir con el patrón al inicio, seguido de cualquier cosa o fin de cadena
                 // Por ejemplo, para "@/" debe coincidir con "@/cualquier-cosa" o solo "@/"
@@ -453,6 +453,7 @@ export class ModuleResolutionOptimizer {
                 path: null,
                 cached: false,
                 resolveTime: performance.now() - startTime,
+                excluded: true,
             };
         }
         // Crear clave de caché
@@ -472,13 +473,16 @@ export class ModuleResolutionOptimizer {
         // Resolver módulo
         let resolvedPath = null;
         try {
-            // 1. Verificar si es subpath de módulo (ej: 'vue/dist/vue.esm-bundler')
-            if (moduleName.includes('/')) {
+            // 1. Parse specifier to correctly handle scoped packages
+            const { packageName, subPath } = parseModuleSpecifier(moduleName);
+            if (subPath) {
+                // Has a real subpath (e.g. 'vue/dist/x' or '@scope/pkg/sub')
                 resolvedPath = await this.resolveSubPath(moduleName);
             }
             else {
+                // Direct package (e.g. 'vue' or '@vueuse/core')
                 // 2. Búsqueda O(1) en el índice
-                resolvedPath = this.resolveFromIndex(moduleName);
+                resolvedPath = this.resolveFromIndex(packageName);
             }
             // 3. Si no se encuentra en índice, intentar resolución tradicional
             if (!resolvedPath) {
@@ -521,8 +525,7 @@ export class ModuleResolutionOptimizer {
      * Resuelve subpaths de módulos (ej: 'vue/dist/vue.esm-bundler')
      */
     async resolveSubPath(moduleName) {
-        const [packageName, ...subPathParts] = moduleName.split('/');
-        const subPath = subPathParts.join('/');
+        const { packageName, subPath } = parseModuleSpecifier(moduleName);
         if (!packageName) {
             return null;
         }
@@ -531,19 +534,19 @@ export class ModuleResolutionOptimizer {
         if (!moduleInfo) {
             return null;
         }
+        // If no subPath, resolve as direct package
+        if (!subPath) {
+            const entryPoint = moduleInfo.optimizedEntry || moduleInfo.entryPoint;
+            return join(moduleInfo.fullPath, entryPoint);
+        }
         // Verificar exports field para subpaths
         if (moduleInfo.hasExports && moduleInfo.packageJson.exports) {
             const exportKey = `./${subPath}`;
             const exportPath = moduleInfo.packageJson.exports[exportKey];
             if (exportPath) {
-                if (typeof exportPath === 'string') {
-                    return join(moduleInfo.fullPath, exportPath);
-                }
-                else if (typeof exportPath === 'object') {
-                    const importPath = exportPath.import || exportPath.default;
-                    if (typeof importPath === 'string') {
-                        return join(moduleInfo.fullPath, importPath);
-                    }
+                const resolved = resolveExportValue(exportPath);
+                if (resolved) {
+                    return join(moduleInfo.fullPath, resolved);
                 }
             }
         }
@@ -872,7 +875,7 @@ export class ModuleResolutionOptimizer {
 export async function getOptimizedModulePath(moduleName, fromFile) {
     const optimizer = ModuleResolutionOptimizer.getInstance();
     const result = await optimizer.resolveModule(moduleName, fromFile);
-    return result.path;
+    return { path: result.path, excluded: result.excluded === true };
 }
 export function getOptimizedAliasPath(path) {
     const optimizer = ModuleResolutionOptimizer.getInstance();

package/dist/compiler/performance-monitor.js

@@ -85,67 +85,67 @@ export class PerformanceMonitor {
             const i = Math.floor(Math.log(bytes) / Math.log(k));
             return (parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]);
         };
-        const report = `
-🚀 VERSACOMPILER PERFORMANCE REPORT
-=====================================
-
-📊 RESUMEN GENERAL
-Hit Rate Total: ${stats.summary.overallHitRate}%
-Cache Hits: ${stats.summary.totalCacheHits}
-Cache Misses: ${stats.summary.totalCacheMisses}
-Memoria Total: ${formatBytes(stats.summary.totalMemoryUsage)}
-Entradas Cache: ${stats.summary.totalCacheEntries}
-
-🎯 VUE HMR CACHE
-Size: ${stats.vueHMRCache.size}/${stats.vueHMRCache.maxSize}
-TTL: ${Math.round(stats.vueHMRCache.ttl / 1000 / 60)}min
-
-📝 PARSER AST CACHE
-Hit Rate: ${stats.parserCache.hitRate}%
-Cache Hits: ${stats.parserCache.cacheHits}
-Cache Misses: ${stats.parserCache.cacheMisses}
-Size: ${stats.parserCache.cacheSize}/${stats.parserCache.maxCacheSize}
-Memoria: ${formatBytes(stats.parserCache.memoryUsage)}/${formatBytes(stats.parserCache.maxMemoryUsage)}
-
-📖 FILE CONTENT CACHE
-Hit Rate: ${stats.fileContentCache.hitRate}%
-Cache Hits: ${stats.fileContentCache.cacheHits}
-Cache Misses: ${stats.fileContentCache.cacheMisses}
-Size: ${stats.fileContentCache.cacheSize}/${stats.fileContentCache.maxCacheSize}
-
-🌐 BROWSERSYNC FILE CACHE
-Hit Rate: ${stats.browserSyncCache.hitRate}%
-Cache Hits: ${stats.browserSyncCache.cacheHits}
-Cache Misses: ${stats.browserSyncCache.cacheMisses}
-Size: ${stats.browserSyncCache.cacheSize}/${stats.browserSyncCache.maxCacheSize}
-Memoria: ${formatBytes(stats.browserSyncCache.memoryUsage)}/${formatBytes(stats.browserSyncCache.maxMemoryUsage)}
-
-🗜️ MINIFICATION CACHE
-Hit Rate: ${stats.minificationCache.hitRate}%
-Cache Hits: ${stats.minificationCache.cacheHits}
-Cache Misses: ${stats.minificationCache.cacheMisses}
-Size: ${stats.minificationCache.cacheSize}/${stats.minificationCache.maxCacheSize}
-Memoria: ${formatBytes(stats.minificationCache.memoryUsage)}/${formatBytes(stats.minificationCache.maxMemoryUsage)}
-Compresión Promedio: ${stats.minificationCache.avgCompressionRatio}%
-
-🔄 TRANSFORM OPTIMIZER
-Hit Rate: ${stats.transformOptimizer.hitRate}%
-Cache Hits: ${stats.transformOptimizer.cacheHits}
-Cache Misses: ${stats.transformOptimizer.cacheMisses}
-Transformaciones: ${stats.transformOptimizer.totalTransforms}
-Size: ${stats.transformOptimizer.cacheSize}
-Memoria: ${formatBytes(stats.transformOptimizer.memoryUsage)}
-
-📦 MODULE RESOLUTION
-Hit Rate: ${stats.moduleResolution.cacheHitRate?.toFixed(1)}%
-Cache Hits: ${stats.moduleResolution.cacheHits}
-Cache Misses: ${stats.moduleResolution.cacheMisses}
-Resoluciones: ${stats.moduleResolution.totalResolutions}
-Índice Módulos: ${stats.moduleResolution.moduleIndexSize}
-Índice Alias: ${stats.moduleResolution.aliasIndexSize}
-Tiempo Promedio: ${stats.moduleResolution.averageResolveTime?.toFixed(2)}ms
-
-=====================================
+        const report = `
+🚀 VERSACOMPILER PERFORMANCE REPORT
+=====================================
+
+📊 RESUMEN GENERAL
+Hit Rate Total: ${stats.summary.overallHitRate}%
+Cache Hits: ${stats.summary.totalCacheHits}
+Cache Misses: ${stats.summary.totalCacheMisses}
+Memoria Total: ${formatBytes(stats.summary.totalMemoryUsage)}
+Entradas Cache: ${stats.summary.totalCacheEntries}
+
+🎯 VUE HMR CACHE
+Size: ${stats.vueHMRCache.size}/${stats.vueHMRCache.maxSize}
+TTL: ${Math.round(stats.vueHMRCache.ttl / 1000 / 60)}min
+
+📝 PARSER AST CACHE
+Hit Rate: ${stats.parserCache.hitRate}%
+Cache Hits: ${stats.parserCache.cacheHits}
+Cache Misses: ${stats.parserCache.cacheMisses}
+Size: ${stats.parserCache.cacheSize}/${stats.parserCache.maxCacheSize}
+Memoria: ${formatBytes(stats.parserCache.memoryUsage)}/${formatBytes(stats.parserCache.maxMemoryUsage)}
+
+📖 FILE CONTENT CACHE
+Hit Rate: ${stats.fileContentCache.hitRate}%
+Cache Hits: ${stats.fileContentCache.cacheHits}
+Cache Misses: ${stats.fileContentCache.cacheMisses}
+Size: ${stats.fileContentCache.cacheSize}/${stats.fileContentCache.maxCacheSize}
+
+🌐 BROWSERSYNC FILE CACHE
+Hit Rate: ${stats.browserSyncCache.hitRate}%
+Cache Hits: ${stats.browserSyncCache.cacheHits}
+Cache Misses: ${stats.browserSyncCache.cacheMisses}
+Size: ${stats.browserSyncCache.cacheSize}/${stats.browserSyncCache.maxCacheSize}
+Memoria: ${formatBytes(stats.browserSyncCache.memoryUsage)}/${formatBytes(stats.browserSyncCache.maxMemoryUsage)}
+
+🗜️ MINIFICATION CACHE
+Hit Rate: ${stats.minificationCache.hitRate}%
+Cache Hits: ${stats.minificationCache.cacheHits}
+Cache Misses: ${stats.minificationCache.cacheMisses}
+Size: ${stats.minificationCache.cacheSize}/${stats.minificationCache.maxCacheSize}
+Memoria: ${formatBytes(stats.minificationCache.memoryUsage)}/${formatBytes(stats.minificationCache.maxMemoryUsage)}
+Compresión Promedio: ${stats.minificationCache.avgCompressionRatio}%
+
+🔄 TRANSFORM OPTIMIZER
+Hit Rate: ${stats.transformOptimizer.hitRate}%
+Cache Hits: ${stats.transformOptimizer.cacheHits}
+Cache Misses: ${stats.transformOptimizer.cacheMisses}
+Transformaciones: ${stats.transformOptimizer.totalTransforms}
+Size: ${stats.transformOptimizer.cacheSize}
+Memoria: ${formatBytes(stats.transformOptimizer.memoryUsage)}
+
+📦 MODULE RESOLUTION
+Hit Rate: ${stats.moduleResolution.cacheHitRate?.toFixed(1)}%
+Cache Hits: ${stats.moduleResolution.cacheHits}
+Cache Misses: ${stats.moduleResolution.cacheMisses}
+Resoluciones: ${stats.moduleResolution.totalResolutions}
+Índice Módulos: ${stats.moduleResolution.moduleIndexSize}
+Índice Alias: ${stats.moduleResolution.aliasIndexSize}
+Tiempo Promedio: ${stats.moduleResolution.averageResolveTime?.toFixed(2)}ms
+
+=====================================
         `;
         return report;
     }

package/dist/compiler/pipeline/build-pipeline.js

@@ -0,0 +1,127 @@
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import { parser } from '../parser.js';
+import { ModuleGraph } from './module-graph.js';
+import { PluginDriver } from './plugin-driver.js';
+function guessLoader(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.vue')
+        return 'vue';
+    if (ext === '.ts')
+        return 'ts';
+    if (ext === '.json')
+        return 'json';
+    if (ext === '.css')
+        return 'css';
+    return 'js';
+}
+function getAstType(loader) {
+    return loader === 'ts' ? 'ts' : 'js';
+}
+function collectModuleRequests(ast) {
+    const requests = [];
+    const staticImports = ast?.module?.staticImports || [];
+    for (const item of staticImports) {
+        const value = item?.moduleRequest?.value;
+        if (typeof value === 'string')
+            requests.push(value);
+    }
+    const dynamicImports = ast?.module?.dynamicImports || [];
+    for (const item of dynamicImports) {
+        const value = item?.moduleRequest?.value;
+        if (typeof value === 'string')
+            requests.push(value);
+    }
+    return requests;
+}
+async function resolveLocalImport(importer, specifier) {
+    if (!specifier.startsWith('.') && !specifier.startsWith('/'))
+        return null;
+    const base = specifier.startsWith('/')
+        ? path.normalize(specifier)
+        : path.resolve(path.dirname(importer), specifier);
+    const ext = path.extname(base);
+    if (ext)
+        return base;
+    const candidates = [
+        `${base}.ts`,
+        `${base}.js`,
+        `${base}.vue`,
+        `${base}.mjs`,
+        `${base}.cjs`,
+        `${base}.json`,
+        path.join(base, 'index.ts'),
+        path.join(base, 'index.js'),
+        path.join(base, 'index.vue'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await stat(candidate);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    return base;
+}
+export class BuildPipeline {
+    driver;
+    graph;
+    constructor(plugins) {
+        this.driver = new PluginDriver(plugins);
+        this.graph = new ModuleGraph();
+    }
+    getModuleGraph() {
+        return this.graph;
+    }
+    async hotUpdate(args) {
+        return this.driver.hotUpdate(args);
+    }
+    async compileFile(filePath) {
+        const resolved = await this.driver.resolve({
+            path: filePath,
+            kind: 'entry',
+        });
+        const entryPath = resolved.path || filePath;
+        const loaded = await this.driver.load({ path: entryPath });
+        const loadErrors = loaded.errors || [];
+        if (!loaded.contents) {
+            await this.driver.end(loadErrors);
+            return {
+                code: '',
+                loader: guessLoader(entryPath),
+                dependencies: [],
+                errors: loadErrors,
+            };
+        }
+        const transformResult = await this.driver.transform({
+            path: entryPath,
+            contents: loaded.contents,
+            loader: loaded.loader || guessLoader(entryPath),
+            meta: loaded.meta,
+        });
+        const transformErrors = transformResult.errors || [];
+        const finalCode = transformResult.contents || '';
+        const finalLoader = transformResult.loader || loaded.loader || guessLoader(entryPath);
+        const ast = await parser(entryPath, finalCode, getAstType(finalLoader));
+        const requests = collectModuleRequests(ast);
+        const resolvedDeps = [];
+        for (const request of requests) {
+            const resolvedDep = await resolveLocalImport(entryPath, request);
+            if (resolvedDep)
+                resolvedDeps.push(resolvedDep);
+        }
+        this.graph.updateImports(entryPath, resolvedDeps);
+        const errors = loadErrors.concat(transformErrors);
+        await this.driver.end(errors);
+        return {
+            code: finalCode,
+            loader: finalLoader,
+            meta: transformResult.meta || loaded.meta,
+            dependencies: resolvedDeps,
+            errors,
+        };
+    }
+}
+//# sourceMappingURL=build-pipeline.js.map