botql 1.0.2 → 1.1.2

package/botql.browser.js

@@ -19,643 +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) {
+          this.type = e, this.value = t, this.line = s;
         }
       };
       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) {
+          throw Error(`syntax error: ${e}`);
         }
-        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();
+            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++;
+            if ("-" === e && "-" === this.peekChar(1)) {
+              for (; this.pos < this.source.length && "\n" !== this.peekChar(); ) this.pos++;
               continue;
             }
-            if (c === '"' || c === "'") {
-              this.tokens.push(this.readString(c));
+            if ('"' === e || "'" === e) {
+              this.tokens.push(this.readString(e));
               continue;
             }
-            if (/[0-9]/.test(c)) {
+            if (/[0-9]/.test(e)) {
               this.tokens.push(this.readNumber());
               continue;
             }
-            if ("{}(),.=+*;".includes(c)) {
-              this.tokens.push(new Token(TokenType.SYMBOL, c, this.line));
-              this.pos++;
+            if ("{}(),.=+*;".includes(e)) {
+              this.tokens.push(new Token(TokenType.SYMBOL, e, this.line)), this.pos++;
               continue;
             }
-            if (/[A-Za-z_]/.test(c)) {
-              const word = this.readWord();
-              this.tokens.push(word);
+            if (/[A-Za-z_]/.test(e)) {
+              let t = this.readWord();
+              this.tokens.push(t);
               continue;
             }
-            this.error(`unexpected character: "${c}"`);
+            this.error(`unexpected character: "${e}"`);
           }
-          this.tokens.push(new Token(TokenType.EOF, null, this.line));
-          return this.tokens;
+          return this.tokens.push(new Token(TokenType.EOF, null, this.line)), this.tokens;
         }
-        readString(quote) {
-          const startLine = this.line;
+        readString(e) {
+          let t = this.line;
           this.pos++;
-          let value = "";
-          while (this.pos < this.source.length && this.peekChar() !== quote) {
-            if (this.peekChar() === "\\") {
-              this.pos++;
-              value += this.peekChar();
-              this.pos++;
+          let s = "";
+          for (; this.pos < this.source.length && this.peekChar() !== e; ) {
+            if ("\\" === this.peekChar()) {
+              this.pos++, s += this.peekChar(), this.pos++;
               continue;
             }
-            if (this.peekChar() === "\n") this.line++;
-            value += this.peekChar();
-            this.pos++;
+            "\n" === this.peekChar() && this.line++, s += this.peekChar(), this.pos++;
           }
-          if (this.peekChar() !== quote) {
-            this.error("unterminated string");
-          }
-          this.pos++;
-          return new Token(TokenType.STRING, value, startLine);
+          return this.peekChar() !== e && this.error("unterminated string"), this.pos++, new Token(TokenType.STRING, s, 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.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();
+          throw Error(`syntax error: ${e}, near "${t ? t.value : "EOF"}"`);
         }
         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("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;
-        }
-        // ---- 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).
+          return !!this.atKeyword("PREVENT") && (this.advance(), this.expectKeyword("DEFAULT"), true);
+        }
         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;
+          return !this.at(TokenType.SYMBOL, ")") && (e = this.parseFileName(), this.at(TokenType.SYMBOL, ",") && (this.advance(), t = this.parseExpression())), this.expect(TokenType.SYMBOL, ")"), { file: e, seconds: t };
         }
         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) {
+          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();
-            return { type: "Literal", value: tok.value };
-          }
-          if (tok.type === TokenType.NUMBER) {
-            this.advance();
-            return { type: "Literal", value: tok.value };
-          }
-          if (tok.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");
         }
@@ -668,97 +382,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();
@@ -1349,572 +1038,297 @@ 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 { Parser: e } = require_Parser();
+      var { MemoryDatabase: t } = require_Database();
+      var { createDefaultFileSystem: s } = require_FileSystem();
+      var { KnowledgeCache: i } = require_RAG();
       var WAITING_TEXTO_PADRAO = "Pensando...";
-      var WAITING_SEGUNDOS_PADRAO = 3;
       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.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);
+            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), f = new e(c).parseProgram(), d = this._flattenImports(f.body, this.fileSystem.dirname(u));
+            i2.push(...d);
           }
-          return [...fromImports, ...ownStatements];
+          return [...i2, ...n];
         }
-        // ---- 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
-          };
+        createContext(e2 = {}) {
+          return { vars: { client: e2.client || null, message: e2.message || null, lastMsg: null, SIGNAL: null }, rawSignal: e2.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);
+          for (let e2 of this.handlers.START) {
+            let t2 = this.createContext();
+            await this.run(e2.body, t2);
           }
         }
-        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;
+        async receiveMessage(e2, t2) {
+          let s2 = this.createContext({ client: e2, message: t2 }), i2 = await this.greetIfNew(e2);
+          if (i2) return s2;
+          for (let n of this.handlers.MESSAGE) await this.run(n.body, s2);
+          return s2;
         }
-        // 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);
-          }
-          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);
-          }
-          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: WAITING_TEXTO_PADRAO, seconds: 3 };
+          let s2 = WAITING_TEXTO_PADRAO;
+          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, f = u + 1, d = f;
+              for (; d < i2 && c > 0; ) "{" === e2[d] ? c++ : "}" === e2[d] && c--, d++;
+              if (0 !== c) throw Error(`runtime error: unclosed "{" for entry ${h} in "${t2}"`);
+              let p = e2.slice(f, d - 1).trim();
+              s2.set(h, p), n = d;
               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 "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 i2 = this.resolveWaitingConfig(e2.waiting, t2), n = Date.now();
+              this.onThinking && await this.onThinking({ client: t2.vars.client, text: i2.text });
+              let r = this.fileSystem.resolve(this._rootBasePath, e2.file), a = this.knowledgeCache.get(r), l = a.analyze(t2.vars.message), o = Date.now() - n, h = 1e3 * i2.seconds - o;
+              if (h > 0 && await new Promise((e3) => setTimeout(e3, h)), "RESPONDER" === l.decision) {
+                let u = l.texto;
+                t2.vars.lastMsg = u, this.onReply && await this.onReply({ target: null, text: u, client: t2.vars.client });
+              } 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 c = String(this.evalExpr(e2.target, t2));
+              this.onForward && await this.onForward({ target: c, 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();