vladx 1.4.1 → 1.5.1

package/examples/stdlib/ambiente.vx

@@ -0,0 +1,8 @@
+importa { prendi } da "@std/Ambiente";
+
+variabile path = prendi("PATH");
+stampa("Tuo percorso di sistema (PATH):");
+stampa(path);
+
+variabile user = prendi("USER") ?? prendi("USERNAME");
+stampa("\nUtente corrente: " + user);

package/examples/stdlib/archivio_extra.vx

@@ -0,0 +1,11 @@
+importa { elencaTutto } da "@std/ArchivioExtra";
+
+stampa("Analisi completa cartella 'src':");
+variabile fileSrc = elencaTutto("src");
+
+// Mostro solo i primi 5 per brevità
+variabile i = 0;
+per (variabile f di fileSrc) {
+    se (i < 5) stampa("- " + f);
+    i++;
+}

package/examples/stdlib/asserzione.vx

@@ -0,0 +1,11 @@
+importa { uguale, vero } da "@std/Asserzione";
+
+stampa("Esecuzione test unitari...");
+
+prova {
+    uguale(10 + 10, 20);
+    vero(5 > 0);
+    stampa("Test passati!");
+} cattura (e) {
+    stampa("Errore asserzione: " + e);
+}

package/examples/stdlib/client_web.vx

@@ -0,0 +1,7 @@
+importa { get } da "@std/ClientWeb";
+
+stampa("Recupero dati da API esterna...");
+variabile dati = get("https://jsonplaceholder.typicode.com/todos/1");
+
+stampa("Risposta ricevuta:");
+stampa(dati);

package/examples/stdlib/codifica.vx

@@ -0,0 +1,8 @@
+importa { base64, daBase64, hex, uri } da "@std/Codifica";
+
+variabile t = "VladX Core";
+
+stampa("Testo: " + t);
+stampa("Base64: " + base64(t));
+stampa("Hex: " + hex(t));
+stampa("URI encoded: " + uri("https://vlad.it?n=vlad x"));

package/examples/stdlib/collezioni.vx

@@ -0,0 +1,11 @@
+importa { CreaMappa, CreaInsieme, chiavi, valori } da "@std/Collezioni";
+
+stampa("--- MAPPA ---");
+variabile m = CreaMappa();
+m.set("chiave", "valore");
+stampa("Contenuto mappa: " + m.get("chiave"));
+
+stampa("\n--- OGGETTI ---");
+variabile obj = { nome: "Vlad", versione: 1.4 };
+stampa("Chiavi: " + chiavi(obj));
+stampa("Valori: " + valori(obj));

package/examples/stdlib/compressione.vx

@@ -0,0 +1,10 @@
+importa { comprimi, decomprimi } da "@std/Compressione";
+
+variabile segreto = "Questo è un messaggio molto lungo che vogliamo comprimere.";
+stampa("Originale (" + lunghezza(segreto) + " byte): " + segreto);
+
+variabile compresso = comprimi(segreto);
+stampa("Compresso (Base64): " + compresso);
+
+variabile decompresso = decomprimi(compresso);
+stampa("Decompresso: " + decompresso);

package/examples/stdlib/console.vx

@@ -0,0 +1,14 @@
+importa { log, errore, avviso, successo, tabella } da "@std/Console";
+
+log("Semplice log di sistema");
+successo("Operazione completata con successo!");
+avviso("Attenzione: valore instabile.");
+errore("Errore critico rilevato!");
+
+variabile dati = [
+    { id: 1, nome: "Vlad" },
+    { id: 2, nome: "Rex" }
+];
+
+stampa("\nVisualizzazione tabella:");
+tabella(dati);

package/examples/stdlib/cripto.vx

@@ -0,0 +1,8 @@
+importa { sha256, md5, uuid, casuale } da "@std/Cripto";
+
+stampa("Generazione UUID: " + uuid());
+stampa("Token casuale (Hex): " + casuale(32));
+
+variabile password = "vlad_password_sicura";
+stampa("SHA256: " + sha256(password));
+stampa("MD5: " + md5(password));

package/examples/stdlib/dati.vx

@@ -0,0 +1,21 @@
+importa { clona, fondi, raggruppa } da "@std/Dati";
+
+stampa("--- CLONE ---");
+variabile a = { x: 1 };
+variabile b = clona(a);
+b.x = 2;
+stampa("a.x (dovrebbe essere 1): " + a.x);
+
+stampa("\n--- MERGE ---");
+variabile base = { nome: "Vlad" };
+variabile extra = { eta: 25 };
+fondi(base, extra);
+stampa(base);
+
+stampa("\n--- GROUP BY ---");
+variabile persone = [
+    { nome: "Luca", citta: "Roma" },
+    { nome: "Sara", citta: "Milano" },
+    { nome: "Marco", citta: "Roma" }
+];
+stampa(raggruppa(persone, "citta"));

package/examples/stdlib/eventi.vx

@@ -0,0 +1,10 @@
+importa { CreaEmitter } da "@std/Eventi";
+
+variabile bus = CreaEmitter();
+
+bus.su("benvenuto", (dati) => {
+    stampa("Evento ricevuto! Dati: " + dati);
+});
+
+stampa("Lancio evento...");
+attendi bus.lancia("benvenuto", "Ciao da VladX");

package/examples/stdlib/json_extra.vx

@@ -0,0 +1,7 @@
+importa { codifica, analizzaSicuro } da "@std/JsonExtra";
+
+variabile dati = { api: "vladx", opzioni: [1, 2, 3] };
+stampa(codifica(dati));
+
+variabile str = '{"valido": vero}';
+stampa("Safe Parse: " + analizzaSicuro(str).valido);

package/examples/stdlib/matematica.vx

@@ -0,0 +1,9 @@
+importa { piGreco, radice, casuale, rotonda, max } da "@std/Matematica";
+
+stampa("Valore di PI: " + piGreco);
+stampa("Radice di 144: " + radice(144));
+stampa("Arrotonda 4.7: " + rotonda(4.7));
+stampa("Massimo tra 10, 50, 20: " + max(10, 50, 20));
+
+variabile n = casuale() * 10;
+stampa("Numero casuale 0-10: " + rotonda(n));

package/examples/stdlib/percorso.vx

@@ -0,0 +1,9 @@
+importa { unisci, base, cartella, estensione, assoluto } da "@std/Percorso";
+
+variabile mioFile = "/home/utente/progetti/test.vx";
+
+stampa("File: " + mioFile);
+stampa("Base: " + base(mioFile));
+stampa("Cartella: " + cartella(mioFile));
+stampa("Estensione: " + estensione(mioFile));
+stampa("Percorso assoluto di 'src': " + assoluto("src"));

package/examples/stdlib/processo.vx

@@ -0,0 +1,9 @@
+importa { id, memoria, piattaforma, versioneNode } da "@std/Processo";
+
+stampa("--- INFO PROCESSO ---");
+stampa("ID: " + id);
+stampa("Piattaforma: " + piattaforma);
+stampa("Node Version: " + versioneNode);
+
+stampa("\nUso memoria:");
+stampa(memoria());

package/examples/stdlib/server_web.vx

@@ -0,0 +1,10 @@
+importa { rispondiJson, errore } da "@std/ServerWeb";
+
+// Esempio d'uso teorico con Rete.server (vedi documentazione)
+// gestore = (richiesta) => {
+//     ritorna rispondiJson({ stato: "ok", msg: "Ciao da VladX" });
+// };
+
+variabile resp = rispondiJson({ id: 1 });
+stampa("Esempio risposta JSON:");
+stampa(resp);

package/examples/stdlib/sql_helper.vx

@@ -0,0 +1,7 @@
+importa { generaInsert } da "@std/SqlHelper";
+
+variabile utente = { nome: "Vlad", eta: 25, ruolo: "Admin" };
+variabile sql = generaInsert("utenti", utente);
+
+stampa("SQL generato:");
+stampa(sql);

package/examples/stdlib/tempo.vx

@@ -0,0 +1,9 @@
+importa { data, ora, pausa, timestamp } da "@std/Tempo";
+
+stampa("Oggi è il: " + data());
+stampa("Ora attuale: " + ora());
+stampa("Timestamp: " + timestamp());
+
+stampa("\nAttendo 1 secondo...");
+attendi pausa(1000);
+stampa("Fine attesa.");

package/examples/stdlib/testo.vx

@@ -0,0 +1,10 @@
+importa { maiuscolo, minuscolo, capitalizza, slugify, pulisci } da "@std/Testo";
+
+variabile testo = "   vladx è fantastico   ";
+
+stampa("Originale: '" + testo + "'");
+stampa("Pulisci: '" + pulisci(testo) + "'");
+stampa("Maiuscolo: " + maiuscolo(testo));
+stampa("Minuscolo: " + minuscolo(testo));
+stampa("Capitalizza: " + capitalizza("vlad"));
+stampa("Slugify: " + slugify("Benvenuti su VladX 2.0!"));

package/examples/stdlib/url.vx

@@ -0,0 +1,11 @@
+importa { analizza, componi } da "@std/Url";
+
+variabile link = "https://vladx.org/search?q=syntax&lang=it#top";
+variabile info = analizza(link);
+
+stampa("Host: " + info.host);
+stampa("Protocollo: " + info.protocollo);
+stampa("Query: " + info.query.q);
+
+variabile nuovoLink = componi("https://api.test.com", { chiave: "123", utente: "vlad" });
+stampa("Nuovo URL: " + nuovoLink);

package/examples/stdlib/validazione.vx

@@ -0,0 +1,5 @@
+importa { email, url, ip } da "@std/Validazione";
+
+stampa("Email valida? " + email("test@vladx.it")); // vero
+stampa("URL valido? " + url("httttp://errore")); // falso
+stampa("IP valido? " + ip("192.168.1.1")); // vero

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vladx",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "description": "VladX - Linguaggio di programmazione con sintassi italiana",
   "main": "src/index.js",
   "type": "commonjs",

package/programs/1/index.vx

@@ -1,4 +1,16 @@
-stampa("Ciao dal programma 1!");
-costante saluti = { matteo: "Ciao!", vlad: "Ehilà!" };
-stampa("Matteo dice: " + saluti.matteo);
-stampa("Vlad dice: " + saluti.vlad);
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome + " e ho " + questo.eta + " anni");
+    }
+}
+
+variabile p1 = nuovo Persona("Mario", 25);
+p1.saluta();
+
+variabile p2 = nuovo Persona("Luigi", 30);
+p2.saluta();

package/programs/main/index.vx

@@ -1,11 +1,15 @@
 variabile passport = {}
 passport.nome = chiedi("Come ti chiami? ")
-passport.eta = chiedi("Quanti anni hai? ")
-
-se(passport.eta >= 18) {
-    stampa("Sei maggiorenne")
+se(Archivio.esiste(`passports/${passport.nome}.json`))  {
+    stampa("GIA ESISTE, VATTENE!!")
 } altrimenti {
-    stampa("Sei minorenne")
-}
+    passport.eta = chiedi("Quanti anni hai? ")
+
+    se(passport.eta >= 18) {
+        stampa("Sei maggiorenne")
+    } altrimenti {
+        stampa("Sei minorenne")
+    }
 
-Archivio.scrivi(`passports/${passport.nome}.json`, JSON.stringify(passport))
+    Archivio.scrivi(`passports/${passport.nome}.json`, JSON.stringify(passport))
+}

package/programs/main/passports/Tanya.json

@@ -0,0 +1 @@
+{"nome":"Tanya","eta":"70"}

package/programs/main/passports/Vlad.json

@@ -1 +1 @@
-{"nome":"Vlad","eta":"25"}
+{"nome":"Vlad","eta":"12"}

package/programs/main/passports/vlad.json

@@ -0,0 +1 @@
+{"nome":"vlad","eta":"13"}

package/programs/tests/test_new_features.vx

@@ -0,0 +1,53 @@
+// Test Nuove Funzionalità VladX
+
+stampa("--- TEST SCEGLI-CASO ---");
+variabile colore = "verde";
+scegli (colore) {
+    caso "rosso":
+        stampa("Alt!");
+        interrompi;
+    caso "verde":
+        stampa("Vai!");
+        interrompi;
+    predefinito:
+        stampa("Colore ignoto");
+}
+
+stampa("\n--- TEST DESTRUTTURAZIONE ---");
+variabile [a, b] = [10, 20];
+stampa("a: " + a + ", b: " + b); // 10, 20
+
+variabile { nome, eta } = { nome: "Vlad", eta: 25, citta: "Roma" };
+stampa("Nome: " + nome + ", Eta: " + eta); // Vlad, 25
+
+stampa("\n--- TEST OPERATORE TERNARIO ---");
+variabile x = 10;
+variabile risultato = x > 5 ? "Maggiore" : "Minore";
+stampa("Risultato: " + risultato); // Maggiore
+
+stampa("\n--- TEST NULLISH COALESCING ---");
+variabile n = nullo;
+variabile val = n ?? "Default";
+stampa("Valore: " + val); // Default
+
+stampa("\n--- TEST OPTIONAL CHAINING ---");
+variabile utente = { info: { nome: "Luca" } };
+stampa("Nome utente: " + utente?.info?.nome); // Luca
+stampa("Cognome utente: " + (utente?.info?.cognome ?? "N/A")); // N/A
+
+stampa("\n--- TEST METODI ARRAY ---");
+variabile numeri = [1, 2, 3, 4, 5];
+variabile raddoppiati = attendi numeri.mappa((n) => n * 2);
+stampa("Raddoppiati: " + raddoppiati); // [2, 4, 6, 8, 10]
+
+variabile pari = attendi numeri.filtra((n) => n % 2 == 0);
+stampa("Pari: " + pari); // [2, 4]
+
+stampa("\n--- TEST MATEMATICA ---");
+stampa("PI: " + Matematica.piGreco);
+stampa("Radice di 16: " + Matematica.radice(16));
+stampa("Casuale (0-1): " + Matematica.casuale());
+
+stampa("\n--- TEST TEMPO ---");
+stampa("Data oggi: " + Tempo.data());
+stampa("Ora attuale: " + Tempo.ora());

package/programs/tests/test_stdlib.vx

@@ -0,0 +1,26 @@
+// Test Integrazione Standard Library VladX
+
+importa { maiuscolo, slugify } da "@std/Testo";
+importa { sha256, uuid } da "@std/Cripto";
+importa { log, successo, avviso } da "@std/Console";
+importa { data, ora } da "@std/Tempo"; // Modulo integrato precendente (ora anche in @std/Cronometro)
+importa { media, somma } da "@std/Calcolo";
+
+stampa("--- TEST @std/Testo ---");
+stampa("Maiuscolo: " + maiuscolo("vladx"));
+stampa("Slug: " + slugify("Questo è un test!"));
+
+stampa("\n--- TEST @std/Cripto ---");
+stampa("SHA256: " + sha256("segreto"));
+stampa("UUID: " + uuid());
+
+stampa("\n--- TEST @std/Calcolo ---");
+variabile voti = [10, 8, 9, 7];
+stampa("Media: " + media(voti));
+stampa("Somma: " + somma(voti));
+
+stampa("\n--- TEST @std/Console ---");
+successo("Questo è un messaggio di successo!");
+avviso("Attenzione: questo è un avviso.");
+
+stampa("\n--- FINE TEST ---");

package/programs/tests/test_templates.vx

@@ -0,0 +1,8 @@
+// Test Template Strings
+variabile nome = "Vlad";
+variabile eta = 25;
+variabile messaggio = `Ciao, mi chiamo ${nome} e ho ${eta} anni.`;
+stampa(messaggio);
+
+variabile calc = `Il doppio di ${eta} è ${eta * 2}.`;
+stampa(calc);

package/src/interpreter/interpreter.js

@@ -204,6 +204,7 @@ const sqlite3 = require('better-sqlite3');
 const mysql = require('mysql2/promise');
 const { Lexer } = require('../lexer/lexer.js');
 const { Parser } = require('../parser/parser.js');
+const stdRegistry = require('../stdlib/registry.js');
 
 class Interpreter {
     constructor() {
@@ -470,6 +471,27 @@ class Interpreter {
             }
         };
         this.globals.define('Rete', Rete);
+
+        // --- MATEMATICA ---
+        const Matematica = {
+            casuale: { call: () => Math.random() },
+            rotonda: { call: (_, args) => Math.round(args[0]) },
+            radice: { call: (_, args) => Math.sqrt(args[0]) },
+            min: { call: (_, args) => Math.min(...args) },
+            max: { call: (_, args) => Math.max(...args) },
+            piGreco: Math.PI,
+            E: Math.E
+        };
+        this.globals.define('Matematica', Matematica);
+
+        // --- TEMPO ---
+        const Tempo = {
+            ora: { call: () => new Date().toLocaleTimeString() },
+            data: { call: () => new Date().toLocaleDateString() },
+            timestamp: { call: () => Date.now() },
+            pausa: { call: async (_, args) => new Promise(res => setTimeout(res, args[0])) }
+        };
+        this.globals.define('Tempo', Tempo);
     }
 
     async interpret(program) {
@@ -503,6 +525,8 @@ class Interpreter {
                 return await this.executeWhileStatement(node, env);
             case 'ForStatement':
                 return await this.executeForStatement(node, env);
+            case 'SwitchStatement':
+                return await this.executeSwitchStatement(node, env);
             case 'ReturnStatement':
                 throw new ReturnValue(node.argument ? await this.evaluate(node.argument, env) : null);
             case 'BreakStatement':
@@ -528,7 +552,48 @@ class Interpreter {
 
     async executeVariableDeclaration(node, env) {
         const value = node.value ? await this.evaluate(node.value, env) : null;
-        env.define(node.name, value, node.isConstant);
+
+        if (typeof node.name === 'string') {
+            env.define(node.name, value, node.isConstant);
+        } else if (node.name.type === 'ArrayPattern') {
+            if (!Array.isArray(value)) throw new Error('Destrutturazione array fallita: il valore non è un array');
+            for (let i = 0; i < node.name.elements.length; i++) {
+                env.define(node.name.elements[i], value[i] !== undefined ? value[i] : null, node.isConstant);
+            }
+        } else if (node.name.type === 'ObjectPattern') {
+            if (typeof value !== 'object' || value === null) throw new Error('Destrutturazione oggetto fallita: il valore non è un oggetto');
+            for (const prop of node.name.properties) {
+                env.define(prop, value[prop] !== undefined ? value[prop] : null, node.isConstant);
+            }
+        }
+    }
+
+    async executeSwitchStatement(node, env) {
+        const discriminant = await this.evaluate(node.discriminant, env);
+        let matched = false;
+        let defaultCase = null;
+
+        for (const switchCase of node.cases) {
+            if (switchCase.test === null) {
+                defaultCase = switchCase;
+                continue;
+            }
+
+            const testValue = await this.evaluate(switchCase.test, env);
+            if (matched || discriminant === testValue) {
+                matched = true;
+                try {
+                    await this.executeBlock(switchCase.consequent, env);
+                } catch (e) {
+                    if (e instanceof BreakSignal) return;
+                    throw e;
+                }
+            }
+        }
+
+        if (!matched && defaultCase) {
+            await this.executeBlock(defaultCase.consequent, env);
+        }
     }
 
     executeFunctionDeclaration(node, env) {
@@ -649,44 +714,54 @@ class Interpreter {
 
     async executeImportDeclaration(node, env) {
         const sourcePath = node.source;
-        let fullPath;
+        let moduleExports;
 
-        if (sourcePath.startsWith('./') || sourcePath.startsWith('../')) {
-            fullPath = path.resolve(path.dirname(this.currentPath), sourcePath);
-        } else {
-            // Check vladx_modules
-            fullPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
-            if (!fullPath.endsWith('.vx')) fullPath += '.vx';
-            if (!fs.existsSync(fullPath)) {
-                // Try index.vx inside the module folder
-                const folderPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
-                fullPath = path.join(folderPath, 'index.vx');
+        // Check if it's a standard library module
+        if (sourcePath.startsWith('@std/')) {
+            if (stdRegistry[sourcePath]) {
+                moduleExports = stdRegistry[sourcePath];
+            } else {
+                throw new Error(`Modulo standard non trovato: ${sourcePath}`);
             }
-        }
-
-        if (!fs.existsSync(fullPath)) {
-            throw new Error(`Modulo non trovato: ${sourcePath}`);
-        }
-
-        let moduleExports;
-        if (this.modules.has(fullPath)) {
-            moduleExports = this.modules.get(fullPath);
         } else {
-            // Load and execute module
-            const content = fs.readFileSync(fullPath, 'utf8');
-            const lexer = new Lexer(content);
-            const tokens = lexer.tokenize();
-            const parser = new Parser(tokens);
-            const program = parser.parse();
+            let fullPath;
 
-            const subInterpreter = new Interpreter();
-            // Sharing the same modules cache
-            subInterpreter.modules = this.modules;
-            subInterpreter.currentPath = fullPath;
+            if (sourcePath.startsWith('./') || sourcePath.startsWith('../')) {
+                fullPath = path.resolve(path.dirname(this.currentPath), sourcePath);
+            } else {
+                // Check vladx_modules
+                fullPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
+                if (!fullPath.endsWith('.vx')) fullPath += '.vx';
+                if (!fs.existsSync(fullPath)) {
+                    // Try index.vx inside the module folder
+                    const folderPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
+                    fullPath = path.join(folderPath, 'index.vx');
+                }
+            }
 
-            await subInterpreter.interpret(program);
-            moduleExports = subInterpreter.exportedSymbols;
-            this.modules.set(fullPath, moduleExports);
+            if (!fs.existsSync(fullPath)) {
+                throw new Error(`Modulo non trovato: ${sourcePath}`);
+            }
+
+            if (this.modules.has(fullPath)) {
+                moduleExports = this.modules.get(fullPath);
+            } else {
+                // Load and execute module
+                const content = fs.readFileSync(fullPath, 'utf8');
+                const lexer = new Lexer(content);
+                const tokens = lexer.tokenize();
+                const parser = new Parser(tokens);
+                const program = parser.parse();
+
+                const subInterpreter = new Interpreter();
+                // Sharing the same modules cache
+                subInterpreter.modules = this.modules;
+                subInterpreter.currentPath = fullPath;
+
+                await subInterpreter.interpret(program);
+                moduleExports = subInterpreter.exportedSymbols;
+                this.modules.set(fullPath, moduleExports);
+            }
         }
 
         // Import specified symbols
@@ -746,6 +821,8 @@ class Interpreter {
                 return await this.evaluateMemberExpression(node, env);
             case 'ArrowFunction':
                 return new ArrowFunc(node.params, node.body, env, node.isAsync);
+            case 'ConditionalExpression':
+                return await this.evaluateConditionalExpression(node, env);
             case 'TemplateLiteral':
                 return await this.evaluateTemplateLiteral(node, env);
             case 'AwaitExpression':
@@ -806,8 +883,18 @@ class Interpreter {
         const left = await this.evaluate(node.left, env);
         if (node.operator === '||') {
             return this.isTruthy(left) ? left : await this.evaluate(node.right, env);
-        } else {
+        } else if (node.operator === '&&') {
             return !this.isTruthy(left) ? left : await this.evaluate(node.right, env);
+        } else if (node.operator === '??') {
+            return (left !== null && left !== undefined) ? left : await this.evaluate(node.right, env);
+        }
+    }
+
+    async evaluateConditionalExpression(node, env) {
+        if (this.isTruthy(await this.evaluate(node.test, env))) {
+            return await this.evaluate(node.consequent, env);
+        } else {
+            return await this.evaluate(node.alternate, env);
         }
     }
 
@@ -897,6 +984,11 @@ class Interpreter {
 
     async evaluateMemberExpression(node, env) {
         const obj = await this.evaluate(node.object, env);
+
+        if (node.optional && (obj === undefined || obj === null)) {
+            return null;
+        }
+
         const prop = node.computed
             ? await this.evaluate(node.property, env)
             : node.property.name;
@@ -916,6 +1008,34 @@ class Interpreter {
             if (prop === 'lunghezza' || prop === 'length') {
                 return obj.length;
             }
+            if (prop === 'mappa' || prop === 'map') {
+                return {
+                    isAsync: true,
+                    call: async (interpreter, args) => {
+                        const callback = args[0];
+                        const results = [];
+                        for (let i = 0; i < obj.length; i++) {
+                            results.push(await callback.call(interpreter, [obj[i], i, obj]));
+                        }
+                        return results;
+                    }
+                };
+            }
+            if (prop === 'filtra' || prop === 'filter') {
+                return {
+                    isAsync: true,
+                    call: async (interpreter, args) => {
+                        const callback = args[0];
+                        const results = [];
+                        for (let i = 0; i < obj.length; i++) {
+                            if (interpreter.isTruthy(await callback.call(interpreter, [obj[i], i, obj]))) {
+                                results.push(obj[i]);
+                            }
+                        }
+                        return results;
+                    }
+                };
+            }
         }
 
         if (obj instanceof VladXInstance) {

package/src/lexer/lexer.js

@@ -270,7 +270,11 @@ class Lexer {
             case ';': this.addToken(TokenType.PUNTO_VIRGOLA, ';'); break;
             case '.': this.addToken(TokenType.PUNTO, '.'); break;
             case ':': this.addToken(TokenType.DUE_PUNTI, ':'); break;
-            case '?': this.addToken(TokenType.PUNTO_INTERROGATIVO, '?'); break;
+            case '?':
+                if (this.match('?')) this.addToken(TokenType.NULLISH, '??');
+                else if (this.match('.')) this.addToken(TokenType.OPTIONAL_CHAINING, '?.');
+                else this.addToken(TokenType.PUNTO_INTERROGATIVO, '?');
+                break;
 
             case '+':
                 if (this.match('+')) this.addToken(TokenType.INCREMENTA, '++');

package/src/lexer/tokens.js

@@ -39,6 +39,9 @@ const TokenType = {
     ATTENDI: 'ATTENDI',
     INTERROMPI: 'INTERROMPI',
     CONTINUA: 'CONTINUA',
+    SCEGLI: 'SCEGLI',
+    CASO: 'CASO',
+    PREDEFINITO: 'PREDEFINITO',
 
     // Operators
     PIU: 'PIU',
@@ -62,6 +65,8 @@ const TokenType = {
     FRECCIA: 'FRECCIA',
     AND: 'AND',
     OR: 'OR',
+    NULLISH: 'NULLISH',
+    OPTIONAL_CHAINING: 'OPTIONAL_CHAINING',
 
     // Delimiters
     PARENTESI_APERTA: 'PARENTESI_APERTA',
@@ -116,7 +121,10 @@ const KEYWORDS = {
     'asincrono': TokenType.ASINCRONO,
     'attendi': TokenType.ATTENDI,
     'interrompi': TokenType.INTERROMPI,
-    'continua': TokenType.CONTINUA
+    'continua': TokenType.CONTINUA,
+    'scegli': TokenType.SCEGLI,
+    'caso': TokenType.CASO,
+    'predefinito': TokenType.PREDEFINITO
 };
 
 module.exports = { TokenType, KEYWORDS };

package/src/parser/ast.js

@@ -27,6 +27,20 @@ class VariableDeclaration extends ASTNode {
     }
 }
 
+class ArrayPattern extends ASTNode {
+    constructor(elements) {
+        super('ArrayPattern');
+        this.elements = elements;
+    }
+}
+
+class ObjectPattern extends ASTNode {
+    constructor(properties) {
+        super('ObjectPattern');
+        this.properties = properties;
+    }
+}
+
 class FunctionDeclaration extends ASTNode {
     constructor(name, params, body, isAsync = false) {
         super('FunctionDeclaration');
@@ -76,6 +90,22 @@ class BlockStatement extends ASTNode {
     }
 }
 
+class SwitchStatement extends ASTNode {
+    constructor(discriminant, cases) {
+        super('SwitchStatement');
+        this.discriminant = discriminant;
+        this.cases = cases;
+    }
+}
+
+class SwitchCase extends ASTNode {
+    constructor(test, consequent) {
+        super('SwitchCase');
+        this.test = test; // null se predefinito
+        this.consequent = consequent;
+    }
+}
+
 class IfStatement extends ASTNode {
     constructor(condition, consequent, alternate = null) {
         super('IfStatement');
@@ -84,8 +114,6 @@ class IfStatement extends ASTNode {
         this.alternate = alternate;
     }
 }
-// ... skip ...
-
 
 class WhileStatement extends ASTNode {
     constructor(condition, body) {
@@ -264,11 +292,12 @@ class CallExpression extends ASTNode {
 }
 
 class MemberExpression extends ASTNode {
-    constructor(object, property, computed = false) {
+    constructor(object, property, computed = false, optional = false) {
         super('MemberExpression');
         this.object = object;
         this.property = property;
         this.computed = computed;
+        this.optional = optional;
     }
 }
 
@@ -290,6 +319,15 @@ class UpdateExpression extends ASTNode {
     }
 }
 
+class ConditionalExpression extends ASTNode {
+    constructor(test, consequent, alternate) {
+        super('ConditionalExpression');
+        this.test = test;
+        this.consequent = consequent;
+        this.alternate = alternate;
+    }
+}
+
 class LogicalExpression extends ASTNode {
     constructor(operator, left, right) {
         super('LogicalExpression');
@@ -362,5 +400,10 @@ module.exports = {
     ThisExpression,
     NewExpression,
     TemplateLiteral,
-    AwaitExpression
+    AwaitExpression,
+    SwitchStatement,
+    SwitchCase,
+    ConditionalExpression,
+    ArrayPattern,
+    ObjectPattern
 };

package/src/parser/parser.js

@@ -89,6 +89,34 @@ class Parser {
     }
 
     variableDeclaration(isConstant) {
+        if (this.match(TokenType.QUADRA_APERTA)) {
+            const elements = [];
+            if (!this.check(TokenType.QUADRA_CHIUSA)) {
+                do {
+                    elements.push(this.consume(TokenType.IDENTIFICATORE, 'Nome variabile atteso in destrutturazione array').value);
+                } while (this.match(TokenType.VIRGOLA));
+            }
+            this.consume(TokenType.QUADRA_CHIUSA, 'Atteso "]" dopo destrutturazione array');
+            this.consume(TokenType.ASSEGNA, 'Inizializzazione richiesta per destrutturazione');
+            const value = this.expression();
+            this.match(TokenType.PUNTO_VIRGOLA);
+            return new AST.VariableDeclaration(new AST.ArrayPattern(elements), value, isConstant);
+        }
+
+        if (this.match(TokenType.GRAFFA_APERTA)) {
+            const properties = [];
+            if (!this.check(TokenType.GRAFFA_CHIUSA)) {
+                do {
+                    properties.push(this.consume(TokenType.IDENTIFICATORE, 'Nome proprietà atteso in destrutturazione oggetto').value);
+                } while (this.match(TokenType.VIRGOLA));
+            }
+            this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" dopo destrutturazione oggetto');
+            this.consume(TokenType.ASSEGNA, 'Inizializzazione richiesta per destrutturazione');
+            const value = this.expression();
+            this.match(TokenType.PUNTO_VIRGOLA);
+            return new AST.VariableDeclaration(new AST.ObjectPattern(properties), value, isConstant);
+        }
+
         const name = this.consume(TokenType.IDENTIFICATORE, 'Nome variabile atteso').value;
         let value = null;
         if (this.match(TokenType.ASSEGNA)) {
@@ -98,7 +126,20 @@ class Parser {
         return new AST.VariableDeclaration(name, value, isConstant);
     }
 
-    // ... imports ...
+    importDeclaration() {
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo "importa"');
+        const specifiers = [];
+        if (!this.check(TokenType.GRAFFA_CHIUSA)) {
+            do {
+                specifiers.push(this.consume(TokenType.IDENTIFICATORE, 'Nome simbolo atteso').value);
+            } while (this.match(TokenType.VIRGOLA));
+        }
+        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" dopo i simboli');
+        this.consume(TokenType.DA, 'Atteso "da" dopo i simboli importati');
+        const source = this.consume(TokenType.STRINGA, 'Atteso percorso modulo').value;
+        this.match(TokenType.PUNTO_VIRGOLA);
+        return new AST.ImportDeclaration(specifiers, source);
+    }
 
     exportDeclaration() {
         if (this.match(TokenType.ASINCRONO)) {
@@ -197,6 +238,7 @@ class Parser {
 
     statement() {
         if (this.match(TokenType.SE)) return this.ifStatement();
+        if (this.match(TokenType.SCEGLI)) return this.switchStatement();
         if (this.match(TokenType.MENTRE)) return this.whileStatement();
         if (this.match(TokenType.PER)) return this.forStatement();
         if (this.match(TokenType.RITORNA)) return this.returnStatement();
@@ -209,6 +251,38 @@ class Parser {
         return this.expressionStatement();
     }
 
+    switchStatement() {
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo "scegli"');
+        const discriminant = this.expression();
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo discriminante');
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo "scegli"');
+
+        const cases = [];
+        while (!this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+            if (this.match(TokenType.CASO)) {
+                const test = this.expression();
+                this.consume(TokenType.DUE_PUNTI, 'Atteso ":" dopo il caso');
+                const consequent = [];
+                while (!this.check(TokenType.CASO) && !this.check(TokenType.PREDEFINITO) && !this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+                    consequent.push(this.declaration());
+                }
+                cases.push(new AST.SwitchCase(test, consequent));
+            } else if (this.match(TokenType.PREDEFINITO)) {
+                this.consume(TokenType.DUE_PUNTI, 'Atteso ":" dopo "predefinito"');
+                const consequent = [];
+                while (!this.check(TokenType.CASO) && !this.check(TokenType.PREDEFINITO) && !this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+                    consequent.push(this.declaration());
+                }
+                cases.push(new AST.SwitchCase(null, consequent));
+            } else {
+                throw new ParserError('Atteso "caso" o "predefinito" all\'interno di "scegli"', this.peek());
+            }
+        }
+
+        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" dopo "scegli"');
+        return new AST.SwitchStatement(discriminant, cases);
+    }
+
     blockStatement() {
         const statements = [];
         while (!this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
@@ -346,7 +420,7 @@ class Parser {
     }
 
     assignment() {
-        const expr = this.logicalOr();
+        const expr = this.conditional();
 
         if (this.match(TokenType.ASSEGNA, TokenType.PIU_ASSEGNA, TokenType.MENO_ASSEGNA)) {
             const operator = this.previous().value;
@@ -357,18 +431,42 @@ class Parser {
         return expr;
     }
 
+    conditional() {
+        let expr = this.logicalOr();
+
+        if (this.match(TokenType.PUNTO_INTERROGATIVO)) {
+            const consequent = this.expression();
+            this.consume(TokenType.DUE_PUNTI, 'Atteso ":" dopo espressione del ternario');
+            const alternate = this.conditional();
+            return new AST.ConditionalExpression(expr, consequent, alternate);
+        }
+
+        return expr;
+    }
+
     logicalOr() {
-        let expr = this.logicalAnd();
+        let expr = this.nullishCoalescing();
 
         while (this.match(TokenType.O, TokenType.OR)) {
             const operator = '||';
-            const right = this.logicalAnd();
+            const right = this.nullishCoalescing();
             expr = new AST.LogicalExpression(operator, expr, right);
         }
 
         return expr;
     }
 
+    nullishCoalescing() {
+        let expr = this.logicalAnd();
+
+        while (this.match(TokenType.NULLISH)) {
+            const right = this.logicalAnd();
+            expr = new AST.LogicalExpression('??', expr, right);
+        }
+
+        return expr;
+    }
+
     logicalAnd() {
         let expr = this.equality();
 
@@ -463,11 +561,14 @@ class Parser {
                 expr = this.finishCall(expr);
             } else if (this.match(TokenType.PUNTO)) {
                 const property = this.consume(TokenType.IDENTIFICATORE, 'Nome proprietà atteso dopo "."');
-                expr = new AST.MemberExpression(expr, new AST.Identifier(property.value), false);
+                expr = new AST.MemberExpression(expr, new AST.Identifier(property.value), false, false);
+            } else if (this.match(TokenType.OPTIONAL_CHAINING)) {
+                const property = this.consume(TokenType.IDENTIFICATORE, 'Nome proprietà atteso dopo "?."');
+                expr = new AST.MemberExpression(expr, new AST.Identifier(property.value), false, true);
             } else if (this.match(TokenType.QUADRA_APERTA)) {
                 const property = this.expression();
                 this.consume(TokenType.QUADRA_CHIUSA, 'Atteso "]" dopo indice');
-                expr = new AST.MemberExpression(expr, property, true);
+                expr = new AST.MemberExpression(expr, property, true, false);
             } else {
                 break;
             }

package/src/stdlib/registry.js

@@ -0,0 +1,301 @@
+/**
+ * VladX Standard Library Registry
+ * Contiene le definizioni di tutti i moduli integrati.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const zlib = require('zlib');
+const { execSync } = require('child_process');
+
+const registry = {};
+
+// --- 1. TESTO ---
+registry['@std/Testo'] = new Map([
+    ['maiuscolo', { call: (_, args) => String(args[0]).toUpperCase() }],
+    ['minuscolo', { call: (_, args) => String(args[0]).toLowerCase() }],
+    ['capitalizza', {
+        call: (_, args) => {
+            const s = String(args[0]);
+            return s.charAt(0).toUpperCase() + s.slice(1);
+        }
+    }],
+    ['pulisci', { call: (_, args) => String(args[0]).trim() }],
+    ['sostituisci', { call: (_, args) => String(args[0]).replace(new RegExp(args[1], 'g'), args[2]) }],
+    ['dividi', { call: (_, args) => String(args[0]).split(args[1]) }],
+    ['contiene', { call: (_, args) => String(args[0]).includes(args[1]) }],
+    ['slugify', { call: (_, args) => String(args[0]).toLowerCase().replace(/\s+/g, '-').replace(/[^\w-]+/g, '') }]
+]);
+
+// --- 2. COLLEZIONI ---
+registry['@std/Collezioni'] = new Map([
+    ['CreaMappa', { call: () => new Map() }],
+    ['CreaInsieme', { call: () => new Set() }],
+    ['unisci', { call: (_, args) => Object.assign({}, ...args) }],
+    ['chiavi', { call: (_, args) => Object.keys(args[0]) }],
+    ['valori', { call: (_, args) => Object.values(args[0]) }]
+]);
+
+// --- 3. PERCORSO ---
+registry['@std/Percorso'] = new Map([
+    ['unisci', { call: (_, args) => path.join(...args) }],
+    ['base', { call: (_, args) => path.basename(args[0]) }],
+    ['cartella', { call: (_, args) => path.dirname(args[0]) }],
+    ['estensione', { call: (_, args) => path.extname(args[0]) }],
+    ['assoluto', { call: (_, args) => path.resolve(args[0]) }]
+]);
+
+// --- 4. CONSOLE ---
+registry['@std/Console'] = new Map([
+    ['log', { call: (_, args) => console.log(...args) }],
+    ['errore', { call: (_, args) => console.error('\x1b[31m%s\x1b[0m', ...args) }],
+    ['avviso', { call: (_, args) => console.warn('\x1b[33m%s\x1b[0m', ...args) }],
+    ['successo', { call: (_, args) => console.log('\x1b[32m%s\x1b[0m', ...args) }],
+    ['pulisci', { call: () => console.clear() }],
+    ['tabella', { call: (_, args) => console.table(args[0]) }]
+]);
+
+// --- 5. CRIPTO ---
+registry['@std/Cripto'] = new Map([
+    ['sha256', { call: (_, args) => crypto.createHash('sha256').update(String(args[0])).digest('hex') }],
+    ['md5', { call: (_, args) => crypto.createHash('md5').update(String(args[0])).digest('hex') }],
+    ['uuid', { call: () => crypto.randomUUID() }],
+    ['casuale', { call: (_, args) => crypto.randomBytes(args[0] || 16).toString('hex') }]
+]);
+
+// --- 6. COMPRESSIONE ---
+registry['@std/Compressione'] = new Map([
+    ['comprimi', { call: (_, args) => zlib.gzipSync(args[0]).toString('base64') }],
+    ['decomprimi', { call: (_, args) => zlib.gunzipSync(Buffer.from(args[0], 'base64')).toString() }]
+]);
+
+// --- 7. URL ---
+registry['@std/Url'] = new Map([
+    ['analizza', {
+        call: (_, args) => {
+            const u = new URL(args[0]);
+            return {
+                protocollo: u.protocol,
+                host: u.host,
+                percorso: u.pathname,
+                query: Object.fromEntries(u.searchParams),
+                frammento: u.hash
+            };
+        }
+    }],
+    ['componi', {
+        call: (_, args) => {
+            const u = new URL(args[0]);
+            Object.entries(args[1] || {}).forEach(([k, v]) => u.searchParams.set(k, v));
+            return u.toString();
+        }
+    }]
+]);
+
+// --- 8. EVENTI ---
+registry['@std/Eventi'] = new Map([
+    ['CreaEmitter', {
+        call: () => {
+            const listeners = {};
+            return {
+                su: {
+                    call: (_, args) => {
+                        const [ev, cb] = args;
+                        if (!listeners[ev]) listeners[ev] = [];
+                        listeners[ev].push(cb);
+                    }
+                },
+                lancia: {
+                    call: async (int, args) => {
+                        const [ev, data] = args;
+                        if (listeners[ev]) {
+                            for (const cb of listeners[ev]) await cb.call(int, [data]);
+                        }
+                    }
+                }
+            };
+        }
+    }]
+]);
+
+// --- 9. PROCESSO ---
+registry['@std/Processo'] = new Map([
+    ['id', process.pid],
+    ['memoria', { call: () => process.memoryUsage() }],
+    ['tempoAttivita', { call: () => process.uptime() }],
+    ['versioneNode', process.version],
+    ['piattaforma', process.platform]
+]);
+
+// --- 10. AMBIENTE ---
+registry['@std/Ambiente'] = new Map([
+    ['prendi', { call: (_, args) => process.env[args[0]] }],
+    ['tutti', { call: () => process.env }]
+]);
+
+// --- 11. DATI ---
+registry['@std/Dati'] = new Map([
+    ['clona', { call: (_, args) => JSON.parse(JSON.stringify(args[0])) }],
+    ['fondi', {
+        call: (_, args) => {
+            const merge = (target, source) => {
+                for (const key of Object.keys(source)) {
+                    if (source[key] instanceof Object) Object.assign(source[key], merge(target[key] || {}, source[key]));
+                }
+                Object.assign(target || {}, source);
+                return target;
+            };
+            return merge(args[0], args[1]);
+        }
+    }],
+    ['raggruppa', {
+        call: (_, args) => {
+            const [arr, key] = args;
+            return arr.reduce((rv, x) => {
+                (rv[x[key]] = rv[x[key]] || []).push(x);
+                return rv;
+            }, {});
+        }
+    }]
+]);
+
+// --- 12. VALIDAZIONE ---
+registry['@std/Validazione'] = new Map([
+    ['email', { call: (_, args) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(args[0]) }],
+    ['url', { call: (_, args) => /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/.test(args[0]) }],
+    ['numero', { call: (_, args) => !isNaN(args[0]) }],
+    ['ip', { call: (_, args) => /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(args[0]) }]
+]);
+
+// --- 13. CALCOLO ---
+registry['@std/Calcolo'] = new Map([
+    ['media', { call: (_, args) => args[0].reduce((a, b) => a + b, 0) / args[0].length }],
+    ['somma', { call: (_, args) => args[0].reduce((a, b) => a + b, 0) }],
+    ['fattoriale', {
+        call: (_, args) => {
+            let f = 1;
+            for (let i = 1; i <= args[0]; i++) f *= i;
+            return f;
+        }
+    }]
+]);
+
+// --- 14. CRONOMETRO ---
+registry['@std/Cronometro'] = new Map([
+    ['oraPrecisa', { call: () => performance.now() }],
+    ['formattaDurata', {
+        call: (_, args) => {
+            const ms = args[0];
+            const s = Math.floor(ms / 1000);
+            const m = Math.floor(s / 60);
+            return `${m}:${(s % 60).toString().padStart(2, '0')}.${(Math.floor(ms % 1000)).toString().padStart(3, '0')}`;
+        }
+    }]
+]);
+
+// --- 15. CODIFICA ---
+registry['@std/Codifica'] = new Map([
+    ['base64', { call: (_, args) => Buffer.from(String(args[0])).toString('base64') }],
+    ['daBase64', { call: (_, args) => Buffer.from(String(args[0]), 'base64').toString() }],
+    ['uri', { call: (_, args) => encodeURIComponent(args[0]) }],
+    ['daUri', { call: (_, args) => decodeURIComponent(args[0]) }],
+    ['hex', { call: (_, args) => Buffer.from(String(args[0])).toString('hex') }]
+]);
+
+// --- 16. ARCHIVIO_EXTRA ---
+registry['@std/ArchivioExtra'] = new Map([
+    ['elencaTutto', {
+        call: (_, args) => {
+            const walk = (dir) => {
+                let results = [];
+                const list = fs.readdirSync(dir);
+                list.forEach(file => {
+                    file = path.resolve(dir, file);
+                    const stat = fs.statSync(file);
+                    if (stat && stat.isDirectory()) results = results.concat(walk(file));
+                    else results.push(file);
+                });
+                return results;
+            };
+            return walk(args[0]);
+        }
+    }],
+    ['copia', { call: (_, args) => fs.copyFileSync(args[0], args[1]) }]
+]);
+
+// --- 17. SERVER_WEB ---
+registry['@std/ServerWeb'] = new Map([
+    ['rispondiJson', {
+        call: (_, args) => {
+            return { stato: 200, intestazioni: { 'Content-Type': 'application/json' }, corpo: args[0] };
+        }
+    }],
+    ['errore', {
+        call: (_, args) => {
+            return { stato: args[0] || 500, corpo: args[1] || "Errore Interno" };
+        }
+    }]
+]);
+
+// --- 18. CLIENT_WEB ---
+registry['@std/ClientWeb'] = new Map([
+    ['get', { call: (_, args) => execSync(`curl -sL "${args[0]}"`, { encoding: 'utf8' }) }],
+    ['post', {
+        call: (_, args) => {
+            const [url, data] = args;
+            return execSync(`curl -sLX POST "${url}" -d '${JSON.stringify(data)}' -H "Content-Type: application/json"`, { encoding: 'utf8' });
+        }
+    }]
+]);
+
+// --- 19. SQL_HELPER ---
+registry['@std/SqlHelper'] = new Map([
+    ['generaInsert', {
+        call: (_, args) => {
+            const [tabella, dati] = args;
+            const keys = Object.keys(dati);
+            const vals = Object.values(dati).map(v => typeof v === 'string' ? `'${v}'` : v);
+            return `INSERT INTO ${tabella} (${keys.join(', ')}) VALUES (${vals.join(', ')})`;
+        }
+    }]
+]);
+
+// --- 20. JSON_EXTRA ---
+registry['@std/JsonExtra'] = new Map([
+    ['codifica', { call: (_, args) => JSON.stringify(args[0], null, 2) }],
+    ['analizzaSicuro', {
+        call: (_, args) => {
+            try { return JSON.parse(args[0]); }
+            catch (e) { return null; }
+        }
+    }]
+]);
+
+// --- 21. ASSERZIONE ---
+registry['@std/Asserzione'] = new Map([
+    ['uguale', {
+        call: (_, args) => {
+            if (args[0] !== args[1]) throw new Error(`Asserzione fallita: ${args[0]} !== ${args[1]}`);
+        }
+    }],
+    ['vero', {
+        call: (_, args) => {
+            if (!args[0]) throw new Error(`Asserzione fallita: atteso vero`);
+        }
+    }],
+    ['falso', {
+        call: (_, args) => {
+            if (args[0]) throw new Error(`Asserzione fallita: atteso falso`);
+        }
+    }]
+]);
+
+// --- ALIAS ---
+registry['@std/Matematica'] = registry['@std/Calcolo'];
+registry['@std/Tempo'] = registry['@std/Cronometro'];
+// Aggiungo anche metodi data/ora a @std/Tempo se mancanti
+registry['@std/Tempo'].set('data', { call: () => new Date().toLocaleDateString() });
+registry['@std/Tempo'].set('ora', { call: () => new Date().toLocaleTimeString() });
+
+module.exports = registry;