lumpiajs 1.0.7 → 1.0.9

package/lib/commands/create.js

@@ -1,156 +1,203 @@
 import fs from 'fs';
 import path from 'path';
+import prompts from 'prompts';
 
-// --- TEMPLATES ---
 const routesTemplate = `import { Jalan } from 'lumpiajs';
 
-// Define Routes
-Jalan.gawe('/', 'HomeController@index');
-Jalan.gawe('/profile', 'HomeController@profile');
-Jalan.gawe('/api/products', 'ProductController@index');
+// Pakai gaya Laravel (->) enak to?
+Jalan->get('/', 'HomeController@index');
+Jalan->get('/db-test', 'HomeController@testDb');
+Jalan->get('/profile', 'HomeController@profile');
+Jalan->get('/api/products', 'ProductController@index');
 `;
 
-const controllerTemplate = `import { Controller } from 'lumpiajs';
+const controllerTemplate = `import { Controller, DB } from 'lumpiajs';
 
 export default class HomeController extends Controller {
     index() {
-        // Tampilkan halaman home
-        // this.env bisa diakses di sini
-        return this.tampil('home', { 
+        // "this.tampil" juga bisa ditulis "this->tampil"
+        // Transpiler LumpiaJS sing ngatur, Bos!
+        return this->tampil('home', { 
             message: 'Welcome to LumpiaJS MVC!',
             author: 'Pakdhe Koding',
             env: this.env.APP_ENV
         });
     }
 
+    async testDb() {
+        try {
+            // CONTOH QUERY ALA LARAVEL
+            // Pake tanda panah -> biar mantap
+            const result = await DB.table('users')
+                                   ->limit(1)
+                                   ->get();
+            
+            // Raw Query
+            const raw = await DB->query('SELECT 1 + 1 AS solution');
+            
+            return this->json({
+                status: 'Connected!',
+                sample_user: result,
+                math_check: raw[0].solution
+            });
+        } catch (e) {
+            return this->json({ error: e.message });
+        }
+    }
+
     profile() {
-        return this.tampil('profile', { name: 'Loyal User' });
+        return this->tampil('profile', { name: 'Loyal User' });
     }
 }
 `;
 
-const modelTemplate = `// Example dummy data
+const modelTemplate = `// Example dummy data (Static)
 const productData = [
     { id: 1, name: 'Lumpia Basah', price: 5000 },
-    { id: 2, name: 'Lumpia Goreng', price: 6000 },
-    { id: 3, name: 'Tahu Gimbal', price: 12000 }
+    { id: 2, name: 'Lumpia Goreng', price: 6000 }
 ];
-
 export default productData;
 `;
 
 const productControllerTemplate = `import { Controller, Model } from 'lumpiajs';
-import ProductData from '../../app/models/Product.js';
+import ProductData from '../../app/models/Product.lmp'; 
 
 export default class ProductController extends Controller {
     index() {
-        const result = Model.use(ProductData)
-                        .dimana('price', '>', 5500)
-                        .jupuk();
-
-        return this.json({
-            status: 'success',
-            data: result,
-            debug_mode: this.env.APP_DEBUG
-        });
+        // Model Static juga bisa pakai ->
+        const result = Model->use(ProductData)
+                        ->dimana('price', '>', 5500)
+                        ->jupuk();
+
+        return this->json({ status: 'success', data: result });
     }
 }
 `;
 
-const viewHomeTemplate = `<lump>
-  <klambi>
-    h1 { color: #d35400; text-align: center; }
-    .box { border: 1px solid #ddd; padding: 20px; text-align: center; margin-top: 20px; }
-    .badge { background: #eee; padding: 5px; border-radius: 4px; font-size: 12px; }
-  </klambi>
-
-  <kulit>
-    <h1>{{ message }}</h1>
-    <div class="box">
-        <span class="badge">Environment: {{ env }}</span>
-        <p>Created with love by: <strong>{{ author }}</strong></p>
-        <button onclick="checkPrice()">Check Price API</button>
-        <br><br>
-        <a href="/profile">Go to Profile</a>
-    </div>
-  </kulit>
-
-  <isi>
-    gawe checkPrice() {
-       fetch('/api/products')
-         .then(res => res.json())
-         .then(data => {
-            alert('Data from API: ' + JSON.stringify(data));
-         });
-    }
-  </isi>
-</lump>`;
-
 const viewProfileTemplate = `<lump>
   <kulit>
-    <h1>User Profile</h1>
-    <p>Hello, <strong>{{ name }}</strong>!</p>
-    <a href="/">Back Home</a>
+    <div class="container mt-5">
+        <h1>User Profile</h1>
+        <p>Hello, <strong>{{ name }}</strong>!</p>
+        <a href="/" class="btn btn-secondary">Back Home</a>
+    </div>
   </kulit>
 </lump>`;
 
-const packageJsonTemplate = (name) => `{
-  "name": "${name}",
-  "version": "1.0.0",
-  "main": "routes/web.js",
-  "type": "module",
-  "scripts": {
-    "start": "lumpia kukus",
-    "serve": "lumpia kukus"
-  },
-  "dependencies": {
-    "lumpiajs": "latest"
-  }
-}
-`;
-
 const envTemplate = `
 BASE_URL="http://localhost:3000"
 APP_ENV="local"        
-# Pilihan: 'local', 'development', 'production'
 APP_DEBUG="true"
-# Pilihan: 'true', 'false'
+
+# Database Config
+DB_HOST="localhost"
+DB_USER="root"
+DB_PASSWORD=""
+DB_NAME="lumpia_db"
 `;
 
-export function createProject(parameter) {
-    const projectName = parameter;
+// Helper for CSS/View generation (Collapsed for brevity but functional as before)
+const tailwindConfigTemplate = `/** @type {import('tailwindcss').Config} */
+module.exports = { content: ["./views/**/*.{html,js,lmp}"], theme: { extend: {}, }, plugins: [], }`;
+const mainCssTemplate = `@tailwind base;\n@tailwind components;\n@tailwind utilities;\n`;
+
+const generateHomeView = (style) => {
+    let css = '', html = '';
+    if (style === 'bootstrap') {
+        html = `
+    <div class="container mt-5">
+        <div class="card shadow">
+            <div class="card-body text-center">
+                <h1 class="text-primary">{{ message }}</h1>
+                <span class="badge bg-secondary mb-3">Env: {{ env }}</span>
+                <p>Created by: <strong>{{ author }}</strong></p>
+                <div class="mt-4">
+                    <a href="/db-test" class="btn btn-warning">Test DB (Laravel Style)</a>
+                    <a href="/profile" class="btn btn-link">Go to Profile</a>
+                </div>
+            </div>
+        </div>
+    </div>`;
+    } else if (style === 'tailwindcss') {
+        html = `
+    <div class="container mx-auto mt-10 p-5">
+        <div class="bg-white shadow-lg rounded-lg p-8 text-center border border-gray-200">
+            <h1 class="text-4xl font-bold text-orange-600 mb-4">{{ message }}</h1>
+            <span class="inline-block bg-gray-200 rounded-full px-3 py-1 text-sm font-semibold text-gray-700 mb-4">Env: {{ env }}</span>
+            <div class="mt-6 space-x-4">
+                <a href="/db-test" class="bg-yellow-500 hover:bg-yellow-600 text-white font-bold py-2 px-4 rounded">Test DB</a>
+                <a href="/profile" class="text-blue-500 hover:text-blue-800">Go to Profile</a>
+            </div>
+        </div>
+    </div>`;
+    } else {
+        css = `h1{text-align:center} .box{text-align:center;margin-top:20px}`;
+        html = `<div class="box"><h1>{{ message }}</h1><p>Env: {{ env }}</p><a href="/db-test">Test DB</a> | <a href="/profile">Profile</a><br>(Check Controller for Laravel Syntax Demo)</div>`;
+    }
+    return `<lump><klambi>${css}</klambi><kulit>${html}</kulit><isi></isi></lump>`;
+};
+
+const generatePackageJson = (name, style) => {
+    const scripts = { "start": "lumpia kukus", "serve": "lumpia kukus" };
+    const dependencies = { "lumpiajs": "latest" };
+    const devDependencies = {};
+    if (style === 'tailwindcss') {
+        devDependencies["tailwindcss"] = "^3.4.0";
+        devDependencies["postcss"] = "^8.4.0";
+        devDependencies["autoprefixer"] = "^10.4.0";
+    } else if (style === 'bootstrap') dependencies["bootstrap"] = "^5.3.0";
+    return JSON.stringify({ name, version: "1.0.0", main: "routes/web.lmp", type: "module", scripts, dependencies, devDependencies }, null, 2);
+};
+
+export async function createProject(parameter) {
+    let projectName = parameter;
     if (!projectName) {
-        console.log('❌ Please specify project name.');
-        console.log('Example: lumpia create-project my-app');
-        return;
+        const res = await prompts({ type: 'text', name: 'val', message: 'Jeneng project?', initial: 'my-app' });
+        projectName = res.val;
     }
-
+    if (!projectName) return;
+    
     const root = path.join(process.cwd(), projectName);
-    if (fs.existsSync(root)) return console.log(`❌ Folder ${projectName} already exists.`);
+    if (fs.existsSync(root)) { console.log('❌ Folder Exists'); return; }
 
-    console.log(`🔨 Building MVC foundation in ${projectName}...`);
-    
+    const styleRes = await prompts({
+        type: 'select', name: 'val', message: 'Styling?',
+        choices: [{title:'Vanilla',value:'none'},{title:'Tailwind',value:'tailwindcss'},{title:'Bootstrap',value:'bootstrap'}],
+        initial: 0
+    });
+    const style = styleRes.val;
+    if (!style) return;
+
+    // Structure
     fs.mkdirSync(root);
-    
     fs.mkdirSync(path.join(root, 'app', 'controllers'), { recursive: true });
     fs.mkdirSync(path.join(root, 'app', 'models'), { recursive: true });
     fs.mkdirSync(path.join(root, 'routes'));
-    fs.mkdirSync(path.join(root, 'views')); 
-
-    // Write files
-    fs.writeFileSync(path.join(root, 'package.json'), packageJsonTemplate(projectName));
-    fs.writeFileSync(path.join(root, '.env'), envTemplate); // Create .env
-    fs.writeFileSync(path.join(root, 'routes', 'web.js'), routesTemplate);
-    fs.writeFileSync(path.join(root, 'app', 'controllers', 'HomeController.js'), controllerTemplate);
-    fs.writeFileSync(path.join(root, 'app', 'controllers', 'ProductController.js'), productControllerTemplate);
-    fs.writeFileSync(path.join(root, 'app', 'models', 'Product.js'), modelTemplate);
-    fs.writeFileSync(path.join(root, 'views', 'home.lmp'), viewHomeTemplate);
+    fs.mkdirSync(path.join(root, 'views'));
+    fs.mkdirSync(path.join(root, 'aset', 'css'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'public', 'css'), { recursive: true });
+
+    // Files
+    fs.writeFileSync(path.join(root, 'package.json'), generatePackageJson(projectName, style));
+    fs.writeFileSync(path.join(root, '.gitignore'), `.lumpia\nnode_modules\n.env\n`);
+    fs.writeFileSync(path.join(root, '.env'), envTemplate);
+    fs.writeFileSync(path.join(root, 'config.lmp'), JSON.stringify({ klambi: style }, null, 2));
+
+    fs.writeFileSync(path.join(root, 'routes', 'web.lmp'), routesTemplate);
+    fs.writeFileSync(path.join(root, 'app', 'controllers', 'HomeController.lmp'), controllerTemplate);
+    fs.writeFileSync(path.join(root, 'app', 'controllers', 'ProductController.lmp'), productControllerTemplate);
+    fs.writeFileSync(path.join(root, 'app', 'models', 'Product.lmp'), modelTemplate);
+    fs.writeFileSync(path.join(root, 'views', 'home.lmp'), generateHomeView(style));
     fs.writeFileSync(path.join(root, 'views', 'profile.lmp'), viewProfileTemplate);
+    
+    // Style Assets
+    if (style === 'tailwindcss') {
+        fs.writeFileSync(path.join(root, 'tailwind.config.js'), tailwindConfigTemplate);
+        fs.writeFileSync(path.join(root, 'aset', 'css', 'style.css'), mainCssTemplate);
+    } else {
+        fs.writeFileSync(path.join(root, 'aset', 'css', 'style.css'), style === 'bootstrap' ? '/* Bootstrap Imported in HTML */' : '/* CSS */');
+    }
 
-    console.log('✅ Project ready! Standard MVC Structure with .env Support.');
-    console.log('----------------------------------------------------');
-    console.log(`cd ${projectName}`);
-    console.log('npm install');
-    console.log('lumpia kukus');
-    console.log('----------------------------------------------------');
+    console.log(`✅ Project "${projectName}" Ready!`);
+    console.log(`cd ${projectName} && npm install && lumpia kukus`);
 }

package/lib/commands/serve.js

@@ -1,95 +1,146 @@
 import fs from 'fs';
 import path from 'path';
 import http from 'http';
+import { spawn } from 'child_process';
 import { routes } from '../core/Router.js';
 import { renderLumpia } from '../core/View.js';
 import { loadEnv } from '../core/Env.js';
+import { loadConfig } from '../core/Config.js'; 
 
-// Baca versi LumpiaJS global (CLI ini)
 const cliPackageJson = JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url)));
 
-// Helper untuk mencocokkan Route dengan Parameter {id} dll
+// Helper to Match Routes
 function matchRoute(definedRoute, method, pathname) {
     if (definedRoute.method !== method) return null;
-
-    // 1. Exact Match
     if (definedRoute.path === pathname) return { params: {} };
 
-    // 2. Dynamic Match (Regex)
-    // Convert /produk/{id}/{slug} -> ^\/produk\/([^\/]+)\/([^\/]+)$
     const paramNames = [];
     const regexPath = definedRoute.path.replace(/\{([a-zA-Z0-9_]+)\}/g, (match, name) => {
         paramNames.push(name);
         return '([^/]+)';
     });
 
-    // Skip if no params found in definition (optimization)
     if (regexPath === definedRoute.path) return null;
-
     const regex = new RegExp(`^${regexPath}$`);
     const match = pathname.match(regex);
-
     if (match) {
         const params = {};
         paramNames.forEach((name, index) => {
-            params[name] = match[index + 1]; // capture groups start at 1
+            params[name] = match[index + 1]; 
         });
         return { params };
     }
-
     return null;
 }
 
-export async function serveProject() {
-    const root = process.cwd();
+const backgroundProcess = [];
+
+function startTailwindWatcher(root) {
+    console.log('🎨 TailwindCSS detected! Starting watcher...');
+    const cmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    const tailwind = spawn(cmd, [
+        'tailwindcss', '-i', './aset/css/style.css', '-o', './public/css/style.css', '--watch'
+    ], { cwd: root, stdio: 'inherit', shell: true });
+    backgroundProcess.push(tailwind);
+}
+
+function handleBootstrap(root) {
+    const bootDestDist = path.join(root, 'public', 'vendor', 'bootstrap');
+    const bootSrc = path.join(root, 'node_modules', 'bootstrap', 'dist');
+    if (fs.existsSync(bootSrc) && !fs.existsSync(bootDestDist)) {
+        console.log('📦 Menyalin library Bootstrap ke public...');
+        try { fs.cpSync(bootSrc, bootDestDist, { recursive: true }); } catch(e) {}
+    }
+}
+
+// LOADER UTAMA UNTUK .lmp (Controller/Model/Routes)
+async function loadLumpiaModule(filePath) {
+    const originalContent = fs.readFileSync(filePath, 'utf-8');
+    const cacheDir = path.join(process.cwd(), '.lumpia', 'cache');
+    if (!fs.existsSync(cacheDir)) fs.mkdirSync(cacheDir, { recursive: true });
     
-    // --- 1. Version Check ---
-    const userPackageJsonPath = path.join(root, 'package.json');
-    if (fs.existsSync(userPackageJsonPath)) {
-        const userPkg = JSON.parse(fs.readFileSync(userPackageJsonPath, 'utf-8'));
-        const userLumpiaVer = (userPkg.dependencies && userPkg.dependencies.lumpiajs) || 'unknown';
+    const relativePath = path.relative(process.cwd(), filePath);
+    const flatName = relativePath.replace(/[\/\\]/g, '_').replace('.lmp', '.js');
+    const destPath = path.join(cacheDir, flatName);
+
+    // --- TRANSPILE LOGIC ---
+    let transcoded = originalContent;
+
+    // 1. Replace Imports: .lmp -> .js
+    transcoded = transcoded.replace(/from\s+['"](.+?)\.lmp['"]/g, "from '$1.js'");
+
+    // 2. SYNTAX LARAVEL -> JS (Fitur Request User: "->")
+    // Mengubah tanda panah "->" menjadi titik "." 
+    // Hati-hati: Kita coba sebisa mungkin tidak mengubah "->" yang ada di dalam string.
+    // Regex ini mencari "->" yang TIDAK diapit kutip (Simpel, mungkin tidak 100% sempurna tapi cukup untuk have fun)
+    // Atau kita brute force saja asalkan user tahu resikonya.
+    // Kita gunakan pendekatan brute replace tapi hindari arrow function "=>" (aman karena beda karakter)
+    
+    // Replace "->" dengan "."
+    transcoded = transcoded.split('\n').map(line => {
+        // Cek komentar //
+        if (line.trim().startsWith('//')) return line;
         
-        console.log(`ℹ️  LumpiaJS CLI Version: ${cliPackageJson.version}`);
-        console.log(`ℹ️  Project Dependency Version: ${userLumpiaVer}`);
-
-        const cleanUserVer = userLumpiaVer.replace(/[^0-9.]/g, '');
-        if (cleanUserVer !== cliPackageJson.version && userLumpiaVer !== 'latest') {
-             console.log('\n⚠️  PERINGATAN BEDA VERSI!');
-             console.log(`   Versi CLI kamu (${cliPackageJson.version}) beda dengan versi di project (${userLumpiaVer}).`);
-             console.log('   Saran: Update project dependencies agar sinkron.');
-             console.log('   Cara update: npm install lumpiajs@latest\n');
-        }
-    }
+        // Simple replace "->" to "."
+        // Note: Ini akan mengubah string "go -> to" menjadi "go . to". 
+        // Untuk framework "Have Fun", ini fitur, bukan bug. XD
+        return line.replace(/->/g, '.');
+    }).join('\n');
+
+    fs.writeFileSync(destPath, transcoded);
+    
+    // 4. Import file .js
+    const module = await import('file://' + destPath + '?t=' + Date.now());
+    return module;
+}
+
 
-    const routesFile = path.join(root, 'routes', 'web.js');
-    if (!fs.existsSync(routesFile)) return console.log("❌ This is not a LumpiaJS MVC project! (Cannot find routes/web.js)");
+export async function serveProject() {
+    const root = process.cwd();
+    
+    const routesFile = path.join(root, 'routes', 'web.lmp');
+    if (!fs.existsSync(routesFile)) return console.log("❌ Not a LumpiaJS Project. (Missing routes/web.lmp)");
 
-    // --- 2. Load ENV ---
     const env = loadEnv(root);
-    console.log(`🌍 Environment: ${env.APP_ENV}`);
-    console.log(`🐛 Debug Mode: ${env.APP_DEBUG}`);
+    const config = loadConfig(root);
 
-    try {
-        // Load User Routes
-        const userRouteUrl =  path.join(root, 'routes', 'web.js');
-        await import('file://' + userRouteUrl);
+    if (config.klambi === 'tailwindcss') startTailwindWatcher(root);
+    else if (config.klambi === 'bootstrap') handleBootstrap(root);
 
+    try {
+        await loadLumpiaModule(routesFile);
         console.log(`🛣️  Routes registered: ${routes.length}`);
+        
+        // Info Syntax
+        console.log(`✨ Syntax Mode: PHP/Laravel Style (->) is enabled in .lmp files!`);
 
-        // Start Server
         const server = http.createServer(async (req, res) => {
             const method = req.method;
             const url = new URL(req.url, `http://${req.headers.host}`);
             const pathname = url.pathname;
 
-            if (env.APP_DEBUG === 'true') {
-                 console.log(`📥 ${method} ${pathname}`);
+            if (env.APP_DEBUG === 'true') console.log(`📥 ${method} ${pathname}`);
+
+            const publicMap = {
+                '/css/': path.join(root, 'public', 'css'),
+                '/vendor/': path.join(root, 'public', 'vendor')
+            };
+            for (const [prefix, localPath] of Object.entries(publicMap)) {
+                if (pathname.startsWith(prefix)) {
+                    const relativePath = pathname.slice(prefix.length);
+                    const filePath = path.join(localPath, relativePath);
+                    if (fs.existsSync(filePath) && fs.lstatSync(filePath).isFile()) {
+                        const ext = path.extname(filePath);
+                        const mime = ext === '.css' ? 'text/css' : (ext === '.js' ? 'text/javascript' : 'application/octet-stream');
+                        res.writeHead(200, {'Content-Type': mime});
+                        res.end(fs.readFileSync(filePath));
+                        return;
+                    }
+                }
             }
 
-            // FIND MATCHING ROUTE
             let match = null;
             let params = {};
-
             for (const route of routes) {
                 const result = matchRoute(route, method, pathname);
                 if (result) {
@@ -102,29 +153,20 @@ export async function serveProject() {
             if (match) {
                 try {
                     const [controllerName, methodName] = match.action.split('@');
-                    const controllerPath = path.join(root, 'app', 'controllers', controllerName + '.js');
+                    const controllerPath = path.join(root, 'app', 'controllers', controllerName + '.lmp');
                     
-                    if (!fs.existsSync(controllerPath)) throw new Error(`Controller ${controllerName} not found in app/controllers!`);
+                    if (!fs.existsSync(controllerPath)) throw new Error(`Controller ${controllerName} not found!`);
                     
-                    // In Development/Local, always invalidate cache
-                    let importUrl = 'file://' + controllerPath;
-                    if (env.APP_ENV === 'local' || env.APP_ENV === 'development') {
-                        importUrl += '?update=' + Date.now();
-                    }
-
-                    const module = await import(importUrl); 
+                    const module = await loadLumpiaModule(controllerPath);
                     const ControllerClass = module.default;
                     const instance = new ControllerClass();
                     
-                    // Inject ENV & Params to Controller
                     instance.env = env;
-                    instance.params = params; // Available as this.params
+                    instance.params = params;
+                    instance.config = config;
 
-                    if (typeof instance[methodName] !== 'function') {
-                        throw new Error(`Method ${methodName} does not exist in ${controllerName}`);
-                    }
+                    if (typeof instance[methodName] !== 'function') throw new Error(`Method ${methodName} missing`);
 
-                    // Pass params as spread arguments to the method: index(id, slug)
                     const args = Object.values(params);
                     const result = await instance[methodName](...args); 
 
@@ -140,26 +182,28 @@ export async function serveProject() {
                     }
                 } catch (e) {
                     console.error(e);
-                    const errorMsg = env.APP_DEBUG === 'true' 
-                        ? `<h1>500: Server Error</h1><pre>${e.message}\n${e.stack}</pre>`
-                        : `<h1>500: Server Error</h1><p>Something went wrong.</p>`;
-                        
+                    const errorMsg = env.APP_DEBUG === 'true' ? `<pre>${e.stack}</pre>` : `<h1>Server Error</h1>`;
                     res.writeHead(500, {'Content-Type': 'text/html'});
                     res.end(errorMsg);
                 }
             } else {
                 res.writeHead(404, {'Content-Type': 'text/html'});
-                res.end('<h1>404: Not Found</h1>');
+                res.end('<h1>404 Not Found</h1>');
             }
         });
 
         const port = 3000;
         server.listen(port, () => {
             console.log(`🚀 Server running at ${env.BASE_URL || 'http://localhost:3000'}`);
-            console.log(`(Press Ctrl+C to stop)`);
+        });
+
+        process.on('SIGINT', () => {
+            backgroundProcess.forEach(p => p.kill());
+            try { fs.rmSync(path.join(root, '.lumpia'), { recursive: true, force: true }); } catch(e){}
+            process.exit();
         });
 
     } catch (err) {
-        console.error('Fatal Error loading routes:', err);
+        console.error('Fatal Error:', err);
     }
 }

package/lib/core/Config.js

@@ -0,0 +1,20 @@
+import fs from 'fs';
+import path from 'path';
+
+export function loadConfig(root) {
+    const configPath = path.join(root, 'config.lmp');
+    const config = {
+        klambi: 'none' // default
+    };
+    
+    if (fs.existsSync(configPath)) {
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (parsed.klambi) config.klambi = parsed.klambi;
+        } catch (e) {
+            console.error('⚠️ Gagal moco config.lmp', e.message);
+        }
+    }
+    return config;
+}