botql 1.1.2 → 1.2.2

package/botql.browser.js

@@ -22,23 +22,29 @@ var BotQL = (() => {
       var TokenType = { KEYWORD: "KEYWORD", STRING: "STRING", NUMBER: "NUMBER", IDENT: "IDENT", SYMBOL: "SYMBOL", EOF: "EOF" };
       var KEYWORDS = /* @__PURE__ */ new Set(["CREATE", "BOT", "PLATFORM", "CONNECT", "TABLE", "PREVENT", "DEFAULT", "ON", "START", "MESSAGE", "FROM", "WHEN", "CONTAINS", "OR", "OTHERWISE", "KEYWORDS", "THINK", "WAITING", "REPLY", "TO", "FORWARD", "PARSE", "SEND", "INSERT", "INTO", "VALUES", "UPDATE", "SET", "WHERE", "RUN", "IMPORT", "AS", "RESPONSE"]);
       var Token = class {
-        constructor(e, t, s) {
-          this.type = e, this.value = t, this.line = s;
+        constructor(e, t, s, r, i) {
+          this.type = e, this.value = t, this.line = s, this.start = r, this.end = i;
+        }
+      };
+      var BotQLSyntaxError = class extends Error {
+        constructor(e, { line: t = null, start: s = 0, end: r = null, near: i = null } = {}) {
+          super(e), this.name = "BotQLSyntaxError", this.line = t, this.start = s, this.end = null === r ? s + 1 : r, this.near = i;
         }
       };
       var Tokenizer = class {
         constructor(e) {
           this.source = e, this.pos = 0, this.line = 1, this.tokens = [];
         }
-        error(e) {
-          throw Error(`syntax error: ${e}`);
+        error(e, t, s) {
+          let r = void 0 !== t ? t : this.pos;
+          throw new BotQLSyntaxError(`syntax error: ${e}`, { line: this.line, start: r, end: s });
         }
         peekChar(e = 0) {
           return this.source[this.pos + e];
         }
         tokenize() {
           for (; this.pos < this.source.length; ) {
-            let e = this.peekChar();
+            let e = this.peekChar(), t = this.pos;
             if ("\n" === e) {
               this.line++, this.pos++;
               continue;
@@ -51,39 +57,24 @@ var BotQL = (() => {
               for (; this.pos < this.source.length && "\n" !== this.peekChar(); ) this.pos++;
               continue;
             }
-            if ('"' === e || "'" === e) {
-              this.tokens.push(this.readString(e));
-              continue;
-            }
-            if (/[0-9]/.test(e)) {
-              this.tokens.push(this.readNumber());
-              continue;
-            }
-            if ("{}(),.=+*;".includes(e)) {
-              this.tokens.push(new Token(TokenType.SYMBOL, e, this.line)), this.pos++;
-              continue;
-            }
-            if (/[A-Za-z_]/.test(e)) {
-              let t = this.readWord();
-              this.tokens.push(t);
-              continue;
-            }
-            this.error(`unexpected character: "${e}"`);
+            let s;
+            '"' === e || "'" === e ? s = this.readString(e) : /[0-9]/.test(e) ? s = this.readNumber() : "{}(),.=+*;".includes(e) ? (s = new Token(TokenType.SYMBOL, e, this.line), this.pos++) : /[A-Za-z_]/.test(e) ? s = this.readWord() : this.error(`unexpected character: "${e}"`, t, t + 1), s.start = t, s.end = this.pos, this.tokens.push(s);
           }
-          return this.tokens.push(new Token(TokenType.EOF, null, this.line)), this.tokens;
+          let r = this.source.length, i = new Token(TokenType.EOF, null, this.line, r, r);
+          return this.tokens.push(i), this.tokens;
         }
         readString(e) {
-          let t = this.line;
+          let t = this.line, s = this.pos;
           this.pos++;
-          let s = "";
+          let r = "";
           for (; this.pos < this.source.length && this.peekChar() !== e; ) {
             if ("\\" === this.peekChar()) {
-              this.pos++, s += this.peekChar(), this.pos++;
+              this.pos++, r += this.peekChar(), this.pos++;
               continue;
             }
-            "\n" === this.peekChar() && this.line++, s += this.peekChar(), this.pos++;
+            "\n" === this.peekChar() && this.line++, r += this.peekChar(), this.pos++;
           }
-          return this.peekChar() !== e && this.error("unterminated string"), this.pos++, new Token(TokenType.STRING, s, t);
+          return this.peekChar() !== e && this.error("unterminated string", s, this.pos), this.pos++, new Token(TokenType.STRING, r, t);
         }
         readNumber() {
           let e = this.line, t = "";
@@ -99,11 +90,11 @@ var BotQL = (() => {
       };
       var Parser = class {
         constructor(e) {
-          this.tokens = new Tokenizer(e).tokenize(), this.pos = 0;
+          this.source = e, this.tokens = new Tokenizer(e).tokenize(), this.pos = 0;
         }
         error(e) {
-          let t = this.current();
-          throw Error(`syntax error: ${e}, near "${t ? t.value : "EOF"}"`);
+          let t = this.current(), s = t && t.type !== TokenType.EOF ? t.value : "EOF", r = t ? t.start : this.source.length, i = t ? t.end : this.source.length;
+          throw new BotQLSyntaxError(`syntax error: ${e}, near "${s}"`, { line: t ? t.line : null, start: r, end: i, near: s });
         }
         current() {
           return this.tokens[this.pos];
@@ -147,7 +138,7 @@ var BotQL = (() => {
           return [this.parseStatement()];
         }
         parseStatement() {
-          return this.atKeyword("CREATE") ? this.parseCreate() : this.atKeyword("PLATFORM") ? this.parsePlatform() : this.atKeyword("CONNECT") ? this.parseConnect() : this.atKeyword("ON") ? this.parseOn() : this.atKeyword("WHEN") ? this.parseWhen() : this.atKeyword("OTHERWISE") ? this.parseOtherwise() : this.atKeyword("REPLY") ? this.parseReply() : this.atKeyword("THINK") ? this.parseThink() : this.atKeyword("FORWARD") ? this.parseForward() : this.atKeyword("PARSE") ? this.parseParseSignal() : this.atKeyword("SEND") ? this.parseSend() : this.atKeyword("INSERT") ? this.parseInsert() : this.atKeyword("UPDATE") ? this.parseUpdate() : this.atKeyword("RUN") ? this.parseRunBot() : this.atKeyword("IMPORT") ? this.parseImport() : void this.error("unexpected statement");
+          return this.atKeyword("CREATE") ? this.parseCreate() : this.atKeyword("PLATFORM") ? this.parsePlatform() : this.atKeyword("CONNECT") ? this.parseConnect() : this.atKeyword("ON") ? this.parseOn() : this.atKeyword("WHEN") ? this.parseWhen() : this.atKeyword("OTHERWISE") ? this.parseOtherwise() : this.atKeyword("REPLY") ? this.parseReply() : this.atKeyword("THINK") ? this.parseThink() : this.atKeyword("WAITING") ? this.parseWaitingStatement() : this.atKeyword("FORWARD") ? this.parseForward() : this.atKeyword("PARSE") ? this.parseParseSignal() : this.atKeyword("SEND") ? this.parseSend() : this.atKeyword("INSERT") ? this.parseInsert() : this.atKeyword("UPDATE") ? this.parseUpdate() : this.atKeyword("RUN") ? this.parseRunBot() : this.atKeyword("IMPORT") ? this.parseImport() : void this.error("unexpected statement");
         }
         parseCreate() {
           if (this.expectKeyword("CREATE"), this.atKeyword("BOT")) {
@@ -270,8 +261,12 @@ var BotQL = (() => {
         tryParseWaiting() {
           if (!this.atKeyword("WAITING")) return null;
           this.advance(), this.expect(TokenType.SYMBOL, "(");
-          let e = null, t = null;
-          return !this.at(TokenType.SYMBOL, ")") && (e = this.parseFileName(), this.at(TokenType.SYMBOL, ",") && (this.advance(), t = this.parseExpression())), this.expect(TokenType.SYMBOL, ")"), { file: e, seconds: t };
+          let e = null, t = null, s = null;
+          return !this.at(TokenType.SYMBOL, ")") && (this.at(TokenType.STRING) ? t = this.advance().value : e = this.parseFileName(), this.at(TokenType.SYMBOL, ",") && (this.advance(), s = this.parseExpression())), this.expect(TokenType.SYMBOL, ")"), { file: e, text: t, seconds: s };
+        }
+        parseWaitingStatement() {
+          let e = this.tryParseWaiting();
+          return { type: "Waiting", file: e.file, text: e.text, seconds: e.seconds };
         }
         parseReply() {
           this.expectKeyword("REPLY");
@@ -374,7 +369,7 @@ var BotQL = (() => {
           this.error("invalid expression");
         }
       };
-      module.exports = { Parser, Tokenizer, TokenType, KEYWORDS };
+      module.exports = { Parser, Tokenizer, TokenType, KEYWORDS, BotQLSyntaxError };
     }
   });
 
@@ -530,505 +525,221 @@ var BotQL = (() => {
   var require_RAG = __commonJS({
     "RAG.js"(exports, module) {
       "use strict";
-      var STOPWORDS = /* @__PURE__ */ new Set([
-        "a",
-        "o",
-        "as",
-        "os",
-        "de",
-        "da",
-        "do",
-        "das",
-        "dos",
-        "e",
-        "ou",
-        "que",
-        "um",
-        "uma",
-        "uns",
-        "umas",
-        "em",
-        "no",
-        "na",
-        "nos",
-        "nas",
-        "por",
-        "para",
-        "com",
-        "sem",
-        "se",
-        "foi",
-        "ser",
-        "sao",
-        "esta",
-        "estao",
-        "ao",
-        "aos",
-        "mas",
-        "como",
-        "tem",
-        "ter",
-        "nao",
-        "sim",
-        "meu",
-        "minha",
-        "seu",
-        "sua",
-        "eu",
-        "tu",
-        "ele",
-        "ela",
-        "nos",
-        "vos",
-        "eles",
-        "elas",
-        "isso",
-        "isto",
-        "aquilo",
-        "quando",
-        "onde",
-        "porque",
-        "qual",
-        "quais",
-        "muito",
-        "muita",
-        "ja",
-        "so"
-      ]);
-      function normalizar(texto) {
-        return texto.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+      var STOPWORDS = /* @__PURE__ */ new Set(["a", "o", "as", "os", "de", "da", "do", "das", "dos", "e", "ou", "que", "um", "uma", "uns", "umas", "em", "no", "na", "nos", "nas", "por", "para", "com", "sem", "se", "foi", "ser", "sao", "esta", "estao", "ao", "aos", "mas", "como", "tem", "ter", "nao", "sim", "meu", "minha", "seu", "sua", "eu", "tu", "ele", "ela", "nos", "vos", "eles", "elas", "isso", "isto", "aquilo", "quando", "onde", "porque", "qual", "quais", "muito", "muita", "ja", "so"]);
+      function normalizar(e) {
+        return e.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
       }
       var SUFIXOS_ADJETIVO_ADVERBIO = ["issimamente", "issimo", "issima", "mente"];
       var SUFIXOS_NOMINALIZACAO = ["acoes", "acao", "imentos", "imento", "idades", "idade"];
-      function stem(palavra) {
-        let p = palavra;
-        for (const suf of SUFIXOS_ADJETIVO_ADVERBIO) {
-          if (p.length > suf.length + 3 && p.endsWith(suf)) {
-            p = p.slice(0, -suf.length);
-            break;
-          }
+      function stem(e) {
+        let t = e;
+        for (let i of SUFIXOS_ADJETIVO_ADVERBIO) if (t.length > i.length + 3 && t.endsWith(i)) {
+          t = t.slice(0, -i.length);
+          break;
         }
-        for (const suf of SUFIXOS_NOMINALIZACAO) {
-          if (p.length > suf.length + 3 && p.endsWith(suf)) {
-            p = p.slice(0, -suf.length);
-            break;
-          }
+        for (let o of SUFIXOS_NOMINALIZACAO) if (t.length > o.length + 3 && t.endsWith(o)) {
+          t = t.slice(0, -o.length);
+          break;
         }
-        if (p.length > 4 && p.endsWith("s") && !p.endsWith("ns")) {
-          p = p.slice(0, -1);
-        }
-        return p;
+        return t.length > 4 && t.endsWith("s") && !t.endsWith("ns") && (t = t.slice(0, -1)), t;
       }
-      function tokenizar(texto) {
-        return normalizar(texto).toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((palavra) => palavra.length > 1 && !STOPWORDS.has(palavra)).map(stem);
+      function tokenizar(e) {
+        return normalizar(e).toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((e2) => e2.length > 1 && !STOPWORDS.has(e2)).map(stem);
       }
-      function distanciaEdicao(a, b) {
-        if (a === b) return 0;
-        const la = a.length;
-        const lb = b.length;
-        if (la === 0) return lb;
-        if (lb === 0) return la;
-        let linhaAnterior = new Array(lb + 1);
-        for (let j = 0; j <= lb; j++) linhaAnterior[j] = j;
-        for (let i = 1; i <= la; i++) {
-          const linhaAtual = [i];
-          for (let j = 1; j <= lb; j++) {
-            const custo = a[i - 1] === b[j - 1] ? 0 : 1;
-            linhaAtual[j] = Math.min(
-              linhaAtual[j - 1] + 1,
-              linhaAnterior[j] + 1,
-              linhaAnterior[j - 1] + custo
-            );
+      function distanciaEdicao(e, t) {
+        if (e === t) return 0;
+        let i = e.length, o = t.length;
+        if (0 === i) return o;
+        if (0 === o) return i;
+        let s = Array(o + 1);
+        for (let r = 0; r <= o; r++) s[r] = r;
+        for (let n = 1; n <= i; n++) {
+          let a = [n];
+          for (let l = 1; l <= o; l++) {
+            let c = e[n - 1] === t[l - 1] ? 0 : 1;
+            a[l] = Math.min(a[l - 1] + 1, s[l] + 1, s[l - 1] + c);
           }
-          linhaAnterior = linhaAtual;
+          s = a;
         }
-        return linhaAnterior[lb];
+        return s[o];
       }
-      function distanciaMaximaTolerada(tamanho) {
-        if (tamanho <= 4) return 0;
-        if (tamanho <= 7) return 1;
-        return 2;
+      function distanciaMaximaTolerada(e) {
+        return e <= 4 ? 0 : e <= 7 ? 1 : 2;
       }
-      var BM25_K1 = 1.5;
-      var BM25_B = 0.75;
-      var PESO_BM25 = 1;
-      var PESO_FRASE = 2.5;
-      var PESO_FUZZY = 0.4;
-      var CONFIANCA_ALTA = 0.55;
-      var CONFIANCA_MINIMA = 0.15;
-      var MARGEM_MINIMA = 0.12;
-      var SIMILARIDADE_DUPLICADA = 0.75;
-      function extrairNomesProprios(texto) {
-        const palavras = texto.split(/\s+/);
-        const encontrados = [];
-        for (let i = 1; i < palavras.length; i++) {
-          const limpa = palavras[i].replace(/^[(["']+|[.,;:!?)\]"']+$/g, "");
-          if (/^[A-ZÀ-Ý][a-zà-ÿ]+$/.test(limpa)) {
-            encontrados.push(limpa);
-          }
+      function extrairNomesProprios(e) {
+        let t = e.split(/\s+/), i = [];
+        for (let o = 1; o < t.length; o++) {
+          let s = t[o].replace(/^[(["']+|[.,;:!?)\]"']+$/g, "");
+          /^[A-ZÀ-Ý][a-zà-ÿ]+$/.test(s) && i.push(s);
         }
-        return encontrados;
+        return i;
       }
       var KnowledgeIndex = class _KnowledgeIndex {
-        /**
-        * @param {string} sourceText Conteúdo do ficheiro de conhecimento.
-        * @param {Object} [options]
-        * @param {Record<string,string>} [options.synonyms] Mapa de termo -> termo
-        *   canónico, para ligar manualmente palavras que o stemmer não junta
-        *   sozinho (ex: { horas: 'horario' }).
-        */
-        constructor(sourceText, options = {}) {
-          this.synonyms = {};
-          for (const [de, para] of Object.entries(options.synonyms || {})) {
-            this.synonyms[stem(normalizar(de.toLowerCase()))] = stem(normalizar(para.toLowerCase()));
-          }
-          this.blocks = _KnowledgeIndex.parseBlocks(sourceText);
-          this._buildIndex();
+        constructor(e, t = {}) {
+          for (let [i, o] of (this.synonyms = {}, Object.entries(t.synonyms || {}))) this.synonyms[stem(normalizar(i.toLowerCase()))] = stem(normalizar(o.toLowerCase()));
+          this.blocks = _KnowledgeIndex.parseBlocks(e), this._buildIndex();
         }
-        static parseBlocks(sourceText) {
-          return sourceText.split(/\n\s*\n/).map((bloco) => bloco.trim()).filter((bloco) => bloco.length > 0);
+        static parseBlocks(e) {
+          return e.split(/\n\s*\n/).map((e2) => e2.trim()).filter((e2) => e2.length > 0);
         }
-        _aplicarSinonimos(tokens) {
-          return tokens.map((t) => this.synonyms[t] || t);
+        _aplicarSinonimos(e) {
+          return e.map((e2) => this.synonyms[e2] || e2);
         }
         _buildIndex() {
-          this.docs = this.blocks.map((bloco) => tokenizar(bloco));
-          this.docTextNormalizado = this.blocks.map((bloco) => normalizar(bloco).toLowerCase());
-          this.docFreq = /* @__PURE__ */ new Map();
-          this.vocabulario = /* @__PURE__ */ new Set();
-          for (const tokens of this.docs) {
-            const vistas = new Set(tokens);
-            for (const palavra of vistas) {
-              this.docFreq.set(palavra, (this.docFreq.get(palavra) || 0) + 1);
-              this.vocabulario.add(palavra);
-            }
+          for (let e of (this.docs = this.blocks.map((e2) => tokenizar(e2)), this.docTextNormalizado = this.blocks.map((e2) => normalizar(e2).toLowerCase()), this.docPalavrasSignificativas = this.blocks.map((e2) => this._palavrasSignificativas(e2)), this.docFreq = /* @__PURE__ */ new Map(), this.vocabulario = /* @__PURE__ */ new Set(), this.docs)) {
+            let t = new Set(e);
+            for (let i of t) this.docFreq.set(i, (this.docFreq.get(i) || 0) + 1), this.vocabulario.add(i);
           }
-          this.listaVocabulario = Array.from(this.vocabulario);
-          this.totalDocs = this.docs.length;
-          this.avgDocLen = this.totalDocs === 0 ? 0 : this.docs.reduce((soma, tokens) => soma + tokens.length, 0) / this.totalDocs;
-        }
-        _idf(palavra) {
-          const n = this.docFreq.get(palavra) || 0;
-          if (n === 0) return 0;
-          return Math.log(1 + (this.totalDocs - n + 0.5) / (n + 0.5));
-        }
-        _termoMaisProximo(termo) {
-          const tolerancia = distanciaMaximaTolerada(termo.length);
-          if (tolerancia === 0) return null;
-          let melhor = null;
-          let melhorDist = tolerancia + 1;
-          for (const candidato of this.listaVocabulario) {
-            if (Math.abs(candidato.length - termo.length) > tolerancia) continue;
-            const d = distanciaEdicao(termo, candidato);
-            if (d < melhorDist) {
-              melhorDist = d;
-              melhor = candidato;
-            }
+          this.listaVocabulario = Array.from(this.vocabulario), this.totalDocs = this.docs.length, this.avgDocLen = 0 === this.totalDocs ? 0 : this.docs.reduce((e, t) => e + t.length, 0) / this.totalDocs;
+        }
+        _idf(e) {
+          let t = this.docFreq.get(e) || 0;
+          return 0 === t ? 0 : Math.log(1 + (this.totalDocs - t + 0.5) / (t + 0.5));
+        }
+        _termoMaisProximo(e) {
+          let t = distanciaMaximaTolerada(e.length);
+          if (0 === t) return null;
+          let i = null, o = t + 1;
+          for (let s of this.listaVocabulario) {
+            if (Math.abs(s.length - e.length) > t) continue;
+            let r = distanciaEdicao(e, s);
+            r < o && (o = r, i = s);
           }
-          return melhorDist <= tolerancia ? melhor : null;
-        }
-        _scoreBM25(queryTokens, docIndex) {
-          const tokens = this.docs[docIndex];
-          if (tokens.length === 0) return 0;
-          const termFreq = /* @__PURE__ */ new Map();
-          for (const t of tokens) termFreq.set(t, (termFreq.get(t) || 0) + 1);
-          let score = 0;
-          for (const termo of queryTokens) {
-            let tf = termFreq.get(termo) || 0;
-            let idf = this._idf(termo);
-            let peso = 1;
-            if (tf === 0) {
-              const proximo = this._termoMaisProximo(termo);
-              if (proximo === null) continue;
-              tf = termFreq.get(proximo) || 0;
-              if (tf === 0) continue;
-              idf = this._idf(proximo);
-              peso = PESO_FUZZY;
+          return o <= t ? i : null;
+        }
+        _scoreBM25(e, t) {
+          let i = this.docs[t];
+          if (0 === i.length) return 0;
+          let o = /* @__PURE__ */ new Map();
+          for (let s of i) o.set(s, (o.get(s) || 0) + 1);
+          let r = 0;
+          for (let n of e) {
+            let a = o.get(n) || 0, l = this._idf(n), c = 1;
+            if (0 === a) {
+              let d = this._termoMaisProximo(n);
+              if (null === d || 0 === (a = o.get(d) || 0)) continue;
+              l = this._idf(d), c = 0.4;
             }
-            const numerador = tf * (BM25_K1 + 1);
-            const denominador = tf + BM25_K1 * (1 - BM25_B + BM25_B * (tokens.length / this.avgDocLen));
-            score += peso * idf * (numerador / denominador);
+            let h = 2.5 * a, u = a + 1.5 * (0.7 + 0.3 * (i.length / this.avgDocLen));
+            r += c * l * (h / u);
           }
-          return score;
-        }
-        _bonusFrase(message, docIndex) {
-          const msgNorm = normalizar(message).toLowerCase().replace(/[^a-z0-9\s]/g, " ");
-          const palavras = msgNorm.split(/\s+/).filter((p) => p.length > 1);
-          if (palavras.length < 2) return 0;
-          const textoBloco = this.docTextNormalizado[docIndex];
-          let bonus = 0;
-          for (let tamanho = Math.min(6, palavras.length); tamanho >= 2; tamanho--) {
-            for (let i = 0; i + tamanho <= palavras.length; i++) {
-              const frase = palavras.slice(i, i + tamanho).join(" ");
-              if (textoBloco.includes(frase)) {
-                bonus += tamanho * tamanho;
+          return r;
+        }
+        _palavrasSignificativas(e) {
+          return normalizar(e).toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((e2) => e2.length > 1 && !STOPWORDS.has(e2));
+        }
+        _bonusFrase(e, t) {
+          let i = this._palavrasSignificativas(e);
+          if (i.length < 2) return 0;
+          let o = this.docPalavrasSignificativas[t], s = 0;
+          for (let r = Math.min(6, i.length); r >= 2; r--) {
+            for (let n = 0; n + r <= i.length; n++) {
+              let a = i.slice(n, n + r);
+              if (this._contemSequencia(o, a)) {
+                s = r;
+                break;
               }
             }
+            if (s > 0) break;
           }
-          return bonus;
-        }
-        _scoreDoc(message, queryTokens, docIndex) {
-          const bm25 = this._scoreBM25(queryTokens, docIndex);
-          const frase = this._bonusFrase(message, docIndex);
-          return PESO_BM25 * bm25 + PESO_FRASE * frase;
-        }
-        // Calcula o score de todos os blocos para a mensagem e devolve ordenado
-        // do maior para o menor. Base partilhada por search() e analyze().
-        _rankTodos(message) {
-          const queryTokens = this._aplicarSinonimos(tokenizar(message));
-          if (queryTokens.length === 0) return [];
-          const resultados = [];
-          for (let i = 0; i < this.totalDocs; i++) {
-            resultados.push({ index: i, score: this._scoreDoc(message, queryTokens, i) });
-          }
-          resultados.sort((a, b) => b.score - a.score);
-          return resultados;
-        }
-        /**
-        * Procura o bloco mais relevante para a mensagem recebida.
-        *
-        * @returns {{text: string, score: number, confidence: number, index: number} | null}
-        *   `confidence` está sempre entre 0 e 1 — não é probabilidade
-        *   estatística real, é uma escala interpretável para decidir um
-        *   limiar no `.sql` (ex: "só responde se confidence > 0.3").
-        */
-        search(message) {
-          if (this.totalDocs === 0) return null;
-          const ranking = this._rankTodos(message);
-          if (ranking.length === 0) return null;
-          const melhor = ranking[0];
-          if (melhor.score <= 0) return null;
-          return {
-            text: this.blocks[melhor.index],
-            score: melhor.score,
-            confidence: melhor.score / (melhor.score + 3),
-            index: melhor.index
-          };
-        }
-        // Jaccard sobre os tokens (já com stem aplicado) de dois blocos já
-        // indexados. Usado só pra detetar "mesmo conteúdo repetido" (valor
-        // alto) — dois blocos sobre o mesmo assunto mas com detalhes
-        // diferentes normalmente NÃO têm jaccard alto (a maior parte da frase
-        // difere), por isso não serve pra decidir se vale a pena tentar unir.
-        _similaridadeBlocos(indexA, indexB) {
-          const a = new Set(this.docs[indexA]);
-          const b = new Set(this.docs[indexB]);
-          if (a.size === 0 || b.size === 0) return 0;
-          let intersecao = 0;
-          for (const t of a) if (b.has(t)) intersecao++;
-          const uniao = a.size + b.size - intersecao;
-          return uniao === 0 ? 0 : intersecao / uniao;
-        }
-        // Quantos tokens (com stem) os dois blocos partilham, em termos
-        // absolutos. Usado como gatilho pra tentar unir: basta partilharem UM
-        // termo de assunto ("entregamos") — quem garante que a fusão é segura
-        // não é isto, é a regra de "exatamente um nome próprio diferente em
-        // cada bloco" dentro de _tentarUnir.
-        _termosPartilhados(indexA, indexB) {
-          const a = new Set(this.docs[indexA]);
-          const b = this.docs[indexB];
-          let count = 0;
-          for (const t of b) if (a.has(t)) count++;
-          return count;
-        }
-        // Compara dois blocos concorrentes pelo nome próprio que cada um
-        // menciona, pra decidir se são "a mesma informação" ou "informação
-        // complementar que dá pra unir":
-        //   - mesmo nome próprio nos dois (ex: os dois falam de Luanda)
-        //     -> { tipo: 'duplicado' }: é a mesma coisa dita de formas
-        //     diferentes, não há o que unir, usa qualquer um dos dois
-        //   - nomes próprios diferentes (ex: Luanda vs Huambo)
-        //     -> { tipo: 'unido', texto: '...' }: funde numa frase só
-        //   - não dá pra identificar com segurança (nenhum nome próprio, ou
-        //     mais de um em algum dos blocos) -> null: quem chama decide o
-        //     que fazer a seguir (normalmente: reanalisar, ou cair no fallback)
-        _tentarUnir(textoA, textoB) {
-          const entidadesA = extrairNomesProprios(textoA);
-          const entidadesB = extrairNomesProprios(textoB);
-          if (entidadesA.length !== 1 || entidadesB.length !== 1) return null;
-          const entidadeA = entidadesA[0];
-          const entidadeB = entidadesB[0];
-          if (normalizar(entidadeA).toLowerCase() === normalizar(entidadeB).toLowerCase()) {
-            return { tipo: "duplicado" };
-          }
-          const primeiraPalavra = textoA.trim().split(/\s+/)[0].replace(/[.,;:!?]+$/, "");
-          return { tipo: "unido", texto: `${primeiraPalavra} em v\xE1rios lugares, como ${entidadeA} e ${entidadeB}.` };
-        }
-        // Segunda tentativa de ranking, usada só quando a primeira ficou
-        // ambígua: descarta metade dos termos da query (os de menor IDF, ou
-        // seja, os mais genéricos/comuns) e refaz o ranking só com os termos
-        // mais raros/decisivos. Uma query mais focada às vezes desempata o
-        // que uma query "cheia" deixa embolado.
-        _reanalisarFocado(message) {
-          const tokens = this._aplicarSinonimos(tokenizar(message));
-          if (tokens.length <= 2) return null;
-          const comIdf = tokens.map((t) => ({ termo: t, idf: this._idf(t) }));
-          comIdf.sort((a, b) => b.idf - a.idf);
-          const focados = comIdf.slice(0, Math.max(1, Math.ceil(tokens.length / 2))).map((x) => x.termo);
-          const resultados = [];
-          for (let i = 0; i < this.totalDocs; i++) {
-            resultados.push({ index: i, score: this._scoreDoc(message, focados, i) });
-          }
-          resultados.sort((a, b) => b.score - a.score);
-          return resultados;
-        }
-        /**
-        * Versão completa da busca: além do melhor bloco, avalia a evidência
-        * (melhor x segundo colocado) e devolve uma decisão explícita, em vez
-        * de deixar o `.sql` decidir tudo com um único limiar de confidence.
-        *
-        * EvidenceEvaluator: compara o melhor resultado com o segundo. Se os
-        * dois estão muito próximos, o motor não tem certeza de qual bloco
-        * responde à pergunta — mesmo que o score absoluto seja alto.
-        *
-        * ConfidenceEngine: mesma fórmula de sempre (score / (score + 3)),
-        * aplicada só ao melhor resultado.
-        *
-        * DecisionEngine: cruza confidence com margem para decidir entre:
-        *   - RESPONDER    confidence alta e o melhor bloco se destaca do 2o,
-        *                  OU os dois concorrentes foram reconciliados (ver
-        *                  abaixo) — nesse caso `texto` já vem pronto pra usar
-        *   - REANALISAR   os blocos concorrentes são sobre assuntos diferentes
-        *                  demais pra reconciliar, e nem a retentativa focada
-        *                  resolveu — o `.sql` decide o que fazer (normalmente
-        *                  cair no fallback do OR REPLY)
-        *   - UNKNOWN      confidence baixa demais, não há bloco que sirva
-        *
-        * Reconciliação (só entra quando o resultado não é decisivo de cara):
-        *   1. Se o melhor e o segundo colocado são basicamente o mesmo
-        *      conteúdo (alta similaridade) — não há nada pra unir, usa o
-        *      melhor tal como está.
-        *   2. Se são blocos diferentes mas do mesmo assunto, e cada um tem
-        *      exatamente um nome próprio diferente (ex: "entregamos em
-        *      Luanda" / "entregamos no Huambo") — tenta fundir numa frase só
-        *      ("entregamos em vários lugares, como Luanda e Huambo").
-        *   3. Se nada disso se aplica, tenta de novo com uma versão mais
-        *      enxuta da pergunta (só os termos mais decisivos) antes de
-        *      desistir.
-        *
-        * @returns {{
-        *   decision: 'RESPONDER'|'REANALISAR'|'UNKNOWN',
-        *   confidence: number,
-        *   margem: number,
-        *   texto: string | null,
-        *   unificado: boolean,
-        *   reanalisado: boolean,
-        *   melhor: {text: string, score: number, index: number} | null,
-        *   segundo: {text: string, score: number, index: number} | null
-        * }}
-        */
-        analyze(message) {
-          const vazio = { decision: "UNKNOWN", confidence: 0, margem: 0, texto: null, unificado: false, reanalisado: false, melhor: null, segundo: null };
-          if (this.totalDocs === 0) return vazio;
-          const ranking = this._rankTodos(message);
-          if (ranking.length === 0 || ranking[0].score <= 0) return vazio;
-          const melhor = ranking[0];
-          const segundo = ranking[1] || { index: -1, score: 0 };
-          const margem = (melhor.score - segundo.score) / melhor.score;
-          const confidence = melhor.score / (melhor.score + 3);
-          const melhorInfo = { text: this.blocks[melhor.index], score: melhor.score, index: melhor.index };
-          const segundoInfo = segundo.index >= 0 ? { text: this.blocks[segundo.index], score: segundo.score, index: segundo.index } : null;
-          if (confidence < CONFIANCA_MINIMA) return vazio;
-          if (confidence >= CONFIANCA_ALTA && margem >= MARGEM_MINIMA) {
-            return {
-              decision: "RESPONDER",
-              confidence,
-              margem,
-              texto: melhorInfo.text,
-              unificado: false,
-              reanalisado: false,
-              melhor: melhorInfo,
-              segundo: segundoInfo
-            };
+          return 0 === s ? 0 : s / i.length;
+        }
+        _contemSequencia(e, t) {
+          outer: for (let i = 0; i + t.length <= e.length; i++) {
+            for (let o = 0; o < t.length; o++) if (e[i + o] !== t[o]) continue outer;
+            return true;
           }
-          if (segundoInfo) {
-            const similaridade = this._similaridadeBlocos(melhor.index, segundo.index);
-            if (similaridade >= SIMILARIDADE_DUPLICADA) {
-              return {
-                decision: "RESPONDER",
-                confidence,
-                margem,
-                texto: melhorInfo.text,
-                unificado: false,
-                reanalisado: false,
-                melhor: melhorInfo,
-                segundo: segundoInfo
-              };
-            }
-            const termosPartilhados = this._termosPartilhados(melhor.index, segundo.index);
-            if (termosPartilhados >= 1) {
-              const resultado = this._tentarUnir(melhorInfo.text, segundoInfo.text);
-              if (resultado && resultado.tipo === "duplicado") {
-                return {
-                  decision: "RESPONDER",
-                  confidence,
-                  margem,
-                  texto: melhorInfo.text,
-                  unificado: false,
-                  reanalisado: false,
-                  melhor: melhorInfo,
-                  segundo: segundoInfo
-                };
-              }
-              if (resultado && resultado.tipo === "unido") {
-                return {
-                  decision: "RESPONDER",
-                  confidence,
-                  margem,
-                  texto: resultado.texto,
-                  unificado: true,
-                  reanalisado: false,
-                  melhor: melhorInfo,
-                  segundo: segundoInfo
-                };
-              }
+          return false;
+        }
+        _bonusTitulo(e, t) {
+          if (0 === e.length) return 0;
+          let i = new Set(this.docPalavrasSignificativas[t].slice(0, 8)), o = new Set(e), s = 0;
+          for (let r of o) i.has(r) && s++;
+          return s / o.size;
+        }
+        _scoreDoc(e, t, i) {
+          let o = this._scoreBM25(t, i), s = this._bonusFrase(e, i), r = this._bonusTitulo(this._palavrasSignificativas(e), i);
+          return 1 * o + 4 * s + 3 * r;
+        }
+        _rankTodos(e) {
+          let t = this._aplicarSinonimos(tokenizar(e));
+          if (0 === t.length) return [];
+          let i = [];
+          for (let o = 0; o < this.totalDocs; o++) i.push({ index: o, score: this._scoreDoc(e, t, o) });
+          return i.sort((e2, t2) => t2.score - e2.score), i;
+        }
+        search(e) {
+          if (0 === this.totalDocs) return null;
+          let t = this._rankTodos(e);
+          if (0 === t.length) return null;
+          let i = t[0];
+          return i.score <= 0 ? null : { text: this.blocks[i.index], score: i.score, confidence: i.score / (i.score + 3), index: i.index };
+        }
+        _similaridadeBlocos(e, t) {
+          let i = new Set(this.docs[e]), o = new Set(this.docs[t]);
+          if (0 === i.size || 0 === o.size) return 0;
+          let s = 0;
+          for (let r of i) o.has(r) && s++;
+          let n = i.size + o.size - s;
+          return 0 === n ? 0 : s / n;
+        }
+        _termosPartilhados(e, t) {
+          let i = new Set(this.docs[e]), o = this.docs[t], s = 0;
+          for (let r of o) i.has(r) && s++;
+          return s;
+        }
+        _tentarUnir(e, t) {
+          let i = extrairNomesProprios(e), o = extrairNomesProprios(t);
+          if (1 !== i.length || 1 !== o.length) return null;
+          let s = i[0], r = o[0];
+          if (normalizar(s).toLowerCase() === normalizar(r).toLowerCase()) return { tipo: "duplicado" };
+          let n = e.trim().split(/\s+/)[0].replace(/[.,;:!?]+$/, "");
+          return { tipo: "unido", texto: `${n} em v\xE1rios lugares, como ${s} e ${r}.` };
+        }
+        _reanalisarFocado(e) {
+          let t = this._aplicarSinonimos(tokenizar(e));
+          if (t.length <= 2) return null;
+          let i = t.map((e2) => ({ termo: e2, idf: this._idf(e2) }));
+          i.sort((e2, t2) => t2.idf - e2.idf);
+          let o = i.slice(0, Math.max(1, Math.ceil(t.length / 2))).map((e2) => e2.termo), s = [];
+          for (let r = 0; r < this.totalDocs; r++) s.push({ index: r, score: this._scoreDoc(e, o, r) });
+          return s.sort((e2, t2) => t2.score - e2.score), s;
+        }
+        analyze(e) {
+          let t = { decision: "UNKNOWN", confidence: 0, margem: 0, texto: null, unificado: false, reanalisado: false, melhor: null, segundo: null };
+          if (0 === this.totalDocs) return t;
+          let i = this._rankTodos(e);
+          if (0 === i.length || i[0].score <= 0) return t;
+          let o = i[0], s = i[1] || { index: -1, score: 0 }, r = (o.score - s.score) / o.score, n = o.score / (o.score + 3), a = { text: this.blocks[o.index], score: o.score, index: o.index }, l = s.index >= 0 ? { text: this.blocks[s.index], score: s.score, index: s.index } : null;
+          if (n < 0.15) return t;
+          if (n >= 0.55 && r >= 0.12) return { decision: "RESPONDER", confidence: n, margem: r, texto: a.text, unificado: false, reanalisado: false, melhor: a, segundo: l };
+          if (l) {
+            let c = this._similaridadeBlocos(o.index, s.index);
+            if (c >= 0.75) return { decision: "RESPONDER", confidence: n, margem: r, texto: a.text, unificado: false, reanalisado: false, melhor: a, segundo: l };
+            let d = this._termosPartilhados(o.index, s.index);
+            if (d >= 1) {
+              let h = this._tentarUnir(a.text, l.text);
+              if (h && "duplicado" === h.tipo) return { decision: "RESPONDER", confidence: n, margem: r, texto: a.text, unificado: false, reanalisado: false, melhor: a, segundo: l };
+              if (h && "unido" === h.tipo) return { decision: "RESPONDER", confidence: n, margem: r, texto: h.texto, unificado: true, reanalisado: false, melhor: a, segundo: l };
             }
           }
-          const tentativa2 = this._reanalisarFocado(message);
-          if (tentativa2 && tentativa2.length > 0 && tentativa2[0].score > 0) {
-            const melhor2 = tentativa2[0];
-            const segundo2 = tentativa2[1] || { index: -1, score: 0 };
-            const margem2 = (melhor2.score - segundo2.score) / melhor2.score;
-            const confidence2 = melhor2.score / (melhor2.score + 3);
-            if (confidence2 >= CONFIANCA_ALTA && margem2 >= MARGEM_MINIMA) {
-              return {
-                decision: "RESPONDER",
-                confidence: confidence2,
-                margem: margem2,
-                texto: this.blocks[melhor2.index],
-                unificado: false,
-                reanalisado: true,
-                melhor: { text: this.blocks[melhor2.index], score: melhor2.score, index: melhor2.index },
-                segundo: segundo2.index >= 0 ? { text: this.blocks[segundo2.index], score: segundo2.score, index: segundo2.index } : null
-              };
-            }
+          let u = this._reanalisarFocado(e);
+          if (u && u.length > 0 && u[0].score > 0) {
+            let f = u[0], $ = u[1] || { index: -1, score: 0 }, m = (f.score - $.score) / f.score, g = f.score / (f.score + 3);
+            if (g >= 0.55 && m >= 0.12) return { decision: "RESPONDER", confidence: g, margem: m, texto: this.blocks[f.index], unificado: false, reanalisado: true, melhor: { text: this.blocks[f.index], score: f.score, index: f.index }, segundo: $.index >= 0 ? { text: this.blocks[$.index], score: $.score, index: $.index } : null };
           }
-          return {
-            decision: "REANALISAR",
-            confidence,
-            margem,
-            texto: null,
-            unificado: false,
-            reanalisado: false,
-            melhor: melhorInfo,
-            segundo: segundoInfo
-          };
+          return { decision: "REANALISAR", confidence: n, margem: r, texto: null, unificado: false, reanalisado: false, melhor: a, segundo: l };
         }
       };
       var KnowledgeCache = class {
-        constructor(fileSystem) {
-          this.fileSystem = fileSystem;
-          this.cache = /* @__PURE__ */ new Map();
-        }
-        get(resolvedPath, options) {
-          if (this.cache.has(resolvedPath)) return this.cache.get(resolvedPath);
-          if (!this.fileSystem.exists(resolvedPath)) {
-            throw new Error(`BotQL/THINK: ficheiro de conhecimento n\xE3o encontrado: "${resolvedPath}"`);
-          }
-          const texto = this.fileSystem.readFile(resolvedPath);
-          const index = new KnowledgeIndex(texto, options);
-          this.cache.set(resolvedPath, index);
-          return index;
+        constructor(e) {
+          this.fileSystem = e, this.cache = /* @__PURE__ */ new Map();
+        }
+        get(e, t) {
+          if (this.cache.has(e)) return this.cache.get(e);
+          if (!this.fileSystem.exists(e)) throw Error(`BotQL/THINK: ficheiro de conhecimento n\xE3o encontrado: "${e}"`);
+          let i = this.fileSystem.readFile(e), o = new KnowledgeIndex(i, t);
+          return this.cache.set(e, o), o;
         }
       };
       module.exports = { KnowledgeIndex, KnowledgeCache, tokenizar, normalizar, stem, distanciaEdicao };
@@ -1042,10 +753,9 @@ var BotQL = (() => {
       var { MemoryDatabase: t } = require_Database();
       var { createDefaultFileSystem: s } = require_FileSystem();
       var { KnowledgeCache: i } = require_RAG();
-      var WAITING_TEXTO_PADRAO = "Pensando...";
       var BotQLInterpreter = class _BotQLInterpreter {
         constructor(e2 = {}) {
-          this.db = e2.db || new t(), this.onReply = e2.onReply || null, this.onForward = e2.onForward || null, this.onSend = e2.onSend || null, this.signalParser = e2.signalParser || ((e3) => e3), this.onThinking = e2.onThinking || null, this.botName = null, this.platform = null, this.connections = [], this.handlers = { START: [], MESSAGE: [], SIGNAL: [] }, this.running = false, this.responseConnections = /* @__PURE__ */ new Set(), this.onResponse = e2.onResponse || null, this.defaultMessageConfig = null, this.nativeFuncs = /* @__PURE__ */ new Map(), this.registerFunction("NOW", () => (/* @__PURE__ */ new Date()).toISOString()), this.fileSystem = e2.fileSystem || s();
+          this.db = e2.db || new t(), this.onReply = e2.onReply || null, this.onForward = e2.onForward || null, this.onSend = e2.onSend || null, this.signalParser = e2.signalParser || ((e3) => e3), this.onThinking = e2.onThinking || null, this.botName = null, this.platform = null, this.connections = [], this.handlers = { START: [], MESSAGE: [], SIGNAL: [] }, this.running = false, this.responseConnections = /* @__PURE__ */ new Set(), this._clientesOcupados = /* @__PURE__ */ new Set(), this.onBusy = e2.onBusy || null, this.onResponse = e2.onResponse || null, this.defaultMessageConfig = null, this.nativeFuncs = /* @__PURE__ */ new Map(), this.registerFunction("NOW", () => (/* @__PURE__ */ new Date()).toISOString()), this.fileSystem = e2.fileSystem || s();
           let n = "undefined" != typeof process && process.cwd ? process.cwd() : "";
           this._basePathStack = [e2.basePath || n], this._importedFiles = /* @__PURE__ */ new Set(), this._rootBasePath = e2.basePath || n, this._keywordsFileCache = /* @__PURE__ */ new Map(), this._replyFileCache = /* @__PURE__ */ new Map(), this.envValues = /* @__PURE__ */ new Map(), this.knowledgeCache = new i(this.fileSystem);
         }
@@ -1111,8 +821,8 @@ var BotQL = (() => {
             if (this._importedFiles.has(u)) continue;
             if (!this.fileSystem.exists(u)) throw Error(`runtime error: IMPORT failed, file not found: "${u}"`);
             this._importedFiles.add(u);
-            let c = this.fileSystem.readFile(u), f = new e(c).parseProgram(), d = this._flattenImports(f.body, this.fileSystem.dirname(u));
-            i2.push(...d);
+            let c = this.fileSystem.readFile(u), d = new e(c).parseProgram(), f = this._flattenImports(d.body, this.fileSystem.dirname(u));
+            i2.push(...f);
           }
           return [...i2, ...n];
         }
@@ -1126,10 +836,16 @@ var BotQL = (() => {
           }
         }
         async receiveMessage(e2, t2) {
-          let s2 = this.createContext({ client: e2, message: t2 }), i2 = await this.greetIfNew(e2);
-          if (i2) return s2;
-          for (let n of this.handlers.MESSAGE) await this.run(n.body, s2);
-          return s2;
+          if (this._clientesOcupados.has(e2)) return this.onBusy && await this.onBusy({ client: e2, message: t2 }), null;
+          this._clientesOcupados.add(e2);
+          try {
+            let s2 = this.createContext({ client: e2, message: t2 }), i2 = await this.greetIfNew(e2);
+            if (i2) return s2;
+            for (let n of this.handlers.MESSAGE) await this.run(n.body, s2);
+            return s2;
+          } finally {
+            this._clientesOcupados.delete(e2);
+          }
         }
         async greetIfNew(e2) {
           if (!this.defaultMessageConfig) return false;
@@ -1182,9 +898,10 @@ var BotQL = (() => {
           return this._keywordsFileCache.set(e2, i2), i2;
         }
         resolveWaitingConfig(e2, t2) {
-          if (!e2) return { text: WAITING_TEXTO_PADRAO, seconds: 3 };
-          let s2 = WAITING_TEXTO_PADRAO;
-          if (e2.file) {
+          if (!e2) return { text: null, seconds: 3 };
+          let s2 = null;
+          if (null !== e2.text && void 0 !== e2.text) s2 = e2.text;
+          else if (e2.file) {
             let i2 = this.fileSystem.resolve(this._rootBasePath, e2.file);
             if (!this.fileSystem.exists(i2)) throw Error(`runtime error: WAITING failed, file not found: "${i2}"`);
             s2 = this.fileSystem.readFile(i2).trim();
@@ -1217,11 +934,11 @@ var BotQL = (() => {
             }
             let h = Number(l[0]), u = a + l[0].length + 1;
             if ("{" === e2[u]) {
-              let c = 1, f = u + 1, d = f;
-              for (; d < i2 && c > 0; ) "{" === e2[d] ? c++ : "}" === e2[d] && c--, d++;
+              let c = 1, d = u + 1, f = d;
+              for (; f < i2 && c > 0; ) "{" === e2[f] ? c++ : "}" === e2[f] && c--, f++;
               if (0 !== c) throw Error(`runtime error: unclosed "{" for entry ${h} in "${t2}"`);
-              let p = e2.slice(f, d - 1).trim();
-              s2.set(h, p), n = d;
+              let p = e2.slice(d, f - 1).trim();
+              s2.set(h, p), n = f;
               continue;
             }
             let m = e2.indexOf("\n", u), w = -1 === m ? i2 : m, g = e2.slice(u, w).trim();
@@ -1236,19 +953,24 @@ var BotQL = (() => {
               t2.vars.lastMsg = s2, this.onReply && await this.onReply({ target: e2.target, text: s2, client: t2.vars.client });
               break;
             }
+            case "Waiting": {
+              let i2 = this.resolveWaitingConfig(e2, t2);
+              this.onThinking && await this.onThinking({ client: t2.vars.client, text: i2.text }), await new Promise((e3) => setTimeout(e3, 1e3 * i2.seconds));
+              break;
+            }
             case "Think": {
-              let i2 = this.resolveWaitingConfig(e2.waiting, t2), n = Date.now();
-              this.onThinking && await this.onThinking({ client: t2.vars.client, text: i2.text });
-              let r = this.fileSystem.resolve(this._rootBasePath, e2.file), a = this.knowledgeCache.get(r), l = a.analyze(t2.vars.message), o = Date.now() - n, h = 1e3 * i2.seconds - o;
-              if (h > 0 && await new Promise((e3) => setTimeout(e3, h)), "RESPONDER" === l.decision) {
-                let u = l.texto;
-                t2.vars.lastMsg = u, this.onReply && await this.onReply({ target: null, text: u, client: t2.vars.client });
+              let n = this.resolveWaitingConfig(e2.waiting, t2), r = Date.now();
+              this.onThinking && await this.onThinking({ client: t2.vars.client, text: n.text });
+              let a = this.fileSystem.resolve(this._rootBasePath, e2.file), l = this.knowledgeCache.get(a), o = l.analyze(t2.vars.message), h = Date.now() - r, u = 1e3 * n.seconds - h;
+              if (u > 0 && await new Promise((e3) => setTimeout(e3, u)), "RESPONDER" === o.decision) {
+                let c = o.texto;
+                t2.vars.lastMsg = c, this.onReply && await this.onReply({ target: null, text: c, client: t2.vars.client });
               } else e2.fallback && await this.execStatement(e2.fallback, t2);
               break;
             }
             case "ForwardTo": {
-              let c = String(this.evalExpr(e2.target, t2));
-              this.onForward && await this.onForward({ target: c, client: t2.vars.client });
+              let d = String(this.evalExpr(e2.target, t2));
+              this.onForward && await this.onForward({ target: d, client: t2.vars.client });
               break;
             }
             case "ParseSignal":