larkhre 11.1.0

package/larkhre.js

@@ -0,0 +1,2094 @@
+// Larkhré — moteur officiel (généré depuis docs/code/index.html par construire.js, ne pas modifier à la main)
+/* ============================================================
+   Larkhré v1.0 — Moteur JavaScript (port du larkhre.py)
+   Créé par Ladji — fonctionne dans tout navigateur.
+   API :
+     Larkhre.run(source, { onPrint(texte), onInput(prompt) -> Promise<string>, shouldStop() -> bool })
+   ============================================================ */
+'use strict';
+
+const Larkhre = (function () {
+
+  // ---------------- ERREURS ----------------
+  class LazError extends Error {
+    constructor(message, line) {
+      super(message);
+      this.lazMessage = message;
+      this.line = line;
+    }
+    toString() {
+      if (this.line) return `✘ Erreur Larkhré (ligne ${this.line}) : ${this.lazMessage}`;
+      return `✘ Erreur Larkhré : ${this.lazMessage}`;
+    }
+  }
+  class ReturnEx { constructor(value) { this.value = value; } }
+  class BreakEx { }
+  class ContinueEx { }
+  class StopEx { }
+
+  // ---------------- LEXER ----------------
+  const KEYWORDS = new Set(['laz', 'fonk', 'rend', 'kan', 'sinon', 'tanke', 'pou', 'dan',
+    'vrai', 'faux', 'walu', 'et', 'ou', 'non', 'kase', 'swiv',
+    'klas', 'herite', 'importe', 'essaie', 'rattrape', 'garde']);
+
+  // v5.0 : les langues — mêmes mots-clés, dans ta langue (#langue: anglais)
+  const LANGUES = {
+    anglais: {
+      laz: 'let', fonk: 'func', rend: 'give', kan: 'when', sinon: 'else',
+      tanke: 'while', pou: 'for', dan: 'in', vrai: 'true', faux: 'false',
+      walu: 'null', et: 'and', ou: 'or', non: 'not', kase: 'stop',
+      swiv: 'next', klas: 'class', herite: 'extends', importe: 'load',
+      essaie: 'try', rattrape: 'catch', garde: 'keep',
+    },
+    // v7.1 : le pack "français académique" — orthographe correcte
+    francais: {
+      laz: 'soit', fonk: 'fonction', rend: 'retourne', kan: 'si', sinon: 'sinon',
+      tanke: 'tantque', pou: 'pour', dan: 'dans', vrai: 'vrai', faux: 'faux',
+      walu: 'rien', et: 'et', ou: 'ou', non: 'non', kase: 'casse',
+      swiv: 'continue', klas: 'classe', herite: 'herite', importe: 'importe',
+      essaie: 'essaie', rattrape: 'rattrape', garde: 'garde',
+    },
+    bambara: { // BROUILLON à faire valider par des locuteurs natifs
+      laz: 'bila', fonk: 'baara', rend: 'segin', kan: 'ni', sinon: 'note',
+      tanke: 'foo', pou: 'ye', dan: 'la', vrai: 'tien', faux: 'galon',
+      walu: 'foyi', et: 'ani', ou: 'walima', non: 'te', kase: 'tige',
+      swiv: 'taa', klas: 'kulu', herite: 'ciden', importe: 'tala',
+      essaie: 'kekan', rattrape: 'minna', garde: 'mara',
+    },
+    wolof: { // BROUILLON à faire valider par des locuteurs natifs
+      laz: 'teg', fonk: 'liggeey', rend: 'delloo', kan: 'su', sinon: 'walla',
+      tanke: 'liye', pou: 'ngir', dan: 'ci', vrai: 'degg', faux: 'fen',
+      walu: 'dara', et: 'ak', ou: 'mbaa', non: 'du', kase: 'taxaw',
+      swiv: 'topp', klas: 'mbooloo', herite: 'donn', importe: 'yeb',
+      essaie: 'jeema', rattrape: 'japp', garde: 'denc',
+    },
+  };
+
+  const LANGUE_RE = /#\s*langue\s*:\s*([a-zA-Z]+)/i;
+
+  function detecteLangue(source) {
+    for (const l of source.split('\n').slice(0, 3)) {
+      const m = l.match(LANGUE_RE);
+      if (m) {
+        const nom = m[1].toLowerCase();
+        if (['larkhre', 'lazarus', 'classique'].includes(nom)) return null; // « lazarus » : l'ancien nom reste accepté
+        if (!(nom in LANGUES)) {
+          throw new LazError(`langue inconnue « ${nom} » (disponibles : larkhre, ${Object.keys(LANGUES).sort().join(', ')})`, 1);
+        }
+        const rmap = {};
+        for (const [k, v] of Object.entries(LANGUES[nom])) rmap[v] = k;
+        return rmap;
+      }
+    }
+    return null;
+  }
+  const TWO_CHAR = new Set(['==', '!=', '<=', '>=', '&&', '||', '..', '+=', '-=', '*=', '/=']);
+  const ONE_CHAR = new Set(['+', '-', '*', '/', '%', '<', '>', '=', '(', ')',
+    '{', '}', '[', ']', ',', '!', ';', '.', ':']);
+
+  function isDigit(c) { return c >= '0' && c <= '9'; }
+  function isAlpha(c) { return /[\p{L}_]/u.test(c); }
+  function isAlnum(c) { return /[\p{L}\p{N}_]/u.test(c); }
+
+  function tokenize(source, langueMap) {
+    const tokens = [];
+    let i = 0, line = 1, parenDepth = 0;
+    const n = source.length;
+
+    while (i < n) {
+      const c = source[i];
+
+      if (c === ' ' || c === '\t' || c === '\r') { i++; continue; }
+
+      if (c === '\n') {
+        if (parenDepth === 0) tokens.push(['NEWLINE', null, line]);
+        line++; i++; continue;
+      }
+
+      if (c === '#' || (c === '/' && source[i + 1] === '/')) {
+        while (i < n && source[i] !== '\n') i++;
+        continue;
+      }
+
+      if (c === '"') {
+        i++;
+        const startLine = line;
+        let buf = '';
+        while (i < n && source[i] !== '"') {
+          const ch = source[i];
+          if (ch === '\n') throw new LazError('chaîne de caractères non fermée (il manque un ")', startLine);
+          if (ch === '\\' && i + 1 < n) {
+            const nxt = source[i + 1];
+            const esc = { n: '\n', t: '\t', '"': '"', '\\': '\\' };
+            buf += (esc[nxt] !== undefined ? esc[nxt] : nxt);
+            i += 2;
+          } else { buf += ch; i++; }
+        }
+        if (i >= n) throw new LazError('chaîne de caractères non fermée (il manque un ")', startLine);
+        i++;
+        tokens.push(['STRING', buf, startLine]);
+        continue;
+      }
+
+      if (isDigit(c)) {
+        const start = i;
+        while (i < n && isDigit(source[i])) i++;
+        if (i < n && source[i] === '.' && isDigit(source[i + 1])) {
+          i++;
+          while (i < n && isDigit(source[i])) i++;
+        }
+        tokens.push(['NUMBER', parseFloat(source.slice(start, i)), line]);
+        continue;
+      }
+
+      if (isAlpha(c)) {
+        const start = i;
+        while (i < n && isAlnum(source[i])) i++;
+        const word = source.slice(start, i);
+        if (KEYWORDS.has(word)) tokens.push([word.toUpperCase(), word, line]);
+        else if (langueMap && word in langueMap) tokens.push([langueMap[word].toUpperCase(), word, line]);
+        else tokens.push(['IDENT', word, line]);
+        continue;
+      }
+
+      const two = source.slice(i, i + 2);
+      if (TWO_CHAR.has(two)) { tokens.push(['OP', two, line]); i += 2; continue; }
+
+      if (ONE_CHAR.has(c)) {
+        if (c === '(' || c === '[') parenDepth++;
+        else if (c === ')' || c === ']') parenDepth = Math.max(0, parenDepth - 1);
+        if (c === ';') tokens.push(['NEWLINE', null, line]);
+        else tokens.push(['OP', c, line]);
+        i++; continue;
+      }
+
+      throw new LazError(`caractère inconnu : '${c}'`, line);
+    }
+    tokens.push(['NEWLINE', null, line]);
+    tokens.push(['EOF', null, line]);
+    return tokens;
+  }
+
+  // ---------------- PARSER ----------------
+  const NICE = { NEWLINE: 'une fin de ligne', EOF: 'la fin du fichier' };
+
+  class Parser {
+    constructor(tokens) { this.tokens = tokens; this.pos = 0; }
+    peek() { return this.tokens[this.pos]; }
+    next() { return this.tokens[this.pos++]; }
+    check(t, v) {
+      const tok = this.peek();
+      if (tok[0] !== t) return false;
+      if (v !== undefined && tok[1] !== v) return false;
+      return true;
+    }
+    accept(t, v) { if (this.check(t, v)) return this.next(); return null; }
+    expect(t, v, what) {
+      const tok = this.peek();
+      if (!this.check(t, v)) {
+        const attendu = what || v || t;
+        let trouve = tok[1] !== null ? tok[1] : tok[0];
+        trouve = NICE[trouve] || trouve;
+        throw new LazError(`j'attendais « ${attendu} » mais j'ai trouvé « ${trouve} »`, tok[2]);
+      }
+      return this.next();
+    }
+    skipNewlines() { while (this.check('NEWLINE')) this.next(); }
+
+    parseProgram() {
+      const stmts = [];
+      this.skipNewlines();
+      while (!this.check('EOF')) {
+        stmts.push(this.parseStatement());
+        this.skipNewlines();
+      }
+      return ['block', stmts];
+    }
+
+    parseBlock() {
+      this.skipNewlines();
+      this.expect('OP', '{', '{');
+      const stmts = [];
+      this.skipNewlines();
+      while (!this.check('OP', '}')) {
+        if (this.check('EOF')) throw new LazError('il manque une accolade fermante }', this.peek()[2]);
+        stmts.push(this.parseStatement());
+        this.skipNewlines();
+      }
+      this.expect('OP', '}', '}');
+      return ['block', stmts];
+    }
+
+    parseStatement() {
+      const tok = this.peek();
+      const line = tok[2];
+
+      if (this.accept('LAZ')) {
+        const name = this.expect('IDENT', undefined, 'un nom de variable')[1];
+        this.expect('OP', '=', '=');
+        return ['declare', name, this.parseExpression(), line];
+      }
+      if (this.accept('GARDE')) {
+        const name = this.expect('IDENT', undefined, 'un nom de variable')[1];
+        this.expect('OP', '=', '=');
+        return ['garde', name, this.parseExpression(), line];
+      }
+      if (this.accept('FONK')) {
+        const name = this.expect('IDENT', undefined, 'un nom de fonction')[1];
+        this.expect('OP', '(', '(');
+        const params = [];
+        if (!this.check('OP', ')')) {
+          params.push(this.expect('IDENT', undefined, 'un paramètre')[1]);
+          while (this.accept('OP', ',')) params.push(this.expect('IDENT', undefined, 'un paramètre')[1]);
+        }
+        this.expect('OP', ')', ')');
+        return ['fonk', name, params, this.parseBlock(), line];
+      }
+      if (this.accept('KAN')) return this.parseKan(line);
+      if (this.accept('TANKE')) {
+        const cond = this.parseExpression();
+        return ['tanke', cond, this.parseBlock(), line];
+      }
+      if (this.accept('POU')) {
+        const v = this.expect('IDENT', undefined, 'un nom de variable')[1];
+        this.expect('DAN', undefined, 'dan');
+        const iterable = this.parseExpression();
+        return ['pou', v, iterable, this.parseBlock(), line];
+      }
+      if (this.accept('REND')) {
+        if (this.check('NEWLINE') || this.check('OP', '}') || this.check('EOF')) return ['rend', null, line];
+        return ['rend', this.parseExpression(), line];
+      }
+      if (this.accept('KASE')) return ['kase', line];
+      if (this.accept('SWIV')) return ['swiv', line];
+
+      if (this.accept('KLAS')) {
+        const name = this.expect('IDENT', undefined, 'un nom de classe')[1];
+        let parent = null;
+        if (this.accept('HERITE')) parent = this.expect('IDENT', undefined, 'un nom de classe parente')[1];
+        this.skipNewlines();
+        this.expect('OP', '{', '{');
+        const methods = [];
+        this.skipNewlines();
+        while (!this.check('OP', '}')) {
+          if (this.check('EOF')) throw new LazError('il manque une accolade fermante } pour la klas', this.peek()[2]);
+          if (!this.check('FONK')) {
+            throw new LazError('dans une klas, on ne met que des fonctions (fonk nom(moi, ...) { ... })', this.peek()[2]);
+          }
+          this.next();
+          const mline = this.peek()[2];
+          const mname = this.expect('IDENT', undefined, 'un nom de fonction')[1];
+          this.expect('OP', '(', '(');
+          const params = [];
+          if (!this.check('OP', ')')) {
+            params.push(this.expect('IDENT', undefined, 'un paramètre')[1]);
+            while (this.accept('OP', ',')) params.push(this.expect('IDENT', undefined, 'un paramètre')[1]);
+          }
+          this.expect('OP', ')', ')');
+          if (params.length === 0) {
+            throw new LazError(`la fonction « ${mname} » d'une klas doit avoir « moi » comme premier paramètre`, mline);
+          }
+          const body = this.parseBlock();
+          methods.push([mname, params, body, mline]);
+          this.skipNewlines();
+        }
+        this.expect('OP', '}', '}');
+        return ['klas', name, parent, methods, line];
+      }
+
+      if (this.accept('IMPORTE')) {
+        const tok2 = this.peek();
+        if (tok2[0] !== 'STRING') {
+          throw new LazError('importe demande un nom de fichier entre guillemets : importe "outils.laz"', line);
+        }
+        this.next();
+        return ['importe', tok2[1], line];
+      }
+
+      if (this.accept('ESSAIE')) {
+        const body = this.parseBlock();
+        this.skipNewlines();
+        this.expect('RATTRAPE', undefined, 'rattrape');
+        const errname = this.expect('IDENT', undefined, "un nom pour l'erreur (ex : rattrape probleme { ... })")[1];
+        const handler = this.parseBlock();
+        return ['essaie', body, errname, handler, line];
+      }
+
+      const expr = this.parseExpression();
+      const tok2 = this.peek();
+      const estCompose = tok2[0] === 'OP' && ['+=', '-=', '*=', '/='].includes(tok2[1]);
+      if (this.check('OP', '=') || estCompose) {
+        const op = this.next()[1];
+        let value = this.parseExpression();
+        if (estCompose) {
+          value = ['binop', op[0], expr, value, line];
+        }
+        if (expr[0] === 'var') return ['assign', expr[1], value, line];
+        if (expr[0] === 'index') return ['assign_index', expr[1], expr[2], value, line];
+        if (expr[0] === 'attr') return ['assign_attr', expr[1], expr[2], value, line];
+        throw new LazError("on ne peut affecter une valeur qu'à une variable, un élément de liste/dico ou une propriété d'objet", line);
+      }
+      return ['expr', expr, line];
+    }
+
+    parseKan(line) {
+      const cond = this.parseExpression();
+      const body = this.parseBlock();
+      let elseBranch = null;
+      const save = this.pos;
+      this.skipNewlines();
+      if (this.accept('SINON')) {
+        if (this.accept('KAN')) elseBranch = ['block', [this.parseKan(this.peek()[2])]];
+        else elseBranch = this.parseBlock();
+      } else {
+        this.pos = save;
+      }
+      return ['kan', cond, body, elseBranch, line];
+    }
+
+    parseExpression() { return this.parseOr(); }
+
+    parseOr() {
+      let left = this.parseAnd();
+      for (;;) {
+        if (this.accept('OU') || this.accept('OP', '||')) left = ['or', left, this.parseAnd()];
+        else break;
+      }
+      return left;
+    }
+    parseAnd() {
+      let left = this.parseNot();
+      for (;;) {
+        if (this.accept('ET') || this.accept('OP', '&&')) left = ['and', left, this.parseNot()];
+        else break;
+      }
+      return left;
+    }
+    parseNot() {
+      if (this.accept('NON') || this.accept('OP', '!')) return ['not', this.parseNot()];
+      return this.parseComparison();
+    }
+    parseComparison() {
+      const left = this.parseRange();
+      const tok = this.peek();
+      if (tok[0] === 'OP' && ['==', '!=', '<', '>', '<=', '>='].includes(tok[1])) {
+        const op = this.next()[1];
+        return ['cmp', op, left, this.parseRange(), tok[2]];
+      }
+      return left;
+    }
+    parseRange() {
+      const left = this.parseAdditive();
+      const tok = this.peek();
+      if (tok[0] === 'OP' && tok[1] === '..') {
+        this.next();
+        return ['range', left, this.parseAdditive(), tok[2]];
+      }
+      return left;
+    }
+    parseAdditive() {
+      let left = this.parseTerm();
+      for (;;) {
+        const tok = this.peek();
+        if (tok[0] === 'OP' && (tok[1] === '+' || tok[1] === '-')) {
+          const op = this.next()[1];
+          left = ['binop', op, left, this.parseTerm(), tok[2]];
+        } else break;
+      }
+      return left;
+    }
+    parseTerm() {
+      let left = this.parseUnary();
+      for (;;) {
+        const tok = this.peek();
+        if (tok[0] === 'OP' && ['*', '/', '%'].includes(tok[1])) {
+          const op = this.next()[1];
+          left = ['binop', op, left, this.parseUnary(), tok[2]];
+        } else break;
+      }
+      return left;
+    }
+    parseUnary() {
+      const tok = this.peek();
+      if (tok[0] === 'OP' && tok[1] === '-') {
+        this.next();
+        return ['neg', this.parseUnary(), tok[2]];
+      }
+      return this.parsePostfix();
+    }
+    parsePostfix() {
+      let expr = this.parsePrimary();
+      for (;;) {
+        const tok = this.peek();
+        if (tok[0] === 'OP' && tok[1] === '(') {
+          this.next();
+          const args = [];
+          if (!this.check('OP', ')')) {
+            args.push(this.parseExpression());
+            while (this.accept('OP', ',')) args.push(this.parseExpression());
+          }
+          this.expect('OP', ')', ')');
+          expr = ['call', expr, args, tok[2]];
+        } else if (tok[0] === 'OP' && tok[1] === '[') {
+          this.next();
+          const index = this.parseExpression();
+          this.expect('OP', ']', ']');
+          expr = ['index', expr, index, tok[2]];
+        } else if (tok[0] === 'OP' && tok[1] === '.') {
+          this.next();
+          const name = this.expect('IDENT', undefined, 'un nom de propriété')[1];
+          expr = ['attr', expr, name, tok[2]];
+        } else break;
+      }
+      return expr;
+    }
+    parsePrimary() {
+      const tok = this.peek();
+      if (tok[0] === 'NUMBER') { this.next(); return ['num', tok[1]]; }
+      if (tok[0] === 'STRING') { this.next(); return ['str', tok[1]]; }
+      if (tok[0] === 'VRAI') { this.next(); return ['bool', true]; }
+      if (tok[0] === 'FAUX') { this.next(); return ['bool', false]; }
+      if (tok[0] === 'WALU') { this.next(); return ['walu']; }
+      if (tok[0] === 'IDENT') { this.next(); return ['var', tok[1], tok[2]]; }
+      if (tok[0] === 'OP' && tok[1] === '(') {
+        this.next();
+        const expr = this.parseExpression();
+        this.expect('OP', ')', ')');
+        return expr;
+      }
+      if (tok[0] === 'OP' && tok[1] === '[') {
+        this.next();
+        const items = [];
+        this.skipNewlines();
+        if (!this.check('OP', ']')) {
+          items.push(this.parseExpression());
+          while (this.accept('OP', ',')) {
+            this.skipNewlines();
+            items.push(this.parseExpression());
+          }
+          this.skipNewlines();
+        }
+        this.expect('OP', ']', ']');
+        return ['list', items, tok[2]];
+      }
+      if (tok[0] === 'OP' && tok[1] === '{') {
+        this.next();
+        const pairs = [];
+        this.skipNewlines();
+        if (!this.check('OP', '}')) {
+          for (;;) {
+            this.skipNewlines();
+            const key = this.parseExpression();
+            this.skipNewlines();
+            this.expect('OP', ':', ':');
+            this.skipNewlines();
+            const value = this.parseExpression();
+            pairs.push([key, value]);
+            this.skipNewlines();
+            if (!this.accept('OP', ',')) break;
+          }
+          this.skipNewlines();
+        }
+        this.expect('OP', '}', '}');
+        return ['dict', pairs, tok[2]];
+      }
+      let trouve = tok[1] !== null ? tok[1] : tok[0];
+      trouve = NICE[trouve] || trouve;
+      throw new LazError(`expression invalide, je ne comprends pas « ${trouve} » (il manque peut-être une valeur)`, tok[2]);
+    }
+  }
+
+  // ---------------- ENVIRONNEMENT ----------------
+  class Env {
+    constructor(parent) { this.vars = new Map(); this.parent = parent || null; }
+    get(name, line) {
+      let e = this;
+      while (e) { if (e.vars.has(name)) return e.vars.get(name); e = e.parent; }
+      throw new LazError(MODE_PYTHON.actif
+          ? `la variable « ${name} » n'existe pas (déclare-la d'abord avec : ${name} = ...)`
+          : `la variable « ${name} » n'existe pas (déclare-la avec : laz ${name} = ...)`, line);
+    }
+    declare(name, value) { this.vars.set(name, value); }
+    assign(name, value, line) {
+      let e = this;
+      while (e) { if (e.vars.has(name)) { e.vars.set(name, value); return; } e = e.parent; }
+      throw new LazError(MODE_PYTHON.actif
+          ? `la variable « ${name} » n'existe pas (déclare-la d'abord avec : ${name} = ...)`
+          : `la variable « ${name} » n'existe pas (déclare-la avec : laz ${name} = ...)`, line);
+    }
+  }
+
+  class LazFunction {
+    constructor(name, params, body, env) {
+      this.name = name; this.params = params; this.body = body; this.env = env;
+    }
+  }
+
+  class LazClass {
+    constructor(name, methods, parent) {
+      this.name = name; this.methods = methods; this.parent = parent || null;
+    }
+    findMethod(name) {
+      let k = this;
+      while (k) { if (k.methods.has(name)) return k.methods.get(name); k = k.parent; }
+      return null;
+    }
+  }
+
+  class LazInstance {
+    constructor(klass) { this.klass = klass; this.fields = new Map(); }
+  }
+
+  class BoundMethod {
+    constructor(fn, instance) { this.fn = fn; this.instance = instance; }
+  }
+
+  // ---------------- VALEURS ----------------
+  function numText(v) {
+    if (Number.isInteger(v)) return String(v);
+    return String(Math.round(v * 1e10) / 1e10);
+  }
+  function toText(v) {
+    if (v === null || v === undefined) return 'walu';
+    if (v === true) return 'vrai';
+    if (v === false) return 'faux';
+    if (typeof v === 'number') return numText(v);
+    if (Array.isArray(v)) {
+      return '[' + v.map(x => typeof x === 'string' ? `"${x}"` : toText(x)).join(', ') + ']';
+    }
+    if (v instanceof Map) {
+      const parts = [];
+      for (const [k, val] of v.entries()) {
+        const ks = typeof k === 'string' ? `"${k}"` : toText(k);
+        const vs = typeof val === 'string' ? `"${val}"` : toText(val);
+        parts.push(`${ks}: ${vs}`);
+      }
+      return '{' + parts.join(', ') + '}';
+    }
+    if (v instanceof LazFunction) return `<fonk ${v.name}>`;
+    if (v instanceof LazClass) return `<klas ${v.name}>`;
+    if (v instanceof LazInstance) return `<objet ${v.klass.name}>`;
+    if (v instanceof BoundMethod) return `<fonk ${v.fn.name}>`;
+    return String(v);
+  }
+  function isTruthy(v) {
+    if (v === null || v === undefined || v === false) return false;
+    if (v === true) return true;
+    if (typeof v === 'number') return v !== 0;
+    if (typeof v === 'string' || Array.isArray(v)) return v.length > 0;
+    if (v instanceof Map) return v.size > 0;
+    return true;
+  }
+  const INTERP_RE = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+
+  function interpolate(s, env) {
+    if (!s.includes('{')) return s;
+    let s2 = s.split('{{').join('\x00').split('}}').join('\x01');
+    s2 = s2.replace(INTERP_RE, (whole, name) => {
+      let e = env;
+      while (e) {
+        if (e.vars.has(name)) return toText(e.vars.get(name));
+        e = e.parent;
+      }
+      return whole;
+    });
+    return s2.split('\x00').join('{').split('\x01').join('}');
+  }
+
+  function checkNumber(v, line, contexte) {
+    if (typeof v !== 'number' || Number.isNaN(v)) {
+      throw new LazError(`${(contexte || 'cette opération')} demande un nombre, pas « ${toText(v)} »`, line);
+    }
+    return v;
+  }
+
+  // ---------------- INTERPRÉTEUR ----------------
+  const MAX_STEPS = 5000000;
+
+
+  // ============================================================
+  //  v11.0 : LE MODE PYTHON BIENVEILLANT (lecteur Python -> AST Larkhré)
+  // ============================================================
+  const PY_MOTS = new Set(['def', 'return', 'if', 'elif', 'else', 'while', 'for', 'in',
+    'break', 'continue', 'pass', 'and', 'or', 'not', 'True', 'False', 'None',
+    'try', 'except', 'as', 'import', 'from']);
+  const PY_FONCTIONS = { print: 'vox', input: 'demand', len: 'taille', str: 'texte', float: 'nombre', int: '__ent', round: 'arondi', sorted: 'tri', abs: '__abs' };
+  const PY_METHODES = { append: 'ajoute', pop: 'retire', upper: 'majus', lower: 'minus', split: 'koupe', replace: 'remplace', join: 'colle' };
+  const PY_OPS2 = new Set(['**', '//', '==', '!=', '<=', '>=', '+=', '-=', '*=', '/=']);
+  const PY_MODE_RE = /#\s*langue\s*:\s*python/i;
+  const MODE_PYTHON = { actif: false };
+
+  function estModePython(source) {
+    return source.split('\n').slice(0, 3).some((l) => PY_MODE_RE.test(l));
+  }
+
+  function pyTokenize(source) {
+    const tokens = [];
+    const indents = [0];
+    const lignes = source.split('\n');
+    let profondeur = 0;
+    for (let num = 1; num <= lignes.length; num++) {
+      const brute = lignes[num - 1];
+      const depouillee = brute.trim();
+      if (profondeur === 0) {
+        if (depouillee === '' || depouillee.startsWith('#')) continue;
+        let larg = 0;
+        for (const c of brute) {
+          if (c === ' ') larg += 1;
+          else if (c === '\t') larg += 4;
+          else break;
+        }
+        if (larg > indents[indents.length - 1]) {
+          indents.push(larg);
+          tokens.push(['INDENT', null, num]);
+        }
+        while (larg < indents[indents.length - 1]) {
+          indents.pop();
+          tokens.push(['DEDENT', null, num]);
+        }
+        if (larg !== indents[indents.length - 1]) {
+          throw new LazError('indentation incohérente : aligne cette ligne avec le bloc auquel elle appartient', num);
+        }
+      }
+      let i = 0;
+      const n = brute.length;
+      while (i < n) {
+        let c = brute[i];
+        if (c === ' ' || c === '\t') { i++; continue; }
+        if (c === '#') break;
+        let estF = false;
+        if ((c === 'f' || c === 'F') && i + 1 < n && (brute[i + 1] === '"' || brute[i + 1] === "'")) {
+          estF = true;
+          i++;
+          c = brute[i];
+        }
+        if (c === '"' || c === "'") {
+          const quote = c;
+          i++;
+          let buf = '';
+          let ferme = false;
+          while (i < n) {
+            const ch = brute[i];
+            if (ch === '\\' && i + 1 < n) {
+              const nxt = brute[i + 1];
+              const esc = { n: '\n', t: '\t', '"': '"', "'": "'", '\\': '\\' };
+              buf += (esc[nxt] !== undefined ? esc[nxt] : nxt);
+              i += 2;
+              continue;
+            }
+            if (ch === quote) { ferme = true; i++; break; }
+            buf += ch;
+            i++;
+          }
+          if (!ferme) throw new LazError(`chaîne de caractères non fermée (il manque un ${quote} )`, num);
+          if (!estF) buf = buf.replace(/\{/g, '{{').replace(/\}/g, '}}');
+          tokens.push(['STRING', buf, num]);
+          continue;
+        }
+        if (isDigit(c) || (c === '.' && i + 1 < n && isDigit(brute[i + 1]))) {
+          const debut = i;
+          while (i < n && (isDigit(brute[i]) || brute[i] === '.')) i++;
+          tokens.push(['NUMBER', parseFloat(brute.slice(debut, i)), num]);
+          continue;
+        }
+        if (/[A-Za-z_]/.test(c)) {
+          const debut = i;
+          while (i < n && /[A-Za-z0-9_]/.test(brute[i])) i++;
+          const mot = brute.slice(debut, i);
+          tokens.push([PY_MOTS.has(mot) ? 'KW' : 'IDENT', mot, num]);
+          continue;
+        }
+        const deux = brute.slice(i, i + 2);
+        if (PY_OPS2.has(deux)) { tokens.push(['OP', deux, num]); i += 2; continue; }
+        if ('+-*/%=<>()[]{},:.'.includes(c)) {
+          if ('([{'.includes(c)) profondeur++;
+          else if (')]}'.includes(c)) profondeur = Math.max(0, profondeur - 1);
+          tokens.push(['OP', c, num]);
+          i++;
+          continue;
+        }
+        if (c === ';') throw new LazError('pas de point-virgule en Python — une instruction par ligne', num);
+        throw new LazError(`caractère inconnu : '${c}'`, num);
+      }
+      if (profondeur === 0 && tokens.length && !['NEWLINE', 'INDENT', 'DEDENT'].includes(tokens[tokens.length - 1][0])) {
+        tokens.push(['NEWLINE', null, num]);
+      }
+    }
+    while (indents.length > 1) {
+      indents.pop();
+      tokens.push(['DEDENT', null, lignes.length]);
+    }
+    tokens.push(['EOF', null, lignes.length]);
+    return tokens;
+  }
+
+  const PY_NICE = { NEWLINE: 'une fin de ligne', EOF: 'la fin du fichier', INDENT: 'une indentation', DEDENT: 'une fin de bloc' };
+
+  class PyParser {
+    constructor(tokens) {
+      this.tokens = tokens;
+      this.pos = 0;
+      this.scopes = [new Set()];
+    }
+    peek() { return this.tokens[this.pos]; }
+    next() { return this.tokens[this.pos++]; }
+    check(t, v) {
+      const tok = this.peek();
+      if (tok[0] !== t) return false;
+      if (v !== undefined && tok[1] !== v) return false;
+      return true;
+    }
+    accept(t, v) { if (this.check(t, v)) return this.next(); return null; }
+    expect(t, v, quoi) {
+      const tok = this.peek();
+      if (!this.check(t, v)) {
+        const attendu = quoi || v || t;
+        const trouve = tok[1] !== null ? tok[1] : (PY_NICE[tok[0]] || tok[0]);
+        throw new LazError(`j'attendais « ${attendu} » mais j'ai trouvé « ${trouve} »`, tok[2]);
+      }
+      return this.next();
+    }
+    sauteLignes() { while (this.check('NEWLINE')) this.next(); }
+
+    parseProgram() {
+      const stmts = [];
+      this.sauteLignes();
+      while (!this.check('EOF')) {
+        stmts.push(this.parseStatement());
+        this.sauteLignes();
+      }
+      return ['block', stmts];
+    }
+
+    parseBloc(line) {
+      this.expect('OP', ':', "les deux-points ':' à la fin de la ligne");
+      this.expect('NEWLINE', undefined, 'un passage à la ligne après les deux-points');
+      this.sauteLignes();
+      if (!this.check('INDENT')) {
+        throw new LazError('le bloc doit être indenté (décalé vers la droite, par exemple de 4 espaces)', this.peek()[2]);
+      }
+      this.next();
+      const stmts = [];
+      this.sauteLignes();
+      while (!this.check('DEDENT') && !this.check('EOF')) {
+        stmts.push(this.parseStatement());
+        this.sauteLignes();
+      }
+      this.accept('DEDENT');
+      return ['block', stmts];
+    }
+
+    declareOuAssigne(nom) {
+      const scope = this.scopes[this.scopes.length - 1];
+      if (scope.has(nom)) return 'assign';
+      scope.add(nom);
+      return 'declare';
+    }
+
+    parseStatement() {
+      const tok = this.peek();
+      const line = tok[2];
+
+      if (this.accept('KW', 'def')) {
+        const nom = this.expect('IDENT', undefined, 'un nom de fonction')[1];
+        this.expect('OP', '(', '(');
+        const params = [];
+        if (!this.check('OP', ')')) {
+          params.push(this.expect('IDENT', undefined, 'un nom de paramètre')[1]);
+          while (this.accept('OP', ',')) params.push(this.expect('IDENT', undefined, 'un nom de paramètre')[1]);
+        }
+        this.expect('OP', ')', ')');
+        this.scopes[this.scopes.length - 1].add(nom);
+        this.scopes.push(new Set(params));
+        const corps = this.parseBloc(line);
+        this.scopes.pop();
+        return ['fonk', nom, params, corps, line];
+      }
+
+      if (this.accept('KW', 'if')) return this.parseIf(line);
+
+      if (this.accept('KW', 'while')) {
+        const cond = this.parseExpression();
+        return ['tanke', cond, this.parseBloc(line), line];
+      }
+
+      if (this.accept('KW', 'for')) {
+        const v = this.expect('IDENT', undefined, 'un nom de variable')[1];
+        this.expect('KW', 'in', 'in');
+        const iterable = this.parseExpression();
+        this.scopes[this.scopes.length - 1].add(v);
+        return ['pou', v, iterable, this.parseBloc(line), line];
+      }
+
+      if (this.accept('KW', 'return')) {
+        if (this.check('NEWLINE')) return ['rend', null, line];
+        return ['rend', this.parseExpression(), line];
+      }
+      if (this.accept('KW', 'break')) return ['kase', line];
+      if (this.accept('KW', 'continue')) return ['swiv', line];
+      if (this.accept('KW', 'pass')) return ['expr', ['walu'], line];
+
+      if (this.accept('KW', 'try')) {
+        const corps = this.parseBloc(line);
+        this.sauteLignes();
+        this.expect('KW', 'except', 'except (après un try, il faut un except)');
+        let nomErreur = 'erreur';
+        if (this.check('IDENT')) {
+          this.next();
+          if (this.accept('KW', 'as')) nomErreur = this.expect('IDENT', undefined, "un nom pour l'erreur")[1];
+        }
+        this.scopes[this.scopes.length - 1].add(nomErreur);
+        const gestion = this.parseBloc(line);
+        return ['essaie', corps, nomErreur, gestion, line];
+      }
+
+      if (this.accept('KW', 'import')) {
+        const module = this.expect('IDENT', undefined, 'un nom de module')[1];
+        if (module !== 'random' && module !== 'math') {
+          throw new LazError(`le module « ${module} » n'est pas disponible dans le mode Python pédagogique (disponibles : random, math)`, line);
+        }
+        return ['expr', ['walu'], line];
+      }
+      if (this.accept('KW', 'from')) {
+        throw new LazError('« from ... import ... » n\'est pas disponible — utilise « import random » et random.randint(...)', line);
+      }
+
+      const expr = this.parseExpression();
+      const optok = this.peek();
+      if (optok[0] === 'OP' && ['=', '+=', '-=', '*=', '/='].includes(optok[1])) {
+        this.next();
+        let valeur = this.parseExpression();
+        if (optok[1] !== '=') valeur = ['binop', optok[1][0], expr, valeur, line];
+        if (expr[0] === 'var') {
+          const genre = this.declareOuAssigne(expr[1]);
+          return [genre, expr[1], valeur, line];
+        }
+        if (expr[0] === 'index') return ['assign_index', expr[1], expr[2], valeur, line];
+        throw new LazError("on ne peut affecter qu'une variable ou une case de liste/dictionnaire", line);
+      }
+      return ['expr', expr, line];
+    }
+
+    parseIf(line) {
+      const cond = this.parseExpression();
+      const corps = this.parseBloc(line);
+      let sinon = null;
+      const posSauv = this.pos;
+      this.sauteLignes();
+      if (this.accept('KW', 'elif')) {
+        const l2 = this.tokens[this.pos - 1][2];
+        sinon = ['block', [this.parseIf(l2)]];
+      } else if (this.accept('KW', 'else')) {
+        const l2 = this.tokens[this.pos - 1][2];
+        sinon = this.parseBloc(l2);
+      } else {
+        this.pos = posSauv;
+      }
+      return ['kan', cond, corps, sinon, line];
+    }
+
+    parseExpression() { return this.parseOr(); }
+    parseOr() {
+      let g = this.parseAnd();
+      while (this.check('KW', 'or')) {
+        const line = this.next()[2];
+        g = ['or', g, this.parseAnd(), line];
+      }
+      return g;
+    }
+    parseAnd() {
+      let g = this.parseNot();
+      while (this.check('KW', 'and')) {
+        const line = this.next()[2];
+        g = ['and', g, this.parseNot(), line];
+      }
+      return g;
+    }
+    parseNot() {
+      if (this.check('KW', 'not')) {
+        const line = this.next()[2];
+        return ['not', this.parseNot(), line];
+      }
+      return this.parseComparaison();
+    }
+    parseComparaison() {
+      let g = this.parseAddition();
+      while (this.peek()[0] === 'OP' && ['==', '!=', '<', '>', '<=', '>='].includes(this.peek()[1])) {
+        const op = this.next();
+        g = ['cmp', op[1], g, this.parseAddition(), op[2]];
+      }
+      return g;
+    }
+    parseAddition() {
+      let g = this.parseMultiplication();
+      while (this.peek()[0] === 'OP' && (this.peek()[1] === '+' || this.peek()[1] === '-')) {
+        const op = this.next();
+        g = ['binop', op[1], g, this.parseMultiplication(), op[2]];
+      }
+      return g;
+    }
+    parseMultiplication() {
+      let g = this.parseUnaire();
+      while (this.peek()[0] === 'OP' && ['*', '/', '//', '%'].includes(this.peek()[1])) {
+        const op = this.next();
+        g = ['binop', op[1], g, this.parseUnaire(), op[2]];
+      }
+      return g;
+    }
+    parseUnaire() {
+      if (this.check('OP', '-')) {
+        const line = this.next()[2];
+        return ['neg', this.parseUnaire(), line];
+      }
+      return this.parsePuissance();
+    }
+    parsePuissance() {
+      const base = this.parsePostfixe();
+      if (this.check('OP', '**')) {
+        const line = this.next()[2];
+        return ['binop', '**', base, this.parseUnaire(), line];
+      }
+      return base;
+    }
+    parsePostfixe() {
+      let expr = this.parsePrimaire();
+      for (;;) {
+        const tok = this.peek();
+        if (this.accept('OP', '(')) {
+          const args = [];
+          if (!this.check('OP', ')')) {
+            args.push(this.parseExpression());
+            while (this.accept('OP', ',')) args.push(this.parseExpression());
+          }
+          this.expect('OP', ')', ')');
+          expr = this.traduitAppel(expr, args, tok[2]);
+          continue;
+        }
+        if (this.accept('OP', '[')) {
+          const index = this.parseExpression();
+          this.expect('OP', ']', ']');
+          expr = ['index', expr, index, tok[2]];
+          continue;
+        }
+        if (this.accept('OP', '.')) {
+          const nom = this.expect('IDENT', undefined, 'un nom de méthode')[1];
+          expr = ['pymeth', expr, nom, tok[2]];
+          continue;
+        }
+        break;
+      }
+      if (expr[0] === 'pymeth') {
+        throw new LazError(`la méthode .${expr[2]} doit être appelée avec des parenthèses`, expr[3]);
+      }
+      return expr;
+    }
+    traduitAppel(callee, args, line) {
+      if (callee[0] === 'pymeth') {
+        const [, objet, nom, l2] = callee;
+        if (objet[0] === 'var' && objet[1] === 'random') {
+          if (nom === 'randint') return ['call', ['var', 'hasard', l2], args, line];
+          throw new LazError(`random.${nom} n'est pas disponible (disponible : random.randint(a, b))`, line);
+        }
+        if (objet[0] === 'var' && objet[1] === 'math') {
+          if (nom === 'sqrt') return ['binop', '**', args[0], ['num', 0.5], line];
+          throw new LazError(`math.${nom} n'est pas disponible (disponible : math.sqrt(x))`, line);
+        }
+        if (nom in PY_METHODES) {
+          if (nom === 'join') return ['call', ['var', 'colle', l2], [args[0], objet], line];
+          if (nom === 'pop') return ['call', ['var', 'retire', l2], [objet, args.length ? args[0] : ['num', -1]], line];
+          if (nom === 'split') return ['call', ['var', 'koupe', l2], [objet, args.length ? args[0] : ['str', ' ']], line];
+          return ['call', ['var', PY_METHODES[nom], l2], [objet, ...args], line];
+        }
+        const dispo = Object.keys(PY_METHODES).sort().join(', ');
+        throw new LazError(`la méthode .${nom} n'est pas disponible dans le mode Python pédagogique (disponibles : ${dispo})`, line);
+      }
+      if (callee[0] === 'var') {
+        const nom = callee[1];
+        if (nom === 'range') return ['call', ['var', '__plage', callee[2]], args, line];
+        if (nom in PY_FONCTIONS) return ['call', ['var', PY_FONCTIONS[nom], callee[2]], args, line];
+      }
+      return ['call', callee, args, line];
+    }
+    parsePrimaire() {
+      const tok = this.peek();
+      const line = tok[2];
+      if (tok[0] === 'NUMBER') { this.next(); return ['num', tok[1]]; }
+      if (tok[0] === 'STRING') { this.next(); return ['str', tok[1]]; }
+      if (this.accept('KW', 'True')) return ['bool', true];
+      if (this.accept('KW', 'False')) return ['bool', false];
+      if (this.accept('KW', 'None')) return ['walu'];
+      if (tok[0] === 'IDENT') { this.next(); return ['var', tok[1], line]; }
+      if (this.accept('OP', '(')) {
+        const e = this.parseExpression();
+        this.expect('OP', ')', ')');
+        return e;
+      }
+      if (this.accept('OP', '[')) {
+        const items = [];
+        if (!this.check('OP', ']')) {
+          items.push(this.parseExpression());
+          while (this.accept('OP', ',')) {
+            if (this.check('OP', ']')) break;
+            items.push(this.parseExpression());
+          }
+        }
+        this.expect('OP', ']', ']');
+        return ['list', items, line];
+      }
+      if (this.accept('OP', '{')) {
+        const paires = [];
+        if (!this.check('OP', '}')) {
+          let k = this.parseExpression();
+          this.expect('OP', ':', ':');
+          paires.push([k, this.parseExpression()]);
+          while (this.accept('OP', ',')) {
+            if (this.check('OP', '}')) break;
+            k = this.parseExpression();
+            this.expect('OP', ':', ':');
+            paires.push([k, this.parseExpression()]);
+          }
+        }
+        this.expect('OP', '}', '}');
+        return ['dict', paires, line];
+      }
+      const trouve = tok[1] !== null ? tok[1] : (PY_NICE[tok[0]] || tok[0]);
+      throw new LazError(`expression attendue, mais j'ai trouvé « ${trouve} »`, line);
+    }
+  }
+
+  function parsePython(source) {
+    return new PyParser(pyTokenize(source)).parseProgram();
+  }
+
+  class Interpreter {
+    constructor(io) {
+      this.io = io;
+      this.fs = (io && io.fs) || new Map();
+      this.dessin = null;
+      this.memoire = (io && io.memoire) || {};
+      this.gardeNoms = new Set();
+      this.vitesse = 0;
+      this.histoire = [];
+      this.globals = new Env(null);
+      this.steps = 0;
+      this.frameFn = null;   // v6 : la fonction appelée à chaque image du jeu
+      this.jeuFini = false;  // v6 : arrete_jeu() a été appelé
+      this.aInterface = false;          // v7 : des widgets ont été créés
+      this.actionsBoutons = new Map();  // v7 : id de bouton -> fonction Larkhré
+      this.compteurWidget = 0;          // v7 : générateur d'identifiants
+      this.makeBuiltins();
+    }
+
+    noteHistoire(line, name, value) {
+      this.histoire.push([line, name, toText(value)]);
+      if (this.histoire.length > 6) this.histoire.shift();
+    }
+
+    snapshot() {
+      const out = [];
+      for (const [k, v] of this.globals.vars.entries()) {
+        if (v && (v.builtin || v instanceof LazFunction || v instanceof LazClass)) continue;
+        out.push([k, toText(v)]);
+        if (out.length >= 12) break;
+      }
+      return out;
+    }
+
+    tick(line) {
+      this.steps++;
+      if (this.steps > MAX_STEPS) {
+        throw new LazError('programme trop long — boucle infinie ?', line);
+      }
+      if (this.io.shouldStop && this.io.shouldStop()) throw new StopEx();
+    }
+
+    need(args, count, name, line) {
+      if (args.length < count) {
+        throw new LazError(`${name}() demande au moins ${count} argument(s), reçu ${args.length}`, line);
+      }
+    }
+
+    makeBuiltins() {
+      const g = this.globals;
+      const self = this;
+      const B = (name, fn) => g.declare(name, { builtin: name, fn });
+
+      B('vox', async (args) => { self.io.onPrint(args.map(toText).join(' ')); return null; });
+      B('demand', async (args) => {
+        const p = args.length ? toText(args[0]) : '';
+        const answer = await self.io.onInput(p);
+        return answer === null || answer === undefined ? '' : String(answer);
+      });
+      B('nombre', async (args, line) => {
+        self.need(args, 1, 'nombre', line);
+        const v = args[0];
+        if (v === true) return 1;
+        if (v === false) return 0;
+        if (typeof v === 'number') return v;
+        const f = parseFloat(String(v).trim().replace(',', '.'));
+        if (Number.isNaN(f) || !/^-?[\d.,]+$/.test(String(v).trim())) {
+          throw new LazError(`impossible de convertir « ${toText(v)} » en nombre`, line);
+        }
+        return f;
+      });
+      B('texte', async (args, line) => { self.need(args, 1, 'texte', line); return toText(args[0]); });
+      B('taille', async (args, line) => {
+        self.need(args, 1, 'taille', line);
+        const v = args[0];
+        if (typeof v === 'string' || Array.isArray(v)) return v.length;
+        if (v instanceof Map) return v.size;
+        throw new LazError('taille() fonctionne avec un texte, une liste ou un dictionnaire', line);
+      });
+      B('ajoute', async (args, line) => {
+        self.need(args, 2, 'ajoute', line);
+        if (!Array.isArray(args[0])) throw new LazError('ajoute() demande une liste en premier argument', line);
+        args[0].push(args[1]);
+        return args[0];
+      });
+      B('retire', async (args, line) => {
+        self.need(args, 2, 'retire', line);
+        const c = args[0];
+        if (c instanceof Map) {
+          const key = checkDictKey(args[1], line);
+          if (!c.has(key)) throw new LazError(`la clé « ${toText(key)} » n'existe pas dans le dictionnaire`, line);
+          const v = c.get(key);
+          c.delete(key);
+          return v;
+        }
+        if (!Array.isArray(c)) throw new LazError('retire() demande une liste ou un dictionnaire en premier argument', line);
+        let idx = Math.trunc(checkNumber(args[1], line, 'retire()'));
+        if (idx < -c.length || idx >= c.length) {
+          throw new LazError(`position ${idx} hors de la liste (taille ${c.length})`, line);
+        }
+        if (idx < 0) idx += c.length;
+        return c.splice(idx, 1)[0];
+      });
+      B('hasard', async (args, line) => {
+        self.need(args, 2, 'hasard', line);
+        const a = Math.trunc(checkNumber(args[0], line, 'hasard()'));
+        const b = Math.trunc(checkNumber(args[1], line, 'hasard()'));
+        const lo = Math.min(a, b), hi = Math.max(a, b);
+        return lo + Math.floor(Math.random() * (hi - lo + 1));
+      });
+      B('arondi', async (args, line) => {
+        self.need(args, 1, 'arondi', line);
+        const v = checkNumber(args[0], line, 'arondi()');
+        const nd = args.length > 1 ? Math.trunc(checkNumber(args[1], line, 'arondi()')) : 0;
+        const m = Math.pow(10, nd);
+        return Math.round(v * m) / m;
+      });
+      B('majus', async (args, line) => { self.need(args, 1, 'majus', line); return toText(args[0]).toUpperCase(); });
+      B('minus', async (args, line) => { self.need(args, 1, 'minus', line); return toText(args[0]).toLowerCase(); });
+      B('koupe', async (args, line) => { self.need(args, 2, 'koupe', line); return toText(args[0]).split(toText(args[1])); });
+      B('tri', async (args, line) => {
+        self.need(args, 1, 'tri', line);
+        if (!Array.isArray(args[0])) throw new LazError('tri() demande une liste', line);
+        const arr = args[0];
+        const allNum = arr.every(x => typeof x === 'number');
+        const allStr = arr.every(x => typeof x === 'string');
+        if (!allNum && !allStr && arr.length > 0) {
+          throw new LazError('tri() ne peut pas trier des types mélangés', line);
+        }
+        const copy = arr.slice();
+        if (allNum) copy.sort((a, b) => a - b);
+        else copy.sort();
+        return copy;
+      });
+      B('tip', async (args, line) => {
+        self.need(args, 1, 'tip', line);
+        const v = args[0];
+        if (v === null || v === undefined) return 'walu';
+        if (v === true || v === false) return 'buli';
+        if (typeof v === 'number') return 'nombre';
+        if (typeof v === 'string') return 'texte';
+        if (Array.isArray(v)) return 'liste';
+        if (v instanceof Map) return 'dico';
+        if (v instanceof LazInstance) return v.klass.name;
+        if (v instanceof LazClass) return 'klas';
+        if (v instanceof LazFunction || v instanceof BoundMethod) return 'fonk';
+        return 'inconnu';
+      });
+
+      // --- nouveautés v2.0 ---
+      B('cles', async (args, line) => {
+        self.need(args, 1, 'cles', line);
+        if (!(args[0] instanceof Map)) throw new LazError('cles() demande un dictionnaire', line);
+        return [...args[0].keys()];
+      });
+      B('valeurs', async (args, line) => {
+        self.need(args, 1, 'valeurs', line);
+        if (!(args[0] instanceof Map)) throw new LazError('valeurs() demande un dictionnaire', line);
+        return [...args[0].values()];
+      });
+      B('contient', async (args, line) => {
+        self.need(args, 2, 'contient', line);
+        const c = args[0], x = args[1];
+        if (c instanceof Map) return c.has(x);
+        if (Array.isArray(c)) return c.some(v => lazEquals(v, x));
+        if (typeof c === 'string') return c.includes(toText(x));
+        throw new LazError('contient() demande un texte, une liste ou un dictionnaire en premier argument', line);
+      });
+      B('colle', async (args, line) => {
+        self.need(args, 2, 'colle', line);
+        if (!Array.isArray(args[0])) throw new LazError('colle() demande une liste en premier argument', line);
+        return args[0].map(toText).join(toText(args[1]));
+      });
+      B('remplace', async (args, line) => {
+        self.need(args, 3, 'remplace', line);
+        return toText(args[0]).split(toText(args[1])).join(toText(args[2]));
+      });
+      B('lis_fichier', async (args, line) => {
+        self.need(args, 1, 'lis_fichier', line);
+        const chemin = toText(args[0]);
+        if (!self.fs.has(chemin)) throw new LazError(`fichier introuvable : ${chemin}`, line);
+        return self.fs.get(chemin);
+      });
+      B('ecris_fichier', async (args, line) => {
+        self.need(args, 2, 'ecris_fichier', line);
+        self.fs.set(toText(args[0]), toText(args[1]));
+        return null;
+      });
+      B('ajoute_fichier', async (args, line) => {
+        self.need(args, 2, 'ajoute_fichier', line);
+        const chemin = toText(args[0]);
+        self.fs.set(chemin, (self.fs.get(chemin) || '') + toText(args[1]));
+        return null;
+      });
+      B('fichier_existe', async (args, line) => {
+        self.need(args, 1, 'fichier_existe', line);
+        return self.fs.has(toText(args[0]));
+      });
+
+      // --- nouveautés v3.0 : la couleur ! ---
+      const COULEURS = {
+        rouge: '31', vert: '32', jaune: '33', bleu: '34',
+        violet: '35', cyan: '36', blanc: '37', or: '93',
+        gris: '90', rose: '95', noir: '30',
+      };
+      const STYLES = { gras: '1', souligne: '4', 'souligné': '4' };
+
+      B('vox_couleur', async (args, line) => {
+        self.need(args, 2, 'vox_couleur', line);
+        const couleur = toText(args[args.length - 1]).toLowerCase();
+        if (!(couleur in COULEURS)) {
+          throw new LazError(`couleur inconnue « ${couleur} » (disponibles : ${Object.keys(COULEURS).sort().join(', ')})`, line);
+        }
+        const texte = args.slice(0, -1).map(toText).join(' ');
+        self.io.onPrint(`\x1b[${COULEURS[couleur]}m${texte}\x1b[0m`);
+        return null;
+      });
+      B('stylise', async (args, line) => {
+        self.need(args, 2, 'stylise', line);
+        const style = toText(args[1]).toLowerCase();
+        const code = COULEURS[style] || STYLES[style];
+        if (!code) {
+          throw new LazError(`style inconnu « ${style} » (disponibles : ${Object.keys(COULEURS).sort().concat(['gras', 'souligne']).join(', ')})`, line);
+        }
+        return `\x1b[${code}m${toText(args[0])}\x1b[0m`;
+      });
+      B('efface_ecran', async () => {
+        if (self.io.onClear) self.io.onClear();
+        return null;
+      });
+
+      // --- nouveautés v3.1 : le mode dessin ! ---
+      const DESSIN_COULEURS = {
+        rouge: '#f87171', vert: '#4ade80', jaune: '#facc15',
+        bleu: '#60a5fa', violet: '#c084fc', cyan: '#22d3ee',
+        blanc: '#e6edf3', or: '#f0b429', gris: '#8b949e',
+        rose: '#f9a8d4', noir: '#0d1117',
+      };
+      const couleurCss = (nom, line) => {
+        nom = toText(nom).toLowerCase();
+        if (nom.startsWith('#')) return nom;
+        if (!(nom in DESSIN_COULEURS)) {
+          throw new LazError(`couleur inconnue « ${nom} » (disponibles : ${Object.keys(DESSIN_COULEURS).sort().join(', ')}, ou un code #rrggbb)`, line);
+        }
+        return DESSIN_COULEURS[nom];
+      };
+      const toileRequise = (line) => {
+        if (!self.dessin) throw new LazError('appelle d\'abord toile(largeur, hauteur) pour créer ta zone de dessin', line);
+        return self.dessin;
+      };
+      const draw = (cmd) => { if (self.io.onDraw) self.io.onDraw(cmd); };
+
+      B('toile', async (args, line) => {
+        self.need(args, 2, 'toile', line);
+        const w = checkNumber(args[0], line, 'toile()');
+        const h = checkNumber(args[1], line, 'toile()');
+        if (w < 1 || h < 1 || w > 2000 || h > 2000) throw new LazError('toile() : dimensions entre 1 et 2000', line);
+        self.dessin = { w, h, formes: [] };
+        draw({ type: 'toile', w, h });
+        return null;
+      });
+      B('fond', async (args, line) => {
+        self.need(args, 1, 'fond', line);
+        const t = toileRequise(line);
+        const c = couleurCss(args[0], line);
+        t.formes.push(['fond', c]);
+        draw({ type: 'fond', c });
+        return null;
+      });
+      B('trace_ligne', async (args, line) => {
+        self.need(args, 5, 'trace_ligne', line);
+        const t = toileRequise(line);
+        const [x1, y1, x2, y2] = args.slice(0, 4).map(a => checkNumber(a, line, 'trace_ligne()'));
+        const c = couleurCss(args[4], line);
+        t.formes.push(['ligne', x1, y1, x2, y2, c]);
+        draw({ type: 'ligne', x1, y1, x2, y2, c });
+        return null;
+      });
+      const rectF = (nom, plein) => async (args, line) => {
+        self.need(args, 5, nom, line);
+        const t = toileRequise(line);
+        const [x, y, w, h] = args.slice(0, 4).map(a => checkNumber(a, line, nom + '()'));
+        const c = couleurCss(args[4], line);
+        t.formes.push(['rect', x, y, w, h, c, plein]);
+        draw({ type: 'rect', x, y, l: w, h, c, plein });
+        return null;
+      };
+      B('trace_rect', rectF('trace_rect', false));
+      B('rect_plein', rectF('rect_plein', true));
+      const cercleF = (nom, plein) => async (args, line) => {
+        self.need(args, 4, nom, line);
+        const t = toileRequise(line);
+        const [x, y, r] = args.slice(0, 3).map(a => checkNumber(a, line, nom + '()'));
+        const c = couleurCss(args[3], line);
+        t.formes.push(['cercle', x, y, r, c, plein]);
+        draw({ type: 'cercle', x, y, r, c, plein });
+        return null;
+      };
+      B('trace_cercle', cercleF('trace_cercle', false));
+      B('cercle_plein', cercleF('cercle_plein', true));
+      B('trace_texte', async (args, line) => {
+        self.need(args, 4, 'trace_texte', line);
+        const t = toileRequise(line);
+        const x = checkNumber(args[0], line, 'trace_texte()');
+        const y = checkNumber(args[1], line, 'trace_texte()');
+        const txt = toText(args[2]);
+        const c = couleurCss(args[3], line);
+        t.formes.push(['texte', x, y, txt, c]);
+        draw({ type: 'texte', x, y, t: txt, c });
+        return null;
+      });
+      B('sauve_dessin', async (args, line) => {
+        self.need(args, 1, 'sauve_dessin', line);
+        const t = toileRequise(line);
+        self.fs.set(toText(args[0]), svgDuDessin(t));
+        return null;
+      });
+
+      // --- nouveautés v4.0 ---
+      B('echoue', async (args, line) => {
+        self.need(args, 1, 'echoue', line);
+        throw new LazError(toText(args[0]), line);
+      });
+
+      // --- nouveautés v5.0 ---
+      B('ralenti', async (args, line) => {
+        self.need(args, 1, 'ralenti', line);
+        const v = checkNumber(args[0], line, 'ralenti()');
+        self.vitesse = Math.min(3, Math.max(0, v));
+        return null;
+      });
+
+      // --- nouveautés v6.0 : le mode JEU (temps réel) ---
+      const SONS_CONNUS = ['clic', 'defaite', 'explosion', 'moteur', 'piece', 'saut', 'victoire'];
+      B('chaque_image', async (args, line) => {
+        self.need(args, 1, 'chaque_image', line);
+        if (!(args[0] instanceof LazFunction)) {
+          throw new LazError('chaque_image() attend une fonction : chaque_image(ma_fonction) — sans parenthèses après son nom', line);
+        }
+        self.frameFn = args[0];
+        return null;
+      });
+      B('touche_pressee', async (args, line) => {
+        self.need(args, 1, 'touche_pressee', line);
+        const nom = toText(args[0]).toLowerCase();
+        return self.io.toucheEnfoncee ? !!self.io.toucheEnfoncee(nom) : false;
+      });
+      B('arrete_jeu', async () => { self.jeuFini = true; return null; });
+
+      // --- nouveauté v8.0 : Larkhré PARLE ---
+      B('dis', async (args, line) => {
+        self.need(args, 1, 'dis', line);
+        const texte = args.map(toText).join(' ');
+        if (self.io.onDis) { try { self.io.onDis(texte); } catch (e) { } }
+        return null;
+      });
+
+      // --- nouveauté v9.0 : Larkhré ECOUTE ---
+      B('ecoute', async (args) => {
+        const prompt = args.length ? toText(args[0]) : '';
+        if (self.io.onEcoute) {
+          const r = await self.io.onEcoute(prompt);
+          return r === null || r === undefined ? '' : String(r);
+        }
+        if (self.io.onInput) {
+          const r = await self.io.onInput(prompt + ' (micro indisponible — tape ta réponse) ');
+          return r === null || r === undefined ? '' : String(r);
+        }
+        return '';
+      });
+
+      // --- aides internes du mode Python (v11) ---
+      B('__plage', async (args, line) => {
+        self.need(args, 1, 'range', line);
+        const vals = args.map(a => Math.trunc(checkNumber(a, line, 'range()')));
+        let debut = 0, fin = 0, pas = 1;
+        if (vals.length === 1) { fin = vals[0]; }
+        else { debut = vals[0]; fin = vals[1]; if (vals.length > 2) pas = vals[2]; }
+        if (pas === 0) throw new LazError('range() : le pas ne peut pas être zéro', line);
+        const out = [];
+        if (pas > 0) { for (let v = debut; v < fin; v += pas) out.push(v); }
+        else { for (let v = debut; v > fin; v += pas) out.push(v); }
+        return out;
+      });
+      B('__ent', async (args, line) => {
+        self.need(args, 1, 'int', line);
+        const v = args[0];
+        if (v === true) return 1;
+        if (v === false) return 0;
+        if (typeof v === 'number') return Math.trunc(v);
+        if (typeof v === 'string') {
+          const f = parseFloat(v.trim().replace(',', '.'));
+          if (Number.isNaN(f) || !/^-?[\d.,]+$/.test(v.trim())) {
+            throw new LazError(`impossible de convertir « ${toText(v)} » en nombre entier`, line);
+          }
+          return Math.trunc(f);
+        }
+        throw new LazError('int() attend un nombre ou un texte', line);
+      });
+      B('__abs', async (args, line) => {
+        self.need(args, 1, 'abs', line);
+        return Math.abs(checkNumber(args[0], line, 'abs()'));
+      });
+
+      // --- nouveautés v10.0 : Larkhré QUANTIQUE ---
+      // Simulateur à vecteur d'état complet (nombres complexes [re, im]).
+      const etatQ = { n: 0, amp: [] };
+      const qRequis = (line) => {
+        if (etatQ.n === 0) throw new LazError('appelle d\'abord qubits(n) pour créer ton registre quantique', line);
+      };
+      const qBit = (idx, q) => (idx >> (etatQ.n - 1 - q)) & 1;
+      const qVerifie = (v, line, nom) => {
+        const q = Math.floor(checkNumber(v, line, nom));
+        if (q < 0 || q >= etatQ.n) throw new LazError(`${nom} : le qubit ${q} n'existe pas (registre de ${etatQ.n} qubits, numérotés de 0 à ${etatQ.n - 1})`, line);
+        return q;
+      };
+      const porte1q = (q, m00, m01, m10, m11) => {
+        const amp = etatQ.amp;
+        const pas = 2 ** (etatQ.n - 1 - q);
+        for (let i = 0; i < amp.length; i++) {
+          if (Math.floor(i / pas) % 2 === 0) {
+            const jdx = i + pas;
+            const a0 = amp[i], a1 = amp[jdx];
+            amp[i] = [m00 * a0[0] + m01 * a1[0], m00 * a0[1] + m01 * a1[1]];
+            amp[jdx] = [m10 * a0[0] + m11 * a1[0], m10 * a0[1] + m11 * a1[1]];
+          }
+        }
+      };
+      B('qubits', async (args, line) => {
+        self.need(args, 1, 'qubits', line);
+        const n = Math.floor(checkNumber(args[0], line, 'qubits()'));
+        if (n < 1 || n > 10) throw new LazError('qubits() : entre 1 et 10 qubits (chaque qubit DOUBLE la mémoire du simulateur !)', line);
+        etatQ.n = n;
+        etatQ.amp = Array.from({ length: 2 ** n }, () => [0, 0]);
+        etatQ.amp[0] = [1, 0];
+        return null;
+      });
+      B('superpose', async (args, line) => {
+        self.need(args, 1, 'superpose', line);
+        qRequis(line);
+        const q = qVerifie(args[0], line, 'superpose()');
+        const r = 1 / Math.sqrt(2);
+        porte1q(q, r, r, r, -r);
+        return null;
+      });
+      B('porte_x', async (args, line) => {
+        self.need(args, 1, 'porte_x', line);
+        qRequis(line);
+        porte1q(qVerifie(args[0], line, 'porte_x()'), 0, 1, 1, 0);
+        return null;
+      });
+      B('porte_z', async (args, line) => {
+        self.need(args, 1, 'porte_z', line);
+        qRequis(line);
+        porte1q(qVerifie(args[0], line, 'porte_z()'), 1, 0, 0, -1);
+        return null;
+      });
+      B('intrique', async (args, line) => {
+        self.need(args, 2, 'intrique', line);
+        qRequis(line);
+        const c = qVerifie(args[0], line, 'intrique()');
+        const t = qVerifie(args[1], line, 'intrique()');
+        if (c === t) throw new LazError('intrique() : le qubit de contrôle et la cible doivent être différents', line);
+        const amp = etatQ.amp;
+        const pas = 2 ** (etatQ.n - 1 - t);
+        for (let i = 0; i < amp.length; i++) {
+          if (qBit(i, c) === 1 && qBit(i, t) === 0) {
+            const jdx = i + pas;
+            const tmp = amp[i];
+            amp[i] = amp[jdx];
+            amp[jdx] = tmp;
+          }
+        }
+        return null;
+      });
+      B('mesure', async (args, line) => {
+        self.need(args, 1, 'mesure', line);
+        qRequis(line);
+        const q = qVerifie(args[0], line, 'mesure()');
+        const amp = etatQ.amp;
+        let p1 = 0;
+        for (let i = 0; i < amp.length; i++) {
+          if (qBit(i, q) === 1) p1 += amp[i][0] ** 2 + amp[i][1] ** 2;
+        }
+        const resultat = Math.random() < p1 ? 1 : 0;
+        let norme = 0;
+        for (let i = 0; i < amp.length; i++) {
+          if (qBit(i, q) !== resultat) amp[i] = [0, 0];
+          else norme += amp[i][0] ** 2 + amp[i][1] ** 2;
+        }
+        if (norme > 0) {
+          norme = Math.sqrt(norme);
+          for (let i = 0; i < amp.length; i++) amp[i] = [amp[i][0] / norme, amp[i][1] / norme];
+        }
+        return resultat;
+      });
+      B('probabilites', async (args, line) => {
+        qRequis(line);
+        const d = new Map();
+        for (let i = 0; i < etatQ.amp.length; i++) {
+          const p = etatQ.amp[i][0] ** 2 + etatQ.amp[i][1] ** 2;
+          if (p > 1e-9) d.set(i.toString(2).padStart(etatQ.n, '0'), Math.round(p * 10000) / 10000);
+        }
+        return d;
+      });
+
+      // --- nouveautés v7.0 : le MODE INTERFACE ---
+      const widget = (cmd) => { if (self.io.onWidget) self.io.onWidget(cmd); };
+      const nouvelId = (prefixe) => { self.compteurWidget++; return prefixe + '_' + self.compteurWidget; };
+      B('titre', async (args, line) => {
+        self.need(args, 1, 'titre', line);
+        self.aInterface = true;
+        widget({ type: 'titre', texte: toText(args[0]) });
+        return null;
+      });
+      B('etiquette', async (args) => {
+        self.aInterface = true;
+        const id = nouvelId('etq');
+        widget({ type: 'etiquette', id, texte: args.length ? toText(args[0]) : '' });
+        return id;
+      });
+      B('bouton', async (args, line) => {
+        self.need(args, 2, 'bouton', line);
+        if (!(args[1] instanceof LazFunction)) {
+          throw new LazError('bouton() attend un texte puis une fonction : bouton("OK", mon_action) — sans parenthèses après le nom de la fonction', line);
+        }
+        self.aInterface = true;
+        const id = nouvelId('btn');
+        self.actionsBoutons.set(id, args[1]);
+        widget({ type: 'bouton', id, texte: toText(args[0]) });
+        return id;
+      });
+      B('champ', async (args) => {
+        self.aInterface = true;
+        const id = nouvelId('chp');
+        widget({ type: 'champ', id, placeholder: args.length ? toText(args[0]) : '' });
+        return id;
+      });
+      B('valeur_de', async (args, line) => {
+        self.need(args, 1, 'valeur_de', line);
+        const v = self.io.getChampValeur ? self.io.getChampValeur(toText(args[0])) : '';
+        return v === null || v === undefined ? '' : String(v);
+      });
+      B('change_texte', async (args, line) => {
+        self.need(args, 2, 'change_texte', line);
+        widget({ type: 'maj', id: toText(args[0]), texte: toText(args[1]) });
+        return null;
+      });
+      B('efface_interface', async () => {
+        self.actionsBoutons.clear();
+        widget({ type: 'efface' });
+        return null;
+      });
+      B('joue_son', async (args, line) => {
+        self.need(args, 1, 'joue_son', line);
+        const nom = toText(args[0]).toLowerCase();
+        if (!SONS_CONNUS.includes(nom)) {
+          throw new LazError(`son inconnu « ${nom} » (disponibles : ${SONS_CONNUS.join(', ')})`, line);
+        }
+        if (self.io.onSon) { try { self.io.onSon(nom); } catch (e) { } }
+        return null;
+      });
+    }
+
+    async run(source) {
+      // v11 : le mode PYTHON BIENVEILLANT
+      if (estModePython(source)) {
+        MODE_PYTHON.actif = true;
+        const ast = parsePython(source);
+        return await this.execBlock(ast, this.globals);
+      }
+      MODE_PYTHON.actif = false;
+      const langueMap = detecteLangue(source);
+      const tokens = tokenize(source, langueMap);
+      const ast = new Parser(tokens).parseProgram();
+      return await this.execBlock(ast, this.globals);
+    }
+
+    collecteGarde() {
+      const jsonOk = (v) => v === null || ['number', 'string', 'boolean'].includes(typeof v)
+        || (Array.isArray(v) && v.every(jsonOk));
+      const out = {};
+      for (const n of this.gardeNoms) {
+        if (this.globals.vars.has(n)) {
+          const v = this.globals.vars.get(n);
+          if (jsonOk(v)) out[n] = v;
+        }
+      }
+      return out;
+    }
+
+    async execBlock(block, env) {
+      let result = null;
+      for (const stmt of block[1]) result = await this.execStmt(stmt, env);
+      return result;
+    }
+
+    async execStmt(stmt, env) {
+      const kind = stmt[0];
+      this.tick(stmt[stmt.length - 1]);
+      // laisser le navigateur respirer (bouton Arrêter, affichage) sur les gros programmes
+      if ((this.steps & 8191) === 0 && this.io.onYield) await this.io.onYield();
+      // v5 : le ralenti pédagogique
+      if (this.vitesse > 0) {
+        if (this.io.onStep) await this.io.onStep(stmt[stmt.length - 1], this.snapshot(), this.vitesse * 1000);
+        else await new Promise(r => setTimeout(r, this.vitesse * 1000));
+      }
+
+      if (kind === 'declare') {
+        const value = await this.eval(stmt[2], env);
+        env.declare(stmt[1], value);
+        this.noteHistoire(stmt[3], stmt[1], value);
+        return null;
+      }
+      if (kind === 'garde') {
+        const [, name, valueNode, line] = stmt;
+        this.gardeNoms.add(name);
+        let value;
+        if (Object.prototype.hasOwnProperty.call(this.memoire, name)) value = this.memoire[name];
+        else value = await this.eval(valueNode, env);
+        env.declare(name, value);
+        this.noteHistoire(line, name, value);
+        return null;
+      }
+      if (kind === 'assign') {
+        const value = await this.eval(stmt[2], env);
+        env.assign(stmt[1], value, stmt[3]);
+        this.noteHistoire(stmt[3], stmt[1], value);
+        return null;
+      }
+      if (kind === 'assign_index') {
+        const [, targetNode, indexNode, valueNode, line] = stmt;
+        const target = await this.eval(targetNode, env);
+        const index = await this.eval(indexNode, env);
+        const value = await this.eval(valueNode, env);
+        if (target instanceof Map) {
+          target.set(checkDictKey(index, line), value);
+          return null;
+        }
+        if (!Array.isArray(target)) throw new LazError('on ne peut modifier par position que les listes et les dictionnaires', line);
+        let idx = Math.trunc(checkNumber(index, line, "l'indexation"));
+        if (idx < -target.length || idx >= target.length) {
+          throw new LazError(`position ${idx} hors de la liste (taille ${target.length})`, line);
+        }
+        if (idx < 0) idx += target.length;
+        target[idx] = value;
+        return null;
+      }
+      if (kind === 'assign_attr') {
+        const [, objNode, name, valueNode, line] = stmt;
+        const obj = await this.eval(objNode, env);
+        if (!(obj instanceof LazInstance)) {
+          throw new LazError('on ne peut modifier une propriété (avec le point .) que sur un objet de klas', line);
+        }
+        obj.fields.set(name, await this.eval(valueNode, env));
+        return null;
+      }
+      if (kind === 'klas') {
+        const [, name, parentName, methods, line] = stmt;
+        let parent = null;
+        if (parentName) {
+          parent = env.get(parentName, line);
+          if (!(parent instanceof LazClass)) {
+            throw new LazError(`« ${parentName} » n'est pas une klas, impossible d'en hériter`, line);
+          }
+        }
+        const mmap = new Map();
+        for (const [mname, params, body] of methods) {
+          mmap.set(mname, new LazFunction(mname, params, body, env));
+        }
+        env.declare(name, new LazClass(name, mmap, parent));
+        return null;
+      }
+      if (kind === 'importe') {
+        throw new LazError("importe n'est pas disponible dans le playground web — utilise la version Python (pip install larkhre)", stmt[2]);
+      }
+      if (kind === 'essaie') {
+        const [, body, errname, handler] = stmt;
+        try {
+          await this.execBlock(body, env);
+        } catch (e) {
+          if (e instanceof LazError) {
+            env.declare(errname, e.lazMessage);
+            await this.execBlock(handler, env);
+          } else {
+            throw e;
+          }
+        }
+        return null;
+      }
+      if (kind === 'fonk') {
+        env.declare(stmt[1], new LazFunction(stmt[1], stmt[2], stmt[3], env));
+        return null;
+      }
+      if (kind === 'kan') {
+        const [, cond, body, elseBranch] = stmt;
+        if (isTruthy(await this.eval(cond, env))) await this.execBlock(body, env);
+        else if (elseBranch) await this.execBlock(elseBranch, env);
+        return null;
+      }
+      if (kind === 'tanke') {
+        const [, cond, body, line] = stmt;
+        while (isTruthy(await this.eval(cond, env))) {
+          this.tick(line);
+          try { await this.execBlock(body, env); }
+          catch (e) {
+            if (e instanceof BreakEx) break;
+            if (e instanceof ContinueEx) continue;
+            throw e;
+          }
+        }
+        return null;
+      }
+      if (kind === 'pou') {
+        const [, varName, iterableNode, body, line] = stmt;
+        let iterable = await this.eval(iterableNode, env);
+        if (typeof iterable === 'string') iterable = iterable.split('');
+        if (iterable instanceof Map) iterable = [...iterable.keys()];
+        if (!Array.isArray(iterable)) {
+          throw new LazError('« pou ... dan ... » demande une liste, un intervalle (1..10), un texte ou un dictionnaire', line);
+        }
+        env.declare(varName, null);
+        for (const item of iterable) {
+          this.tick(line);
+          env.vars.set(varName, item);
+          try { await this.execBlock(body, env); }
+          catch (e) {
+            if (e instanceof BreakEx) break;
+            if (e instanceof ContinueEx) continue;
+            throw e;
+          }
+        }
+        return null;
+      }
+      if (kind === 'rend') {
+        const value = stmt[1] !== null ? await this.eval(stmt[1], env) : null;
+        throw new ReturnEx(value);
+      }
+      if (kind === 'kase') throw new BreakEx();
+      if (kind === 'swiv') throw new ContinueEx();
+      if (kind === 'expr') return await this.eval(stmt[1], env);
+
+      throw new LazError(`instruction inconnue : ${kind}`);
+    }
+
+    async eval(node, env) {
+      const kind = node[0];
+      this.tick();
+
+      if (kind === 'num' || kind === 'bool') return node[1];
+      if (kind === 'str') return interpolate(node[1], env);
+      if (kind === 'walu') return null;
+      if (kind === 'var') return env.get(node[1], node[2]);
+      if (kind === 'list') {
+        const out = [];
+        for (const item of node[1]) out.push(await this.eval(item, env));
+        return out;
+      }
+      if (kind === 'dict') {
+        const [, pairs, line] = node;
+        const d = new Map();
+        for (const [knode, vnode] of pairs) {
+          const k = checkDictKey(await this.eval(knode, env), line);
+          d.set(k, await this.eval(vnode, env));
+        }
+        return d;
+      }
+      if (kind === 'attr') {
+        const [, objNode, name, line] = node;
+        const obj = await this.eval(objNode, env);
+        if (obj instanceof LazInstance) {
+          if (obj.fields.has(name)) return obj.fields.get(name);
+          const m = obj.klass.findMethod(name);
+          if (m) return new BoundMethod(m, obj);
+          throw new LazError(`« ${name} » n'existe pas dans cet objet de klas ${obj.klass.name}`, line);
+        }
+        throw new LazError(`le point (.${name}) s'utilise sur un objet créé avec une klas`, line);
+      }
+      if (kind === 'range') {
+        const [, startNode, endNode, line] = node;
+        const start = Math.trunc(checkNumber(await this.eval(startNode, env), line, "l'intervalle .."));
+        const end = Math.trunc(checkNumber(await this.eval(endNode, env), line, "l'intervalle .."));
+        const step = end >= start ? 1 : -1;
+        const out = [];
+        for (let v = start; step > 0 ? v <= end : v >= end; v += step) {
+          out.push(v);
+          if (out.length > 1000000) throw new LazError('intervalle trop grand (plus d\'un million d\'éléments)', line);
+        }
+        return out;
+      }
+      if (kind === 'or') {
+        const left = await this.eval(node[1], env);
+        if (isTruthy(left)) return left;
+        return await this.eval(node[2], env);
+      }
+      if (kind === 'and') {
+        const left = await this.eval(node[1], env);
+        if (!isTruthy(left)) return left;
+        return await this.eval(node[2], env);
+      }
+      if (kind === 'not') return !isTruthy(await this.eval(node[1], env));
+      if (kind === 'neg') {
+        return -checkNumber(await this.eval(node[1], env), node[2], 'le signe -');
+      }
+      if (kind === 'cmp') {
+        const [, op, leftNode, rightNode, line] = node;
+        const left = await this.eval(leftNode, env);
+        const right = await this.eval(rightNode, env);
+        if (op === '==') return lazEquals(left, right);
+        if (op === '!=') return !lazEquals(left, right);
+        if (!(typeof left === 'string' && typeof right === 'string')) {
+          checkNumber(left, line, `la comparaison ${op}`);
+          checkNumber(right, line, `la comparaison ${op}`);
+        }
+        if (op === '<') return left < right;
+        if (op === '>') return left > right;
+        if (op === '<=') return left <= right;
+        if (op === '>=') return left >= right;
+      }
+      if (kind === 'binop') {
+        const [, op, leftNode, rightNode, line] = node;
+        const left = await this.eval(leftNode, env);
+        const right = await this.eval(rightNode, env);
+        if (op === '+') {
+          if (typeof left === 'string' || typeof right === 'string') return toText(left) + toText(right);
+          if (Array.isArray(left) && Array.isArray(right)) return left.concat(right);
+          checkNumber(left, line, "l'addition +");
+          checkNumber(right, line, "l'addition +");
+          return left + right;
+        }
+        checkNumber(left, line, `l'opération ${op}`);
+        checkNumber(right, line, `l'opération ${op}`);
+        if (op === '-') return left - right;
+        if (op === '*') return left * right;
+        if (op === '/') {
+          if (right === 0) throw new LazError('division par zéro impossible', line);
+          return left / right;
+        }
+        if (op === '%') {
+          if (right === 0) throw new LazError('modulo par zéro impossible', line);
+          // modulo « à la Python » : toujours du signe du diviseur
+          return ((left % right) + right) % right;
+        }
+        if (op === '//') {
+          if (right === 0) throw new LazError('division par zéro impossible', line);
+          return Math.floor(left / right);
+        }
+        if (op === '**') {
+          return Math.pow(left, right);
+        }
+      }
+      if (kind === 'index') {
+        const [, targetNode, indexNode, line] = node;
+        const target = await this.eval(targetNode, env);
+        const index = await this.eval(indexNode, env);
+        if (target instanceof Map) {
+          const k = checkDictKey(index, line);
+          if (!target.has(k)) throw new LazError(`la clé « ${toText(k)} » n'existe pas dans le dictionnaire`, line);
+          return target.get(k);
+        }
+        if (!(Array.isArray(target) || typeof target === 'string')) {
+          throw new LazError('on ne peut indexer que les listes, les textes et les dictionnaires', line);
+        }
+        let idx = Math.trunc(checkNumber(index, line, "l'indexation"));
+        if (idx < -target.length || idx >= target.length) {
+          throw new LazError(`position ${idx} hors limites (taille ${target.length})`, line);
+        }
+        if (idx < 0) idx += target.length;
+        return target[idx];
+      }
+      if (kind === 'call') {
+        const [, calleeNode, argNodes, line] = node;
+        const callee = await this.eval(calleeNode, env);
+        const args = [];
+        for (const a of argNodes) args.push(await this.eval(a, env));
+
+        if (callee && callee.builtin) return await callee.fn(args, line);
+
+        if (callee instanceof LazFunction) {
+          if (args.length !== callee.params.length) {
+            throw new LazError(
+              `la fonction « ${callee.name} » attend ${callee.params.length} argument(s), reçu ${args.length}`, line);
+          }
+          return await this.callFunction(callee, args);
+        }
+
+        if (callee instanceof BoundMethod) {
+          const fn = callee.fn;
+          const expected = fn.params.length - 1;
+          if (args.length !== expected) {
+            throw new LazError(`la fonction « ${fn.name} » attend ${expected} argument(s), reçu ${args.length}`, line);
+          }
+          return await this.callFunction(fn, [callee.instance, ...args]);
+        }
+
+        if (callee instanceof LazClass) {
+          const inst = new LazInstance(callee);
+          const init = callee.findMethod('init');
+          if (init) {
+            const expected = init.params.length - 1;
+            if (args.length !== expected) {
+              throw new LazError(`la klas « ${callee.name} » attend ${expected} argument(s) pour init, reçu ${args.length}`, line);
+            }
+            await this.callFunction(init, [inst, ...args]);
+          } else if (args.length) {
+            throw new LazError(`la klas « ${callee.name} » n'a pas de fonction init : on l'appelle sans argument`, line);
+          }
+          return inst;
+        }
+
+        throw new LazError(`« ${toText(callee)} » n'est pas une fonction`, line);
+      }
+      throw new LazError(`expression inconnue : ${kind}`);
+    }
+
+    async callFunction(fn, args) {
+      const callEnv = new Env(fn.env);
+      for (let i = 0; i < args.length; i++) callEnv.declare(fn.params[i], args[i]);
+      try {
+        await this.execBlock(fn.body, callEnv);
+      } catch (e) {
+        if (e instanceof ReturnEx) return e.value;
+        throw e;
+      }
+      return null;
+    }
+  }
+
+  function lazEquals(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) if (!lazEquals(a[i], b[i])) return false;
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) return false;
+      for (const [k, v] of a.entries()) {
+        if (!b.has(k) || !lazEquals(v, b.get(k))) return false;
+      }
+      return true;
+    }
+    return a === b;
+  }
+
+  function svgDuDessin(t) {
+    const fmt = (v) => numText(v);
+    const W = fmt(t.w), H = fmt(t.h);
+    const out = [`<svg xmlns='http://www.w3.org/2000/svg' width='${W}' height='${H}' viewBox='0 0 ${W} ${H}'>`];
+    out.push(`<rect width='${W}' height='${H}' fill='#0d1117'/>`);
+    for (const f of t.formes) {
+      const k = f[0];
+      if (k === 'fond') {
+        out.push(`<rect width='${W}' height='${H}' fill='${f[1]}'/>`);
+      } else if (k === 'ligne') {
+        out.push(`<line x1='${fmt(f[1])}' y1='${fmt(f[2])}' x2='${fmt(f[3])}' y2='${fmt(f[4])}' stroke='${f[5]}' stroke-width='3' stroke-linecap='round'/>`);
+      } else if (k === 'rect') {
+        const remplir = f[6] ? f[5] : 'none';
+        const contour = f[6] ? '' : ` stroke='${f[5]}' stroke-width='3'`;
+        out.push(`<rect x='${fmt(f[1])}' y='${fmt(f[2])}' width='${fmt(f[3])}' height='${fmt(f[4])}' fill='${remplir}'${contour}/>`);
+      } else if (k === 'cercle') {
+        const remplir = f[5] ? f[4] : 'none';
+        const contour = f[5] ? '' : ` stroke='${f[4]}' stroke-width='3'`;
+        out.push(`<circle cx='${fmt(f[1])}' cy='${fmt(f[2])}' r='${fmt(f[3])}' fill='${remplir}'${contour}/>`);
+      } else if (k === 'texte') {
+        const txt = f[3].replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        out.push(`<text x='${fmt(f[1])}' y='${fmt(f[2])}' fill='${f[4]}' font-family='monospace' font-size='16'>${txt}</text>`);
+      }
+    }
+    out.push('</svg>');
+    return out.join('\n');
+  }
+
+  function checkDictKey(k, line) {
+    if (!(typeof k === 'string' || typeof k === 'number')) {
+      throw new LazError("les clés d'un dictionnaire doivent être des textes ou des nombres", line);
+    }
+    return k;
+  }
+
+  // ---------------- API PUBLIQUE ----------------
+  async function run(source, io) {
+    const interp = new Interpreter(io || {
+      onPrint: (t) => console.log(t),
+      onInput: async () => '',
+      shouldStop: () => false,
+    });
+    try {
+      await interp.run(source);
+      // v6/v7 : si chaque_image() a été appelé OU si une interface existe,
+      // le programme reste vivant : boucle d'images + clics de boutons
+      if (interp.frameFn || interp.aInterface) {
+        if (interp.io.onJeuDemarre) interp.io.onJeuDemarre(interp.frameFn ? 'jeu' : 'interface');
+        while (!interp.jeuFini) {
+          if (interp.io.shouldStop && interp.io.shouldStop()) throw new StopEx();
+          interp.steps = 0; // chaque tour repart de zéro (l'appli peut durer des heures)
+          // v7 : les clics de boutons en attente
+          const clics = interp.io.prendClics ? interp.io.prendClics() : [];
+          for (const id of clics) {
+            const action = interp.actionsBoutons.get(id);
+            if (action) await interp.callFunction(action, []);
+          }
+          if (interp.frameFn) await interp.callFunction(interp.frameFn, []);
+          if (interp.io.onFrame) await interp.io.onFrame();
+          else await new Promise(r => setTimeout(r, 33));
+        }
+        if (interp.io.onJeuTermine) interp.io.onJeuTermine();
+      }
+      if (interp.gardeNoms.size && interp.io.onSauveMemoire) {
+        interp.io.onSauveMemoire(interp.collecteGarde());
+      }
+      return { ok: true };
+    } catch (e) {
+      if (interp.gardeNoms.size && interp.io.onSauveMemoire) {
+        try { interp.io.onSauveMemoire(interp.collecteGarde()); } catch (e2) { }
+      }
+      if (e instanceof StopEx) return { ok: false, stopped: true };
+      if (e instanceof LazError) return { ok: false, error: e.toString(), histoire: interp.histoire };
+      if (e instanceof ReturnEx) return { ok: true };
+      if (e instanceof BreakEx || e instanceof ContinueEx) {
+        return { ok: false, error: '✘ Erreur Larkhré : « kase » et « swiv » ne s\'utilisent que dans une boucle' };
+      }
+      if (e instanceof RangeError) {
+        return { ok: false, error: '✘ Erreur Larkhré : récursion trop profonde (boucle infinie ?)' };
+      }
+      return { ok: false, error: '✘ Erreur Larkhré : ' + (e.message || String(e)) };
+    }
+  }
+
+  return { run, toText, LazError, version: '11.1' };
+})();
+
+if (typeof module !== 'undefined' && module.exports) module.exports = Larkhre;