trellis 1.0.4 → 1.0.7

package/dist/query/index.js

@@ -0,0 +1,1643 @@
+// src/query/datalog-evaluator.ts
+class ExternalPredicates {
+  static regex(str, pattern) {
+    if (typeof pattern === "string") {
+      try {
+        const regexMatch = pattern.match(/^\/(.*)\/([gimuy]*)$/);
+        if (regexMatch) {
+          const [, regexPattern, flags] = regexMatch;
+          const regex = new RegExp(regexPattern, flags || "i");
+          return regex.test(str);
+        }
+        return new RegExp(pattern, "i").test(str);
+      } catch (e) {
+        console.warn(`Invalid regex pattern: ${pattern}`, e);
+        return str.toLowerCase().includes(pattern.toLowerCase());
+      }
+    }
+    return pattern.test(str);
+  }
+  static gt(a, b) {
+    return a > b;
+  }
+  static lt(a, b) {
+    return a < b;
+  }
+  static between(val, min, max) {
+    return val >= min && val <= max;
+  }
+  static contains(str, substr) {
+    return str.toLowerCase().includes(substr.toLowerCase());
+  }
+  static after(a, b) {
+    return a > b;
+  }
+  static betweenDate(d, start, end) {
+    return d >= start && d <= end;
+  }
+  static sum(values) {
+    return values.reduce((a, b) => a + b, 0);
+  }
+  static count(values) {
+    return values.length;
+  }
+  static avg(values) {
+    return values.length > 0 ? this.sum(values) / values.length : 0;
+  }
+}
+
+class DatalogEvaluator {
+  store;
+  rules = [];
+  ws = new Map;
+  constructor(store) {
+    this.store = store;
+  }
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+  seedBaseFacts() {
+    const attrRows = [];
+    for (const f of this.store.getAllFacts()) {
+      if (f) {
+        attrRows.push([f.e, f.a, f.v]);
+      }
+    }
+    this.ws.set("attr", attrRows);
+    const linkRows = [];
+    for (const link of this.store.getAllLinks()) {
+      linkRows.push([link.e1, link.a, link.e2]);
+    }
+    this.ws.set("link", linkRows);
+  }
+  pushDerived(predicate, tuple) {
+    const bucket = this.ws.get(predicate) || [];
+    if (!this.ws.has(predicate)) {
+      this.ws.set(predicate, bucket);
+    }
+    const key = JSON.stringify(tuple);
+    if (!bucket._keys) {
+      bucket._keys = new Set;
+    }
+    const keys = bucket._keys;
+    if (keys.has(key)) {
+      return false;
+    }
+    bucket.push(tuple);
+    keys.add(key);
+    return true;
+  }
+  evaluate(query, limit) {
+    const startTime = performance.now();
+    const trace = [];
+    this.seedBaseFacts();
+    let added = true;
+    let iterations = 0;
+    const maxIterations = 100;
+    while (added && iterations < maxIterations) {
+      added = false;
+      for (const rule of this.rules) {
+        const bindings2 = this.findBindingsOverWS(rule.body);
+        for (const binding of bindings2) {
+          const head = this.substitute(rule.head, binding);
+          const tuple = head.terms.map((term) => this.resolveTerm(term, binding));
+          if (this.pushDerived(head.predicate, tuple)) {
+            added = true;
+          }
+        }
+      }
+      iterations++;
+    }
+    const bindings = this.findBindingsOverWS(query.goals, trace, limit);
+    return {
+      bindings,
+      executionTime: performance.now() - startTime,
+      plan: `Semi-naive evaluation: ${iterations} iterations, ${this.getTotalFacts()} facts`,
+      trace
+    };
+  }
+  getTotalFacts() {
+    let total = 0;
+    for (const tuples of this.ws.values()) {
+      total += tuples.length;
+    }
+    return total;
+  }
+  findBindingsOverWS(goals, trace, limit) {
+    if (goals.length === 0) {
+      return [{}];
+    }
+    let bindings = [{}];
+    for (const goal of goals) {
+      const goalStartTime = performance.now();
+      const newBindings = [];
+      outer:
+        for (const binding of bindings) {
+          const goalBindings = this.evaluateGoal(goal, binding);
+          for (const goalBinding of goalBindings) {
+            const merged = { ...binding, ...goalBinding };
+            let hasConflict = false;
+            for (const key in merged) {
+              if (binding[key] !== undefined && goalBinding[key] !== undefined && binding[key] !== goalBinding[key]) {
+                hasConflict = true;
+                break;
+              }
+            }
+            if (!hasConflict) {
+              newBindings.push(merged);
+              if (limit !== undefined && newBindings.length >= limit)
+                break outer;
+            }
+          }
+        }
+      bindings = newBindings;
+      if (trace) {
+        trace.push({
+          goal: `${goal.predicate}(${goal.terms.join(", ")})`,
+          bindingsCount: bindings.length,
+          durationMs: performance.now() - goalStartTime
+        });
+      }
+    }
+    const uniqueBindings = new Map;
+    for (const binding of bindings) {
+      const key = JSON.stringify(binding);
+      uniqueBindings.set(key, binding);
+    }
+    return Array.from(uniqueBindings.values());
+  }
+  evaluateGoal(goal, binding) {
+    const { predicate, terms } = goal;
+    if (predicate === "not") {
+      const inner = goal.terms[0];
+      const res = this.evaluateGoal(inner, binding);
+      return res.length === 0 ? [binding] : [];
+    }
+    if (predicate === "attr") {
+      return this.evaluateAttrPredicate(terms, binding);
+    }
+    if (predicate === "link") {
+      return this.evaluateLinkPredicate(terms, binding);
+    }
+    if (predicate === "gt" || predicate === "lt" || predicate === "between" || predicate === ">" || predicate === "<" || predicate === ">=" || predicate === "<=" || predicate === "=" || predicate === "!=") {
+      return this.evaluateComparisonPredicate(goal, binding);
+    }
+    if (predicate === "regex" || predicate === "contains") {
+      return this.evaluateStringPredicate(goal, binding);
+    }
+    if (predicate === "after" || predicate === "betweenDate") {
+      return this.evaluateDatePredicate(goal, binding);
+    }
+    if (predicate.startsWith("ext_")) {
+      return this.evaluateExternalPredicate(goal, binding);
+    }
+    return this.evalPredicateFromWS(predicate, terms, binding);
+  }
+  evalPredicateFromWS(predicate, terms, binding) {
+    const rows = this.ws.get(predicate) || [];
+    const results = [];
+    rowloop:
+      for (const row of rows) {
+        const newBinding = { ...binding };
+        for (let i = 0;i < terms.length; i++) {
+          const term = terms[i];
+          const val = row[i];
+          if (typeof term === "string" && term.startsWith("?")) {
+            const bound = newBinding[term];
+            if (bound !== undefined && bound !== val) {
+              continue rowloop;
+            }
+            newBinding[term] = val;
+          } else {
+            if (term !== val) {
+              continue rowloop;
+            }
+          }
+        }
+        results.push(newBinding);
+      }
+    return results;
+  }
+  evaluateAttrPredicate(terms, binding) {
+    if (terms.length !== 3)
+      return [];
+    const [entity, attribute, value] = terms.map((term) => this.resolveTerm(term, binding));
+    const results = [];
+    if (typeof entity === "string" && !entity.startsWith("?") && typeof attribute === "string" && !attribute.startsWith("?") && (typeof value !== "string" || !value.startsWith("?"))) {
+      const facts = this.store.getFactsByValue(attribute, value);
+      for (const fact of facts) {
+        if (fact.e === entity) {
+          results.push({});
+        }
+      }
+      return results;
+    }
+    if (typeof entity === "string" && !entity.startsWith("?") && typeof attribute === "string" && !attribute.startsWith("?")) {
+      const facts = this.store.getFactsByEntity(entity);
+      for (const fact of facts) {
+        if (fact.a === attribute) {
+          const newBinding = { ...binding };
+          if (typeof value === "string" && value.startsWith("?")) {
+            newBinding[value] = fact.v;
+            results.push(newBinding);
+          } else if (fact.v === value) {
+            results.push(newBinding);
+          }
+        }
+      }
+      return results;
+    }
+    if (typeof attribute === "string" && !attribute.startsWith("?")) {
+      const facts = this.store.getFactsByAttribute(attribute);
+      for (const fact of facts) {
+        const newBinding = { ...binding };
+        if (typeof entity === "string" && !entity.startsWith("?") && fact.e !== entity) {
+          continue;
+        }
+        if ((typeof value !== "string" || !value.startsWith("?")) && fact.v !== value) {
+          continue;
+        }
+        if (typeof entity === "string" && entity.startsWith("?")) {
+          newBinding[entity] = fact.e;
+        }
+        if (typeof value === "string" && value.startsWith("?")) {
+          newBinding[value] = fact.v;
+        }
+        results.push(newBinding);
+      }
+      return results;
+    }
+    return [];
+  }
+  evaluateLinkPredicate(terms, binding) {
+    if (terms.length !== 3)
+      return [];
+    const [e1, a, e2] = terms;
+    const results = [];
+    const links = this.store.getAllLinks();
+    for (const link of links) {
+      const newBinding = { ...binding };
+      let matches = true;
+      if (typeof e1 === "string" && !e1.startsWith("?")) {
+        if (link.e1 !== e1)
+          continue;
+      } else if (typeof e1 === "string" && e1.startsWith("?")) {
+        newBinding[e1] = link.e1;
+      }
+      if (typeof a === "string" && !a.startsWith("?")) {
+        if (link.a !== a)
+          continue;
+      } else if (typeof a === "string" && a.startsWith("?")) {
+        newBinding[a] = link.a;
+      }
+      if (typeof e2 === "string" && !e2.startsWith("?")) {
+        if (link.e2 !== e2)
+          continue;
+      } else if (typeof e2 === "string" && e2.startsWith("?")) {
+        newBinding[e2] = link.e2;
+      }
+      if (matches) {
+        results.push(newBinding);
+      }
+    }
+    return results;
+  }
+  evaluateComparisonPredicate(goal, binding) {
+    const { predicate, terms } = goal;
+    if (terms.length < 2)
+      return [];
+    const left = this.resolveTerm(terms[0], binding);
+    const right = this.resolveTerm(terms[1], binding);
+    let leftNum = left;
+    let rightNum = right;
+    if (typeof left === "string" && !isNaN(Number(left))) {
+      leftNum = Number(left);
+    }
+    if (typeof right === "string" && !isNaN(Number(right))) {
+      rightNum = Number(right);
+    }
+    if (typeof leftNum !== "number" || typeof rightNum !== "number")
+      return [];
+    let result = false;
+    switch (predicate) {
+      case "gt":
+      case ">":
+        result = ExternalPredicates.gt(leftNum, rightNum);
+        break;
+      case "lt":
+      case "<":
+        result = ExternalPredicates.lt(leftNum, rightNum);
+        break;
+      case ">=":
+        result = leftNum >= rightNum;
+        break;
+      case "<=":
+        result = leftNum <= rightNum;
+        break;
+      case "=":
+        result = leftNum === rightNum;
+        break;
+      case "!=":
+        result = leftNum !== rightNum;
+        break;
+      case "between":
+        if (terms.length >= 3) {
+          const max = this.resolveTerm(terms[2], binding);
+          let maxNum = max;
+          if (typeof max === "string" && !isNaN(Number(max))) {
+            maxNum = Number(max);
+          }
+          if (typeof maxNum === "number") {
+            result = ExternalPredicates.between(leftNum, rightNum, maxNum);
+          }
+        }
+        break;
+    }
+    return result ? [{}] : [];
+  }
+  evaluateStringPredicate(goal, binding) {
+    const { predicate, terms } = goal;
+    if (terms.length < 2)
+      return [];
+    const str = this.resolveTerm(terms[0], binding);
+    const pattern = this.resolveTerm(terms[1], binding);
+    if (typeof str !== "string" || typeof pattern !== "string")
+      return [];
+    let result = false;
+    switch (predicate) {
+      case "regex":
+        result = ExternalPredicates.regex(str, pattern);
+        break;
+      case "contains":
+        result = ExternalPredicates.contains(str, pattern);
+        break;
+    }
+    return result ? [{}] : [];
+  }
+  evaluateDatePredicate(goal, binding) {
+    const { predicate, terms } = goal;
+    if (terms.length < 2)
+      return [];
+    const left = this.resolveTerm(terms[0], binding);
+    const right = this.resolveTerm(terms[1], binding);
+    if (!(left instanceof Date) || !(right instanceof Date))
+      return [];
+    let result = false;
+    switch (predicate) {
+      case "after":
+        result = ExternalPredicates.after(left, right);
+        break;
+      case "betweenDate":
+        if (terms.length >= 3) {
+          const end = this.resolveTerm(terms[2], binding);
+          if (end instanceof Date) {
+            result = ExternalPredicates.betweenDate(left, right, end);
+          }
+        }
+        break;
+    }
+    return result ? [{}] : [];
+  }
+  evaluateExternalPredicate(goal, binding) {
+    const { predicate, terms } = goal;
+    const resolvedTerms = terms.map((term) => this.resolveTerm(term, binding));
+    let result = false;
+    switch (predicate) {
+      case "ext_regex":
+        if (resolvedTerms.length >= 2 && typeof resolvedTerms[0] === "string") {
+          result = ExternalPredicates.regex(resolvedTerms[0], resolvedTerms[1]);
+        }
+        break;
+      case "ext_gt":
+        if (resolvedTerms.length >= 2 && typeof resolvedTerms[0] === "number" && typeof resolvedTerms[1] === "number") {
+          result = ExternalPredicates.gt(resolvedTerms[0], resolvedTerms[1]);
+        }
+        break;
+      case "ext_between":
+        if (resolvedTerms.length >= 3 && typeof resolvedTerms[0] === "number" && typeof resolvedTerms[1] === "number" && typeof resolvedTerms[2] === "number") {
+          result = ExternalPredicates.between(resolvedTerms[0], resolvedTerms[1], resolvedTerms[2]);
+        }
+        break;
+      case "ext_contains":
+        if (resolvedTerms.length >= 2 && typeof resolvedTerms[0] === "string") {
+          result = ExternalPredicates.contains(resolvedTerms[0], resolvedTerms[1]);
+        }
+        break;
+    }
+    return result ? [{}] : [];
+  }
+  resolveTerm(term, binding) {
+    if (typeof term === "string" && term.startsWith("?")) {
+      return binding[term] || term;
+    }
+    return term;
+  }
+  substitute(atom, binding) {
+    return {
+      predicate: atom.predicate,
+      terms: atom.terms.map((term) => this.resolveTerm(term, binding))
+    };
+  }
+}
+// src/query/attribute-resolver.ts
+class AttributeResolver {
+  schema = {};
+  buildSchema(catalog) {
+    this.schema = {};
+    for (const entry of catalog) {
+      const entityType = "default";
+      const attributeName = entry.attribute;
+      if (!this.schema[entityType]) {
+        this.schema[entityType] = {};
+      }
+      this.schema[entityType][attributeName] = {
+        type: entry.type,
+        distinctCount: entry.distinctCount,
+        examples: entry.examples
+      };
+    }
+  }
+  resolveAttribute(entityType, queryAttribute) {
+    const entitySchema = this.schema[entityType];
+    if (!entitySchema) {
+      return null;
+    }
+    const queryLower = queryAttribute.toLowerCase();
+    if (entitySchema[queryAttribute]) {
+      return queryAttribute;
+    }
+    for (const [actualAttribute] of Object.entries(entitySchema)) {
+      if (actualAttribute.toLowerCase() === queryLower) {
+        return actualAttribute;
+      }
+    }
+    return null;
+  }
+  validateQuery(entityType, attributes) {
+    const errors = [];
+    const resolved = new Map;
+    for (const attr of attributes) {
+      const resolvedAttr = this.resolveAttribute(entityType, attr);
+      if (resolvedAttr) {
+        resolved.set(attr, resolvedAttr);
+      } else {
+        errors.push(`Unknown attribute '${attr}' for entity type '${entityType}'. Available attributes: ${Object.keys(this.schema[entityType] || {}).join(", ")}`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      resolved
+    };
+  }
+  getAvailableAttributes(entityType) {
+    return Object.keys(this.schema[entityType] || {});
+  }
+  getSchema() {
+    return this.schema;
+  }
+}
+
+// src/query/query-optimizer.ts
+class QueryOptimizer {
+  catalog;
+  constructor(catalog = []) {
+    this.catalog = catalog;
+  }
+  optimize(query) {
+    if (query.goals.length <= 1)
+      return query;
+    const optimizedGoals = [];
+    const remainingGoals = [...query.goals];
+    const boundVars = new Set;
+    const typeGoalIdx = remainingGoals.findIndex((g) => g.predicate === "attr" && g.terms[1] === "type");
+    if (typeGoalIdx !== -1) {
+      const typeGoal = remainingGoals.splice(typeGoalIdx, 1)[0];
+      optimizedGoals.push(typeGoal);
+      this.collectVars(typeGoal, boundVars);
+    }
+    while (remainingGoals.length > 0) {
+      const bestIdx = this.findBestNextGoal(remainingGoals, boundVars);
+      if (bestIdx === -1) {
+        const goal = remainingGoals.splice(0, 1)[0];
+        optimizedGoals.push(goal);
+        this.collectVars(goal, boundVars);
+      } else {
+        const goal = remainingGoals.splice(bestIdx, 1)[0];
+        optimizedGoals.push(goal);
+        this.collectVars(goal, boundVars);
+      }
+      let pushdownPossible = true;
+      while (pushdownPossible) {
+        const filterIdx = remainingGoals.findIndex((g) => this.isFilter(g) && this.isSatisfied(g, boundVars));
+        if (filterIdx !== -1) {
+          const filter = remainingGoals.splice(filterIdx, 1)[0];
+          optimizedGoals.push(filter);
+        } else {
+          pushdownPossible = false;
+        }
+      }
+    }
+    return {
+      ...query,
+      goals: optimizedGoals
+    };
+  }
+  findBestNextGoal(goals, boundVars) {
+    let bestIdx = -1;
+    let bestScore = -1;
+    const filterVars = new Set;
+    for (const goal of goals) {
+      if (this.isFilter(goal)) {
+        for (const term of goal.terms) {
+          if (typeof term === "string" && term.startsWith("?")) {
+            filterVars.add(term);
+          }
+        }
+      }
+    }
+    for (let i = 0;i < goals.length; i++) {
+      const goal = goals[i];
+      if (this.isFilter(goal))
+        continue;
+      let score = this.calculateRestrictiveness(goal, boundVars);
+      for (const term of goal.terms) {
+        if (typeof term === "string" && term.startsWith("?") && !boundVars.has(term) && filterVars.has(term)) {
+          score += 25;
+        }
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        bestIdx = i;
+      }
+    }
+    return bestIdx;
+  }
+  calculateRestrictiveness(goal, boundVars) {
+    let score = 0;
+    const terms = goal.terms;
+    for (const term of terms) {
+      if (typeof term !== "string" || !term.startsWith("?")) {
+        score += 100;
+      } else if (boundVars.has(term)) {
+        score += 50;
+      }
+    }
+    if (goal.predicate === "attr" && typeof terms[1] === "string") {
+      const entry = this.catalog.find((e) => e.attribute === terms[1]);
+      if (entry) {
+        if (entry.cardinality === "one") {
+          score += 20;
+        }
+        score -= Math.min(10, entry.distinctCount / 100);
+      }
+    }
+    return score;
+  }
+  isFilter(goal) {
+    const filters = new Set([
+      "gt",
+      "lt",
+      "between",
+      "regex",
+      "contains",
+      ">",
+      "<",
+      ">=",
+      "<=",
+      "=",
+      "!=",
+      "after",
+      "betweenDate"
+    ]);
+    return filters.has(goal.predicate) || goal.predicate.startsWith("ext_");
+  }
+  isSatisfied(goal, boundVars) {
+    return goal.terms.every((term) => {
+      if (typeof term === "string" && term.startsWith("?")) {
+        return boundVars.has(term);
+      }
+      return true;
+    });
+  }
+  collectVars(goal, boundVars) {
+    for (const term of goal.terms) {
+      if (typeof term === "string" && term.startsWith("?")) {
+        boundVars.add(term);
+      }
+    }
+  }
+}
+
+// src/query/eqls-parser.ts
+class EQLSParser {
+  tokens = [];
+  current = 0;
+  errors = [];
+  static KEYWORDS = new Set([
+    "FIND",
+    "AS",
+    "WHERE",
+    "AND",
+    "OR",
+    "RETURN",
+    "ORDER",
+    "BY",
+    "LIMIT",
+    "ASC",
+    "DESC",
+    "BETWEEN",
+    "CONTAINS",
+    "MATCHES",
+    "IN"
+  ]);
+  static SINGLE_CHAR_OPERATORS = new Set(["=", ">", "<"]);
+  static MULTI_CHAR_OPERATORS = new Set([
+    "CONTAINS",
+    "MATCHES",
+    "BETWEEN",
+    "IN"
+  ]);
+  parse(query) {
+    this.tokens = this.tokenize(query);
+    this.current = 0;
+    this.errors = [];
+    try {
+      const parsed = this.parseQuery();
+      if (this.errors.length > 0) {
+        return { errors: this.errors };
+      }
+      return { query: parsed, errors: [] };
+    } catch (error) {
+      this.errors.push({
+        line: 1,
+        column: 1,
+        message: `Parse error: ${error instanceof Error ? error.message : "Unknown error"}`
+      });
+      return { errors: this.errors };
+    }
+  }
+  tokenize(input) {
+    const tokens = [];
+    const lines = input.split(`
+`);
+    for (let lineNum = 0;lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("--"))
+        continue;
+      let pos = 0;
+      while (pos < line.length) {
+        const char = line[pos];
+        if (char === " ") {
+          pos++;
+          continue;
+        }
+        if (char === '"') {
+          const start = pos;
+          pos++;
+          while (pos < line.length && line[pos] !== '"') {
+            if (line[pos] === "\\" && pos + 1 < line.length) {
+              pos += 2;
+            } else {
+              pos++;
+            }
+          }
+          if (pos < line.length) {
+            pos++;
+            const value = line.slice(start + 1, pos - 1);
+            tokens.push({
+              type: "STRING",
+              value,
+              line: lineNum + 1,
+              column: start + 1
+            });
+          } else {
+            this.errors.push({
+              line: lineNum + 1,
+              column: start + 1,
+              message: "Unterminated string literal"
+            });
+            break;
+          }
+        } else if (char === "/" && pos + 1 < line.length) {
+          const start = pos;
+          pos++;
+          while (pos < line.length && line[pos] !== "/") {
+            if (line[pos] === "\\" && pos + 1 < line.length) {
+              pos += 2;
+            } else {
+              pos++;
+            }
+          }
+          if (pos < line.length) {
+            pos++;
+            const pattern = line.slice(start, pos);
+            tokens.push({
+              type: "REGEX",
+              value: pattern,
+              line: lineNum + 1,
+              column: start + 1
+            });
+          } else {
+            this.errors.push({
+              line: lineNum + 1,
+              column: start + 1,
+              message: "Unterminated regex literal"
+            });
+            break;
+          }
+        } else if (char.match(/[A-Za-z_@]/)) {
+          const start = pos;
+          while (pos < line.length && line[pos].match(/[A-Za-z0-9_:@-]/)) {
+            pos++;
+          }
+          const value = line.slice(start, pos);
+          const upperValue = value.toUpperCase();
+          let type = "IDENTIFIER";
+          let tokenValue = value;
+          if (EQLSParser.KEYWORDS.has(upperValue)) {
+            type = upperValue;
+            tokenValue = upperValue;
+          } else if (EQLSParser.MULTI_CHAR_OPERATORS.has(upperValue)) {
+            type = "OPERATOR";
+            tokenValue = upperValue;
+          }
+          tokens.push({
+            type,
+            value: tokenValue,
+            line: lineNum + 1,
+            column: start + 1
+          });
+        } else if (char.match(/[0-9]/)) {
+          const start = pos;
+          let hasDecimal = false;
+          while (pos < line.length) {
+            const nextChar = line[pos];
+            if (nextChar.match(/[0-9]/)) {
+              pos++;
+            } else if (nextChar === "." && !hasDecimal && pos + 1 < line.length && line[pos + 1].match(/[0-9]/)) {
+              hasDecimal = true;
+              pos++;
+            } else {
+              break;
+            }
+          }
+          const value = line.slice(start, pos);
+          const numValue = value.includes(".") ? parseFloat(value) : parseInt(value, 10);
+          tokens.push({
+            type: "NUMBER",
+            value: numValue,
+            line: lineNum + 1,
+            column: start + 1
+          });
+        } else if (char === ".") {
+          tokens.push({
+            type: "DOT",
+            value: ".",
+            line: lineNum + 1,
+            column: pos + 1
+          });
+          pos++;
+        } else if (char === "?") {
+          const start = pos;
+          pos++;
+          while (pos < line.length && line[pos].match(/[A-Za-z0-9_]/)) {
+            pos++;
+          }
+          const value = line.slice(start, pos);
+          tokens.push({
+            type: "VARIABLE",
+            value,
+            line: lineNum + 1,
+            column: start + 1
+          });
+        } else if (EQLSParser.SINGLE_CHAR_OPERATORS.has(char) || char === "!" && pos + 1 < line.length && line[pos + 1] === "=" || char === ">" && pos + 1 < line.length && line[pos + 1] === "=" || char === "<" && pos + 1 < line.length && line[pos + 1] === "=" || char === "=" && pos + 1 < line.length && line[pos + 1] === "=") {
+          const start = pos;
+          if (char === "!" || char === ">" || char === "<" || char === "=") {
+            pos += 2;
+          } else {
+            pos++;
+          }
+          const value = line.slice(start, pos);
+          tokens.push({
+            type: "OPERATOR",
+            value,
+            line: lineNum + 1,
+            column: start + 1
+          });
+        } else if (char === ",") {
+          tokens.push({
+            type: "COMMA",
+            value: ",",
+            line: lineNum + 1,
+            column: pos + 1
+          });
+          pos++;
+        } else if (char === "(") {
+          tokens.push({
+            type: "LPAREN",
+            value: "(",
+            line: lineNum + 1,
+            column: pos + 1
+          });
+          pos++;
+        } else if (char === ")") {
+          tokens.push({
+            type: "RPAREN",
+            value: ")",
+            line: lineNum + 1,
+            column: pos + 1
+          });
+          pos++;
+        } else {
+          this.errors.push({
+            line: lineNum + 1,
+            column: pos + 1,
+            message: `Unexpected character '${char}'`,
+            expected: ["identifier", "string", "number", "operator"]
+          });
+          pos++;
+        }
+      }
+    }
+    return tokens;
+  }
+  parseQuery() {
+    this.expect("FIND");
+    const find = this.expect("IDENTIFIER").value;
+    this.expect("AS");
+    const as = this.expect("VARIABLE").value;
+    let where;
+    if (this.match("WHERE")) {
+      where = this.parseExpression();
+    }
+    let returnFields;
+    if (this.match("RETURN")) {
+      returnFields = this.parseReturnFields();
+    }
+    let orderBy;
+    if (this.match("ORDER")) {
+      this.expect("BY");
+      const field = this.parseAttributeReference();
+      const direction = this.match("DESC") ? "DESC" : this.match("ASC") ? "ASC" : "ASC";
+      orderBy = { field, direction };
+    }
+    let limit;
+    if (this.match("LIMIT")) {
+      limit = this.expect("NUMBER").value;
+    }
+    return { find, as, where, return: returnFields, orderBy, limit };
+  }
+  parseExpression() {
+    let left = this.parseTerm();
+    while (this.match("AND") || this.match("OR")) {
+      const op = this.previous().value;
+      const right = this.parseTerm();
+      left = { op, left, right };
+    }
+    return left;
+  }
+  parseTerm() {
+    if (this.match("LPAREN")) {
+      const expr = this.parseExpression();
+      this.expect("RPAREN");
+      return expr;
+    }
+    if ((this.check("STRING") || this.check("NUMBER") || this.check("IDENTIFIER")) && this.tokens[this.current + 1]?.type === "IN") {
+      const value = this.parseValue();
+      this.expect("IN");
+      const field = this.parseAttributeReference();
+      return { type: "MEMBERSHIP", value, field };
+    }
+    return this.parsePredicate();
+  }
+  parsePredicate() {
+    const field = this.parseAttributeReference();
+    if (this.match("BETWEEN")) {
+      const min = this.expect("NUMBER").value;
+      this.expect("AND");
+      const max = this.expect("NUMBER").value;
+      return { type: "BETWEEN", field, min, max };
+    }
+    if (this.match("CONTAINS")) {
+      const pattern = this.expect("STRING").value;
+      return { type: "CONTAINS", field, pattern };
+    }
+    if (this.match("MATCHES")) {
+      const regex = this.expect("REGEX").value;
+      return { type: "MATCHES", field, regex };
+    }
+    if (this.match("IN")) {
+      const value = this.parseValue();
+      return { type: "MEMBERSHIP", value, field };
+    }
+    const op = this.expect("OPERATOR").value.trim();
+    const right = this.parseValue();
+    if (op === "=" || op === "==") {
+      return { type: "EQUALS", field, value: right };
+    } else {
+      return { type: "COMP", left: field, op, right };
+    }
+  }
+  parseAttributeReference() {
+    const variable = this.expect("VARIABLE").value;
+    const attributeParts = [];
+    while (this.check("DOT")) {
+      this.advance();
+      const attributePart = this.expect("IDENTIFIER").value;
+      attributeParts.push(this.toCamelCase(attributePart));
+    }
+    if (attributeParts.length > 0) {
+      return `${variable}.${attributeParts.join(".")}`;
+    }
+    return variable;
+  }
+  toCamelCase(str) {
+    return str;
+  }
+  parseValue() {
+    if (this.match("STRING"))
+      return this.previous().value;
+    if (this.match("NUMBER"))
+      return this.previous().value;
+    if (this.match("IDENTIFIER")) {
+      const value = this.previous().value;
+      if (value === "true")
+        return true;
+      if (value === "false")
+        return false;
+      return value;
+    }
+    if (this.match("VARIABLE"))
+      return this.previous().value;
+    throw new Error(`Expected value, got ${this.peek().type}`);
+  }
+  parseReturnFields() {
+    const fields = [];
+    do {
+      const field = this.parseAttributeReference();
+      fields.push(field);
+    } while (this.match("COMMA"));
+    return fields;
+  }
+  extractContainsFields(expr) {
+    const fields = [];
+    if ("op" in expr && (expr.op === "AND" || expr.op === "OR")) {
+      fields.push(...this.extractContainsFields(expr.left));
+      fields.push(...this.extractContainsFields(expr.right));
+    } else if ("type" in expr && expr.type === "CONTAINS" && "field" in expr) {
+      fields.push(expr.field);
+    }
+    return fields;
+  }
+  match(type) {
+    if (this.check(type)) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  check(type) {
+    if (this.isAtEnd())
+      return false;
+    return this.peek().type === type;
+  }
+  advance() {
+    if (!this.isAtEnd())
+      this.current++;
+    return this.previous();
+  }
+  isAtEnd() {
+    return this.peek().type === "EOF";
+  }
+  peek() {
+    return this.tokens[this.current] || {
+      type: "EOF",
+      value: "",
+      line: 0,
+      column: 0
+    };
+  }
+  previous() {
+    return this.tokens[this.current - 1] || {
+      type: "EOF",
+      value: "",
+      line: 0,
+      column: 0
+    };
+  }
+  expect(type) {
+    if (this.check(type)) {
+      return this.advance();
+    }
+    const token = this.peek();
+    this.errors.push({
+      line: token.line,
+      column: token.column,
+      message: `Expected ${type}, got ${token.type}`,
+      expected: [type]
+    });
+    throw new Error(`Expected ${type}, got ${token.type}`);
+  }
+}
+
+class EQLSCompiler {
+  projectionMap = new Map;
+  tempCounter = 0;
+  compileAll(eqlsQuery) {
+    const baseGoals = [];
+    const baseVariables = new Set;
+    this.projectionMap.clear();
+    this.tempCounter = 0;
+    baseGoals.push({
+      predicate: "attr",
+      terms: [eqlsQuery.as, "type", eqlsQuery.find]
+    });
+    baseVariables.add(eqlsQuery.as.substring(1));
+    const returnGoals = [];
+    const returnVars = new Set;
+    if (eqlsQuery.return) {
+      for (const field of eqlsQuery.return) {
+        if (this.isAttributeReference(field)) {
+          const [entityVar, attributePath] = this.splitAttributeReference(field);
+          const outputVar = this.generateTempVar();
+          returnVars.add(outputVar);
+          returnGoals.push({
+            predicate: "attr",
+            terms: [entityVar, attributePath, `?${outputVar}`]
+          });
+          this.projectionMap.set(field, `?${outputVar}`);
+        } else {
+          returnVars.add(field.substring(1));
+          this.projectionMap.set(field, field);
+        }
+      }
+    }
+    const clauses = eqlsQuery.where ? this.toDNF(eqlsQuery.where) : [[]];
+    const compiledQueries = [];
+    for (const clause of clauses) {
+      const goals = [...baseGoals];
+      const variables = new Set(baseVariables);
+      for (const pred of clause) {
+        this.compilePredicate(pred, goals, variables);
+      }
+      for (const g of returnGoals)
+        goals.push(g);
+      for (const v of returnVars)
+        variables.add(v);
+      compiledQueries.push({ goals, variables });
+    }
+    return compiledQueries;
+  }
+  compile(eqlsQuery) {
+    const all = this.compileAll(eqlsQuery);
+    return all[0] || { goals: [], variables: new Set };
+  }
+  getProjectionMap() {
+    return this.projectionMap;
+  }
+  isAttributeReference(field) {
+    return field.includes(".") && field.startsWith("?");
+  }
+  splitAttributeReference(field) {
+    const parts = field.split(".");
+    if (parts.length < 2) {
+      throw new Error(`Invalid attribute reference: ${field}`);
+    }
+    const entityVar = parts[0];
+    const attributePath = parts.slice(1).join(".");
+    return [entityVar, attributePath];
+  }
+  compileExpression(expr, goals, variables) {
+    if (!expr || typeof expr !== "object") {
+      throw new Error(`Invalid expression: ${expr}`);
+    }
+    if ("op" in expr && (expr.op === "AND" || expr.op === "OR")) {
+      this.compileExpression(expr.left, goals, variables);
+      this.compileExpression(expr.right, goals, variables);
+    } else {
+      this.compilePredicate(expr, goals, variables);
+    }
+  }
+  compilePredicate(pred, goals, variables) {
+    switch (pred.type) {
+      case "EQUALS":
+        goals.push({
+          predicate: "attr",
+          terms: [
+            this.extractEntityVar(pred.field),
+            this.extractAttributePath(pred.field),
+            pred.value
+          ]
+        });
+        break;
+      case "MEMBERSHIP":
+        goals.push({
+          predicate: "attr",
+          terms: [
+            this.extractEntityVar(pred.field),
+            this.extractAttributePath(pred.field),
+            pred.value
+          ]
+        });
+        break;
+      case "COMP":
+        const tempVar = this.generateTempVar();
+        variables.add(tempVar);
+        goals.push({
+          predicate: "attr",
+          terms: [
+            this.extractEntityVar(pred.left),
+            this.extractAttributePath(pred.left),
+            `?${tempVar}`
+          ]
+        });
+        goals.push({
+          predicate: pred.op.toLowerCase(),
+          terms: [`?${tempVar}`, pred.right]
+        });
+        break;
+      case "BETWEEN":
+        const tempVar2 = this.generateTempVar();
+        variables.add(tempVar2);
+        goals.push({
+          predicate: "attr",
+          terms: [
+            this.extractEntityVar(pred.field),
+            this.extractAttributePath(pred.field),
+            `?${tempVar2}`
+          ]
+        });
+        goals.push({
+          predicate: "between",
+          terms: [`?${tempVar2}`, pred.min, pred.max]
+        });
+        break;
+      case "CONTAINS":
+        const tempVar3 = this.generateTempVar();
+        variables.add(tempVar3);
+        goals.push({
+          predicate: "attr",
+          terms: [
+            this.extractEntityVar(pred.field),
+            this.extractAttributePath(pred.field),
+            `?${tempVar3}`
+          ]
+        });
+        goals.push({
+          predicate: "contains",
+          terms: [`?${tempVar3}`, pred.pattern]
+        });
+        break;
+      case "MATCHES":
+        const tempVar4 = this.generateTempVar();
+        variables.add(tempVar4);
+        const attributePath = this.extractAttributePath(pred.field);
+        const entityVar = this.extractEntityVar(pred.field);
+        goals.push({
+          predicate: "attr",
+          terms: [entityVar, attributePath, `?${tempVar4}`]
+        });
+        goals.push({
+          predicate: "regex",
+          terms: [`?${tempVar4}`, pred.regex]
+        });
+        break;
+    }
+  }
+  extractEntityVar(field) {
+    const parts = field.split(".");
+    return parts[0];
+  }
+  extractAttributePath(field) {
+    const parts = field.split(".");
+    if (parts.length > 1) {
+      return parts.slice(1).join(".");
+    }
+    return field.substring(1);
+  }
+  generateTempVar() {
+    this.tempCounter += 1;
+    return `temp${this.tempCounter}`;
+  }
+  toDNF(expr) {
+    if ("op" in expr && (expr.op === "AND" || expr.op === "OR")) {
+      const left = this.toDNF(expr.left);
+      const right = this.toDNF(expr.right);
+      if (expr.op === "OR") {
+        return [...left, ...right];
+      }
+      const combined = [];
+      for (const l of left) {
+        for (const r of right) {
+          combined.push([...l, ...r]);
+        }
+      }
+      return combined;
+    }
+    return [[expr]];
+  }
+}
+
+class EQLSProcessor {
+  parser = new EQLSParser;
+  compiler = new EQLSCompiler;
+  attributeResolver = new AttributeResolver;
+  catalog = [];
+  setSchema(catalog) {
+    this.catalog = catalog;
+    this.attributeResolver.buildSchema(catalog);
+  }
+  process(query) {
+    const parseResult = this.parser.parse(query);
+    if (parseResult.errors.length > 0) {
+      return { errors: parseResult.errors };
+    }
+    this.ensureFieldsInProjection(parseResult.query);
+    if (Object.keys(this.attributeResolver.getSchema()).length > 0) {
+      const entityType = "default";
+      const attributes = this.extractAttributes(parseResult.query);
+      const validation = this.attributeResolver.validateQuery(entityType, attributes);
+      if (!validation.valid) {
+        return {
+          errors: validation.errors.map((msg) => ({
+            message: msg,
+            line: 1,
+            column: 1
+          }))
+        };
+      }
+      this.resolveAttributesInQuery(parseResult.query, validation.resolved);
+    }
+    const compiledQueries = this.compiler.compileAll(parseResult.query);
+    const optimizer = new QueryOptimizer(this.catalog);
+    const optimizedQueries = compiledQueries.map((q) => optimizer.optimize(q));
+    const projectionMap = this.compiler.getProjectionMap();
+    return {
+      query: optimizedQueries[0],
+      queries: optimizedQueries,
+      errors: [],
+      projectionMap,
+      meta: {
+        orderBy: parseResult.query.orderBy,
+        limit: parseResult.query.limit
+      }
+    };
+  }
+  ensureFieldsInProjection(eqlsQuery) {
+    if (!eqlsQuery.return) {
+      eqlsQuery.return = [];
+    }
+    if (eqlsQuery.where) {
+      const matchesFields = this.extractMatchesFields(eqlsQuery.where);
+      for (const field of matchesFields) {
+        if (!eqlsQuery.return.includes(field)) {
+          eqlsQuery.return.push(field);
+        }
+      }
+      const containsFields = this.extractContainsFields(eqlsQuery.where);
+      for (const field of containsFields) {
+        if (!eqlsQuery.return.includes(field)) {
+          eqlsQuery.return.push(field);
+        }
+      }
+    }
+    if (eqlsQuery.orderBy?.field) {
+      const field = eqlsQuery.orderBy.field;
+      if (!eqlsQuery.return.includes(field)) {
+        eqlsQuery.return.push(field);
+      }
+    }
+  }
+  extractMatchesFields(expr) {
+    const fields = [];
+    if ("op" in expr && (expr.op === "AND" || expr.op === "OR")) {
+      fields.push(...this.extractMatchesFields(expr.left));
+      fields.push(...this.extractMatchesFields(expr.right));
+    } else if ("type" in expr && expr.type === "MATCHES" && "field" in expr) {
+      fields.push(expr.field);
+    }
+    return fields;
+  }
+  extractContainsFields(expr) {
+    const fields = [];
+    if ("op" in expr && (expr.op === "AND" || expr.op === "OR")) {
+      fields.push(...this.extractContainsFields(expr.left));
+      fields.push(...this.extractContainsFields(expr.right));
+    } else if ("type" in expr && expr.type === "CONTAINS" && "field" in expr) {
+      fields.push(expr.field);
+    }
+    return fields;
+  }
+  extractAttributes(eqlsQuery) {
+    const attributes = new Set;
+    if (eqlsQuery.where) {
+      this.extractAttributesFromExpression(eqlsQuery.where, attributes);
+    }
+    if (eqlsQuery.return) {
+      for (const field of eqlsQuery.return) {
+        if (this.isAttributeReference(field)) {
+          const [, attribute] = this.splitAttributeReference(field);
+          attributes.add(attribute);
+        }
+      }
+    }
+    return Array.from(attributes);
+  }
+  extractAttributesFromExpression(expr, attributes) {
+    if ("op" in expr && (expr.op === "AND" || expr.op === "OR")) {
+      this.extractAttributesFromExpression(expr.left, attributes);
+      this.extractAttributesFromExpression(expr.right, attributes);
+    } else if ("field" in expr) {
+      if (this.isAttributeReference(expr.field)) {
+        const [, attribute] = this.splitAttributeReference(expr.field);
+        attributes.add(attribute);
+      }
+    } else if ("left" in expr && "right" in expr) {
+      if (typeof expr.left === "string" && this.isAttributeReference(expr.left)) {
+        const [, attribute] = this.splitAttributeReference(expr.left);
+        attributes.add(attribute);
+      }
+    }
+  }
+  resolveAttributesInQuery(eqlsQuery, resolved) {
+    if (eqlsQuery.where) {
+      this.resolveAttributesInExpression(eqlsQuery.where, resolved);
+    }
+    if (eqlsQuery.return) {
+      for (let i = 0;i < eqlsQuery.return.length; i++) {
+        const field = eqlsQuery.return[i];
+        if (this.isAttributeReference(field)) {
+          const [entityVar, attribute] = this.splitAttributeReference(field);
+          const resolvedAttr = resolved.get(attribute);
+          if (resolvedAttr) {
+            eqlsQuery.return[i] = `${entityVar}.${resolvedAttr}`;
+          }
+        }
+      }
+    }
+  }
+  resolveAttributesInExpression(expr, resolved) {
+    if ("op" in expr && (expr.op === "AND" || expr.op === "OR")) {
+      this.resolveAttributesInExpression(expr.left, resolved);
+      this.resolveAttributesInExpression(expr.right, resolved);
+    } else if ("field" in expr) {
+      if (this.isAttributeReference(expr.field)) {
+        const [entityVar, attribute] = this.splitAttributeReference(expr.field);
+        const resolvedAttr = resolved.get(attribute);
+        if (resolvedAttr) {
+          expr.field = `${entityVar}.${resolvedAttr}`;
+        }
+      }
+    } else if ("left" in expr && "right" in expr) {
+      if (typeof expr.left === "string" && this.isAttributeReference(expr.left)) {
+        const [entityVar, attribute] = this.splitAttributeReference(expr.left);
+        const resolvedAttr = resolved.get(attribute);
+        if (resolvedAttr) {
+          expr.left = `${entityVar}.${resolvedAttr}`;
+        }
+      }
+    }
+  }
+  isAttributeReference(field) {
+    return field.includes(".");
+  }
+  splitAttributeReference(field) {
+    const parts = field.split(".");
+    return [parts[0], parts.slice(1).join(".")];
+  }
+}
+// src/query/query-examples.ts
+class QueryBuilder {
+  evaluator;
+  constructor(evaluator) {
+    this.evaluator = evaluator;
+  }
+  popularCrimePosts() {
+    return {
+      goals: [
+        { predicate: "attr", terms: ["?P", "type", "post"] },
+        { predicate: "attr", terms: ["?P", "tags", "crime"] },
+        { predicate: "attr", terms: ["?P", "reactions.likes", "?Likes"] },
+        { predicate: "gt", terms: ["?Likes", 1000] }
+      ],
+      variables: new Set(["P", "Likes"])
+    };
+  }
+  stormyMidViews() {
+    return {
+      goals: [
+        { predicate: "attr", terms: ["?P", "type", "post"] },
+        { predicate: "attr", terms: ["?P", "body", "?Body"] },
+        { predicate: "regex", terms: ["?Body", "(storm|forest)"] },
+        { predicate: "attr", terms: ["?P", "views", "?Views"] },
+        { predicate: "between", terms: ["?Views", 1000, 5000] }
+      ],
+      variables: new Set(["P", "Body", "Views"])
+    };
+  }
+  topTagsByLikes() {
+    return {
+      goals: [
+        { predicate: "attr", terms: ["?P", "type", "post"] },
+        { predicate: "attr", terms: ["?P", "tags", "?Tag"] },
+        { predicate: "attr", terms: ["?P", "reactions.likes", "?Likes"] }
+      ],
+      variables: new Set(["Tag", "Likes"])
+    };
+  }
+  highEngagementPosts() {
+    return {
+      goals: [
+        { predicate: "attr", terms: ["?P", "type", "post"] },
+        { predicate: "attr", terms: ["?P", "reactions.likes", "?Likes"] },
+        { predicate: "attr", terms: ["?P", "views", "?Views"] },
+        { predicate: "gt", terms: ["?Likes", "?HalfViews"] }
+      ],
+      variables: new Set(["P", "Likes", "Views"])
+    };
+  }
+  postsByUser(userId) {
+    return {
+      goals: [
+        { predicate: "attr", terms: ["?P", "type", "post"] },
+        { predicate: "attr", terms: ["?P", "userId", userId] }
+      ],
+      variables: new Set(["P"])
+    };
+  }
+  postsWithTag(tag) {
+    return {
+      goals: [
+        { predicate: "attr", terms: ["?P", "type", "post"] },
+        { predicate: "attr", terms: ["?P", "tags", tag] }
+      ],
+      variables: new Set(["P"])
+    };
+  }
+  postsWithTitleKeyword(keyword) {
+    return {
+      goals: [
+        { predicate: "attr", terms: ["?P", "type", "post"] },
+        { predicate: "attr", terms: ["?P", "title", "?Title"] },
+        { predicate: "contains", terms: ["?Title", keyword] }
+      ],
+      variables: new Set(["P", "Title"])
+    };
+  }
+}
+
+class EmailQueryBuilder {
+  evaluator;
+  constructor(evaluator) {
+    this.evaluator = evaluator;
+  }
+  awaitingReply() {
+    return {
+      goals: [
+        { predicate: "attr", terms: ["?M", "type", "email"] },
+        { predicate: "attr", terms: ["?M", "is_last_in_thread", true] },
+        { predicate: "attr", terms: ["?M", "to", "trent@..."] }
+      ],
+      variables: new Set(["M"])
+    };
+  }
+  unpaidInvoices() {
+    return {
+      goals: [
+        { predicate: "attr", terms: ["?M", "type", "email"] },
+        { predicate: "attr", terms: ["?M", "subject", "?Subject"] },
+        { predicate: "ext_regex", terms: ["?Subject", "invoice|receipt|bill"] }
+      ],
+      variables: new Set(["M", "Subject"])
+    };
+  }
+}
+
+class QueryRunner {
+  store;
+  evaluator;
+  queryBuilder;
+  constructor(store) {
+    this.store = store;
+    this.evaluator = new DatalogEvaluator(store);
+    this.queryBuilder = new QueryBuilder(this.evaluator);
+    this.addDerivedPredicates();
+  }
+  addDerivedPredicates() {
+    const popularRule = {
+      head: { predicate: "popular", terms: ["?P", "?Likes"] },
+      body: [
+        { predicate: "attr", terms: ["?P", "type", "post"] },
+        { predicate: "attr", terms: ["?P", "reactions.likes", "?Likes"] },
+        { predicate: "gt", terms: ["?Likes", 500] }
+      ]
+    };
+    const veryPopularRule = {
+      head: { predicate: "very_popular", terms: ["?P"] },
+      body: [
+        { predicate: "popular", terms: ["?P", "?Likes"] },
+        { predicate: "gt", terms: ["?Likes", 1000] }
+      ]
+    };
+    const unfeaturedRule = {
+      head: { predicate: "unfeatured", terms: ["?P"] },
+      body: [
+        { predicate: "attr", terms: ["?P", "type", "post"] }
+      ]
+    };
+    this.evaluator.addRule(popularRule);
+    this.evaluator.addRule(veryPopularRule);
+    this.evaluator.addRule(unfeaturedRule);
+  }
+  async runQuery(query) {
+    const result = this.evaluator.evaluate(query);
+    return {
+      results: result.bindings,
+      count: result.bindings.length,
+      executionTime: result.executionTime,
+      plan: result.plan
+    };
+  }
+  async getPopularCrimePosts() {
+    return this.runQuery(this.queryBuilder.popularCrimePosts());
+  }
+  async getStormyMidViews() {
+    return this.runQuery(this.queryBuilder.stormyMidViews());
+  }
+  async getTopTagsByLikes() {
+    const result = await this.runQuery(this.queryBuilder.topTagsByLikes());
+    const tagLikes = new Map;
+    for (const binding of result.results) {
+      const tag = binding.Tag;
+      const likes = binding.Likes;
+      tagLikes.set(tag, (tagLikes.get(tag) || 0) + likes);
+    }
+    const sortedTags = Array.from(tagLikes.entries()).sort(([, a], [, b]) => b - a).map(([tag, totalLikes]) => ({ tag, totalLikes }));
+    return {
+      ...result,
+      aggregatedResults: sortedTags
+    };
+  }
+  async getHighEngagementPosts() {
+    return this.runQuery(this.queryBuilder.highEngagementPosts());
+  }
+  async getPostsByUser(userId) {
+    return this.runQuery(this.queryBuilder.postsByUser(userId));
+  }
+  async getPostsWithTag(tag) {
+    return this.runQuery(this.queryBuilder.postsWithTag(tag));
+  }
+  async getPostsWithTitleKeyword(keyword) {
+    return this.runQuery(this.queryBuilder.postsWithTitleKeyword(keyword));
+  }
+  async getPopularPosts() {
+    const query = {
+      goals: [{ predicate: "popular", terms: ["?P", "?Likes"] }],
+      variables: new Set(["P", "Likes"])
+    };
+    return this.runQuery(query);
+  }
+  async getVeryPopularPosts() {
+    const query = {
+      goals: [{ predicate: "very_popular", terms: ["?P"] }],
+      variables: new Set(["P"])
+    };
+    return this.runQuery(query);
+  }
+  async getUnfeaturedPosts() {
+    const query = {
+      goals: [{ predicate: "unfeatured", terms: ["?P"] }],
+      variables: new Set(["P"])
+    };
+    return this.runQuery(query);
+  }
+  async getPopularUnfeaturedPosts() {
+    const query = {
+      goals: [
+        { predicate: "popular", terms: ["?P", "?Likes"] },
+        { predicate: "unfeatured", terms: ["?P"] }
+      ],
+      variables: new Set(["P", "Likes"])
+    };
+    return this.runQuery(query);
+  }
+  getCatalog() {
+    return {
+      entries: this.store.getCatalog(),
+      stats: this.store.getStats()
+    };
+  }
+}
+export {
+  QueryRunner,
+  QueryBuilder,
+  ExternalPredicates,
+  EmailQueryBuilder,
+  EQLSProcessor,
+  EQLSParser,
+  EQLSCompiler,
+  DatalogEvaluator,
+  AttributeResolver
+};