botql 1.0.1 → 1.0.2

package/botql.browser.js

@@ -0,0 +1,1921 @@
+"use strict";
+var BotQL = (() => {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    try {
+      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    } catch (e) {
+      throw mod = 0, e;
+    }
+  };
+
+  // Parser.js
+  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 Token = class {
+        constructor(type, value, line) {
+          this.type = type;
+          this.value = value;
+          this.line = line;
+        }
+      };
+      var Tokenizer = class {
+        constructor(source) {
+          this.source = source;
+          this.pos = 0;
+          this.line = 1;
+          this.tokens = [];
+        }
+        error(msg) {
+          throw new Error(`syntax error: ${msg}`);
+        }
+        peekChar(offset = 0) {
+          return this.source[this.pos + offset];
+        }
+        tokenize() {
+          while (this.pos < this.source.length) {
+            const c = this.peekChar();
+            if (c === "\n") {
+              this.line++;
+              this.pos++;
+              continue;
+            }
+            if (/\s/.test(c)) {
+              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++;
+              continue;
+            }
+            if (/[A-Za-z_]/.test(c)) {
+              const word = this.readWord();
+              this.tokens.push(word);
+              continue;
+            }
+            this.error(`unexpected character: "${c}"`);
+          }
+          this.tokens.push(new Token(TokenType.EOF, null, this.line));
+          return this.tokens;
+        }
+        readString(quote) {
+          const startLine = 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++;
+              continue;
+            }
+            if (this.peekChar() === "\n") this.line++;
+            value += this.peekChar();
+            this.pos++;
+          }
+          if (this.peekChar() !== quote) {
+            this.error("unterminated string");
+          }
+          this.pos++;
+          return new Token(TokenType.STRING, value, startLine);
+        }
+        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);
+        }
+        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);
+        }
+      };
+      var Parser = class {
+        constructor(source) {
+          this.tokens = new Tokenizer(source).tokenize();
+          this.pos = 0;
+        }
+        error(msg) {
+          const tok = this.current();
+          throw new Error(`syntax error: ${msg}, near "${tok ? tok.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;
+        }
+        atKeyword(...values) {
+          return this.at(TokenType.KEYWORD) && values.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);
+        }
+        advance() {
+          const tok = this.current();
+          if (tok.type !== TokenType.EOF) this.pos++;
+          return tok;
+        }
+        expect(type, value) {
+          if (!this.at(type, value)) {
+            this.error(`expected ${value || type}`);
+          }
+          return this.advance();
+        }
+        expectKeyword(value) {
+          return this.expect(TokenType.KEYWORD, value);
+        }
+        isAtEnd() {
+          return this.at(TokenType.EOF);
+        }
+        // ---- Programa ----
+        parseProgram() {
+          const statements = [];
+          while (!this.isAtEnd()) {
+            statements.push(this.parseStatement());
+          }
+          return { type: "Program", body: statements };
+        }
+        // ---- 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;
+          }
+          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 ----
+        parseCreate() {
+          this.expectKeyword("CREATE");
+          if (this.atKeyword("BOT")) {
+            this.advance();
+            const name = this.expect(TokenType.STRING).value;
+            return { type: "CreateBot", name };
+          }
+          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 };
+          }
+          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);
+            }
+            columns.push({ name: colName, columnType: colType, constraints });
+            if (this.at(TokenType.SYMBOL, ",")) this.advance();
+          }
+          this.expect(TokenType.SYMBOL, ")");
+          return columns;
+        }
+        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).
+        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()) {
+            this.expect(TokenType.SYMBOL, "(");
+            const file = this.parseFileName();
+            this.expect(TokenType.SYMBOL, ",");
+            const index = this.parseExpression();
+            this.expect(TokenType.SYMBOL, ")");
+            return { file, index };
+          }
+          const value = this.parseExpression();
+          return { value };
+        }
+        // ---- 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.
+        parseConnect() {
+          this.expectKeyword("CONNECT");
+          if (this.atKeyword("RESPONSE")) {
+            this.advance();
+            const alias = this.expect(TokenType.IDENT).value;
+            return { type: "ConnectResponse", alias };
+          }
+          const service = this.advance().value;
+          const kind = this.advance().value;
+          const credential = this.expect(TokenType.STRING).value;
+          return { type: "Connect", service, kind, credential };
+        }
+        // ---- ON START | ON MESSAGE | ON SIGNAL FROM "..." ----
+        parseOn() {
+          this.expectKeyword("ON");
+          if (this.atKeyword("START")) {
+            this.advance();
+            const body = this.parseBody();
+            return { type: "On", event: "START", body };
+          }
+          if (this.atKeyword("MESSAGE")) {
+            this.advance();
+            const body = this.parseBody();
+            return { type: "On", event: "MESSAGE", body };
+          }
+          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.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 };
+        }
+        parseCondition() {
+          this.expectKeyword("CONTAINS");
+          if (this.at(TokenType.SYMBOL, "(")) {
+            const values = this.parseStringList();
+            return { op: "CONTAINS_ANY", values };
+          }
+          if (this.atKeyword("KEYWORDS")) {
+            this.advance();
+            this.expect(TokenType.SYMBOL, "(");
+            const path = this.parseFileName();
+            this.expect(TokenType.SYMBOL, ")");
+            return { op: "CONTAINS_KEYWORDS_FILE", path };
+          }
+          const value = this.expect(TokenType.STRING).value;
+          return { op: "CONTAINS", value };
+        }
+        // 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;
+        }
+        // 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;
+        }
+        // ---- 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.
+        parseThink() {
+          this.expectKeyword("THINK");
+          this.expect(TokenType.SYMBOL, "(");
+          const file = 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.
+        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 };
+        }
+        parseReply() {
+          this.expectKeyword("REPLY");
+          let target = null;
+          if (this.atKeyword("TO")) {
+            this.advance();
+            target = this.advance().value;
+          }
+          if (this.isReplyFileForm()) {
+            this.expect(TokenType.SYMBOL, "(");
+            const file = this.parseFileName();
+            this.expect(TokenType.SYMBOL, ",");
+            const index = this.parseExpression();
+            this.expect(TokenType.SYMBOL, ")");
+            return { type: "Reply", target, file, index };
+          }
+          const value = this.parseExpression();
+          return { type: "Reply", target, value };
+        }
+        // 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 === ".";
+        }
+        // ---- FORWARD TO "contacto" ----
+        parseForward() {
+          this.expectKeyword("FORWARD");
+          this.expectKeyword("TO");
+          const target = this.parseExpression();
+          return { type: "ForwardTo", target };
+        }
+        // ---- PARSE SIGNAL ----
+        parseParseSignal() {
+          this.expectKeyword("PARSE");
+          if (!this.atWord("SIGNAL")) this.error("expected SIGNAL after PARSE");
+          this.advance();
+          return { type: "ParseSignal" };
+        }
+        // ---- SEND TO destino ----
+        parseSend() {
+          this.expectKeyword("SEND");
+          this.expectKeyword("TO");
+          const target = this.advance().value;
+          return { type: "SendTo", target };
+        }
+        // ---- 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 };
+        }
+        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;
+        }
+        // ---- UPDATE tabela SET col = expr WHERE expr ----
+        parseUpdate() {
+          this.expectKeyword("UPDATE");
+          const table = this.expect(TokenType.IDENT).value;
+          this.expectKeyword("SET");
+          const column = 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.
+        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 };
+        }
+        // ---- RUN BOT ----
+        parseRunBot() {
+          this.expectKeyword("RUN");
+          this.expectKeyword("BOT");
+          return { 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, "+")) {
+            this.advance();
+            const right = this.parsePrimary();
+            node = { type: "Binary", op: "+", left: node, right };
+          }
+          return node;
+        }
+        // Igualdade, usada em WHERE (ex: id = LAST_INSERT_ID())
+        parseComparison() {
+          const left = this.parseExpression();
+          if (this.at(TokenType.SYMBOL, "=")) {
+            this.advance();
+            const right = this.parseExpression();
+            return { type: "Binary", op: "=", left, right };
+          }
+          return left;
+        }
+        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) {
+            this.advance();
+            let node = { type: "Identifier", name: tok.value };
+            if (this.at(TokenType.SYMBOL, "(")) {
+              const args = this.parseExpressionList();
+              node = { type: "Call", callee: node.name, args };
+            }
+            while (this.at(TokenType.SYMBOL, ".")) {
+              this.advance();
+              const prop = this.expect(TokenType.IDENT).value;
+              node = { type: "Member", object: node, property: prop };
+            }
+            return node;
+          }
+          this.error("invalid expression");
+        }
+      };
+      module.exports = { Parser, Tokenizer, TokenType, KEYWORDS };
+    }
+  });
+
+  // Database.js
+  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 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);
+          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 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;
+      }
+      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);
+          } else {
+            const sql = `UPDATE ${table} SET ${column} = ? WHERE id = (SELECT MAX(id) FROM ${table})`;
+            this.driver.prepare(sql).run(value);
+          }
+        }
+        getRows(table) {
+          return this.driver.prepare(`SELECT * FROM ${table}`).all();
+        }
+        close() {
+          this.driver.close();
+        }
+      };
+      module.exports = { MemoryDatabase, SQLiteDatabase };
+    }
+  });
+
+  // FileSystem.js
+  var require_FileSystem = __commonJS({
+    "FileSystem.js"(exports, module) {
+      "use strict";
+      var MemoryFileSystem = class {
+        constructor(files = {}) {
+          this.files = new Map(
+            Object.entries(files).map(([k, v]) => [this._normalize(k), v])
+          );
+        }
+        _normalize(p) {
+          return String(p).replace(/^\.\//, "").replace(/\/+/g, "/").trim();
+        }
+        setFile(path, content) {
+          this.files.set(this._normalize(path), content);
+        }
+        exists(path) {
+          return this.files.has(this._normalize(path));
+        }
+        readFile(path) {
+          const key = this._normalize(path);
+          if (!this.files.has(key)) {
+            throw new Error(`BotQL: ficheiro n\xE3o encontrado: "${path}"`);
+          }
+          return this.files.get(key);
+        }
+        // basePath e' ignorado de proposito: no browser nao ha nocao real de
+        // diretorio corrente, os ficheiros importados sao identificados pelo
+        // nome/caminho tal como o utilizador os registou.
+        resolve(basePath, relativePath) {
+          return this._normalize(relativePath);
+        }
+        dirname(filePath) {
+          const norm = this._normalize(filePath);
+          const idx = norm.lastIndexOf("/");
+          return idx === -1 ? "" : norm.slice(0, idx);
+        }
+      };
+      var NodeFileSystem = class {
+        constructor() {
+          this._fs = __require("fs");
+          this._path = __require("path");
+        }
+        exists(path) {
+          return this._fs.existsSync(path);
+        }
+        readFile(path) {
+          return this._fs.readFileSync(path, "utf8");
+        }
+        resolve(basePath, relativePath) {
+          return this._path.resolve(basePath, relativePath);
+        }
+        dirname(filePath) {
+          return this._path.dirname(filePath);
+        }
+      };
+      var isNode = typeof process !== "undefined" && process.versions && !!process.versions.node;
+      function createDefaultFileSystem() {
+        return isNode ? new NodeFileSystem() : new MemoryFileSystem();
+      }
+      var api = { MemoryFileSystem, NodeFileSystem, createDefaultFileSystem };
+      if (typeof module !== "undefined" && module.exports) {
+        module.exports = api;
+      } else {
+        exports.BotQLFileSystem = api;
+      }
+    }
+  });
+
+  // RAG.js
+  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 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;
+          }
+        }
+        for (const suf of SUFIXOS_NOMINALIZACAO) {
+          if (p.length > suf.length + 3 && p.endsWith(suf)) {
+            p = p.slice(0, -suf.length);
+            break;
+          }
+        }
+        if (p.length > 4 && p.endsWith("s") && !p.endsWith("ns")) {
+          p = p.slice(0, -1);
+        }
+        return p;
+      }
+      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 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 distanciaMaximaTolerada(tamanho) {
+        if (tamanho <= 4) return 0;
+        if (tamanho <= 7) return 1;
+        return 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);
+          }
+        }
+        return encontrados;
+      }
+      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();
+        }
+        static parseBlocks(sourceText) {
+          return sourceText.split(/\n\s*\n/).map((bloco) => bloco.trim()).filter((bloco) => bloco.length > 0);
+        }
+        _aplicarSinonimos(tokens) {
+          return tokens.map((t) => this.synonyms[t] || t);
+        }
+        _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;
+            }
+          }
+          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;
+              }
+            }
+          }
+          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
+            };
+          }
+          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
+                };
+              }
+            }
+          }
+          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
+              };
+            }
+          }
+          return {
+            decision: "REANALISAR",
+            confidence,
+            margem,
+            texto: null,
+            unificado: false,
+            reanalisado: false,
+            melhor: melhorInfo,
+            segundo: segundoInfo
+          };
+        }
+      };
+      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;
+        }
+      };
+      module.exports = { KnowledgeIndex, KnowledgeCache, tokenizar, normalizar, stem, distanciaEdicao };
+    }
+  });
+
+  // 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 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}`);
+            }
+          }
+        }
+        // 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);
+              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);
+              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);
+          }
+        }
+        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;
+        }
+        // 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;
+              }
+              continue;
+            }
+            if (stmt.type === "Otherwise") {
+              if (!groupMatched) await this.run(stmt.body, ctx);
+              groupMatched = 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;
+              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;
+              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;
+          }
+          return entries;
+        }
+        // ---- Execução de um statement de ação ----
+        async execStatement(stmt, ctx) {
+          switch (stmt.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 });
+              }
+              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);
+              }
+              break;
+            }
+            case "ForwardTo": {
+              const target = String(this.evalExpr(stmt.target, ctx));
+              if (this.onForward) {
+                await this.onForward({ target, client: ctx.vars.client });
+              }
+              break;
+            }
+            case "ParseSignal": {
+              ctx.vars.SIGNAL = await this.signalParser(ctx.rawSignal);
+              break;
+            }
+            case "SendTo": {
+              if (this.onSend) {
+                await this.onSend({ target: stmt.target, signal: ctx.vars.SIGNAL });
+              }
+              break;
+            }
+            case "Insert": {
+              this.execInsert(stmt, ctx);
+              break;
+            }
+            case "Update": {
+              this.execUpdate(stmt, ctx);
+              break;
+            }
+            default:
+              throw new Error(`runtime error: unsupported statement inside event: ${stmt.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];
+          } 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`);
+            }
+          }
+          const token = this.envValues.get(alias);
+          const text = await this.onResponse({ alias, token, message: ctx.vars.message, client: ctx.vars.client });
+          return text;
+        }
+        evalExpr(node, ctx) {
+          switch (node.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}"`);
+            }
+            case "Member": {
+              const obj = this.evalExpr(node.object, ctx);
+              if (obj === null || obj === void 0) return void 0;
+              return obj[node.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);
+            }
+            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);
+              }
+              if (node.op === "=") return left === right;
+              throw new Error(`runtime error: unsupported operator: "${node.op}"`);
+            }
+            default:
+              throw new Error(`runtime error: unsupported expression: ${node.type}`);
+          }
+        }
+      };
+      module.exports = { BotQLInterpreter, MemoryDatabase };
+    }
+  });
+  return require_botql();
+})();