nyte 1.2.3 → 1.2.5

package/src/builder.js

@@ -15,15 +15,20 @@
  * limitations under the License.
  */
 
-const { build: viteBuild, createServer, defineConfig } = require('vite');
-const react = require('@vitejs/plugin-react');
+const { rollup, watch: rollupWatch } = require('rollup');
 const path = require('path');
 const Console = require("./api/console").default;
 const fs = require('fs');
 const { readdir, stat } = require("node:fs/promises");
-const { rm } = require("fs-extra");
 
-// Lista de módulos nativos do Node.js para marcar como externos
+
+// Plugins Oficiais do Rollup
+const nodeResolve = require('@rollup/plugin-node-resolve').default;
+const commonjs = require('@rollup/plugin-commonjs').default;
+const replace = require('@rollup/plugin-replace').default;
+const esbuild = require('rollup-plugin-esbuild').default;
+
+// Lista de módulos nativos do Node.js
 const nodeBuiltIns = [
     'assert', 'buffer', 'child_process', 'cluster', 'crypto', 'dgram', 'dns',
     'domain', 'events', 'fs', 'http', 'https', 'net', 'os', 'path', 'punycode',
@@ -31,49 +36,6 @@ const nodeBuiltIns = [
     'util', 'v8', 'vm', 'zlib', 'module', 'worker_threads', 'perf_hooks'
 ];
 
-/**
- * Plugin para replicar o comportamento de Aliases do TSConfig
- */
-const customAliasPlugin = () => {
-    return {
-        name: 'custom-tsconfig-paths',
-        config(config) {
-            const projectDir = process.cwd();
-            const tsconfigPath = path.join(projectDir, 'tsconfig.json');
-            let aliasMap = {};
-
-            if (fs.existsSync(tsconfigPath)) {
-                try {
-                    const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');
-                    const jsonContent = tsconfigContent.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
-                    const tsconfig = JSON.parse(jsonContent);
-
-                    if (tsconfig.compilerOptions?.paths) {
-                        const baseUrl = tsconfig.compilerOptions.baseUrl || '.';
-                        const basePath = path.resolve(projectDir, baseUrl);
-
-                        for (const [alias, paths] of Object.entries(tsconfig.compilerOptions.paths)) {
-                            if (Array.isArray(paths) && paths.length > 0) {
-                                const cleanAlias = alias.replace(/\/\*$/, '');
-                                const cleanPath = paths[0].replace(/\/\*$/, '');
-                                aliasMap[cleanAlias] = path.resolve(basePath, cleanPath);
-                            }
-                        }
-                    }
-                } catch (error) {
-                    Console.warn('Error reading tsconfig.json for aliases:', error.message);
-                }
-            }
-
-            return {
-                resolve: {
-                    alias: aliasMap
-                }
-            };
-        }
-    };
-};
-
 /**
  * Plugin para Markdown
  */
@@ -92,19 +54,83 @@ const markdownPlugin = () => {
 };
 
 /**
- * Plugin para CSS/PostCSS Manual (Virtual Module Strategy)
+ * Plugin para CSS/PostCSS Manual (Smart Extraction + Tailwind Fix)
  */
-const customPostCssPlugin = () => {
+const customPostCssPlugin = (isProduction) => {
+    let cachedProcessor = null;
+    let configLoaded = false;
+
+    // Função auxiliar para inicializar o PostCSS apenas uma vez
+    const initPostCss = async (projectDir) => {
+        if (configLoaded) return cachedProcessor;
+
+        // CRÍTICO: Garante que o Tailwind saiba que é produção para purgar CSS não usado
+        process.env.NODE_ENV = isProduction ? 'production' : 'development';
+
+        const postcssConfigPath = path.join(projectDir, 'postcss.config.js');
+        const postcssConfigMjsPath = path.join(projectDir, 'postcss.config.mjs');
+        const configPath = fs.existsSync(postcssConfigPath) ? postcssConfigPath :
+            (fs.existsSync(postcssConfigMjsPath) ? postcssConfigMjsPath : null);
+
+        if (configPath) {
+            try {
+                let postcss;
+                try {
+                    postcss = require(path.join(projectDir, 'node_modules', 'postcss'));
+                } catch {
+                    try { postcss = require('postcss'); } catch (e) { return null; }
+                }
+
+                if (postcss) {
+                    delete require.cache[require.resolve(configPath)];
+                    const config = require(configPath);
+                    const postcssConfig = config.default || config;
+
+                    const plugins = [];
+                    if (postcssConfig.plugins) {
+                        if (Array.isArray(postcssConfig.plugins)) {
+                            plugins.push(...postcssConfig.plugins.map(p => {
+                                if (typeof p === 'string') {
+                                    try {
+                                        const resolved = require.resolve(p, { paths: [projectDir] });
+                                        return require(resolved);
+                                    } catch { return require(p); }
+                                }
+                                return p;
+                            }));
+                        } else {
+                            for (const [name, options] of Object.entries(postcssConfig.plugins)) {
+                                try {
+                                    const resolvedPath = require.resolve(name, { paths: [projectDir] });
+                                    const pluginModule = require(resolvedPath);
+                                    plugins.push(pluginModule(options || {}));
+                                } catch (e) {
+                                    Console.warn(`Unable to load plugin ${name}:`, e.message);
+                                }
+                            }
+                        }
+                    }
+                    cachedProcessor = postcss(plugins);
+                }
+            } catch (e) {
+                Console.warn(`Error initializing PostCSS:`, e.message);
+            }
+        }
+        configLoaded = true;
+        return cachedProcessor;
+    };
+
     return {
         name: 'custom-postcss-plugin',
-        enforce: 'pre',
 
         async resolveId(source, importer) {
+            if (source.startsWith('\0custom-css:')) return null;
+
             if (source.endsWith('.css')) {
-                if (source.startsWith('\0custom-css:')) return null;
                 const resolution = await this.resolve(source, importer, { skipSelf: true });
                 if (resolution && resolution.id) {
-                    return `\0custom-css:${resolution.id}.js`;
+                    if (resolution.id.startsWith('\0custom-css:')) return resolution.id;
+                    return `\0custom-css:${resolution.id}`;
                 }
             }
             return null;
@@ -112,68 +138,53 @@ const customPostCssPlugin = () => {
 
         async load(id) {
             if (id.startsWith('\0custom-css:')) {
-                const filePath = id.slice('\0custom-css:'.length, -3);
+                let filePath = id.slice('\0custom-css:'.length);
+                while (filePath.startsWith('\0custom-css:')) {
+                    filePath = filePath.slice('\0custom-css:'.length);
+                }
+
                 const cssContent = await fs.promises.readFile(filePath, 'utf8');
-                const projectDir = process.cwd();
-                const postcssConfigPath = path.join(projectDir, 'postcss.config.js');
-                const postcssConfigMjsPath = path.join(projectDir, 'postcss.config.mjs');
 
+                // Usa o processador em cache ou inicializa se for a primeira vez
+                const processor = await initPostCss(process.cwd());
                 let processedCss = cssContent;
 
-                if (fs.existsSync(postcssConfigPath) || fs.existsSync(postcssConfigMjsPath)) {
+                if (processor) {
                     try {
-                        let postcss;
-                        try {
-                            const postcssPath = path.join(projectDir, 'node_modules', 'postcss');
-                            postcss = require(postcssPath);
-                        } catch {
-                            try { postcss = require('postcss'); } catch (e) {
-                                Console.warn('PostCSS not found. Using raw CSS.');
-                            }
-                        }
-
-                        if (postcss) {
-                            const configPath = fs.existsSync(postcssConfigPath) ? postcssConfigPath : postcssConfigMjsPath;
-                            delete require.cache[require.resolve(configPath)];
-                            const config = require(configPath);
-                            const postcssConfig = config.default || config;
-
-                            const plugins = [];
-                            if (postcssConfig.plugins) {
-                                if (Array.isArray(postcssConfig.plugins)) {
-                                    plugins.push(...postcssConfig.plugins.map(p => {
-                                        if (typeof p === 'string') {
-                                            try {
-                                                const resolved = require.resolve(p, { paths: [projectDir] });
-                                                return require(resolved);
-                                            } catch { return require(p); }
-                                        }
-                                        return p;
-                                    }));
-                                } else {
-                                    for (const [name, options] of Object.entries(postcssConfig.plugins)) {
-                                        try {
-                                            const resolvedPath = require.resolve(name, { paths: [projectDir] });
-                                            const pluginModule = require(resolvedPath);
-                                            plugins.push(pluginModule(options || {}));
-                                        } catch (e) {
-                                            Console.warn(`Unable to load plugin ${name}:`, e.message);
-                                        }
-                                    }
-                                }
-                            }
-
-                            const result = await postcss(plugins).process(cssContent, {
-                                from: filePath,
-                                to: filePath.replace(/\.css$/, '.processed.css')
-                            });
-                            processedCss = result.css;
-                        }
+                        const result = await processor.process(cssContent, {
+                            from: filePath,
+                            to: filePath
+                        });
+                        processedCss = result.css;
                     } catch (e) {
-                        Console.warn(`Error processing CSS with PostCSS:`, e.message);
+                        Console.warn(`PostCSS process error:`, e.message);
                     }
                 }
 
+                // ESTRATÉGIA DE EXTRAÇÃO INTELIGENTE
+                if (isProduction) {
+                    // Emite arquivo físico (Melhora Cache e Tamanho do JS)
+                    const referenceId = this.emitFile({
+                        type: 'asset',
+                        name: path.basename(filePath),
+                        source: processedCss
+                    });
+
+                    // Retorna código JS que auto-injeta o <link>
+                    // Isso mantém compatibilidade (não quebra o app) mas usa arquivo externo
+                    return `
+                        const cssUrl = import.meta.ROLLUP_FILE_URL_${referenceId};
+                        if (typeof document !== 'undefined') {
+                            const link = document.createElement('link');
+                            link.rel = 'stylesheet';
+                            link.href = cssUrl;
+                            document.head.appendChild(link);
+                        }
+                        export default cssUrl;
+                    `;
+                }
+
+                // Modo DEV (Inline para Hot Reload mais rápido)
                 return `
                     const css = ${JSON.stringify(processedCss)};
                     if (typeof document !== 'undefined') {
@@ -190,99 +201,156 @@ const customPostCssPlugin = () => {
 };
 
 /**
- * Plugin para forçar Assets como Base64
+ * Plugin Inteligente para Assets (Substitui forceBase64Plugin)
+ * - Dev: Base64 (Rápido)
+ * - Prod: Arquivos > 4KB viram URL (Melhora LCP), < 4KB Base64 (Menos requests)
  */
-const forceBase64Plugin = () => {
+const smartAssetPlugin = (isProduction) => {
+    const INLINE_LIMIT = 4096; // 4KB
+
     return {
-        name: 'force-base64-assets',
+        name: 'smart-asset-loader',
         async load(id) {
             const cleanId = id.split('?')[0];
+            if (cleanId.startsWith('\0')) return null;
+
             const ext = path.extname(cleanId).slice(1).toLowerCase();
 
             const mimeTypes = {
                 'png': 'image/png', 'jpg': 'image/jpeg', 'jpeg': 'image/jpeg',
                 'gif': 'image/gif', 'webp': 'image/webp', 'avif': 'image/avif',
-                'ico': 'image/x-icon', 'bmp': 'image/bmp', 'tif': 'image/tiff', 'tiff': 'image/tiff',
-                'woff': 'font/woff', 'woff2': 'font/woff2', 'ttf': 'font/ttf',
-                'otf': 'font/otf', 'eot': 'application/vnd.ms-fontobject',
+                'ico': 'image/x-icon', 'bmp': 'image/bmp', 'tif': 'image/tiff',
+                'tiff': 'image/tiff', 'woff': 'font/woff', 'woff2': 'font/woff2',
+                'ttf': 'font/ttf', 'otf': 'font/otf', 'eot': 'application/vnd.ms-fontobject',
                 'mp3': 'audio/mpeg', 'wav': 'audio/wav', 'ogg': 'audio/ogg',
                 'm4a': 'audio/mp4', 'aac': 'audio/aac', 'flac': 'audio/flac',
-                'mp4': 'video/mp4', 'webm': 'video/webm', 'ogv': 'video/ogg'
+                'mp4': 'video/mp4', 'webm': 'video/webm', 'ogv': 'video/ogg',
+                'svg': 'svg', 'txt': 'txt'
             };
 
-            if (mimeTypes[ext]) {
-                const buffer = await fs.promises.readFile(cleanId);
-                const base64 = buffer.toString('base64');
-                return `export default "data:${mimeTypes[ext]};base64,${base64}";`;
-            }
+            const type = mimeTypes[ext];
+            if (!type) return null;
 
-            if (ext === 'svg') {
+            // Text files always strings
+            if (type === 'txt') {
                 const content = await fs.promises.readFile(cleanId, 'utf8');
-                const base64 = Buffer.from(content).toString('base64');
+                return `export default ${JSON.stringify(content)};`;
+            }
+
+            const buffer = await fs.promises.readFile(cleanId);
+            const size = buffer.length;
+
+            // MODO PRODUÇÃO: Otimização de Assets
+            if (isProduction) {
+                // SVG: Se for pequeno inlina, se grande emite arquivo
+                if (type === 'svg') {
+                    if (size < INLINE_LIMIT) {
+                        const content = buffer.toString('utf8');
+                        const base64 = buffer.toString('base64');
+                        return `
+                            export default "data:image/svg+xml;base64,${base64}";
+                            export const svgContent = ${JSON.stringify(content)};
+                        `;
+                    } else {
+                        // Emite arquivo físico
+                        const referenceId = this.emitFile({
+                            type: 'asset',
+                            name: path.basename(cleanId),
+                            source: buffer
+                        });
+                        const content = buffer.toString('utf8');
+                        return `
+                            export default import.meta.ROLLUP_FILE_URL_${referenceId};
+                            export const svgContent = ${JSON.stringify(content)};
+                        `;
+                    }
+                }
+
+                // Outros assets
+                if (size < INLINE_LIMIT) {
+                    return `export default "data:${type};base64,${buffer.toString('base64')}";`;
+                } else {
+                    const referenceId = this.emitFile({
+                        type: 'asset',
+                        name: path.basename(cleanId),
+                        source: buffer
+                    });
+                    return `export default import.meta.ROLLUP_FILE_URL_${referenceId};`;
+                }
+            }
+
+            // MODO DESENVOLVIMENTO: Tudo Base64 para performance de build
+            if (type === 'svg') {
+                const content = buffer.toString('utf8');
+                const base64 = buffer.toString('base64');
                 return `
                     export default "data:image/svg+xml;base64,${base64}";
                     export const svgContent = ${JSON.stringify(content)};
                 `;
             }
-
-            if (ext === 'txt') {
-                const content = await fs.promises.readFile(cleanId, 'utf8');
-                return `export default ${JSON.stringify(content)};`;
-            }
+            return `export default "data:${type};base64,${buffer.toString('base64')}";`;
         }
     };
 };
 
 /**
- * Helper para criar configuração base do Vite
+ * Gera a configuração base do Rollup
  */
-function createBaseConfig(entryPoint, outdir, isProduction) {
-    const projectDir = process.cwd();
-
-    return defineConfig({
-        root: path.dirname(entryPoint),
-        // Base relativa para garantir carregamento correto
-        base: '/_nyte/',
-        configFile: false,
-        publicDir: false,
-        logLevel: 'error',
-        clearScreen: false,
-        define: {
-            'process.env.NODE_ENV': isProduction ? '"production"' : '"development"'
-        },
-        resolve: {
-            extensions: ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']
-        },
+function createRollupConfig(entryPoint, outdir, isProduction) {
+    return {
+        input: entryPoint,
+        external: nodeBuiltIns,
+        // Otimização: Em prod usa 'recommended' para limpar código morto
+        treeshake: isProduction ? 'recommended' : false,
+        cache: true,
+        perf: false,
         plugins: [
-            customPostCssPlugin(),
-            react(),
-            customAliasPlugin(),
+            nodeResolve({
+                extensions: ['.mjs', '.js', '.json', '.node', '.jsx', '.tsx', '.ts'],
+                preferBuiltins: true,
+                browser: false,
+                dedupe: ['react', 'react-dom'] // Otimização: Evita duplicar React no bundle
+            }),
+
+            commonjs({
+                sourceMap: !isProduction
+            }),
+
             markdownPlugin(),
-            forceBase64Plugin(),
-        ],
-        build: {
-            outDir: outdir,
-            emptyOutDir: false,
-            minify: isProduction ? 'esbuild' : false,
-            sourcemap: !isProduction,
-            target: 'es2020',
-            reportCompressedSize: false,
-            chunkSizeWarningLimit: 10000,
-            commonjsOptions: {
-                transformMixedEsModules: true,
-                include: [/node_modules/, /packages/],
-            },
-            rollupOptions: {
-                input: entryPoint,
-                external: nodeBuiltIns,
-                onwarn(warning, warn) {
-                    if (warning.code === 'MODULE_LEVEL_DIRECTIVE') return;
-                    if (warning.code === 'INVALID_ANNOTATION') return;
-                    warn(warning);
+
+            // Passamos isProduction para ativar a Extração Inteligente
+            customPostCssPlugin(isProduction),
+
+            // Substitui forceBase64Plugin pelo Smart
+            smartAssetPlugin(isProduction),
+
+            replace({
+                preventAssignment: true,
+                values: {
+                    'process.env.NODE_ENV': JSON.stringify(isProduction ? 'production' : 'development')
                 }
-            }
+            }),
+
+            esbuild({
+                include: /\.[jt]sx?$/,
+                exclude: /node_modules/,
+                sourceMap: !isProduction,
+                minify: isProduction,
+                // Otimização: Remove comentários legais em produção
+                legalComments: isProduction ? 'none' : 'eof',
+                treeShaking: isProduction,
+                target: isProduction ? 'es2020' : 'esnext',
+                jsx: 'automatic',
+                define: { __VERSION__: '"1.0.0"' },
+                loaders: { '.json': 'json', '.js': 'jsx' }
+            })
+        ],
+        onwarn(warning, warn) {
+            if (warning.code === 'MODULE_LEVEL_DIRECTIVE') return;
+            if (warning.code === 'THIS_IS_UNDEFINED') return;
+            warn(warning);
         }
-    });
+    };
 }
 
 /**
@@ -292,22 +360,44 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
     await cleanDirectoryExcept(outdir, 'temp');
 
     try {
-        const config = createBaseConfig(entryPoint, outdir, isProduction);
+        const inputOptions = createRollupConfig(entryPoint, outdir, isProduction);
 
-        config.build.lib = false;
-        config.build.rollupOptions.output = {
+        const outputOptions = {
+            dir: outdir,
             format: 'es',
+            // Padrão de nomes mantido, mas com estrutura para vários arquivos
             entryFileNames: isProduction ? 'main-[hash].js' : 'main.js',
             chunkFileNames: 'chunks/[name]-[hash].js',
             assetFileNames: 'assets/[name]-[hash][extname]',
+            sourcemap: !isProduction,
+
+            // OTIMIZAÇÃO: Separação granular para melhor Cache e Load Time
             manualChunks(id) {
                 if (id.includes('node_modules')) {
+                    // React Core isolado (muda pouco, cache longo)
+                    if (id.includes('react') || id.includes('scheduler') || id.includes('prop-types')) {
+                        return 'vendor-react';
+                    }
+
+                    // UI Libs comuns (opcional, pode ajustar conforme necessidade)
+                    if (id.includes('framer-motion') || id.includes('@radix-ui')) {
+                        return 'vendor-ui';
+                    }
+
+                    // Utils comuns
+                    if (id.includes('lodash') || id.includes('date-fns') || id.includes('axios')) {
+                        return 'vendor-utils';
+                    }
+
+                    // Resto das dependências
                     return 'vendor';
                 }
             }
         };
 
-        await viteBuild(config);
+        const bundle = await rollup(inputOptions);
+        await bundle.write(outputOptions);
+        await bundle.close();
 
     } catch (error) {
         Console.error('An error occurred while building with chunks:', error);
@@ -320,22 +410,21 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
  */
 async function build(entryPoint, outfile, isProduction = false) {
     const outdir = path.dirname(outfile);
-    const filename = path.basename(outfile);
-
     await cleanDirectoryExcept(outdir, 'temp');
 
     try {
-        const config = createBaseConfig(entryPoint, outdir, isProduction);
-
-        config.build.cssCodeSplit = false;
-        config.build.rollupOptions.output = {
+        const inputOptions = createRollupConfig(entryPoint, outdir, isProduction);
+        const outputOptions = {
+            file: outfile,
             format: 'iife',
             name: 'HwebApp',
-            entryFileNames: filename,
-            inlineDynamicImports: true,
+            sourcemap: !isProduction,
+            inlineDynamicImports: true
         };
 
-        await viteBuild(config);
+        const bundle = await rollup(inputOptions);
+        await bundle.write(outputOptions);
+        await bundle.close();
 
     } catch (error) {
         Console.error('An error occurred during build:', error);
@@ -344,127 +433,78 @@ async function build(entryPoint, outfile, isProduction = false) {
 }
 
 /**
- * Watches with code splitting enabled (MODIFICADO: No DEV MODE, desativa splitting)
+ * Helper para lidar com notificações do Watcher
+ */
+function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
+    let hasError = false;
+
+    watcher.on('event', event => {
+        if (event.code === 'START') hasError = false;
+
+        if (event.code === 'ERROR') {
+            hasError = true;
+            const errDetails = {
+                message: event.error?.message || 'Unknown build error',
+                name: event.error?.name,
+                stack: event.error?.stack,
+                id: event.error?.id,
+                loc: event.error?.loc
+            };
+
+            if (hotReloadManager) hotReloadManager.onBuildComplete(false, errDetails);
+            else Console.error("Build Error:", event.error);
+
+            if (resolveFirstBuild) resolveFirstBuild();
+        }
+
+        if (event.code === 'BUNDLE_END') event.result.close();
+
+        if (event.code === 'END') {
+            if (!hasError && hotReloadManager) hotReloadManager.onBuildComplete(true);
+            if (resolveFirstBuild) {
+                resolveFirstBuild();
+                resolveFirstBuild = null;
+            }
+        }
+    });
+}
+
+/**
+ * Watches with code splitting enabled
  */
 async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
     await cleanDirectoryExcept(outdir, 'temp');
 
     try {
-        const config = createBaseConfig(entryPoint, outdir, false);
+        // DEV MODE: isProduction = false
+        const inputOptions = createRollupConfig(entryPoint, outdir, false);
 
-        config.build.watch = {};
-
-        // MODIFICAÇÃO SOLICITADA:
-        // No modo DEV (Watch), forçamos um único arquivo (IIFE) para evitar
-        // problemas de 404 com chunks e simplificar o debug.
-        // O splitting fica restrito ao build de produção.
-        config.build.cssCodeSplit = false;
-        config.build.rollupOptions.output = {
+        const outputOptions = {
+            dir: outdir,
             format: 'iife',
             name: 'HwebApp',
             entryFileNames: 'main.js',
-            inlineDynamicImports: true // <--- Força tudo em um arquivo só
-            // Removido manualChunks para evitar conflito com inlineDynamicImports
+            inlineDynamicImports: true,
+            sourcemap: true
         };
 
-        // Adiciona notificação de build via plugin
-        config.plugins.push({
-            name: 'build-notifier',
-            // Controle de ciclo: um ciclo começa no buildStart e termina no buildEnd.
-            // Se houve erro no ciclo, não podemos considerar "complete".
-            buildStart() {
-                this.__nyteCycleHadError = false;
-            },
-            closeBundle() {
-                // closeBundle pode rodar em situações inesperadas; não usamos isso pra limpar erro.
-            },
-            buildEnd(error) {
-                if (error) {
-                    this.__nyteCycleHadError = true;
-                    if (hotReloadManager) {
-                        hotReloadManager.onBuildComplete(false, {
-                            message: error.message,
-                            name: error.name,
-                            stack: error.stack,
-                            // Vite/Rollup às vezes coloca infos adicionais
-                            cause: error.cause,
-                            loc: error.loc,
-                            frame: error.frame,
-                            id: error.id,
-                            plugin: error.plugin,
-                            pluginCode: error.pluginCode,
-                            watchFiles: error.watchFiles
-                        });
-                    }
-                }
+        const watchOptions = {
+            ...inputOptions,
+            output: outputOptions,
+            watch: {
+                exclude: 'node_modules/**',
+                clearScreen: false,
+                skipWrite: false
             }
-        });
-
-        const watcher = await viteBuild(config);
-
-        // Flags do ciclo do watcher (mais confiável para decidir sucesso)
-        let watcherCycleHadError = false;
-
-        if (watcher && typeof watcher.on === 'function') {
-            watcher.on('event', (event) => {
-                if (!event) return;
-
-                if (event.code === 'ERROR') {
-                    watcherCycleHadError = true;
-
-                    if (hotReloadManager) {
-                        hotReloadManager.onBuildComplete(false, {
-                            message: event.error?.message || 'Unknown build error',
-                            name: event.error?.name,
-                            stack: event.error?.stack,
-                            cause: event.error?.cause,
-                            loc: event.error?.loc,
-                            frame: event.error?.frame,
-                            id: event.error?.id,
-                            plugin: event.error?.plugin,
-                            pluginCode: event.error?.pluginCode,
-                            watchFiles: event.error?.watchFiles
-                        });
-                    }
-                }
-
-                if (event.code === 'BUNDLE_END') {
-                    if (hotReloadManager) {
-                        if (!watcherCycleHadError) {
-                            hotReloadManager.onBuildComplete(true);
-                        }
-                    }
-
-                    // Próximo ciclo
-                    watcherCycleHadError = false;
-                }
-            });
-        }
-
-        // Aguarda o primeiro build terminar
-        await new Promise((resolve) => {
-            let initialBuild = true;
-            watcher.on('event', (event) => {
-                if (event.code === 'BUNDLE_END') {
-                    if (initialBuild) {
-                        initialBuild = false;
-                        resolve();
-                    }
-                }
-            });
-        });
+        };
 
+        const watcher = rollupWatch(watchOptions);
+        await new Promise((resolve) => handleWatcherEvents(watcher, hotReloadManager, resolve));
         return watcher;
 
     } catch (error) {
         Console.error('Error starting watch mode with chunks:', error);
-        if (hotReloadManager) {
-            hotReloadManager.onBuildComplete(false, {
-                message: error.message,
-                name: error.name,
-                stack: error.stack
-            });
-        }
+        if (hotReloadManager) hotReloadManager.onBuildComplete(false, { message: error.message });
         throw error;
     }
 }
@@ -474,98 +514,34 @@ async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
  */
 async function watch(entryPoint, outfile, hotReloadManager = null) {
     const outdir = path.dirname(outfile);
-    const filename = path.basename(outfile);
 
     try {
-        const config = createBaseConfig(entryPoint, outdir, false);
+        const inputOptions = createRollupConfig(entryPoint, outdir, false);
 
-        config.build.watch = {};
-        config.build.cssCodeSplit = false;
-        config.build.rollupOptions.output = {
+        const outputOptions = {
+            file: outfile,
             format: 'iife',
             name: 'HwebApp',
-            entryFileNames: filename,
-            inlineDynamicImports: true
+            inlineDynamicImports: true,
+            sourcemap: true
         };
 
-        config.plugins.push({
-            name: 'build-notifier',
-            buildStart() {
-                this.__nyteCycleHadError = false;
-            },
-            closeBundle() {
-                // Ignorado para sinalização de sucesso
-            },
-            buildEnd(error) {
-                if (error) {
-                    this.__nyteCycleHadError = true;
-                    if (hotReloadManager) {
-                        hotReloadManager.onBuildComplete(false, {
-                            message: error.message,
-                            name: error.name,
-                            stack: error.stack,
-                            cause: error.cause,
-                            loc: error.loc,
-                            frame: error.frame,
-                            id: error.id,
-                            plugin: error.plugin,
-                            pluginCode: error.pluginCode,
-                            watchFiles: error.watchFiles
-                        });
-                    }
-                }
+        const watchOptions = {
+            ...inputOptions,
+            output: outputOptions,
+            watch: {
+                exclude: 'node_modules/**',
+                clearScreen: false
             }
-        });
-
-        const watcher = await viteBuild(config);
-
-        let watcherCycleHadError = false;
-
-        if (watcher && typeof watcher.on === 'function') {
-            watcher.on('event', (event) => {
-                if (!event) return;
-
-                if (event.code === 'ERROR') {
-                    watcherCycleHadError = true;
-
-                    if (hotReloadManager) {
-                        hotReloadManager.onBuildComplete(false, {
-                            message: event.error?.message || 'Unknown build error',
-                            name: event.error?.name,
-                            stack: event.error?.stack,
-                            cause: event.error?.cause,
-                            loc: event.error?.loc,
-                            frame: event.error?.frame,
-                            id: event.error?.id,
-                            plugin: event.error?.plugin,
-                            pluginCode: event.error?.pluginCode,
-                            watchFiles: event.error?.watchFiles
-                        });
-                    }
-                }
-
-                if (event.code === 'BUNDLE_END') {
-                    if (hotReloadManager) {
-                        if (!watcherCycleHadError) {
-                            hotReloadManager.onBuildComplete(true);
-                        }
-                    }
-                    watcherCycleHadError = false;
-                }
-            });
-        }
+        };
 
-        // (removido) await viteBuild(config); // já estamos em watch mode
+        const watcher = rollupWatch(watchOptions);
+        await new Promise((resolve) => handleWatcherEvents(watcher, hotReloadManager, resolve));
+        return watcher;
 
     } catch (error) {
         Console.error('Error starting watch mode:', error);
-        if (hotReloadManager) {
-            hotReloadManager.onBuildComplete(false, {
-                message: error.message,
-                name: error.name,
-                stack: error.stack
-            });
-        }
+        if (hotReloadManager) hotReloadManager.onBuildComplete(false, { message: error.message });
         throw error;
     }
 }
@@ -573,20 +549,19 @@ async function watch(entryPoint, outfile, hotReloadManager = null) {
 async function cleanDirectoryExcept(dirPath, excludeFolder) {
     try {
         if (!fs.existsSync(dirPath)) return;
-
         const excludes = Array.isArray(excludeFolder) ? excludeFolder : [excludeFolder];
         const items = await readdir(dirPath);
 
-        for (const item of items) {
-            if (excludes.includes(item)) continue;
+        // Paraleliza a limpeza
+        await Promise.all(items.map(async (item) => {
+            if (excludes.includes(item)) return;
             const itemPath = path.join(dirPath, item);
             const info = await stat(itemPath);
-            await rm(itemPath, { recursive: info.isDirectory(), force: true });
-        }
+            fs.rm(itemPath, {recursive: info.isDirectory(), force: true});
+        }));
     } catch (e) {
         Console.warn(`Warning cleaning directory: ${e.message}`);
     }
 }
 
-module.exports = { build, watch, buildWithChunks, watchWithChunks };
-
+module.exports = { build, watch, buildWithChunks, watchWithChunks };