botql 1.0.2 → 1.2.2

package/botql.browser.js

@@ -19,648 +19,357 @@ var BotQL = (() => {
   var require_Parser = __commonJS({
     "Parser.js"(exports, module) {
       "use strict";
-      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 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(type, value, line) {
-          this.type = type;
-          this.value = value;
-          this.line = line;
+        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(source) {
-          this.source = source;
-          this.pos = 0;
-          this.line = 1;
-          this.tokens = [];
+        constructor(e) {
+          this.source = e, this.pos = 0, this.line = 1, this.tokens = [];
         }
-        error(msg) {
-          throw new Error(`syntax error: ${msg}`);
+        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(offset = 0) {
-          return this.source[this.pos + offset];
+        peekChar(e = 0) {
+          return this.source[this.pos + e];
         }
         tokenize() {
-          while (this.pos < this.source.length) {
-            const c = this.peekChar();
-            if (c === "\n") {
-              this.line++;
-              this.pos++;
+          for (; this.pos < this.source.length; ) {
+            let e = this.peekChar(), t = this.pos;
+            if ("\n" === e) {
+              this.line++, this.pos++;
               continue;
             }
-            if (/\s/.test(c)) {
+            if (/\s/.test(e)) {
               this.pos++;
               continue;
             }
-            if (c === "-" && this.peekChar(1) === "-") {
-              while (this.pos < this.source.length && this.peekChar() !== "\n") this.pos++;
-              continue;
-            }
-            if (c === '"' || c === "'") {
-              this.tokens.push(this.readString(c));
-              continue;
-            }
-            if (/[0-9]/.test(c)) {
-              this.tokens.push(this.readNumber());
-              continue;
-            }
-            if ("{}(),.=+*;".includes(c)) {
-              this.tokens.push(new Token(TokenType.SYMBOL, c, this.line));
-              this.pos++;
+            if ("-" === e && "-" === this.peekChar(1)) {
+              for (; this.pos < this.source.length && "\n" !== this.peekChar(); ) this.pos++;
               continue;
             }
-            if (/[A-Za-z_]/.test(c)) {
-              const word = this.readWord();
-              this.tokens.push(word);
-              continue;
-            }
-            this.error(`unexpected character: "${c}"`);
+            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);
           }
-          this.tokens.push(new Token(TokenType.EOF, null, this.line));
-          return 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(quote) {
-          const startLine = this.line;
+        readString(e) {
+          let t = this.line, s = this.pos;
           this.pos++;
-          let value = "";
-          while (this.pos < this.source.length && this.peekChar() !== quote) {
-            if (this.peekChar() === "\\") {
-              this.pos++;
-              value += this.peekChar();
-              this.pos++;
+          let r = "";
+          for (; this.pos < this.source.length && this.peekChar() !== e; ) {
+            if ("\\" === this.peekChar()) {
+              this.pos++, r += this.peekChar(), this.pos++;
               continue;
             }
-            if (this.peekChar() === "\n") this.line++;
-            value += this.peekChar();
-            this.pos++;
-          }
-          if (this.peekChar() !== quote) {
-            this.error("unterminated string");
+            "\n" === this.peekChar() && this.line++, r += this.peekChar(), this.pos++;
           }
-          this.pos++;
-          return new Token(TokenType.STRING, value, startLine);
+          return this.peekChar() !== e && this.error("unterminated string", s, this.pos), this.pos++, new Token(TokenType.STRING, r, t);
         }
         readNumber() {
-          const startLine = this.line;
-          let value = "";
-          while (this.pos < this.source.length && /[0-9.]/.test(this.peekChar())) {
-            value += this.peekChar();
-            this.pos++;
-          }
-          return new Token(TokenType.NUMBER, Number(value), startLine);
+          let e = this.line, t = "";
+          for (; this.pos < this.source.length && /[0-9.]/.test(this.peekChar()); ) t += this.peekChar(), this.pos++;
+          return new Token(TokenType.NUMBER, Number(t), e);
         }
         readWord() {
-          const startLine = this.line;
-          let value = "";
-          while (this.pos < this.source.length && /[A-Za-z0-9_]/.test(this.peekChar())) {
-            value += this.peekChar();
-            this.pos++;
-          }
-          const upper = value.toUpperCase();
-          if (KEYWORDS.has(upper) && value === upper) {
-            return new Token(TokenType.KEYWORD, upper, startLine);
-          }
-          return new Token(TokenType.IDENT, value, startLine);
+          let e = this.line, t = "";
+          for (; this.pos < this.source.length && /[A-Za-z0-9_]/.test(this.peekChar()); ) t += this.peekChar(), this.pos++;
+          let s = t.toUpperCase();
+          return KEYWORDS.has(s) && t === s ? new Token(TokenType.KEYWORD, s, e) : new Token(TokenType.IDENT, t, e);
         }
       };
       var Parser = class {
-        constructor(source) {
-          this.tokens = new Tokenizer(source).tokenize();
-          this.pos = 0;
+        constructor(e) {
+          this.source = e, this.tokens = new Tokenizer(e).tokenize(), this.pos = 0;
         }
-        error(msg) {
-          const tok = this.current();
-          throw new Error(`syntax error: ${msg}, near "${tok ? tok.value : "EOF"}"`);
+        error(e) {
+          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];
         }
-        at(type, value) {
-          const tok = this.current();
-          if (tok.type !== type) return false;
-          if (value !== void 0 && tok.value !== value) return false;
-          return true;
+        at(e, t) {
+          let s = this.current();
+          return s.type === e && (void 0 === t || s.value === t);
         }
-        atKeyword(...values) {
-          return this.at(TokenType.KEYWORD) && values.includes(this.current().value);
+        atKeyword(...e) {
+          return this.at(TokenType.KEYWORD) && e.includes(this.current().value);
         }
-        // Casa por valor, independente do token ser KEYWORD ou IDENT.
-        // Necessário para palavras como "SIGNAL", que tanto introduz um
-        // evento (ON SIGNAL FROM) como é usada como identificador (SIGNAL.PAIR).
-        atWord(...values) {
-          const tok = this.current();
-          return (tok.type === TokenType.KEYWORD || tok.type === TokenType.IDENT) && values.includes(tok.value);
+        atWord(...e) {
+          let t = this.current();
+          return (t.type === TokenType.KEYWORD || t.type === TokenType.IDENT) && e.includes(t.value);
         }
         advance() {
-          const tok = this.current();
-          if (tok.type !== TokenType.EOF) this.pos++;
-          return tok;
+          let e = this.current();
+          return e.type !== TokenType.EOF && this.pos++, e;
         }
-        expect(type, value) {
-          if (!this.at(type, value)) {
-            this.error(`expected ${value || type}`);
-          }
-          return this.advance();
+        expect(e, t) {
+          return this.at(e, t) || this.error(`expected ${t || e}`), this.advance();
         }
-        expectKeyword(value) {
-          return this.expect(TokenType.KEYWORD, value);
+        expectKeyword(e) {
+          return this.expect(TokenType.KEYWORD, e);
         }
         isAtEnd() {
           return this.at(TokenType.EOF);
         }
-        // ---- Programa ----
         parseProgram() {
-          const statements = [];
-          while (!this.isAtEnd()) {
-            statements.push(this.parseStatement());
-          }
-          return { type: "Program", body: statements };
+          let e = [];
+          for (; !this.isAtEnd(); ) e.push(this.parseStatement());
+          return { type: "Program", body: e };
         }
-        // ---- Bloco { ... } ou statement único ----
-        // Regra da linguagem: bloco com mais de uma ação usa chaves,
-        // uma única ação não precisa.
         parseBody() {
           if (this.at(TokenType.SYMBOL, "{")) {
             this.advance();
-            const statements = [];
-            while (!this.at(TokenType.SYMBOL, "}")) {
-              if (this.isAtEnd()) this.error('unclosed block "{"');
-              statements.push(this.parseStatement());
-            }
-            this.advance();
-            return statements;
+            let e = [];
+            for (; !this.at(TokenType.SYMBOL, "}"); ) this.isAtEnd() && this.error('unclosed block "{"'), e.push(this.parseStatement());
+            return this.advance(), e;
           }
           return [this.parseStatement()];
         }
-        // ---- Dispatch de statement ----
         parseStatement() {
-          if (this.atKeyword("CREATE")) return this.parseCreate();
-          if (this.atKeyword("PLATFORM")) return this.parsePlatform();
-          if (this.atKeyword("CONNECT")) return this.parseConnect();
-          if (this.atKeyword("ON")) return this.parseOn();
-          if (this.atKeyword("WHEN")) return this.parseWhen();
-          if (this.atKeyword("OTHERWISE")) return this.parseOtherwise();
-          if (this.atKeyword("REPLY")) return this.parseReply();
-          if (this.atKeyword("THINK")) return this.parseThink();
-          if (this.atKeyword("FORWARD")) return this.parseForward();
-          if (this.atKeyword("PARSE")) return this.parseParseSignal();
-          if (this.atKeyword("SEND")) return this.parseSend();
-          if (this.atKeyword("INSERT")) return this.parseInsert();
-          if (this.atKeyword("UPDATE")) return this.parseUpdate();
-          if (this.atKeyword("RUN")) return this.parseRunBot();
-          if (this.atKeyword("IMPORT")) return this.parseImport();
-          this.error("unexpected statement");
-        }
-        // ---- CREATE BOT / CREATE TABLE ----
+          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() {
-          this.expectKeyword("CREATE");
-          if (this.atKeyword("BOT")) {
+          if (this.expectKeyword("CREATE"), this.atKeyword("BOT")) {
             this.advance();
-            const name = this.expect(TokenType.STRING).value;
-            return { type: "CreateBot", name };
+            let e = this.expect(TokenType.STRING).value;
+            return { type: "CreateBot", name: e };
           }
           if (this.atKeyword("TABLE")) {
             this.advance();
-            const name = this.expect(TokenType.IDENT).value;
-            const columns = this.parseColumnList();
-            const preventDefault = this.tryParsePreventDefault();
-            const defaultMessage = this.tryParseDefaultMessage();
-            return { type: "CreateTable", name, columns, preventDefault, defaultMessage };
+            let t = this.expect(TokenType.IDENT).value, s = this.parseColumnList(), r = this.tryParsePreventDefault(), i = this.tryParseDefaultMessage();
+            return { type: "CreateTable", name: t, columns: s, preventDefault: r, defaultMessage: i };
           }
           this.error("expected BOT or TABLE after CREATE");
         }
         parseColumnList() {
           this.expect(TokenType.SYMBOL, "(");
-          const columns = [];
-          while (!this.at(TokenType.SYMBOL, ")")) {
-            const colName = this.expect(TokenType.IDENT).value;
-            const constraints = [];
-            let colType = null;
-            while (this.at(TokenType.IDENT) && !this.at(TokenType.SYMBOL, ",") && !this.at(TokenType.SYMBOL, ")")) {
-              const word = this.advance().value;
-              if (!colType) colType = word;
-              else constraints.push(word);
+          let e = [];
+          for (; !this.at(TokenType.SYMBOL, ")"); ) {
+            let t = this.expect(TokenType.IDENT).value, s = [], r = null;
+            for (; this.at(TokenType.IDENT) && !this.at(TokenType.SYMBOL, ",") && !this.at(TokenType.SYMBOL, ")"); ) {
+              let i = this.advance().value;
+              r ? s.push(i) : r = i;
             }
-            columns.push({ name: colName, columnType: colType, constraints });
-            if (this.at(TokenType.SYMBOL, ",")) this.advance();
+            e.push({ name: t, columnType: r, constraints: s }), this.at(TokenType.SYMBOL, ",") && this.advance();
           }
-          this.expect(TokenType.SYMBOL, ")");
-          return columns;
+          return this.expect(TokenType.SYMBOL, ")"), e;
         }
         tryParsePreventDefault() {
-          if (this.atKeyword("PREVENT")) {
-            this.advance();
-            this.expectKeyword("DEFAULT");
-            return true;
-          }
-          return false;
+          return !!this.atKeyword("PREVENT") && (this.advance(), this.expectKeyword("DEFAULT"), true);
         }
-        // ---- DEFAULT MESSAGE "texto" ----
-        // ---- DEFAULT MESSAGE (ficheiro.txt, N) ----
-        //
-        // Modificador do CREATE TABLE, ao lado de PREVENT DEFAULT: saudação
-        // automática enviada só na primeira mensagem de cada client/sender
-        // (ver botql.js, receiveMessage). Aceita texto direto ou a mesma forma
-        // de ficheiro indexado do REPLY — por isso reaproveita isReplyFileForm
-        // para o lookahead. "DEFAULT" aqui não é o mesmo "DEFAULT" de "PREVENT
-        // DEFAULT" — só é reconhecido como início de DEFAULT MESSAGE quando NÃO
-        // vem logo a seguir a PREVENT (tryParsePreventDefault já consumiu esse
-        // caso antes de chegarmos aqui).
         tryParseDefaultMessage() {
           if (!this.atKeyword("DEFAULT")) return null;
-          const next = this.tokens[this.pos + 1];
-          if (!next || next.type !== TokenType.KEYWORD || next.value !== "MESSAGE") return null;
-          this.advance();
-          this.advance();
-          if (this.isReplyFileForm()) {
+          let e = this.tokens[this.pos + 1];
+          if (!e || e.type !== TokenType.KEYWORD || "MESSAGE" !== e.value) return null;
+          if (this.advance(), this.advance(), this.isReplyFileForm()) {
             this.expect(TokenType.SYMBOL, "(");
-            const file = this.parseFileName();
+            let t = this.parseFileName();
             this.expect(TokenType.SYMBOL, ",");
-            const index = this.parseExpression();
-            this.expect(TokenType.SYMBOL, ")");
-            return { file, index };
+            let s = this.parseExpression();
+            return this.expect(TokenType.SYMBOL, ")"), { file: t, index: s };
           }
-          const value = this.parseExpression();
-          return { value };
+          let r = this.parseExpression();
+          return { value: r };
         }
-        // ---- PLATFORM ----
         parsePlatform() {
           this.expectKeyword("PLATFORM");
-          const value = this.advance().value;
-          return { type: "Platform", value };
-        }
-        // ---- CONNECT SERVIÇO TIPO "credencial" ----
-        // ---- CONNECT RESPONSE alias ----
-        //
-        // A segunda forma liga o bot a uma IA usando um valor já importado (o
-        // alias de um IMPORT {..., N} AS alias) — só estabelece a ligação,
-        // não dispara nada sozinho (quem dispara é Response()/Response(alias),
-        // dentro de uma ação). RESPONSE é keyword fixa aqui, por isso da para
-        // distinguir logo no primeiro token, sem lookahead: a forma normal
-        // nunca começa por essa palavra.
+          let e = this.advance().value;
+          return { type: "Platform", value: e };
+        }
         parseConnect() {
-          this.expectKeyword("CONNECT");
-          if (this.atKeyword("RESPONSE")) {
+          if (this.expectKeyword("CONNECT"), this.atKeyword("RESPONSE")) {
             this.advance();
-            const alias = this.expect(TokenType.IDENT).value;
-            return { type: "ConnectResponse", alias };
+            let e = this.expect(TokenType.IDENT).value;
+            return { type: "ConnectResponse", alias: e };
           }
-          const service = this.advance().value;
-          const kind = this.advance().value;
-          const credential = this.expect(TokenType.STRING).value;
-          return { type: "Connect", service, kind, credential };
+          let t = this.advance().value, s = this.advance().value, r = this.expect(TokenType.STRING).value;
+          return { type: "Connect", service: t, kind: s, credential: r };
         }
-        // ---- ON START | ON MESSAGE | ON SIGNAL FROM "..." ----
         parseOn() {
-          this.expectKeyword("ON");
-          if (this.atKeyword("START")) {
+          if (this.expectKeyword("ON"), this.atKeyword("START")) {
             this.advance();
-            const body = this.parseBody();
-            return { type: "On", event: "START", body };
+            let e = this.parseBody();
+            return { type: "On", event: "START", body: e };
           }
           if (this.atKeyword("MESSAGE")) {
             this.advance();
-            const body = this.parseBody();
-            return { type: "On", event: "MESSAGE", body };
+            let t = this.parseBody();
+            return { type: "On", event: "MESSAGE", body: t };
           }
           if (this.atWord("SIGNAL")) {
-            this.advance();
-            this.expectKeyword("FROM");
-            const source = this.expect(TokenType.STRING).value;
-            const body = this.parseBody();
-            return { type: "On", event: "SIGNAL", source, body };
+            this.advance(), this.expectKeyword("FROM");
+            let s = this.expect(TokenType.STRING).value, r = this.parseBody();
+            return { type: "On", event: "SIGNAL", source: s, body: r };
           }
           this.error("unexpected event after ON");
         }
-        // ---- WHEN CONTAINS "..." [OR CONTAINS "..."]* ----
         parseWhen() {
           this.expectKeyword("WHEN");
-          const conditions = [this.parseCondition()];
-          while (this.atKeyword("OR")) {
-            this.advance();
-            conditions.push(this.parseCondition());
-          }
-          const body = this.parseBody();
-          return { type: "When", conditions, body };
+          let e = [this.parseCondition()];
+          for (; this.atKeyword("OR"); ) this.advance(), e.push(this.parseCondition());
+          let t = this.parseBody();
+          return { type: "When", conditions: e, body: t };
         }
         parseCondition() {
-          this.expectKeyword("CONTAINS");
-          if (this.at(TokenType.SYMBOL, "(")) {
-            const values = this.parseStringList();
-            return { op: "CONTAINS_ANY", values };
+          if (this.expectKeyword("CONTAINS"), this.at(TokenType.SYMBOL, "(")) {
+            let e = this.parseStringList();
+            return { op: "CONTAINS_ANY", values: e };
           }
           if (this.atKeyword("KEYWORDS")) {
-            this.advance();
-            this.expect(TokenType.SYMBOL, "(");
-            const path = this.parseFileName();
-            this.expect(TokenType.SYMBOL, ")");
-            return { op: "CONTAINS_KEYWORDS_FILE", path };
+            this.advance(), this.expect(TokenType.SYMBOL, "(");
+            let t = this.parseFileName();
+            return this.expect(TokenType.SYMBOL, ")"), { op: "CONTAINS_KEYWORDS_FILE", path: t };
           }
-          const value = this.expect(TokenType.STRING).value;
-          return { op: "CONTAINS", value };
+          let s = this.expect(TokenType.STRING).value;
+          return { op: "CONTAINS", value: s };
         }
-        // Lista de strings entre parênteses: ("a", "b", "c")
         parseStringList() {
           this.expect(TokenType.SYMBOL, "(");
-          const values = [];
-          while (!this.at(TokenType.SYMBOL, ")")) {
-            values.push(this.expect(TokenType.STRING).value);
-            if (this.at(TokenType.SYMBOL, ",")) this.advance();
-          }
-          this.expect(TokenType.SYMBOL, ")");
-          return values;
+          let e = [];
+          for (; !this.at(TokenType.SYMBOL, ")"); ) e.push(this.expect(TokenType.STRING).value), this.at(TokenType.SYMBOL, ",") && this.advance();
+          return this.expect(TokenType.SYMBOL, ")"), e;
         }
-        // Nome de ficheiro sem aspas, ex: saudacoes.txt ou lista_bot.sql.
-        // O tokenizer separa "saudacoes" (IDENT) e ".txt" em IDENT + SYMBOL('.')
-        // + IDENT, por isso remontamos aqui em vez de pedir um STRING.
         parseFileName() {
-          let name = this.expect(TokenType.IDENT).value;
-          while (this.at(TokenType.SYMBOL, ".")) {
-            this.advance();
-            name += "." + this.expect(TokenType.IDENT).value;
-          }
-          return name;
+          let e = this.expect(TokenType.IDENT).value;
+          for (; this.at(TokenType.SYMBOL, "."); ) this.advance(), e += "." + this.expect(TokenType.IDENT).value;
+          return e;
         }
-        // ---- OTHERWISE ----
         parseOtherwise() {
           this.expectKeyword("OTHERWISE");
-          const body = this.parseBody();
-          return { type: "Otherwise", body };
-        }
-        // ---- REPLY [TO alvo] expressão ----
-        // ---- REPLY [TO alvo] (ficheiro.txt, N) ----
-        //
-        // A segunda forma referencia uma entrada numerada de um ficheiro de
-        // respostas (uma linha "N- texto" por entrada). Distingue-se da
-        // expressão comum porque começa por "(" seguido de um nome de
-        // ficheiro (IDENT + "." + IDENT), e não por uma STRING/NUMBER/IDENT
-        // isolado — daí o lookahead antes de decidir qual ramo seguir.
-        // ---- THINK(ficheiro.txt) ----
-        // ---- THINK(ficheiro.txt) OR REPLY (fallback.txt, N) ----
-        // ---- THINK(ficheiro.txt) OR REPLY "texto fixo" ----
-        //
-        // Diferente de REPLY: THINK não responde com um texto já mapeado, faz
-        // retrieval local sobre um ficheiro de conhecimento (ver RAG.js) e só
-        // responde se achar um bloco com confiança suficiente. Antes de
-        // procurar, sinaliza onThinking (para a plataforma poder mostrar
-        // "Pensando..." enquanto isso, já que a busca — em ficheiros grandes —
-        // não é instantânea como um REPLY comum).
-        //
-        // O "OR REPLY ..." é o fallback: só corre se THINK não encontrar nada
-        // com confiança suficiente. Fica preso ao mesmo statement (não é um
-        // segundo statement solto no corpo do WHEN) porque só faz sentido
-        // junto — um REPLY fallback sem THINK antes seria só um REPLY normal.
+          let e = this.parseBody();
+          return { type: "Otherwise", body: e };
+        }
         parseThink() {
-          this.expectKeyword("THINK");
-          this.expect(TokenType.SYMBOL, "(");
-          const file = this.parseFileName();
+          this.expectKeyword("THINK"), this.expect(TokenType.SYMBOL, "(");
+          let e = this.parseFileName();
           this.expect(TokenType.SYMBOL, ")");
-          const waiting = this.tryParseWaiting();
-          let fallback = null;
-          if (this.atKeyword("OR")) {
-            this.advance();
-            fallback = this.parseReply();
-          }
-          return { type: "Think", file, waiting, fallback };
-        }
-        // ---- WAITING() | WAITING(ficheiro.txt) | WAITING(ficheiro.txt, N) ----
-        //
-        // Modificador do THINK, sempre logo a seguir a ele, antes do OR (ver
-        // parseThink acima). Os dois argumentos são opcionais e independentes:
-        // sem nenhum, o interpretador usa texto e tempo mínimo por omissão
-        // ("Pensando...", 3 segundos) — ver botql.js, resolveWaitingConfig.
+          let t = this.tryParseWaiting(), s = null;
+          return this.atKeyword("OR") && (this.advance(), s = this.parseReply()), { type: "Think", file: e, waiting: t, fallback: s };
+        }
         tryParseWaiting() {
           if (!this.atKeyword("WAITING")) return null;
-          this.advance();
-          this.expect(TokenType.SYMBOL, "(");
-          let file = null;
-          let seconds = null;
-          if (!this.at(TokenType.SYMBOL, ")")) {
-            file = this.parseFileName();
-            if (this.at(TokenType.SYMBOL, ",")) {
-              this.advance();
-              seconds = this.parseExpression();
-            }
-          }
-          this.expect(TokenType.SYMBOL, ")");
-          return { file, seconds };
+          this.advance(), this.expect(TokenType.SYMBOL, "(");
+          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");
-          let target = null;
-          if (this.atKeyword("TO")) {
-            this.advance();
-            target = this.advance().value;
-          }
-          if (this.isReplyFileForm()) {
+          let e = null;
+          if (this.atKeyword("TO") && (this.advance(), e = this.advance().value), this.isReplyFileForm()) {
             this.expect(TokenType.SYMBOL, "(");
-            const file = this.parseFileName();
+            let t = this.parseFileName();
             this.expect(TokenType.SYMBOL, ",");
-            const index = this.parseExpression();
-            this.expect(TokenType.SYMBOL, ")");
-            return { type: "Reply", target, file, index };
+            let s = this.parseExpression();
+            return this.expect(TokenType.SYMBOL, ")"), { type: "Reply", target: e, file: t, index: s };
           }
-          const value = this.parseExpression();
-          return { type: "Reply", target, value };
+          let r = this.parseExpression();
+          return { type: "Reply", target: e, value: r };
         }
-        // Lookahead: "(" IDENT "." IDENT "," ... — só a forma de ficheiro
-        // tem "." logo a seguir ao primeiro identificador dentro dos
-        // parênteses. Uma chamada de função normal, ex: (NOW()), nunca
-        // bate aqui.
         isReplyFileForm() {
           if (!this.at(TokenType.SYMBOL, "(")) return false;
-          const next = this.tokens[this.pos + 1];
-          const afterNext = this.tokens[this.pos + 2];
-          return !!next && next.type === TokenType.IDENT && !!afterNext && afterNext.type === TokenType.SYMBOL && afterNext.value === ".";
+          let e = this.tokens[this.pos + 1], t = this.tokens[this.pos + 2];
+          return !!e && e.type === TokenType.IDENT && !!t && t.type === TokenType.SYMBOL && "." === t.value;
         }
-        // ---- FORWARD TO "contacto" ----
         parseForward() {
-          this.expectKeyword("FORWARD");
-          this.expectKeyword("TO");
-          const target = this.parseExpression();
-          return { type: "ForwardTo", target };
+          this.expectKeyword("FORWARD"), this.expectKeyword("TO");
+          let e = this.parseExpression();
+          return { type: "ForwardTo", target: e };
         }
-        // ---- PARSE SIGNAL ----
         parseParseSignal() {
-          this.expectKeyword("PARSE");
-          if (!this.atWord("SIGNAL")) this.error("expected SIGNAL after PARSE");
-          this.advance();
-          return { type: "ParseSignal" };
+          return this.expectKeyword("PARSE"), this.atWord("SIGNAL") || this.error("expected SIGNAL after PARSE"), this.advance(), { type: "ParseSignal" };
         }
-        // ---- SEND TO destino ----
         parseSend() {
-          this.expectKeyword("SEND");
-          this.expectKeyword("TO");
-          const target = this.advance().value;
-          return { type: "SendTo", target };
+          this.expectKeyword("SEND"), this.expectKeyword("TO");
+          let e = this.advance().value;
+          return { type: "SendTo", target: e };
         }
-        // ---- INSERT INTO tabela [(cols)] [VALUES (vals)] ----
         parseInsert() {
-          this.expectKeyword("INSERT");
-          this.expectKeyword("INTO");
-          const table = this.expect(TokenType.IDENT).value;
-          let columns = null;
-          if (this.at(TokenType.SYMBOL, "(")) {
-            columns = this.parseExpressionList();
-          }
-          let values = null;
-          if (this.atKeyword("VALUES")) {
-            this.advance();
-            values = this.parseExpressionList();
-          }
-          return { type: "Insert", table, columns, values };
+          this.expectKeyword("INSERT"), this.expectKeyword("INTO");
+          let e = this.expect(TokenType.IDENT).value, t = null;
+          this.at(TokenType.SYMBOL, "(") && (t = this.parseExpressionList());
+          let s = null;
+          return this.atKeyword("VALUES") && (this.advance(), s = this.parseExpressionList()), { type: "Insert", table: e, columns: t, values: s };
         }
         parseExpressionList() {
           this.expect(TokenType.SYMBOL, "(");
-          const items = [];
-          while (!this.at(TokenType.SYMBOL, ")")) {
-            items.push(this.parseExpression());
-            if (this.at(TokenType.SYMBOL, ",")) this.advance();
-          }
-          this.expect(TokenType.SYMBOL, ")");
-          return items;
+          let e = [];
+          for (; !this.at(TokenType.SYMBOL, ")"); ) e.push(this.parseExpression()), this.at(TokenType.SYMBOL, ",") && this.advance();
+          return this.expect(TokenType.SYMBOL, ")"), e;
         }
-        // ---- UPDATE tabela SET col = expr WHERE expr ----
         parseUpdate() {
           this.expectKeyword("UPDATE");
-          const table = this.expect(TokenType.IDENT).value;
+          let e = this.expect(TokenType.IDENT).value;
           this.expectKeyword("SET");
-          const column = this.expect(TokenType.IDENT).value;
+          let t = this.expect(TokenType.IDENT).value;
           this.expect(TokenType.SYMBOL, "=");
-          const value = this.parseExpression();
-          let where = null;
-          if (this.atKeyword("WHERE")) {
-            this.advance();
-            where = this.parseComparison();
-          }
-          return { type: "Update", table, set: { column, value }, where };
-        }
-        // ---- IMPORT {ficheiro.sql} ----
-        // ---- IMPORT {ficheiro.txt, N} ----
-        // ---- IMPORT {ficheiro.txt, N} AS alias ----
-        //
-        // A segunda forma importa só a entrada N de um ficheiro de valores
-        // (o mesmo formato "N- texto" usado por REPLY (ficheiro, N)), em vez
-        // do ficheiro inteiro. O índice é opcional, tal como em REPLY.
-        //
-        // AS alias só faz sentido junto com o índice (dá nome ao valor lido,
-        // para CONNECT RESPONSE/Response(...) e qualquer outra expressão
-        // referenciarem por esse nome em vez do nome generico "env"). Sem AS,
-        // mantém-se o comportamento original: o valor cai em env.NOME_FICHEIRO.
+          let s = this.parseExpression(), r = null;
+          return this.atKeyword("WHERE") && (this.advance(), r = this.parseComparison()), { type: "Update", table: e, set: { column: t, value: s }, where: r };
+        }
         parseImport() {
-          this.expectKeyword("IMPORT");
-          this.expect(TokenType.SYMBOL, "{");
-          const path = this.parseFileName();
-          let index = null;
-          if (this.at(TokenType.SYMBOL, ",")) {
-            this.advance();
-            index = this.parseExpression();
-          }
-          this.expect(TokenType.SYMBOL, "}");
-          let alias = null;
-          if (this.atKeyword("AS")) {
-            this.advance();
-            alias = this.expect(TokenType.IDENT).value;
-          }
-          return { type: "Import", path, index, alias };
+          this.expectKeyword("IMPORT"), this.expect(TokenType.SYMBOL, "{");
+          let e = this.parseFileName(), t = null;
+          this.at(TokenType.SYMBOL, ",") && (this.advance(), t = this.parseExpression()), this.expect(TokenType.SYMBOL, "}");
+          let s = null;
+          return this.atKeyword("AS") && (this.advance(), s = this.expect(TokenType.IDENT).value), { type: "Import", path: e, index: t, alias: s };
         }
-        // ---- RUN BOT ----
         parseRunBot() {
-          this.expectKeyword("RUN");
-          this.expectKeyword("BOT");
-          return { type: "RunBot" };
+          return this.expectKeyword("RUN"), this.expectKeyword("BOT"), { type: "RunBot" };
         }
-        // ---- Expressões: literais, identificadores, chamadas, acesso a
-        // propriedade (obj.prop) e concatenação com "+" ----
         parseExpression() {
-          let node = this.parsePrimary();
-          while (this.at(TokenType.SYMBOL, "+")) {
+          let e = this.parsePrimary();
+          for (; this.at(TokenType.SYMBOL, "+"); ) {
             this.advance();
-            const right = this.parsePrimary();
-            node = { type: "Binary", op: "+", left: node, right };
+            let t = this.parsePrimary();
+            e = { type: "Binary", op: "+", left: e, right: t };
           }
-          return node;
+          return e;
         }
-        // Igualdade, usada em WHERE (ex: id = LAST_INSERT_ID())
         parseComparison() {
-          const left = this.parseExpression();
+          let e = this.parseExpression();
           if (this.at(TokenType.SYMBOL, "=")) {
             this.advance();
-            const right = this.parseExpression();
-            return { type: "Binary", op: "=", left, right };
+            let t = this.parseExpression();
+            return { type: "Binary", op: "=", left: e, right: t };
           }
-          return left;
+          return e;
         }
         parsePrimary() {
-          const tok = this.current();
-          if (tok.type === TokenType.STRING) {
-            this.advance();
-            return { type: "Literal", value: tok.value };
-          }
-          if (tok.type === TokenType.NUMBER) {
-            this.advance();
-            return { type: "Literal", value: tok.value };
-          }
-          if (tok.type === TokenType.IDENT) {
+          let e = this.current();
+          if (e.type === TokenType.STRING || e.type === TokenType.NUMBER) return this.advance(), { type: "Literal", value: e.value };
+          if (e.type === TokenType.IDENT) {
             this.advance();
-            let node = { type: "Identifier", name: tok.value };
+            let t = { type: "Identifier", name: e.value };
             if (this.at(TokenType.SYMBOL, "(")) {
-              const args = this.parseExpressionList();
-              node = { type: "Call", callee: node.name, args };
+              let s = this.parseExpressionList();
+              t = { type: "Call", callee: t.name, args: s };
             }
-            while (this.at(TokenType.SYMBOL, ".")) {
+            for (; this.at(TokenType.SYMBOL, "."); ) {
               this.advance();
-              const prop = this.expect(TokenType.IDENT).value;
-              node = { type: "Member", object: node, property: prop };
+              let r = this.expect(TokenType.IDENT).value;
+              t = { type: "Member", object: t, property: r };
             }
-            return node;
+            return t;
           }
           this.error("invalid expression");
         }
       };
-      module.exports = { Parser, Tokenizer, TokenType, KEYWORDS };
+      module.exports = { Parser, Tokenizer, TokenType, KEYWORDS, BotQLSyntaxError };
     }
   });
 
@@ -668,97 +377,72 @@ var BotQL = (() => {
   var require_Database = __commonJS({
     "Database.js"(exports, module) {
       "use strict";
-      var CONTEXT_SCHEMA = [
-        { name: "id", columnType: "INT", constraints: ["PRIMARY", "KEY", "AUTO_INCREMENT"] },
-        { name: "client", columnType: "TEXT", constraints: [] },
-        { name: "message", columnType: "TEXT", constraints: [] },
-        { name: "reply", columnType: "TEXT", constraints: [] },
-        { name: "created_at", columnType: "DATETIME", constraints: [] }
-      ];
+      var CONTEXT_SCHEMA = [{ name: "id", columnType: "INT", constraints: ["PRIMARY", "KEY", "AUTO_INCREMENT"] }, { name: "client", columnType: "TEXT", constraints: [] }, { name: "message", columnType: "TEXT", constraints: [] }, { name: "reply", columnType: "TEXT", constraints: [] }, { name: "created_at", columnType: "DATETIME", constraints: [] }];
       var MemoryDatabase = class {
         constructor() {
-          this.tables = /* @__PURE__ */ new Map();
-          this.autoIncrement = /* @__PURE__ */ new Map();
-        }
-        createTable(name, columns, preventDefault) {
-          const resolvedColumns = name === "Context" && columns.length === 0 ? CONTEXT_SCHEMA : columns;
-          if (this.tables.has(name)) {
-            if (preventDefault) return;
-            throw new Error(`runtime error: table "${name}" already exists`);
-          }
-          this.tables.set(name, { columns: resolvedColumns, rows: [] });
-          this.autoIncrement.set(name, 0);
-        }
-        insert(table, columnNames, values) {
-          const t = this.tables.get(table);
-          if (!t) throw new Error(`runtime error: table "${table}" does not exist`);
-          const nextId = this.autoIncrement.get(table) + 1;
-          this.autoIncrement.set(table, nextId);
-          const row = { id: nextId };
-          columnNames.forEach((col, i) => {
-            row[col] = values[i];
-          });
-          t.rows.push(row);
-          return nextId;
-        }
-        update(table, column, value, whereColumn, whereValue) {
-          const t = this.tables.get(table);
-          if (!t) throw new Error(`runtime error: table "${table}" does not exist`);
-          const row = whereColumn ? t.rows.find((r) => r[whereColumn] === whereValue) : t.rows[t.rows.length - 1];
-          if (row) row[column] = value;
-          return row || null;
-        }
-        getRows(table) {
-          const t = this.tables.get(table);
+          this.tables = /* @__PURE__ */ new Map(), this.autoIncrement = /* @__PURE__ */ new Map();
+        }
+        createTable(e, t, r) {
+          let s = "Context" === e && 0 === t.length ? CONTEXT_SCHEMA : t;
+          if (this.tables.has(e)) {
+            if (r) return;
+            throw Error(`runtime error: table "${e}" already exists`);
+          }
+          this.tables.set(e, { columns: s, rows: [] }), this.autoIncrement.set(e, 0);
+        }
+        insert(e, t, r) {
+          let s = this.tables.get(e);
+          if (!s) throw Error(`runtime error: table "${e}" does not exist`);
+          let n = this.autoIncrement.get(e) + 1;
+          this.autoIncrement.set(e, n);
+          let i = { id: n };
+          return t.forEach((e2, t2) => {
+            i[e2] = r[t2];
+          }), s.rows.push(i), n;
+        }
+        update(e, t, r, s, n) {
+          let i = this.tables.get(e);
+          if (!i) throw Error(`runtime error: table "${e}" does not exist`);
+          let a = s ? i.rows.find((e2) => e2[s] === n) : i.rows[i.rows.length - 1];
+          return a && (a[t] = r), a || null;
+        }
+        getRows(e) {
+          let t = this.tables.get(e);
           return t ? t.rows.slice() : [];
         }
       };
-      function mapColumnType(columnType) {
-        const type = (columnType || "").toUpperCase();
-        if (type === "INT" || type === "INTEGER") return "INTEGER";
-        if (type === "DATETIME" || type === "DATE") return "TEXT";
-        return "TEXT";
+      function mapColumnType(e) {
+        let t = (e || "").toUpperCase();
+        return "INT" === t || "INTEGER" === t ? "INTEGER" : "TEXT";
       }
-      function buildColumnDef(col) {
-        const type = mapColumnType(col.columnType);
-        const isPrimary = col.constraints.includes("PRIMARY") && col.constraints.includes("KEY");
-        const isAutoIncrement = col.constraints.includes("AUTO_INCREMENT");
-        let def = `${col.name} ${type}`;
-        if (isPrimary) def += " PRIMARY KEY";
-        if (isPrimary && isAutoIncrement) def += " AUTOINCREMENT";
-        return def;
+      function buildColumnDef(e) {
+        let t = mapColumnType(e.columnType), r = e.constraints.includes("PRIMARY") && e.constraints.includes("KEY"), s = e.constraints.includes("AUTO_INCREMENT"), n = `${e.name} ${t}`;
+        return r && (n += " PRIMARY KEY"), r && s && (n += " AUTOINCREMENT"), n;
       }
       var SQLiteDatabase = class {
-        /**
-        * @param {string} filePath Caminho do ficheiro .sqlite, ou ":memory:" para um banco temporário.
-        */
-        constructor(filePath = ":memory:") {
-          const { DatabaseSync } = __require("node:sqlite");
-          this.driver = new DatabaseSync(filePath);
-        }
-        createTable(name, columns, preventDefault) {
-          const resolvedColumns = name === "Context" && columns.length === 0 ? CONTEXT_SCHEMA : columns;
-          const columnDefs = resolvedColumns.map(buildColumnDef).join(", ");
-          const ifNotExists = preventDefault ? "IF NOT EXISTS " : "";
-          this.driver.exec(`CREATE TABLE ${ifNotExists}${name} (${columnDefs})`);
-        }
-        insert(table, columnNames, values) {
-          const placeholders = columnNames.map(() => "?").join(", ");
-          const sql = `INSERT INTO ${table} (${columnNames.join(", ")}) VALUES (${placeholders})`;
-          const info = this.driver.prepare(sql).run(...values);
-          return Number(info.lastInsertRowid);
-        }
-        update(table, column, value, whereColumn, whereValue) {
-          if (whereColumn) {
-            const sql = `UPDATE ${table} SET ${column} = ? WHERE ${whereColumn} = ?`;
-            this.driver.prepare(sql).run(value, whereValue);
+        constructor(e = ":memory:") {
+          let { DatabaseSync: t } = __require("node:sqlite");
+          this.driver = new t(e);
+        }
+        createTable(e, t, r) {
+          let s = "Context" === e && 0 === t.length ? CONTEXT_SCHEMA : t, n = s.map(buildColumnDef).join(", ");
+          this.driver.exec(`CREATE TABLE ${r ? "IF NOT EXISTS " : ""}${e} (${n})`);
+        }
+        insert(e, t, r) {
+          let s = t.map(() => "?").join(", "), n = `INSERT INTO ${e} (${t.join(", ")}) VALUES (${s})`, i = this.driver.prepare(n).run(...r);
+          return Number(i.lastInsertRowid);
+        }
+        update(e, t, r, s, n) {
+          if (s) {
+            let i = `UPDATE ${e} SET ${t} = ? WHERE ${s} = ?`;
+            this.driver.prepare(i).run(r, n);
           } else {
-            const sql = `UPDATE ${table} SET ${column} = ? WHERE id = (SELECT MAX(id) FROM ${table})`;
-            this.driver.prepare(sql).run(value);
+            let a = `UPDATE ${e} SET ${t} = ? WHERE id = (SELECT MAX(id) FROM ${e})`;
+            this.driver.prepare(a).run(r);
           }
         }
-        getRows(table) {
-          return this.driver.prepare(`SELECT * FROM ${table}`).all();
+        getRows(e) {
+          return this.driver.prepare(`SELECT * FROM ${e}`).all();
         }
         close() {
           this.driver.close();
@@ -841,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
-            );
-          }
-          linhaAnterior = linhaAtual;
-        }
-        return linhaAnterior[lb];
+      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);
+          }
+          s = a;
+        }
+        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);
-            }
-          }
-          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;
+          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 = 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 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;
             }
-          }
-          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;
-            }
-            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);
-          }
-          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;
+            let h = 2.5 * a, u = a + 1.5 * (0.7 + 0.3 * (i.length / this.avgDocLen));
+            r += c * l * (h / u);
+          }
+          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 };
@@ -1349,572 +749,308 @@ var BotQL = (() => {
   // botql.js
   var require_botql = __commonJS({
     "botql.js"(exports, module) {
-      var { Parser } = require_Parser();
-      var { MemoryDatabase } = require_Database();
-      var { createDefaultFileSystem } = require_FileSystem();
-      var { KnowledgeCache } = require_RAG();
-      var WAITING_TEXTO_PADRAO = "Pensando...";
-      var WAITING_SEGUNDOS_PADRAO = 3;
+      var { Parser: e } = require_Parser();
+      var { MemoryDatabase: t } = require_Database();
+      var { createDefaultFileSystem: s } = require_FileSystem();
+      var { KnowledgeCache: i } = require_RAG();
       var BotQLInterpreter = class _BotQLInterpreter {
-        constructor(options = {}) {
-          this.db = options.db || new MemoryDatabase();
-          this.onReply = options.onReply || null;
-          this.onForward = options.onForward || null;
-          this.onSend = options.onSend || null;
-          this.signalParser = options.signalParser || ((raw) => raw);
-          this.onThinking = options.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 = options.onResponse || null;
-          this.defaultMessageConfig = null;
-          this.nativeFuncs = /* @__PURE__ */ new Map();
-          this.registerFunction("NOW", () => (/* @__PURE__ */ new Date()).toISOString());
-          this.fileSystem = options.fileSystem || createDefaultFileSystem();
-          const defaultBasePath = typeof process !== "undefined" && process.cwd ? process.cwd() : "";
-          this._basePathStack = [options.basePath || defaultBasePath];
-          this._importedFiles = /* @__PURE__ */ new Set();
-          this._rootBasePath = options.basePath || defaultBasePath;
-          this._keywordsFileCache = /* @__PURE__ */ new Map();
-          this._replyFileCache = /* @__PURE__ */ new Map();
-          this.envValues = /* @__PURE__ */ new Map();
-          this.knowledgeCache = new KnowledgeCache(this.fileSystem);
-        }
-        static fromSource(source, options = {}) {
-          const ast = new Parser(source).parseProgram();
-          const interpreter = new _BotQLInterpreter(options);
-          interpreter.load(ast);
-          return interpreter;
-        }
-        // Lê um ficheiro .sql do disco (ou de outro fileSystem injetado) e usa
-        // a sua pasta como base para resolver IMPORTs relativos dentro dele.
-        static fromFile(filePath, options = {}) {
-          const fileSystem = options.fileSystem || createDefaultFileSystem();
-          const resolved = fileSystem.resolve("", filePath);
-          const source = fileSystem.readFile(resolved);
-          return _BotQLInterpreter.fromSource(source, {
-            ...options,
-            fileSystem,
-            basePath: fileSystem.dirname(resolved)
-          });
-        }
-        registerFunction(name, fn) {
-          this.nativeFuncs.set(name, fn);
-        }
-        // ---- Carregamento da AST: statements de topo, fora de eventos ----
-        //
-        // IMPORT é sempre resolvido antes de qualquer outro comando, independente
-        // de onde aparece no ficheiro (tal como o SOURCE do MySQL ou o \i do
-        // psql) — por isso o corpo é primeiro "achatado": todo o conteúdo vindo
-        // de ficheiros importados entra ANTES dos statements do próprio ficheiro,
-        // recursivamente, mesmo que o IMPORT apareça no meio ou no fim do texto.
-        load(ast, basePath = this._basePathStack[this._basePathStack.length - 1]) {
-          const flatBody = this._flattenImports(ast.body, basePath);
-          for (const node of flatBody) {
-            switch (node.type) {
-              case "CreateBot":
-                this.botName = node.name;
-                break;
-              case "Platform":
-                this.platform = node.value;
-                break;
-              case "Connect":
-                this.connections.push({
-                  service: node.service,
-                  kind: node.kind,
-                  credential: node.credential
-                });
-                break;
-              case "ConnectResponse":
-                if (!this.envValues.has(node.alias)) {
-                  throw new Error(`runtime error: CONNECT RESPONSE failed, alias "${node.alias}" was not imported (use IMPORT {..., N} AS ${node.alias})`);
-                }
-                this.responseConnections.add(node.alias);
-                break;
-              case "CreateTable":
-                this.db.createTable(node.name, node.columns, node.preventDefault);
-                if (node.defaultMessage) {
-                  const senderColumn = node.name === "Context" ? "client" : (node.columns.find((c) => c.name === "client" || c.name === "sender") || {}).name;
-                  if (!senderColumn) {
-                    throw new Error(`runtime error: DEFAULT MESSAGE on table "${node.name}" requires a "client" or "sender" column`);
-                  }
-                  this.defaultMessageConfig = { table: node.name, senderColumn, ...node.defaultMessage };
-                }
-                break;
-              case "On":
-                this.handlers[node.event].push(node);
-                break;
-              case "RunBot":
-                this.running = true;
-                break;
-              default:
-                throw new Error(`runtime error: unsupported top-level statement: ${node.type}`);
-            }
+        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._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);
+        }
+        static fromSource(t2, s2 = {}) {
+          let i2 = new e(t2).parseProgram(), n = new _BotQLInterpreter(s2);
+          return n.load(i2), n;
+        }
+        static fromFile(e2, t2 = {}) {
+          let i2 = t2.fileSystem || s(), n = i2.resolve("", e2), r = i2.readFile(n);
+          return _BotQLInterpreter.fromSource(r, { ...t2, fileSystem: i2, basePath: i2.dirname(n) });
+        }
+        registerFunction(e2, t2) {
+          this.nativeFuncs.set(e2, t2);
+        }
+        load(e2, t2 = this._basePathStack[this._basePathStack.length - 1]) {
+          let s2 = this._flattenImports(e2.body, t2);
+          for (let i2 of s2) switch (i2.type) {
+            case "CreateBot":
+              this.botName = i2.name;
+              break;
+            case "Platform":
+              this.platform = i2.value;
+              break;
+            case "Connect":
+              this.connections.push({ service: i2.service, kind: i2.kind, credential: i2.credential });
+              break;
+            case "ConnectResponse":
+              if (!this.envValues.has(i2.alias)) throw Error(`runtime error: CONNECT RESPONSE failed, alias "${i2.alias}" was not imported (use IMPORT {..., N} AS ${i2.alias})`);
+              this.responseConnections.add(i2.alias);
+              break;
+            case "CreateTable":
+              if (this.db.createTable(i2.name, i2.columns, i2.preventDefault), i2.defaultMessage) {
+                let n = "Context" === i2.name ? "client" : (i2.columns.find((e3) => "client" === e3.name || "sender" === e3.name) || {}).name;
+                if (!n) throw Error(`runtime error: DEFAULT MESSAGE on table "${i2.name}" requires a "client" or "sender" column`);
+                this.defaultMessageConfig = { table: i2.name, senderColumn: n, ...i2.defaultMessage };
+              }
+              break;
+            case "On":
+              this.handlers[i2.event].push(i2);
+              break;
+            case "RunBot":
+              this.running = true;
+              break;
+            default:
+              throw Error(`runtime error: unsupported top-level statement: ${i2.type}`);
           }
         }
-        // Devolve um array de statements sem nenhum nó 'Import': o conteúdo de
-        // cada ficheiro importado é lido, parseado e achatado recursivamente
-        // primeiro (imports dentro de imports também respeitam a regra), e só
-        // depois vêm os statements que pertencem a este próprio ficheiro.
-        //
-        // IMPORT {ficheiro.sql} (sem índice) — comportamento original: lê o
-        // ficheiro inteiro como código BotQL e junta ao programa.
-        //
-        // IMPORT {ficheiro.txt, N} (com índice) — não é código: lê só a
-        // entrada N do ficheiro (mesmo formato "N- valor" do REPLY indexado)
-        // e guarda em this.envValues. Com AS alias, a chave é o alias (fica
-        // acessível diretamente pelo nome, ex: K, CONNECT RESPONSE K); sem
-        // AS, mantém-se o comportamento original — chave é o nome do
-        // ficheiro sem extensão, só acessível via env.NOME_FICHEIRO. Um
-        // ficheiro sem AS não pode ser usado por CONNECT RESPONSE (exige
-        // alias explícito, para não colidir com outros IMPORTs do mesmo
-        // ficheiro em índices diferentes).
-        // Não produz nenhum statement — é resolvido e removido do AST aqui
-        // mesmo, antes de correr qualquer evento.
-        _flattenImports(body, basePath) {
-          const fromImports = [];
-          const ownStatements = [];
-          for (const node of body) {
-            if (node.type !== "Import") {
-              ownStatements.push(node);
+        _flattenImports(t2, s2) {
+          let i2 = [], n = [];
+          for (let r of t2) {
+            if ("Import" !== r.type) {
+              n.push(r);
               continue;
             }
-            if (node.index !== null && node.index !== void 0) {
-              const index = this.evalExpr(node.index, this.createContext());
-              const entries = this._loadIndexedFile(node.path, basePath);
-              const value = entries.get(Number(index));
-              if (value === void 0) {
-                throw new Error(`runtime error: IMPORT failed, entry ${index} not found in "${node.path}"`);
-              }
-              const key = node.alias || node.path.replace(/\.[^.]+$/, "");
-              this.envValues.set(key, value);
+            if (null !== r.index && void 0 !== r.index) {
+              let a = this.evalExpr(r.index, this.createContext()), l = this._loadIndexedFile(r.path, s2), o = l.get(Number(a));
+              if (void 0 === o) throw Error(`runtime error: IMPORT failed, entry ${a} not found in "${r.path}"`);
+              let h = r.alias || r.path.replace(/\.[^.]+$/, "");
+              this.envValues.set(h, o);
               continue;
             }
-            const fullPath = this.fileSystem.resolve(basePath, node.path);
-            if (this._importedFiles.has(fullPath)) continue;
-            if (!this.fileSystem.exists(fullPath)) {
-              throw new Error(`runtime error: IMPORT failed, file not found: "${fullPath}"`);
-            }
-            this._importedFiles.add(fullPath);
-            const source = this.fileSystem.readFile(fullPath);
-            const importedAst = new Parser(source).parseProgram();
-            const nestedFlat = this._flattenImports(importedAst.body, this.fileSystem.dirname(fullPath));
-            fromImports.push(...nestedFlat);
-          }
-          return [...fromImports, ...ownStatements];
-        }
-        // ---- Contexto de execução de um evento ----
-        createContext(base = {}) {
-          return {
-            vars: {
-              client: base.client || null,
-              message: base.message || null,
-              lastMsg: null,
-              SIGNAL: null
-            },
-            rawSignal: base.rawSignal || null,
-            lastInsertId: null
-          };
-        }
-        // ---- Ciclo de vida do bot ----
-        async start() {
-          for (const handler of this.handlers.START) {
-            const ctx = this.createContext();
-            await this.run(handler.body, ctx);
+            let u = this.fileSystem.resolve(s2, r.path);
+            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), d = new e(c).parseProgram(), f = this._flattenImports(d.body, this.fileSystem.dirname(u));
+            i2.push(...f);
           }
+          return [...i2, ...n];
         }
-        async receiveMessage(client, message) {
-          const ctx = this.createContext({ client, message });
-          const cumprimentou = await this.greetIfNew(client);
-          if (cumprimentou) return ctx;
-          for (const handler of this.handlers.MESSAGE) {
-            await this.run(handler.body, ctx);
-          }
-          return ctx;
-        }
-        // Mostra a DEFAULT MESSAGE para este client, se ainda não for
-        // conhecido — sem precisar de nenhuma mensagem recebida. Usado por
-        // receiveMessage() (caso real, reativo) e também pode ser chamado
-        // diretamente pelo editor/preview ao abrir o chat, já que aí não há a
-        // restrição das plataformas reais de só poder responder depois do
-        // utilizador escrever primeiro. Devolve true se cumprimentou (e por
-        // isso nada mais deve correr nesse turno), false caso contrário —
-        // incluindo quando não há DEFAULT MESSAGE nenhuma configurada.
-        async greetIfNew(client) {
-          if (!this.defaultMessageConfig) return false;
-          const { table, senderColumn } = this.defaultMessageConfig;
-          const jaConhecido = this.db.getRows(table).some((row) => row[senderColumn] === client);
-          if (jaConhecido) return false;
-          const ctx = this.createContext({ client });
-          const text = this.resolveDefaultMessageText(this.defaultMessageConfig, ctx);
-          ctx.vars.lastMsg = text;
-          this.db.insert(table, [senderColumn], [client]);
-          if (this.onReply) {
-            await this.onReply({ target: null, text, client });
-          }
-          return true;
+        createContext(e2 = {}) {
+          return { vars: { client: e2.client || null, message: e2.message || null, lastMsg: null, SIGNAL: null }, rawSignal: e2.rawSignal || null, lastInsertId: null };
         }
-        // Resolve o texto do DEFAULT MESSAGE: mesma dualidade texto-direto vs
-        // ficheiro indexado que o REPLY já tem (ver resolveReplyFromFile).
-        resolveDefaultMessageText(config, ctx) {
-          if (config.file) {
-            return this.resolveReplyFromFile(config.file, config.index, ctx);
+        async start() {
+          for (let e2 of this.handlers.START) {
+            let t2 = this.createContext();
+            await this.run(e2.body, t2);
           }
-          return String(this.evalExpr(config.value, ctx));
         }
-        async receiveSignal(source, rawSignal) {
-          const ctx = this.createContext({ rawSignal });
-          for (const handler of this.handlers.SIGNAL) {
-            if (handler.source !== source) continue;
-            await this.run(handler.body, ctx);
+        async receiveMessage(e2, t2) {
+          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);
           }
-          return ctx;
-        }
-        // ---- Execução de uma lista de statements (corpo de um bloco) ----
-        async run(statements, ctx) {
-          let groupMatched = false;
-          for (let i = 0; i < statements.length; i++) {
-            const stmt = statements[i];
-            if (stmt.type === "When") {
-              if (i === 0 || statements[i - 1].type !== "When") groupMatched = false;
-              const isMatch = stmt.conditions.some((cond) => this.evalCondition(cond, ctx));
-              if (isMatch) {
-                await this.run(stmt.body, ctx);
-                groupMatched = true;
-              }
+        }
+        async greetIfNew(e2) {
+          if (!this.defaultMessageConfig) return false;
+          let { table: t2, senderColumn: s2 } = this.defaultMessageConfig, i2 = this.db.getRows(t2).some((t3) => t3[s2] === e2);
+          if (i2) return false;
+          let n = this.createContext({ client: e2 }), r = this.resolveDefaultMessageText(this.defaultMessageConfig, n);
+          return n.vars.lastMsg = r, this.db.insert(t2, [s2], [e2]), this.onReply && await this.onReply({ target: null, text: r, client: e2 }), true;
+        }
+        resolveDefaultMessageText(e2, t2) {
+          return e2.file ? this.resolveReplyFromFile(e2.file, e2.index, t2) : String(this.evalExpr(e2.value, t2));
+        }
+        async receiveSignal(e2, t2) {
+          let s2 = this.createContext({ rawSignal: t2 });
+          for (let i2 of this.handlers.SIGNAL) i2.source === e2 && await this.run(i2.body, s2);
+          return s2;
+        }
+        async run(e2, t2) {
+          let s2 = false;
+          for (let i2 = 0; i2 < e2.length; i2++) {
+            let n = e2[i2];
+            if ("When" === n.type) {
+              (0 === i2 || "When" !== e2[i2 - 1].type) && (s2 = false);
+              let r = n.conditions.some((e3) => this.evalCondition(e3, t2));
+              r && (await this.run(n.body, t2), s2 = true);
               continue;
             }
-            if (stmt.type === "Otherwise") {
-              if (!groupMatched) await this.run(stmt.body, ctx);
-              groupMatched = false;
+            if ("Otherwise" === n.type) {
+              s2 || await this.run(n.body, t2), s2 = false;
               continue;
             }
-            await this.execStatement(stmt, ctx);
-          }
-        }
-        evalCondition(cond, ctx) {
-          if (typeof ctx.vars.message !== "string") return false;
-          const message = ctx.vars.message.toLowerCase();
-          if (cond.op === "CONTAINS") {
-            return message.includes(cond.value.toLowerCase());
-          }
-          if (cond.op === "CONTAINS_ANY") {
-            return cond.values.some((v) => message.includes(v.toLowerCase()));
-          }
-          if (cond.op === "CONTAINS_KEYWORDS_FILE") {
-            const words = this._loadKeywordsFile(cond.path);
-            return words.some((v) => message.includes(v.toLowerCase()));
-          }
-          throw new Error(`runtime error: unsupported condition: ${cond.op}`);
-        }
-        // Lê um ficheiro de keywords: uma palavra/frase por linha, nada mais.
-        // Sem comentários nem qualquer outra sintaxe misturada de propósito —
-        // um ficheiro só serve para um fim, evita ambiguidade sobre o que é
-        // keyword e o que não é. Resultado fica em cache — chamado a cada
-        // mensagem recebida, não pode reler disco/rede sempre.
-        _loadKeywordsFile(path) {
-          if (this._keywordsFileCache.has(path)) {
-            return this._keywordsFileCache.get(path);
-          }
-          const fullPath = this.fileSystem.resolve(this._rootBasePath, path);
-          if (!this.fileSystem.exists(fullPath)) {
-            throw new Error(`runtime error: KEYWORDS failed, file not found: "${fullPath}"`);
-          }
-          const raw = this.fileSystem.readFile(fullPath);
-          const words = raw.split("\n").map((linha) => linha.trim()).filter((linha) => linha.length > 0);
-          this._keywordsFileCache.set(path, words);
-          return words;
-        }
-        // Resolve o texto e o tempo mínimo do WAITING(...) de um THINK. Sem
-        // WAITING nenhum no .sql (stmt.waiting === null), ou com WAITING()
-        // vazio, usa os valores por omissão. O ficheiro do WAITING é lido tal
-        // e qual (texto/HTML livre) — ao contrário do REPLY/DEFAULT MESSAGE
-        // indexados, não é o formato "N- valor".
-        resolveWaitingConfig(waiting, ctx) {
-          if (!waiting) return { text: WAITING_TEXTO_PADRAO, seconds: WAITING_SEGUNDOS_PADRAO };
-          let text = WAITING_TEXTO_PADRAO;
-          if (waiting.file) {
-            const fullPath = this.fileSystem.resolve(this._rootBasePath, waiting.file);
-            if (!this.fileSystem.exists(fullPath)) {
-              throw new Error(`runtime error: WAITING failed, file not found: "${fullPath}"`);
-            }
-            text = this.fileSystem.readFile(fullPath).trim();
-          }
-          let seconds = WAITING_SEGUNDOS_PADRAO;
-          if (waiting.seconds) {
-            seconds = Number(this.evalExpr(waiting.seconds, ctx));
-          }
-          return { text, seconds };
-        }
-        // Resolve REPLY (ficheiro.txt, indice): lê o índice (número ou
-        // expressão que resolve a número) e devolve o texto da entrada
-        // correspondente do ficheiro de respostas.
-        resolveReplyFromFile(file, indexNode, ctx) {
-          const index = this.evalExpr(indexNode, ctx);
-          const entries = this._loadIndexedFile(file, this._rootBasePath);
-          const text = entries.get(Number(index));
-          if (text === void 0) {
-            throw new Error(`runtime error: REPLY failed, entry ${index} not found in "${file}"`);
-          }
-          return text;
-        }
-        // Lê um ficheiro de entradas numeradas. Duas formas, na mesma
-        // entrada N, nunca misturadas:
-        //
-        //   N- texto            — uma linha só (forma original, continua igual)
-        //   N-{ ... }            — bloco delimitado por chaves, pode ter
-        //                          varias linhas e HTML/Markdown/CSS por
-        //                          dentro. So fecha na "}" que corresponde a
-        //                          "{" que abriu — chaves internas (ex: um
-        //                          style="{color:red}" dentro do HTML) contam
-        //                          para o aninhamento e NAO fecham a entrada
-        //                          cedo. Rigoroso: uma "{" sem a "}"
-        //                          correspondente antes do fim do ficheiro e'
-        //                          erro, nunca silenciosamente ignorado.
-        //
-        // Resultado e' um Map indice -> valor, em cache — usado tanto por
-        // REPLY (ficheiro, N) como por IMPORT {ficheiro, N}.
-        _loadIndexedFile(path, basePath) {
-          if (this._replyFileCache.has(path)) {
-            return this._replyFileCache.get(path);
-          }
-          const fullPath = this.fileSystem.resolve(basePath, path);
-          if (!this.fileSystem.exists(fullPath)) {
-            throw new Error(`runtime error: file not found: "${fullPath}"`);
-          }
-          const raw = this.fileSystem.readFile(fullPath);
-          const entries = this._parseIndexedEntries(raw, path);
-          this._replyFileCache.set(path, entries);
-          return entries;
-        }
-        // Parser char-by-char do formato de entradas numeradas. Percorre o
-        // ficheiro procurando "N-" no inicio de uma linha (ignorando espacos);
-        // o que vem a seguir decide a forma:
-        //   "{" logo a seguir -> bloco: conta chaves ate a correspondente
-        //        fechar, valor e' o conteudo entre elas (sem as chaves),
-        //        aparado nas pontas.
-        //   qualquer outra coisa -> forma de uma linha: valor e' o resto da
-        //        linha, aparado.
-        _parseIndexedEntries(raw, path) {
-          const entries = /* @__PURE__ */ new Map();
-          const len = raw.length;
-          let i = 0;
-          while (i < len) {
-            const lineStart = i;
-            let j = lineStart;
-            while (j < len && (raw[j] === " " || raw[j] === "	")) j++;
-            const numMatch = /^\d+/.exec(raw.slice(j));
-            if (!numMatch || raw[j + numMatch[0].length] !== "-") {
-              const nl2 = raw.indexOf("\n", lineStart);
-              i = nl2 === -1 ? len : nl2 + 1;
+            await this.execStatement(n, t2);
+          }
+        }
+        evalCondition(e2, t2) {
+          if ("string" != typeof t2.vars.message) return false;
+          let s2 = t2.vars.message.toLowerCase();
+          if ("CONTAINS" === e2.op) return s2.includes(e2.value.toLowerCase());
+          if ("CONTAINS_ANY" === e2.op) return e2.values.some((e3) => s2.includes(e3.toLowerCase()));
+          if ("CONTAINS_KEYWORDS_FILE" === e2.op) {
+            let i2 = this._loadKeywordsFile(e2.path);
+            return i2.some((e3) => s2.includes(e3.toLowerCase()));
+          }
+          throw Error(`runtime error: unsupported condition: ${e2.op}`);
+        }
+        _loadKeywordsFile(e2) {
+          if (this._keywordsFileCache.has(e2)) return this._keywordsFileCache.get(e2);
+          let t2 = this.fileSystem.resolve(this._rootBasePath, e2);
+          if (!this.fileSystem.exists(t2)) throw Error(`runtime error: KEYWORDS failed, file not found: "${t2}"`);
+          let s2 = this.fileSystem.readFile(t2), i2 = s2.split("\n").map((e3) => e3.trim()).filter((e3) => e3.length > 0);
+          return this._keywordsFileCache.set(e2, i2), i2;
+        }
+        resolveWaitingConfig(e2, t2) {
+          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();
+          }
+          let n = 3;
+          return e2.seconds && (n = Number(this.evalExpr(e2.seconds, t2))), { text: s2, seconds: n };
+        }
+        resolveReplyFromFile(e2, t2, s2) {
+          let i2 = this.evalExpr(t2, s2), n = this._loadIndexedFile(e2, this._rootBasePath), r = n.get(Number(i2));
+          if (void 0 === r) throw Error(`runtime error: REPLY failed, entry ${i2} not found in "${e2}"`);
+          return r;
+        }
+        _loadIndexedFile(e2, t2) {
+          if (this._replyFileCache.has(e2)) return this._replyFileCache.get(e2);
+          let s2 = this.fileSystem.resolve(t2, e2);
+          if (!this.fileSystem.exists(s2)) throw Error(`runtime error: file not found: "${s2}"`);
+          let i2 = this.fileSystem.readFile(s2), n = this._parseIndexedEntries(i2, e2);
+          return this._replyFileCache.set(e2, n), n;
+        }
+        _parseIndexedEntries(e2, t2) {
+          let s2 = /* @__PURE__ */ new Map(), i2 = e2.length, n = 0;
+          for (; n < i2; ) {
+            let r = n, a = r;
+            for (; a < i2 && (" " === e2[a] || "	" === e2[a]); ) a++;
+            let l = /^\d+/.exec(e2.slice(a));
+            if (!l || "-" !== e2[a + l[0].length]) {
+              let o = e2.indexOf("\n", r);
+              n = -1 === o ? i2 : o + 1;
               continue;
             }
-            const index = Number(numMatch[0]);
-            let k = j + numMatch[0].length + 1;
-            if (raw[k] === "{") {
-              let depth = 1;
-              const contentStart = k + 1;
-              let p = contentStart;
-              while (p < len && depth > 0) {
-                if (raw[p] === "{") depth++;
-                else if (raw[p] === "}") depth--;
-                p++;
-              }
-              if (depth !== 0) {
-                throw new Error(`runtime error: unclosed "{" for entry ${index} in "${path}"`);
-              }
-              const value2 = raw.slice(contentStart, p - 1).trim();
-              entries.set(index, value2);
-              i = p;
+            let h = Number(l[0]), u = a + l[0].length + 1;
+            if ("{" === e2[u]) {
+              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(d, f - 1).trim();
+              s2.set(h, p), n = f;
               continue;
             }
-            const nl = raw.indexOf("\n", k);
-            const lineEnd = nl === -1 ? len : nl;
-            const value = raw.slice(k, lineEnd).trim();
-            entries.set(index, value);
-            i = nl === -1 ? len : nl + 1;
+            let m = e2.indexOf("\n", u), w = -1 === m ? i2 : m, g = e2.slice(u, w).trim();
+            s2.set(h, g), n = -1 === m ? i2 : m + 1;
           }
-          return entries;
+          return s2;
         }
-        // ---- Execução de um statement de ação ----
-        async execStatement(stmt, ctx) {
-          switch (stmt.type) {
+        async execStatement(e2, t2) {
+          switch (e2.type) {
             case "Reply": {
-              const text = stmt.file ? this.resolveReplyFromFile(stmt.file, stmt.index, ctx) : String(await this.evalReplyValue(stmt.value, ctx));
-              ctx.vars.lastMsg = text;
-              if (this.onReply) {
-                await this.onReply({ target: stmt.target, text, client: ctx.vars.client });
-              }
+              let s2 = e2.file ? this.resolveReplyFromFile(e2.file, e2.index, t2) : String(await this.evalReplyValue(e2.value, t2));
+              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": {
-              const waiting = this.resolveWaitingConfig(stmt.waiting, ctx);
-              const inicio = Date.now();
-              if (this.onThinking) {
-                await this.onThinking({ client: ctx.vars.client, text: waiting.text });
-              }
-              const fullPath = this.fileSystem.resolve(this._rootBasePath, stmt.file);
-              const index = this.knowledgeCache.get(fullPath);
-              const resultado = index.analyze(ctx.vars.message);
-              const decorrido = Date.now() - inicio;
-              const faltam = waiting.seconds * 1e3 - decorrido;
-              if (faltam > 0) {
-                await new Promise((resolve) => setTimeout(resolve, faltam));
-              }
-              if (resultado.decision === "RESPONDER") {
-                const text = resultado.texto;
-                ctx.vars.lastMsg = text;
-                if (this.onReply) {
-                  await this.onReply({ target: null, text, client: ctx.vars.client });
-                }
-              } else if (stmt.fallback) {
-                await this.execStatement(stmt.fallback, ctx);
-              }
+              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": {
-              const target = String(this.evalExpr(stmt.target, ctx));
-              if (this.onForward) {
-                await this.onForward({ target, client: ctx.vars.client });
-              }
+              let d = String(this.evalExpr(e2.target, t2));
+              this.onForward && await this.onForward({ target: d, client: t2.vars.client });
               break;
             }
-            case "ParseSignal": {
-              ctx.vars.SIGNAL = await this.signalParser(ctx.rawSignal);
+            case "ParseSignal":
+              t2.vars.SIGNAL = await this.signalParser(t2.rawSignal);
               break;
-            }
-            case "SendTo": {
-              if (this.onSend) {
-                await this.onSend({ target: stmt.target, signal: ctx.vars.SIGNAL });
-              }
+            case "SendTo":
+              this.onSend && await this.onSend({ target: e2.target, signal: t2.vars.SIGNAL });
               break;
-            }
-            case "Insert": {
-              this.execInsert(stmt, ctx);
+            case "Insert":
+              this.execInsert(e2, t2);
               break;
-            }
-            case "Update": {
-              this.execUpdate(stmt, ctx);
+            case "Update":
+              this.execUpdate(e2, t2);
               break;
-            }
             default:
-              throw new Error(`runtime error: unsupported statement inside event: ${stmt.type}`);
+              throw Error(`runtime error: unsupported statement inside event: ${e2.type}`);
           }
         }
-        execInsert(stmt, ctx) {
-          let columnNames;
-          let values;
-          if (stmt.table === "Context" && (!stmt.columns || stmt.columns.length === 0) && !stmt.values) {
-            columnNames = ["client", "message", "created_at"];
-            values = [ctx.vars.client, ctx.vars.message, (/* @__PURE__ */ new Date()).toISOString()];
-          } else {
-            columnNames = (stmt.columns || []).map((c) => c.name);
-            values = (stmt.values || []).map((v) => this.evalExpr(v, ctx));
-          }
-          ctx.lastInsertId = this.db.insert(stmt.table, columnNames, values);
-        }
-        execUpdate(stmt, ctx) {
-          const value = this.evalExpr(stmt.set.value, ctx);
-          let whereColumn = null;
-          let whereValue = null;
-          if (stmt.where) {
-            whereColumn = stmt.where.left.name;
-            whereValue = this.evalExpr(stmt.where.right, ctx);
-          }
-          this.db.update(stmt.table, stmt.set.column, value, whereColumn, whereValue);
-        }
-        // ---- Avaliação de expressões ----
-        // Ponto de entrada usado só por REPLY <expr>: trata Response()/
-        // Response(alias) como caso especial assíncrono (chama this.onResponse,
-        // que fala de verdade com a IA ligada) e delega qualquer outra
-        // expressão ao evalExpr síncrono normal. Response() não pode ser
-        // composto dentro de + (ex: REPLY "x" + Response() não é suportado) —
-        // só faz sentido como o valor direto do REPLY, conforme a doc.
-        async evalReplyValue(node, ctx) {
-          if (node.type === "Call" && node.callee === "Response") {
-            return this.execResponse(node, ctx);
-          }
-          return this.evalExpr(node, ctx);
-        }
-        // Response() / Response(alias): dispara o ciclo com a IA ligada via
-        // CONNECT RESPONSE — envia a mensagem atual, espera, devolve o texto.
-        // Sem argumento só é válido com exatamente uma ligação (ambíguo com
-        // mais que uma); com argumento, o alias tem de corresponder a um
-        // CONNECT RESPONSE já feito.
-        async execResponse(node, ctx) {
-          if (!this.onResponse) {
-            throw new Error("runtime error: Response() failed, no AI connected (missing onResponse handler)");
-          }
-          let alias;
-          if (node.args.length === 0) {
-            if (this.responseConnections.size === 0) {
-              throw new Error("runtime error: Response() failed, no CONNECT RESPONSE found");
-            }
-            if (this.responseConnections.size > 1) {
-              throw new Error(`runtime error: Response() is ambiguous with multiple CONNECT RESPONSE (${[...this.responseConnections].join(", ")}); use Response(alias)`);
-            }
-            alias = [...this.responseConnections][0];
+        execInsert(e2, t2) {
+          let s2, i2;
+          "Context" !== e2.table || e2.columns && 0 !== e2.columns.length || e2.values ? (s2 = (e2.columns || []).map((e3) => e3.name), i2 = (e2.values || []).map((e3) => this.evalExpr(e3, t2))) : (s2 = ["client", "message", "created_at"], i2 = [t2.vars.client, t2.vars.message, (/* @__PURE__ */ new Date()).toISOString()]), t2.lastInsertId = this.db.insert(e2.table, s2, i2);
+        }
+        execUpdate(e2, t2) {
+          let s2 = this.evalExpr(e2.set.value, t2), i2 = null, n = null;
+          e2.where && (i2 = e2.where.left.name, n = this.evalExpr(e2.where.right, t2)), this.db.update(e2.table, e2.set.column, s2, i2, n);
+        }
+        async evalReplyValue(e2, t2) {
+          return "Call" === e2.type && "Response" === e2.callee ? this.execResponse(e2, t2) : this.evalExpr(e2, t2);
+        }
+        async execResponse(e2, t2) {
+          if (!this.onResponse) throw Error("runtime error: Response() failed, no AI connected (missing onResponse handler)");
+          let s2;
+          if (0 === e2.args.length) {
+            if (0 === this.responseConnections.size) throw Error("runtime error: Response() failed, no CONNECT RESPONSE found");
+            if (this.responseConnections.size > 1) throw Error(`runtime error: Response() is ambiguous with multiple CONNECT RESPONSE (${[...this.responseConnections].join(", ")}); use Response(alias)`);
+            s2 = [...this.responseConnections][0];
           } else {
-            const argNode = node.args[0];
-            if (argNode.type !== "Identifier") {
-              throw new Error("runtime error: Response(alias) expects an alias name, not a string or expression");
-            }
-            alias = argNode.name;
-            if (!this.responseConnections.has(alias)) {
-              throw new Error(`runtime error: Response(${alias}) failed, no CONNECT RESPONSE ${alias} found`);
-            }
+            let i2 = e2.args[0];
+            if ("Identifier" !== i2.type) throw Error("runtime error: Response(alias) expects an alias name, not a string or expression");
+            if (s2 = i2.name, !this.responseConnections.has(s2)) throw Error(`runtime error: Response(${s2}) failed, no CONNECT RESPONSE ${s2} found`);
           }
-          const token = this.envValues.get(alias);
-          const text = await this.onResponse({ alias, token, message: ctx.vars.message, client: ctx.vars.client });
-          return text;
+          let n = this.envValues.get(s2), r = await this.onResponse({ alias: s2, token: n, message: t2.vars.message, client: t2.vars.client });
+          return r;
         }
-        evalExpr(node, ctx) {
-          switch (node.type) {
+        evalExpr(e2, t2) {
+          switch (e2.type) {
             case "Literal":
-              return node.value;
-            case "Identifier": {
-              if (node.name === "env") {
-                return Object.fromEntries(this.envValues);
-              }
-              if (Object.prototype.hasOwnProperty.call(ctx.vars, node.name)) {
-                return ctx.vars[node.name];
-              }
-              if (this.envValues.has(node.name)) {
-                return this.envValues.get(node.name);
-              }
-              throw new Error(`runtime error: unknown identifier: "${node.name}"`);
-            }
+              return e2.value;
+            case "Identifier":
+              if ("env" === e2.name) return Object.fromEntries(this.envValues);
+              if (Object.prototype.hasOwnProperty.call(t2.vars, e2.name)) return t2.vars[e2.name];
+              if (this.envValues.has(e2.name)) return this.envValues.get(e2.name);
+              throw Error(`runtime error: unknown identifier: "${e2.name}"`);
             case "Member": {
-              const obj = this.evalExpr(node.object, ctx);
-              if (obj === null || obj === void 0) return void 0;
-              return obj[node.property];
+              let s2 = this.evalExpr(e2.object, t2);
+              if (null == s2) return;
+              return s2[e2.property];
             }
             case "Call": {
-              if (node.callee === "LAST_INSERT_ID") return ctx.lastInsertId;
-              const fn = this.nativeFuncs.get(node.callee);
-              if (!fn) throw new Error(`runtime error: unknown function: "${node.callee}"`);
-              const args = node.args.map((a) => this.evalExpr(a, ctx));
-              return fn(...args);
+              if ("LAST_INSERT_ID" === e2.callee) return t2.lastInsertId;
+              let i2 = this.nativeFuncs.get(e2.callee);
+              if (!i2) throw Error(`runtime error: unknown function: "${e2.callee}"`);
+              let n = e2.args.map((e3) => this.evalExpr(e3, t2));
+              return i2(...n);
             }
             case "Binary": {
-              const left = this.evalExpr(node.left, ctx);
-              const right = this.evalExpr(node.right, ctx);
-              if (node.op === "+") {
-                if (typeof left === "number" && typeof right === "number") return left + right;
-                return String(left) + String(right);
+              let r = this.evalExpr(e2.left, t2), a = this.evalExpr(e2.right, t2);
+              if ("+" === e2.op) {
+                if ("number" == typeof r && "number" == typeof a) return r + a;
+                return String(r) + String(a);
               }
-              if (node.op === "=") return left === right;
-              throw new Error(`runtime error: unsupported operator: "${node.op}"`);
+              if ("=" === e2.op) return r === a;
+              throw Error(`runtime error: unsupported operator: "${e2.op}"`);
             }
             default:
-              throw new Error(`runtime error: unsupported expression: ${node.type}`);
+              throw Error(`runtime error: unsupported expression: ${e2.type}`);
           }
         }
       };
-      module.exports = { BotQLInterpreter, MemoryDatabase };
+      module.exports = { BotQLInterpreter, MemoryDatabase: t };
     }
   });
   return require_botql();