vatts 1.2.0 → 1.2.2

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2026 itsmuzin
+Copyright 2026 mfraz
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

package/README.md

@@ -14,16 +14,20 @@ ___
 
 ## Getting Started
 
-**Vatts.js** is a modern, full-featured web framework for **Node.js**, designed to deliver **high performance**, **true simplicity**, and a **smooth developer experience** from the very first command.
+**Vatts.js** is a modern, full-featured web framework for **Node.js** with first-class support for **React and Vue**.
 
-It removes unnecessary configuration and complex abstractions, allowing you to focus on what truly matters: **building fast, secure, and scalable applications**.
+It is a **multi-framework platform**, allowing you to build applications using **either React or Vue per project** — not both at the same time.  
+This keeps the ecosystem clean, predictable, and optimized for performance and tooling.
+
+Vatts removes unnecessary configuration and complex abstractions, allowing you to focus on what truly matters: **building fast, secure, and scalable applications**.
 
 ### Why choose Vatts.js?
-- Extremely fast — architecture optimized for low overhead
-- Intuitive API — easy to learn and pleasant to use
-- Productivity from the first minute — zero unnecessary boilerplate
-- Full integration between backend and frontend
-- Built for modern projects — TypeScript-friendly, modular, and extensible
+-  Extremely fast — architecture optimized for low overhead
+-  Intuitive API — easy to learn and pleasant to use
+-  Productivity from the first minute — zero unnecessary boilerplate
+-  Multi-framework — choose **React or Vue per project**
+-  Full integration between backend and frontend
+-  Built for modern projects — TypeScript-friendly, modular, and extensible
 
 ___
 

package/dist/api/console.js

@@ -1,7 +1,7 @@
 "use strict";
 /*
  * This file is part of the Vatts.js Project.
- * Copyright (c) 2026 itsmuzin
+ * Copyright (c) 2026 mfraz
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/dist/api/framework.js

@@ -5,6 +5,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cachedFramework = void 0;
 exports.default = detectFramework;
+/*
+ * This file is part of the Vatts.js Project.
+ * Copyright (c) 2026 mfraz
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 // Variável para armazenar o resultado em memória

package/dist/bin/vatts.js

@@ -2,7 +2,7 @@
 "use strict";
 /*
  * This file is part of the Vatts.js Project.
- * Copyright (c) 2026 itsmuzin
+ * Copyright (c) 2026 mfraz
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -100,6 +100,7 @@ program
     .option('--ssl', 'Activates HTTPS/SSL mode')
     .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
     .action((options) => {
+    process.env.NODE_ENV = 'production';
     initializeApp(options, false);
 });
 program

package/dist/builder.d.ts

@@ -1,16 +1,4 @@
-/**
- * Builds a single entry point into a single output file (IIFE Format)
- */
 export function build(entryPoint: any, outfile: any, isProduction?: boolean): Promise<void>;
-/**
- * Watches an entry point (Single File)
- */
 export function watch(entryPoint: any, outfile: any, hotReloadManager?: null): Promise<import("rollup").RollupWatcher>;
-/**
- * Builds with code splitting into multiple chunks (ESM Format) - MODO PRODUÇÃO
- */
 export function buildWithChunks(entryPoint: any, outdir: any, isProduction?: boolean): Promise<void>;
-/**
- * Watches with code splitting enabled
- */
 export function watchWithChunks(entryPoint: any, outdir: any, hotReloadManager?: null): Promise<import("rollup").RollupWatcher>;

package/dist/builder.js

@@ -1,7 +1,7 @@
 "use strict";
 /*
  * This file is part of the Vatts.js Project.
- * Copyright (c) 2026 itsmuzin
+ * Copyright (c) 2026 mfraz
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,29 +28,11 @@ const path = require('path');
 const Console = require("./api/console").default;
 const fs = require('fs');
 const { readdir, stat, rm } = require("node:fs/promises");
-// 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;
-const jsonPlugin = require("@rollup/plugin-json").default;
 const { loadTsConfigPaths, resolveTsConfigAlias } = require('./tsconfigPaths');
-// --- Helper de Detecção de Framework ---
-function detectFramework(projectDir = process.cwd()) {
-    try {
-        const pkgPath = path.join(projectDir, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-            if (deps.react || deps['react-dom'])
-                return 'react';
-            if (deps.vue || deps['nuxt'])
-                return 'vue';
-        }
-    }
-    catch (e) { }
-    return 'react';
-}
+// Import Framework specific builders
+const { createReactConfig } = require('./react/react.build');
+const { createVueConfig } = require('./vue/vue.build');
+// --- Common Plugins Definitions ---
 const tsconfigPathsPlugin = (projectDir = process.cwd()) => {
     const info = loadTsConfigPaths(projectDir);
     return {
@@ -66,15 +48,6 @@ const tsconfigPathsPlugin = (projectDir = process.cwd()) => {
         }
     };
 };
-const nodeBuiltIns = [
-    'assert', 'buffer', 'child_process', 'cluster', 'crypto', 'dgram', 'dns',
-    'domain', 'events', 'fs', 'http', 'https', 'net', 'os', 'path', 'punycode',
-    'querystring', 'readline', 'stream', 'string_decoder', 'tls', 'tty', 'url',
-    'util', 'v8', 'vm', 'zlib', 'module', 'worker_threads', 'perf_hooks'
-];
-/**
- * Plugin para Markdown
- */
 const markdownPlugin = () => {
     return {
         name: 'markdown-loader',
@@ -88,32 +61,6 @@ const markdownPlugin = () => {
         }
     };
 };
-/**
- * [CORREÇÃO] Plugin que injeta 'export default {}' se estiver faltando.
- * Resolve o problema de rotas que exportam apenas 'config' mas não o componente.
- */
-const vueScriptFixPlugin = () => {
-    return {
-        name: 'vatts-vue-script-fix',
-        transform(code, id) {
-            // Intercepta arquivos virtuais de script TS do Vue
-            if (id.includes('?vue&type=script') && id.includes('lang.ts')) {
-                // Se o código NÃO tem export default, a gente cria um objeto vazio
-                // Isso satisfaz o Rollup/Vue Plugin que espera um componente
-                if (!code.includes('export default')) {
-                    return {
-                        code: code + '\nexport default {};',
-                        map: null // Sourcemap null pra simplificar
-                    };
-                }
-            }
-            return null;
-        }
-    };
-};
-/**
- * Plugin para CSS/PostCSS Manual (Otimizado para RAM)
- */
 const customPostCssPlugin = (isProduction) => {
     let cachedProcessor = null;
     let configLoaded = false;
@@ -148,8 +95,7 @@ const customPostCssPlugin = (isProduction) => {
                             plugins.push(...postcssConfig.plugins.map(p => {
                                 if (typeof p === 'string') {
                                     try {
-                                        const resolved = require.resolve(p, { paths: [projectDir] });
-                                        return require(__rewriteRelativeImportExtension(resolved));
+                                        return require(__rewriteRelativeImportExtension(require.resolve(p, { paths: [projectDir] })));
                                     }
                                     catch {
                                         return require(__rewriteRelativeImportExtension(p));
@@ -162,8 +108,7 @@ const customPostCssPlugin = (isProduction) => {
                             for (const [name, options] of Object.entries(postcssConfig.plugins)) {
                                 try {
                                     const resolvedPath = require.resolve(name, { paths: [projectDir] });
-                                    const pluginModule = require(__rewriteRelativeImportExtension(resolvedPath));
-                                    plugins.push(pluginModule(options || {}));
+                                    plugins.push(require(__rewriteRelativeImportExtension(resolvedPath))(options || {}));
                                 }
                                 catch (e) {
                                     Console.warn(`Unable to load plugin ${name}:`, e.message);
@@ -190,11 +135,7 @@ const customPostCssPlugin = (isProduction) => {
             let processedCss = code;
             if (processor) {
                 try {
-                    const result = await processor.process(code, {
-                        from: id,
-                        to: id,
-                        map: false
-                    });
+                    const result = await processor.process(code, { from: id, to: id, map: false });
                     processedCss = result.css;
                 }
                 catch (e) {
@@ -202,11 +143,7 @@ const customPostCssPlugin = (isProduction) => {
                 }
             }
             const cleanName = path.basename(id).split('?')[0];
-            const referenceId = this.emitFile({
-                type: 'asset',
-                name: cleanName,
-                source: processedCss
-            });
+            const referenceId = this.emitFile({ type: 'asset', name: cleanName, source: processedCss });
             return {
                 code: `
                 const cssUrl = String(import.meta.ROLLUP_FILE_URL_${referenceId});
@@ -223,9 +160,6 @@ const customPostCssPlugin = (isProduction) => {
         }
     };
 };
-/**
- * Plugin Inteligente para Assets (Otimizado para RAM)
- */
 const smartAssetPlugin = (isProduction) => {
     const INLINE_LIMIT = 4096;
     return {
@@ -259,20 +193,14 @@ const smartAssetPlugin = (isProduction) => {
                 if (size < INLINE_LIMIT) {
                     const content = buffer.toString('utf8');
                     const base64 = buffer.toString('base64');
-                    buffer = null;
                     return `
                         export default "data:image/svg+xml;base64,${base64}";
                         export const svgContent = ${JSON.stringify(content)};
                     `;
                 }
                 else {
-                    const referenceId = this.emitFile({
-                        type: 'asset',
-                        name: path.basename(cleanId),
-                        source: buffer
-                    });
+                    const referenceId = this.emitFile({ type: 'asset', name: path.basename(cleanId), source: buffer });
                     const content = buffer.toString('utf8');
-                    buffer = null;
                     return `
                         export default String(import.meta.ROLLUP_FILE_URL_${referenceId});
                         export const svgContent = ${JSON.stringify(content)};
@@ -281,163 +209,76 @@ const smartAssetPlugin = (isProduction) => {
             }
             if (size < INLINE_LIMIT) {
                 const base64 = buffer.toString('base64');
-                buffer = null;
                 return `export default "data:${type};base64,${base64}";`;
             }
             else {
-                const referenceId = this.emitFile({
-                    type: 'asset',
-                    name: path.basename(cleanId),
-                    source: buffer
-                });
-                buffer = null;
+                const referenceId = this.emitFile({ type: 'asset', name: path.basename(cleanId), source: buffer });
                 return `export default String(import.meta.ROLLUP_FILE_URL_${referenceId});`;
             }
         }
     };
 };
-/**
- * Gera a configuração base do Rollup
- */
-async function createRollupConfig(entryPoint, outdir, isProduction) {
+const nodeBuiltIns = [
+    'assert', 'buffer', 'child_process', 'cluster', 'crypto', 'dgram', 'dns',
+    'domain', 'events', 'fs', 'http', 'https', 'net', 'os', 'path', 'punycode',
+    'querystring', 'readline', 'stream', 'string_decoder', 'tls', 'tty', 'url',
+    'util', 'v8', 'vm', 'zlib', 'module', 'worker_threads', 'perf_hooks'
+];
+// --- Core Logic ---
+function detectFramework(projectDir = process.cwd()) {
+    try {
+        const pkgPath = path.join(projectDir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (deps.react || deps['react-dom'])
+                return 'react';
+            if (deps.vue || deps['nuxt'])
+                return 'vue';
+        }
+    }
+    catch (e) { }
+    return 'react';
+}
+async function getFrameworkConfig(entryPoint, outdir, isProduction) {
     const framework = detectFramework();
-    const hasVue = framework === 'vue';
-    const hasReact = framework === 'react';
-    const replaceValues = {
-        'process.env.NODE_ENV': JSON.stringify(isProduction ? 'production' : 'development'),
-        'process.env.PORT': JSON.stringify(process.vatts.port || 3000)
-    };
-    let vuePlugin = null;
-    if (hasVue) {
-        replaceValues['__VUE_OPTIONS_API__'] = JSON.stringify(true);
-        replaceValues['__VUE_PROD_DEVTOOLS__'] = JSON.stringify(!isProduction);
-        try {
-            let vuePkg;
-            try {
-                vuePkg = require('rollup-plugin-vue');
-            }
-            catch (e) {
-                if (e.code === 'ERR_REQUIRE_ESM') {
-                    vuePkg = await import('rollup-plugin-vue');
+    // Plugins que rodam ANTES da resolução de módulos (Configuração, Bloqueios de Framework incorreto)
+    const prePlugins = [
+        tsconfigPathsPlugin(process.cwd()),
+        {
+            name: 'block-vue-artifacts-generic',
+            load(id) {
+                // Se não for vue, bloqueia artifacts. O build.vue lida com o inverso.
+                if (framework !== 'vue' && (id.endsWith('.vue') || id.endsWith('.vue.js'))) {
+                    return 'export default {};';
                 }
-                else {
-                    throw e;
-                }
-            }
-            const vueFactory = vuePkg.default || vuePkg;
-            if (typeof vueFactory === 'function') {
-                vuePlugin = vueFactory({
-                    compilerOptions: {
-                        isCustomElement: (tag) => tag.includes('-')
-                    }
-                });
+                return null;
             }
         }
-        catch (e) {
-            Console.warn("Vue detected but failed to load rollup-plugin-vue:", e.message);
-        }
-    }
-    let extensions = ['.mjs', '.js', '.json', '.node', '.jsx', '.tsx', '.ts'];
-    if (hasVue) {
-        extensions = ['.vue', ...extensions];
-    }
-    // REGEX ESSENCIAL: Permite que o ESBuild processe os arquivos virtuais do Vue
-    let esbuildInclude;
-    if (hasVue) {
-        esbuildInclude = /\.[jt]sx?$|\.vue\?vue.*lang\.ts/;
+    ];
+    // Plugins que rodam DEPOIS da transformação do Framework (Markdown, CSS, Assets)
+    // Isso é crucial para o Vue, pois o CSS é gerado dinamicamente e precisa ser pego aqui.
+    const postPlugins = [
+        markdownPlugin(),
+        customPostCssPlugin(isProduction),
+        smartAssetPlugin(isProduction)
+    ];
+    const pluginConfig = { prePlugins, postPlugins };
+    if (framework === 'vue') {
+        Console.info("Framework detected: Vue.js");
+        return await createVueConfig(entryPoint, outdir, isProduction, pluginConfig);
     }
     else {
-        esbuildInclude = /\.[jt]sx?$/;
+        Console.info("Framework detected: React/Standard");
+        return await createReactConfig(entryPoint, outdir, isProduction, pluginConfig);
     }
-    const esbuildLoaders = {
-        '.js': 'jsx',
-        '.ts': 'ts',
-        '.tsx': 'tsx',
-        '.vue': 'ts'
-    };
-    return {
-        input: entryPoint,
-        external: nodeBuiltIns,
-        treeshake: {
-            moduleSideEffects: 'no-external',
-            preset: isProduction ? 'recommended' : 'smallest'
-        },
-        cache: isProduction ? true : false,
-        perf: false,
-        maxParallelFileOps: 20,
-        plugins: [
-            replace({
-                preventAssignment: true,
-                values: replaceValues
-            }),
-            tsconfigPathsPlugin(process.cwd()),
-            {
-                name: 'block-volar-artifacts',
-                load(id) {
-                    if (/\.vue\.(js|ts|d\.ts|map)$/.test(id)) {
-                        return 'export default {};';
-                    }
-                    return null;
-                }
-            },
-            {
-                name: 'block-vue-artifacts',
-                load(id) {
-                    if (!hasVue && (id.endsWith('.vue') || id.endsWith('.vue.js'))) {
-                        return 'export default {};';
-                    }
-                    return null;
-                }
-            },
-            nodeResolve({
-                extensions,
-                preferBuiltins: true,
-                browser: true,
-                dedupe: hasReact ? ['react', 'react-dom'] : (hasVue ? ['vue'] : [])
-            }),
-            ...(hasVue && vuePlugin ? [vuePlugin] : []),
-            // AQUI ESTÁ A MÁGICA: Plugin que corrige a falta do export default
-            ...(hasVue ? [vueScriptFixPlugin()] : []),
-            commonjs({
-                sourceMap: !isProduction,
-                requireReturnsDefault: 'auto',
-                ignoreTryCatch: true
-            }),
-            markdownPlugin(),
-            customPostCssPlugin(isProduction),
-            smartAssetPlugin(isProduction),
-            jsonPlugin(),
-            esbuild({
-                include: esbuildInclude,
-                exclude: /node_modules/,
-                sourceMap: !isProduction,
-                minify: isProduction,
-                legalComments: 'none',
-                treeShaking: isProduction,
-                target: 'esnext',
-                jsx: 'automatic',
-                define: { __VERSION__: '"1.0.0"' },
-                loaders: esbuildLoaders
-            })
-        ],
-        onwarn(warning, warn) {
-            if (warning.code === 'MODULE_LEVEL_DIRECTIVE')
-                return;
-            if (warning.code === 'THIS_IS_UNDEFINED')
-                return;
-            if (warning.code === 'CIRCULAR_DEPENDENCY' && warning.message.includes('node_modules'))
-                return;
-            warn(warning);
-        }
-    };
 }
-/**
- * Builds with code splitting into multiple chunks (ESM Format) - MODO PRODUÇÃO
- */
+// --- Build Functions ---
 async function buildWithChunks(entryPoint, outdir, isProduction = false) {
     await cleanDirectoryExcept(outdir, 'temp');
     try {
-        const inputOptions = await createRollupConfig(entryPoint, outdir, isProduction);
+        const inputOptions = await getFrameworkConfig(entryPoint, outdir, isProduction);
+        inputOptions.external = nodeBuiltIns;
         const outputOptions = {
             dir: outdir,
             format: 'es',
@@ -449,18 +290,14 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
             manualChunks(id) {
                 if (id.includes('node_modules')) {
                     const normalizedId = id.replace(/\\/g, '/');
-                    if (/\/node_modules\/(react|react-dom|scheduler|prop-types|loose-envify|object-assign)\//.test(normalizedId)) {
+                    if (/\/node_modules\/(react|react-dom|scheduler|prop-types|loose-envify|object-assign)\//.test(normalizedId))
                         return 'vendor-react';
-                    }
-                    if (/\/node_modules\/(vue|@vue)\//.test(normalizedId)) {
+                    if (/\/node_modules\/(vue|@vue)\//.test(normalizedId))
                         return 'vendor-vue';
-                    }
-                    if (id.includes('framer-motion') || id.includes('@radix-ui') || id.includes('@headlessui')) {
+                    if (id.includes('framer-motion') || id.includes('@radix-ui') || id.includes('@headlessui'))
                         return 'vendor-ui';
-                    }
-                    if (id.includes('lodash') || id.includes('date-fns') || id.includes('axios')) {
+                    if (id.includes('lodash') || id.includes('date-fns') || id.includes('axios'))
                         return 'vendor-utils';
-                    }
                     return 'vendor';
                 }
             }
@@ -474,14 +311,12 @@ async function buildWithChunks(entryPoint, outdir, isProduction = false) {
         process.exit(1);
     }
 }
-/**
- * Builds a single entry point into a single output file (IIFE Format)
- */
 async function build(entryPoint, outfile, isProduction = false) {
     const outdir = path.dirname(outfile);
     await cleanDirectoryExcept(outdir, 'temp');
     try {
-        const inputOptions = await createRollupConfig(entryPoint, outdir, isProduction);
+        const inputOptions = await getFrameworkConfig(entryPoint, outdir, isProduction);
+        inputOptions.external = nodeBuiltIns;
         const outputOptions = {
             file: outfile,
             format: 'iife',
@@ -499,9 +334,7 @@ async function build(entryPoint, outfile, isProduction = false) {
         process.exit(1);
     }
 }
-/**
- * Helper para lidar com notificações do Watcher
- */
+// --- Watch Functions ---
 function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
     let currentBuildId = 0;
     let lastStartedBuildId = 0;
@@ -527,29 +360,25 @@ function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
                 loc: event.error?.loc,
                 buildId: currentBuildId
             };
-            if (hotReloadManager) {
+            if (hotReloadManager)
                 hotReloadManager.onBuildComplete(false, errDetails);
-            }
             else
                 Console.error("Build Error:", event.error);
             if (resolveFirstBuild)
                 resolveFirstBuild();
         }
-        if (event.code === 'BUNDLE_END') {
+        if (event.code === 'BUNDLE_END')
             event.result.close();
-        }
         if (event.code === 'END') {
             const endBuildId = currentBuildId;
             const hadError = erroredBuildIds.has(endBuildId);
             if (endBuildId === lastStartedBuildId && !hadError) {
-                if (hotReloadManager) {
+                if (hotReloadManager)
                     hotReloadManager.onBuildComplete(true, { buildId: endBuildId });
-                }
             }
-            for (const id of erroredBuildIds) {
+            for (const id of erroredBuildIds)
                 if (id < lastStartedBuildId)
                     erroredBuildIds.delete(id);
-            }
             if (resolveFirstBuild) {
                 resolveFirstBuild();
                 resolveFirstBuild = null;
@@ -557,13 +386,11 @@ function handleWatcherEvents(watcher, hotReloadManager, resolveFirstBuild) {
         }
     });
 }
-/**
- * Watches with code splitting enabled
- */
 async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
     await cleanDirectoryExcept(outdir, 'temp');
     try {
-        const inputOptions = await createRollupConfig(entryPoint, outdir, false);
+        const inputOptions = await getFrameworkConfig(entryPoint, outdir, false);
+        inputOptions.external = nodeBuiltIns;
         const outputOptions = {
             dir: outdir,
             format: 'es',
@@ -573,12 +400,7 @@ async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
         const watchOptions = {
             ...inputOptions,
             output: outputOptions,
-            watch: {
-                exclude: 'node_modules/**',
-                clearScreen: false,
-                skipWrite: false,
-                buildDelay: 100
-            }
+            watch: { exclude: 'node_modules/**', clearScreen: false, skipWrite: false, buildDelay: 100 }
         };
         const watcher = rollupWatch(watchOptions);
         await new Promise((resolve) => handleWatcherEvents(watcher, hotReloadManager, resolve));
@@ -591,13 +413,11 @@ async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
         throw error;
     }
 }
-/**
- * Watches an entry point (Single File)
- */
 async function watch(entryPoint, outfile, hotReloadManager = null) {
     const outdir = path.dirname(outfile);
     try {
-        const inputOptions = await createRollupConfig(entryPoint, outdir, false);
+        const inputOptions = await getFrameworkConfig(entryPoint, outdir, false);
+        inputOptions.external = nodeBuiltIns;
         const outputOptions = {
             file: outfile,
             format: 'es',
@@ -606,11 +426,7 @@ async function watch(entryPoint, outfile, hotReloadManager = null) {
         const watchOptions = {
             ...inputOptions,
             output: outputOptions,
-            watch: {
-                exclude: 'node_modules/**',
-                clearScreen: false,
-                buildDelay: 100
-            }
+            watch: { exclude: 'node_modules/**', clearScreen: false, buildDelay: 100 }
         };
         const watcher = rollupWatch(watchOptions);
         await new Promise((resolve) => handleWatcherEvents(watcher, hotReloadManager, resolve));
@@ -637,9 +453,7 @@ async function cleanDirectoryExcept(dirPath, excludeFolder) {
                 const info = await stat(itemPath);
                 await rm(itemPath, { recursive: info.isDirectory(), force: true });
             }
-            catch (e) {
-                // Ignora erro se arquivo sumir
-            }
+            catch (e) { }
         }
     }
     catch (e) {

package/dist/client/clientRouter.js

@@ -1,7 +1,7 @@
 "use strict";
 /*
  * This file is part of the Vatts.js Project.
- * Copyright (c) 2026 itsmuzin
+ * Copyright (c) 2026 mfraz
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/dist/client/rpc.js

@@ -1,7 +1,7 @@
 "use strict";
 /*
  * This file is part of the Vatts.js Project.
- * Copyright (c) 2026 itsmuzin
+ * Copyright (c) 2026 mfraz
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.