trellis 1.0.4 → 1.0.7

package/dist/graph/index.js

@@ -0,0 +1,2248 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+// src/graph/graph.ts
+class Graph {
+  nodes = new Map;
+  edges = new Map;
+  outIdx = new Map;
+  addNode(n) {
+    if (this.nodes.has(n.id))
+      throw new Error(`node exists: ${n.id}`);
+    this.nodes.set(n.id, n);
+    if (!this.outIdx.has(n.id))
+      this.outIdx.set(n.id, []);
+  }
+  addEdge(e) {
+    if (!this.nodes.has(e.from) || !this.nodes.has(e.to)) {
+      throw new Error(`dangling edge ${e.id}: ${e.from} -> ${e.to}`);
+    }
+    if (this.edges.has(e.id))
+      throw new Error(`edge exists: ${e.id}`);
+    this.edges.set(e.id, e);
+    this.outIdx.get(e.from).push(e.id);
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  out(from) {
+    const ids = this.outIdx.get(from) || [];
+    return ids.map((id) => this.edges.get(id)).filter(Boolean);
+  }
+  allNodes() {
+    return this.nodes.values();
+  }
+  allEdges() {
+    return this.edges.values();
+  }
+}
+// src/graph/validators.ts
+function validateGraph(g) {
+  for (const n of g.allNodes()) {
+    const byLabel = new Map;
+    for (const e of g.out(n.id)) {
+      if (!e.label)
+        continue;
+      const list = byLabel.get(e.label) || [];
+      list.push(e.id);
+      byLabel.set(e.label, list);
+    }
+    for (const [label, ids] of byLabel) {
+      if (ids.length > 1) {
+        throw new Error(`node ${n.id} has duplicate label "${label}" on edges ${ids.join(",")}`);
+      }
+    }
+  }
+}
+// src/graph/engine.ts
+import crypto from "node:crypto";
+
+// src/graph/util.ts
+var interpolate = (tpl, vars) => tpl.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (_m, k) => String(pluck(vars, k) ?? ""));
+function pluck(obj, path) {
+  return path.split(".").reduce((o, k) => o && o[k] !== undefined ? o[k] : undefined, obj);
+}
+
+// src/graph/executors.ts
+function makeDefaultExecutors(opts) {
+  const { llm, stream, tools } = opts;
+  const Agent = async (node, state) => {
+    const { system = "", prompt = "", model = "gpt-4o", vars = {}, stream: wantStream = false } = node.data || {};
+    const rendered = interpolate(String(prompt || ""), { ...vars, input: state.input, state });
+    state.log?.("info", `Agent executing: ${node.id}`, { model, system: system.slice(0, 100) });
+    if (wantStream && typeof stream === "function") {
+      const iter = await stream({ model, system, prompt: rendered });
+      return { output: { stream: iter }, next: "success" };
+    } else {
+      const { text } = await llm({ model, system, prompt: rendered });
+      return { output: { text }, next: "success" };
+    }
+  };
+  const Tool = async (node, state) => {
+    const { name, args = {} } = node.data || {};
+    console.log(`\uD83D\uDD27 [TOOL] Executing tool: ${name}`);
+    console.log(`\uD83D\uDCCB [TOOL] Args:`, args);
+    console.log(`\uD83D\uDCE5 [TOOL] Input:`, state.output?.text ? `"${String(state.output.text).slice(0, 100)}..."` : "none");
+    console.log(`\uD83E\uDDE0 [TOOL] State memory keys:`, Object.keys(state.memory || {}));
+    const fn = tools[name];
+    if (!fn) {
+      console.log(`❌ [TOOL] Tool '${name}' not found in registry`);
+      console.log(`\uD83D\uDD0D [TOOL] Available tools:`, Object.keys(tools));
+      throw new Error(`tool missing: ${name}`);
+    }
+    state.log?.("info", `Tool executing: ${name}`, { args });
+    try {
+      const toolArgs = { ...args, input: state.output?.text, state };
+      console.log(`⚡ [TOOL] Calling tool with:`, {
+        argKeys: Object.keys(toolArgs),
+        hasState: !!toolArgs.state,
+        hasInput: !!toolArgs.input
+      });
+      const res = await fn(toolArgs);
+      console.log(`✅ [TOOL] Tool '${name}' completed successfully`);
+      console.log(`\uD83D\uDCE4 [TOOL] Result type:`, typeof res);
+      console.log(`\uD83D\uDCE4 [TOOL] Result preview:`, res && typeof res === "object" ? Object.keys(res) : String(res).slice(0, 100));
+      return { output: { tool: name, result: res }, next: "success" };
+    } catch (error) {
+      console.log(`❌ [TOOL] Tool '${name}' failed:`, error.message);
+      throw error;
+    }
+  };
+  const Router = async (node, state) => {
+    const { routes = [] } = node.data || {};
+    const hit = routes.find((r) => r?.when?.(state));
+    const label = hit?.label || "default";
+    state.log?.("debug", `Router routing to: ${label}`, { nodeId: node.id });
+    return { output: state.output, next: label };
+  };
+  const Guard = async (node, state) => {
+    const { allow } = node.data || {};
+    const ok = typeof allow === "function" ? allow(state) : !!allow;
+    state.log?.("debug", `Guard ${ok ? "passed" : "failed"}`, { nodeId: node.id });
+    return { output: state.output, next: ok ? "pass" : "fail" };
+  };
+  const MemoryRead = async (node, state) => {
+    const { key } = node.data || {};
+    const v = state.memory?.[key];
+    state.log?.("debug", `Memory read: ${key}`, { value: v });
+    return { output: { ...state.output, memory: { [key]: v } }, next: "success" };
+  };
+  const MemoryWrite = async (node, state) => {
+    const { key, from = "output.text" } = node.data || {};
+    const val = pluck(state, from);
+    state.memory ||= {};
+    state.memory[key] = val;
+    state.log?.("debug", `Memory write: ${key}`, { value: val });
+    return { output: state.output, next: "success" };
+  };
+  const End = async (_node, state) => {
+    state.log?.("info", "Execution completed");
+    return { output: state.output, next: null };
+  };
+  return { Agent, Tool, Router, Guard, MemoryRead, MemoryWrite, End };
+}
+
+// src/graph/engine.ts
+class Engine {
+  g;
+  exec;
+  llm;
+  tools;
+  maxSteps;
+  perNodeMs;
+  emit;
+  orchestrator;
+  constructor(graph, {
+    executors = {},
+    llm,
+    tools = {},
+    maxSteps = 200,
+    perNodeMs = 15000,
+    orchestrator,
+    onEvent
+  } = {}) {
+    this.g = graph;
+    this.llm = llm ?? (async () => ({ text: "(mock LLM)" }));
+    this.tools = tools;
+    this.maxSteps = maxSteps;
+    this.perNodeMs = perNodeMs;
+    this.orchestrator = orchestrator;
+    this.emit = onEvent;
+    this.exec = {
+      ...makeDefaultExecutors({ llm: this.llm, stream: this.llm?.stream, tools: this.tools }),
+      ...executors
+    };
+  }
+  async* run(startId, input, seedState = {}) {
+    let current = this.g.getNode(startId);
+    if (!current)
+      throw new Error("no start node");
+    let steps = 0;
+    const runId = crypto.randomUUID?.() || `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const traces = [];
+    const journal = [];
+    let state = {
+      runId,
+      step: 0,
+      input,
+      output: null,
+      memory: {},
+      meta: {},
+      traces,
+      journal,
+      log: (level, msg, data) => this.log(state, level, msg, data),
+      ...seedState
+    };
+    console.log(`\uD83D\uDE80 [ENGINE] Starting run ${runId} at node '${startId}'`);
+    console.log(`\uD83D\uDCCA [ENGINE] Initial state:`, {
+      step: state.step,
+      inputType: typeof input,
+      memoryKeys: Object.keys(state.memory || {}),
+      startNode: current.id,
+      nodeKind: current.kind
+    });
+    this.emit?.({ type: "run.start", ts: Date.now(), runId, data: { input, startId } });
+    await this.orchestrator?.onRunStart?.(state);
+    while (current) {
+      if (++steps > this.maxSteps)
+        throw new Error(`step budget exceeded (${this.maxSteps})`);
+      state.step = steps;
+      console.log(`
+\uD83D\uDD04 [ENGINE] Step ${steps}: Executing node '${current.id}' (${current.kind})`);
+      console.log(`\uD83D\uDCCB [ENGINE] Node data:`, current.data);
+      console.log(`\uD83E\uDDE0 [ENGINE] Current state memory keys:`, Object.keys(state.memory || {}));
+      const outEdges = this.g.out(current.id);
+      console.log(`\uD83D\uDD17 [ENGINE] Outgoing edges from '${current.id}': [${outEdges.map((e) => `${e.to}(${e.label || "default"})`).join(", ")}]`);
+      this.emit?.({ type: "node.start", ts: Date.now(), runId, nodeId: current.id });
+      await this.orchestrator?.beforeNode?.(current, state);
+      const t0 = Date.now();
+      let result = { output: state.output, next: null };
+      let err;
+      try {
+        const exec = this.exec[current.kind];
+        if (!exec)
+          throw new Error(`no executor for kind: ${current.kind}`);
+        console.log(`⚡ [ENGINE] Executing ${current.kind} executor...`);
+        result = await withTimeout(exec(current, state), this.perNodeMs);
+        console.log(`✅ [ENGINE] Executor completed:`, {
+          outputType: typeof result.output,
+          outputKeys: result.output && typeof result.output === "object" ? Object.keys(result.output) : "n/a",
+          nextNode: result.next,
+          hasOutput: !!result.output
+        });
+        await this.orchestrator?.afterNode?.(current, state, result);
+      } catch (e) {
+        err = e?.message ?? String(e);
+        console.log(`❌ [ENGINE] Executor failed:`, { error: err, node: current.id, kind: current.kind });
+        const errorAction = await this.orchestrator?.onError?.(current, state, e);
+        if (errorAction === "retry") {
+          continue;
+        } else if (errorAction === "skip") {
+          result = { output: state.output, next: "success" };
+        } else {
+          result = { output: state.output, next: "fail" };
+        }
+        this.emit?.({ type: "node.error", ts: Date.now(), runId, nodeId: current.id, data: { error: err } });
+      }
+      state.output = result.output;
+      const trace = {
+        nodeId: current.id,
+        kind: current.kind,
+        tStart: t0,
+        tEnd: Date.now(),
+        next: result.next,
+        error: err
+      };
+      traces.push(trace);
+      console.log(`\uD83C\uDFC1 [ENGINE] Node '${current.id}' completed in ${trace.tEnd - trace.tStart}ms`);
+      console.log(`\uD83D\uDCE4 [ENGINE] Output type: ${typeof state.output}`);
+      console.log(`\uD83D\uDD00 [ENGINE] Next routing label: '${result.next || "null"}'`);
+      this.emit?.({ type: "node.end", ts: trace.tEnd, runId, nodeId: current.id, data: trace });
+      yield { state, trace };
+      if (!result.next) {
+        console.log(`\uD83D\uDED1 [ENGINE] No next routing label - ending execution`);
+        break;
+      }
+      const edgeOverride = await this.orchestrator?.beforeEdgeSelect?.(current.id, result.next, state);
+      const finalLabel = edgeOverride?.overrideLabel || result.next;
+      console.log(`\uD83D\uDD0D [ENGINE] Selecting edge from '${current.id}' with label '${finalLabel}'`);
+      const edge = this.selectEdge(current.id, finalLabel, state);
+      if (!edge) {
+        console.log(`❌ [ENGINE] No matching edge found for label '${finalLabel}' from '${current.id}'`);
+        const availableEdges = this.g.out(current.id);
+        console.log(`\uD83D\uDD17 [ENGINE] Available edges:`, availableEdges.map((e) => ({
+          to: e.to,
+          label: e.label || "default",
+          hasCond: !!e.cond
+        })));
+        if (err)
+          throw new Error(`unhandled error at ${current.id}: ${err}`);
+        break;
+      }
+      console.log(`✅ [ENGINE] Selected edge: ${current.id} -> ${edge.to} (label: '${edge.label || "default"}')`);
+      this.emit?.({ type: "edge.select", ts: Date.now(), runId, edgeId: edge.id, data: { from: current.id, to: edge.to, label: finalLabel } });
+      const nextNode = this.g.getNode(edge.to);
+      if (!nextNode) {
+        console.log(`❌ [ENGINE] Target node '${edge.to}' not found in graph`);
+        break;
+      }
+      console.log(`➡️  [ENGINE] Transitioning to node '${edge.to}' (${nextNode.kind})`);
+      current = nextNode;
+    }
+    console.log(`
+\uD83C\uDFC1 [ENGINE] Run ${runId} completed after ${steps} steps`);
+    console.log(`\uD83D\uDCCA [ENGINE] Final state:`, {
+      outputType: typeof state.output,
+      memoryKeys: Object.keys(state.memory || {}),
+      traceCount: traces.length,
+      lastNode: traces[traces.length - 1]?.nodeId
+    });
+    this.emit?.({ type: "run.end", ts: Date.now(), runId, data: { output: state.output, steps } });
+    await this.orchestrator?.onRunEnd?.(state);
+    return state;
+  }
+  async runToEnd(...args) {
+    const gen = this.run(...args);
+    for await (const _ of gen) {}
+    const result = await gen.next();
+    return result.value;
+  }
+  selectEdge(fromId, label, state) {
+    const outs = this.g.out(fromId);
+    console.log(`\uD83D\uDD0D [ENGINE] selectEdge: Checking ${outs.length} outgoing edges from '${fromId}' for label '${label}'`);
+    const labeled = outs.filter((e) => e.label === label);
+    console.log(`\uD83C\uDFF7️  [ENGINE] Found ${labeled.length} edges with exact label match`);
+    const pool = labeled.length ? labeled : outs.filter((e) => e.label === "default");
+    console.log(`\uD83C\uDFAF [ENGINE] Edge pool size: ${pool.length} (using ${labeled.length ? "labeled" : "default"} edges)`);
+    for (const edge of pool) {
+      const condResult = typeof edge.cond === "function" ? edge.cond(state) : true;
+      console.log(`\uD83D\uDD04 [ENGINE] Testing edge ${fromId} -> ${edge.to}: condition=${condResult}`);
+      if (condResult) {
+        console.log(`✅ [ENGINE] Selected edge: ${edge.id} (${fromId} -> ${edge.to})`);
+        return edge;
+      }
+    }
+    console.log(`❌ [ENGINE] No suitable edge found`);
+    return null;
+  }
+  log(state, level, msg, data) {
+    const entry = {
+      ts: Date.now(),
+      level,
+      nodeId: state.traces.at(-1)?.nodeId,
+      msg,
+      data
+    };
+    state.journal.push(entry);
+    this.emit?.({ type: "run.log", ts: entry.ts, runId: state.runId, data: entry });
+  }
+}
+function withTimeout(p, ms) {
+  let to;
+  const timeout = new Promise((_, rej) => {
+    to = setTimeout(() => rej(new Error(`node timeout ${ms}ms`)), ms);
+  });
+  return Promise.race([p.finally(() => clearTimeout(to)), timeout]);
+}
+// src/store/eav-store.ts
+function* flatten(obj, base = "") {
+  if (Array.isArray(obj)) {
+    for (const v of obj) {
+      yield* flatten(v, base);
+    }
+  } else if (obj && typeof obj === "object") {
+    for (const [k, v] of Object.entries(obj)) {
+      yield* flatten(v, base ? `${base}.${k}` : k);
+    }
+  } else {
+    yield [base, obj];
+  }
+}
+function jsonEntityFacts(entityId, root, type) {
+  const facts = [{ e: entityId, a: "type", v: type }];
+  for (const [a, v] of flatten(root)) {
+    if (v === undefined || v === null)
+      continue;
+    if (Array.isArray(v)) {
+      for (const el of v) {
+        facts.push({ e: entityId, a, v: el });
+      }
+    } else if (typeof v === "object") {} else {
+      facts.push({ e: entityId, a, v });
+    }
+  }
+  return facts;
+}
+
+class EAVStore {
+  facts = [];
+  links = [];
+  catalog = new Map;
+  eavIndex = new Map;
+  aevIndex = new Map;
+  aveIndex = new Map;
+  linkIndex = new Map;
+  linkReverseIndex = new Map;
+  linkAttrIndex = new Map;
+  distinct = new Map;
+  addFacts(facts) {
+    for (let i = 0;i < facts.length; i++) {
+      const fact = facts[i];
+      if (fact) {
+        this.facts.push(fact);
+        this.updateIndexes(fact, this.facts.length - 1);
+        this.updateCatalog(fact);
+      }
+    }
+  }
+  addLinks(links) {
+    for (const link of links) {
+      this.links.push(link);
+      this.updateLinkIndexes(link);
+    }
+  }
+  deleteFacts(factsToDelete) {
+    for (const fact of factsToDelete) {
+      const valueKey = this.valueKey(fact.v);
+      const indices = this.aveIndex.get(fact.a)?.get(valueKey);
+      if (!indices)
+        continue;
+      let foundIdx = -1;
+      for (const idx of indices) {
+        const storedFact = this.facts[idx];
+        if (storedFact && storedFact.e === fact.e && storedFact.a === fact.a) {
+          foundIdx = idx;
+          break;
+        }
+      }
+      if (foundIdx !== -1) {
+        this.facts[foundIdx] = undefined;
+        this.eavIndex.get(fact.e)?.get(fact.a)?.delete(foundIdx);
+        this.aevIndex.get(fact.a)?.get(fact.e)?.delete(foundIdx);
+        this.aveIndex.get(fact.a)?.get(valueKey)?.delete(foundIdx);
+        const entry = this.catalog.get(fact.a);
+        if (entry) {}
+      }
+    }
+  }
+  deleteLinks(linksToDelete) {
+    for (const link of linksToDelete) {
+      const initialLen = this.links.length;
+      this.links = this.links.filter((l) => !(l.e1 === link.e1 && l.a === link.a && l.e2 === link.e2));
+      if (this.links.length < initialLen) {
+        this.linkIndex.get(link.e1)?.get(link.a)?.delete(link.e2);
+        this.linkReverseIndex.get(link.e2)?.get(link.a)?.delete(link.e1);
+        const attrPairs = this.linkAttrIndex.get(link.a);
+        if (attrPairs) {
+          for (const pair of attrPairs) {
+            if (pair[0] === link.e1 && pair[1] === link.e2) {
+              attrPairs.delete(pair);
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  updateIndexes(fact, index) {
+    if (!this.eavIndex.has(fact.e)) {
+      this.eavIndex.set(fact.e, new Map);
+    }
+    if (!this.eavIndex.get(fact.e).has(fact.a)) {
+      this.eavIndex.get(fact.e).set(fact.a, new Set);
+    }
+    this.eavIndex.get(fact.e).get(fact.a).add(index);
+    if (!this.aevIndex.has(fact.a)) {
+      this.aevIndex.set(fact.a, new Map);
+    }
+    if (!this.aevIndex.get(fact.a).has(fact.e)) {
+      this.aevIndex.get(fact.a).set(fact.e, new Set);
+    }
+    this.aevIndex.get(fact.a).get(fact.e).add(index);
+    if (!this.aveIndex.has(fact.a)) {
+      this.aveIndex.set(fact.a, new Map);
+    }
+    const valueKey = this.valueKey(fact.v);
+    if (!this.aveIndex.get(fact.a).has(valueKey)) {
+      this.aveIndex.get(fact.a).set(valueKey, new Set);
+    }
+    this.aveIndex.get(fact.a).get(valueKey).add(index);
+  }
+  updateLinkIndexes(link) {
+    if (!this.linkIndex.has(link.e1)) {
+      this.linkIndex.set(link.e1, new Map);
+    }
+    const e1Attrs = this.linkIndex.get(link.e1);
+    if (!e1Attrs.has(link.a)) {
+      e1Attrs.set(link.a, new Set);
+    }
+    e1Attrs.get(link.a).add(link.e2);
+    if (!this.linkReverseIndex.has(link.e2)) {
+      this.linkReverseIndex.set(link.e2, new Map);
+    }
+    const e2Attrs = this.linkReverseIndex.get(link.e2);
+    if (!e2Attrs.has(link.a)) {
+      e2Attrs.set(link.a, new Set);
+    }
+    e2Attrs.get(link.a).add(link.e1);
+    if (!this.linkAttrIndex.has(link.a)) {
+      this.linkAttrIndex.set(link.a, new Set);
+    }
+    this.linkAttrIndex.get(link.a).add([link.e1, link.e2]);
+  }
+  valueKey(v) {
+    if (v instanceof Date)
+      return `date:${v.toISOString()}`;
+    return `${typeof v}:${v}`;
+  }
+  updateCatalog(fact) {
+    const entry = this.catalog.get(fact.a) || {
+      attribute: fact.a,
+      type: this.inferType(fact.v),
+      cardinality: "one",
+      distinctCount: 0,
+      examples: []
+    };
+    const factType = this.inferType(fact.v);
+    if (entry.type !== factType && entry.type !== "mixed") {
+      entry.type = "mixed";
+    }
+    const entityAttrs = this.eavIndex.get(fact.e)?.get(fact.a);
+    if (entityAttrs && entityAttrs.size > 1) {
+      entry.cardinality = "many";
+    }
+    const k = this.valueKey(fact.v);
+    const s = this.distinct.get(fact.a) || (this.distinct.set(fact.a, new Set), this.distinct.get(fact.a));
+    s.add(k);
+    entry.distinctCount = s.size;
+    if (entry.examples.length < 5 && !entry.examples.includes(fact.v)) {
+      entry.examples.push(fact.v);
+    }
+    if (typeof fact.v === "number") {
+      entry.min = Math.min(entry.min ?? fact.v, fact.v);
+      entry.max = Math.max(entry.max ?? fact.v, fact.v);
+    }
+    this.catalog.set(fact.a, entry);
+  }
+  inferType(v) {
+    if (typeof v === "string")
+      return "string";
+    if (typeof v === "number")
+      return "number";
+    if (typeof v === "boolean")
+      return "boolean";
+    if (v instanceof Date)
+      return "date";
+    return "mixed";
+  }
+  getFactsByEntity(entity) {
+    const indices = this.eavIndex.get(entity);
+    if (!indices)
+      return [];
+    const result = [];
+    for (const attrIndices of indices.values()) {
+      for (const idx of attrIndices) {
+        const fact = this.facts[idx];
+        if (fact) {
+          result.push(fact);
+        }
+      }
+    }
+    return result;
+  }
+  getFactsByAttribute(attribute) {
+    const indices = this.aevIndex.get(attribute);
+    if (!indices)
+      return [];
+    const result = [];
+    for (const entityIndices of indices.values()) {
+      for (const idx of entityIndices) {
+        const fact = this.facts[idx];
+        if (fact) {
+          result.push(fact);
+        }
+      }
+    }
+    return result;
+  }
+  getFactsByValue(attribute, value) {
+    const indices = this.aveIndex.get(attribute)?.get(this.valueKey(value));
+    if (!indices)
+      return [];
+    return Array.from(indices).map((idx) => this.facts[idx]).filter((fact) => fact !== undefined);
+  }
+  getCatalog() {
+    return Array.from(this.catalog.values());
+  }
+  getCatalogEntry(attribute) {
+    return this.catalog.get(attribute);
+  }
+  getAllFacts() {
+    return this.facts.filter((f) => f !== undefined);
+  }
+  getAllLinks() {
+    return [...this.links];
+  }
+  getLinksByEntity(entity) {
+    const results = [];
+    const forwardLinks = this.linkIndex.get(entity);
+    if (forwardLinks) {
+      for (const [attr, targets] of forwardLinks) {
+        for (const target of targets) {
+          results.push({ e1: entity, a: attr, e2: target });
+        }
+      }
+    }
+    const reverseLinks = this.linkReverseIndex.get(entity);
+    if (reverseLinks) {
+      for (const [attr, sources] of reverseLinks) {
+        for (const source of sources) {
+          results.push({ e1: source, a: attr, e2: entity });
+        }
+      }
+    }
+    return results;
+  }
+  getLinksByAttribute(attribute) {
+    const results = [];
+    const links = this.linkAttrIndex.get(attribute);
+    if (links) {
+      for (const [e1, e2] of links) {
+        results.push({ e1, a: attribute, e2 });
+      }
+    }
+    return results;
+  }
+  getLinksByEntityAndAttribute(entity, attribute) {
+    const results = [];
+    const attrs = this.linkIndex.get(entity);
+    if (attrs) {
+      const targets = attrs.get(attribute);
+      if (targets) {
+        for (const target of targets) {
+          results.push({ e1: entity, a: attribute, e2: target });
+        }
+      }
+    }
+    return results;
+  }
+  getStats() {
+    return {
+      totalFacts: this.facts.length,
+      totalLinks: this.links.length,
+      uniqueEntities: this.eavIndex.size,
+      uniqueAttributes: this.aevIndex.size,
+      catalogEntries: this.catalog.size
+    };
+  }
+  snapshot() {
+    return {
+      facts: this.facts.filter((f) => f !== undefined),
+      links: [...this.links],
+      catalog: this.getCatalog()
+    };
+  }
+  restore(snapshot) {
+    this.facts = [];
+    this.links = [];
+    this.catalog.clear();
+    this.eavIndex.clear();
+    this.aevIndex.clear();
+    this.aveIndex.clear();
+    this.linkIndex.clear();
+    this.linkReverseIndex.clear();
+    this.linkAttrIndex.clear();
+    this.distinct.clear();
+    this.addFacts(snapshot.facts);
+    this.addLinks(snapshot.links);
+    if (snapshot.catalog) {
+      for (const entry of snapshot.catalog) {
+        this.catalog.set(entry.attribute, entry);
+      }
+    }
+  }
+}
+
+// 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/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/graph/tools.ts
+var vm = null;
+try {
+  vm = await import("node:vm");
+} catch {}
+var builtinTools = {
+  async run_js({ input }) {
+    const m = String(input ?? "").match(/```(?:js|javascript)?\s*([\s\S]*?)```/i);
+    if (!m)
+      return { error: "no code block" };
+    const code = m[1];
+    if (vm?.default || vm?.Script) {
+      try {
+        const Script = vm.default?.Script ?? vm.Script;
+        const script = new Script(code, { filename: "user.js" });
+        const ctx = (vm.default?.createContext ?? vm.createContext)({});
+        const res = await script.runInContext(ctx, {
+          timeout: 500,
+          microtaskMode: "afterEvaluate"
+        });
+        return { ok: true, result: res };
+      } catch (e) {
+        return { ok: false, error: String(e) };
+      }
+    }
+    try {
+      const fn = new Function(code);
+      const res = await (async () => fn())();
+      return { ok: true, result: res };
+    } catch (e) {
+      return { ok: false, error: String(e) };
+    }
+  },
+  async tql_query({
+    query,
+    data,
+    dataUrl,
+    entityType = "item",
+    idKey = "id",
+    limit = 100,
+    state
+  }) {
+    try {
+      const eqlsQuery = query || (typeof state?.input === "string" ? state.input : "");
+      if (!eqlsQuery) {
+        return { error: "No EQL-S query provided" };
+      }
+      const store = new EAVStore;
+      let sourceData = data;
+      if (!sourceData && dataUrl) {
+        const response = await fetch(dataUrl);
+        if (!response.ok) {
+          return { error: `Failed to fetch data: ${response.statusText}` };
+        }
+        sourceData = await response.json();
+      }
+      if (!sourceData) {
+        const memoryKey = entityType === "post" ? "posts" : entityType === "user" ? "users" : entityType;
+        sourceData = state?.memory?.[memoryKey] || state?.memory?.data || state?.data;
+      }
+      if (!sourceData) {
+        return {
+          error: "No data source provided (data, dataUrl, or state.memory.data)"
+        };
+      }
+      const dataArray = Array.isArray(sourceData) ? sourceData : [sourceData];
+      for (let i = 0;i < dataArray.length; i++) {
+        const item = dataArray[i];
+        const entityId = item[idKey] ? `${entityType}:${item[idKey]}` : `${entityType}:${i}`;
+        const facts = jsonEntityFacts(entityId, item, entityType);
+        store.addFacts(facts);
+      }
+      const processor = new EQLSProcessor;
+      const catalog = store.getCatalog();
+      processor.setSchema(catalog);
+      const evaluator = new DatalogEvaluator(store);
+      const parseResult = processor.process(eqlsQuery);
+      if (parseResult.errors.length > 0) {
+        return {
+          ok: false,
+          error: "Query parsing failed",
+          parseErrors: parseResult.errors.map((e) => ({
+            line: e.line,
+            column: e.column,
+            message: e.message,
+            expected: e.expected
+          }))
+        };
+      }
+      const result = evaluator.evaluate(parseResult.query);
+      const limitedResults = limit > 0 ? result.bindings.slice(0, limit) : result.bindings;
+      return {
+        ok: true,
+        results: limitedResults,
+        count: limitedResults.length,
+        totalCount: result.bindings.length,
+        executionTime: result.executionTime,
+        store: {
+          totalFacts: store.getStats().totalFacts,
+          uniqueEntities: store.getStats().uniqueEntities,
+          uniqueAttributes: store.getStats().uniqueAttributes
+        }
+      };
+    } catch (e) {
+      return {
+        ok: false,
+        error: e?.message || String(e),
+        stack: e?.stack
+      };
+    }
+  },
+  async tql_load_data({
+    data,
+    dataUrl,
+    key = "data",
+    state
+  }) {
+    try {
+      let sourceData = data;
+      if (!sourceData && dataUrl) {
+        const response = await fetch(dataUrl);
+        if (!response.ok) {
+          return { error: `Failed to fetch data: ${response.statusText}` };
+        }
+        sourceData = await response.json();
+      }
+      if (!sourceData) {
+        return { error: "No data source provided (data or dataUrl)" };
+      }
+      if (state?.memory) {
+        state.memory[key] = sourceData;
+      }
+      const count = Array.isArray(sourceData) ? sourceData.length : 1;
+      return {
+        ok: true,
+        message: `Loaded ${count} items into state.memory.${key}`,
+        count,
+        dataType: Array.isArray(sourceData) ? "array" : typeof sourceData
+      };
+    } catch (e) {
+      return {
+        ok: false,
+        error: e?.message || String(e)
+      };
+    }
+  }
+};
+export {
+  validateGraph,
+  pluck,
+  makeDefaultExecutors,
+  interpolate,
+  builtinTools,
+  Graph,
+  Engine
+};