trellis 1.0.8 → 2.0.6

package/dist/cli/server.js

@@ -1,3321 +0,0 @@
-#!/usr/bin/env node
-import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/ai/orchestrator.ts
-import { openai } from "@ai-sdk/openai";
-import { generateText, streamText, generateObject } from "ai";
-import { z as z2 } from "zod";
-function identifyEntityType(query) {
-  const normalizedQuery = query.toLowerCase();
-  const entityPatterns = [
-    /(?:find|show|list|get|search)\s+([a-z]+s?)\b/i,
-    /\b([a-z]+s?)\s+(?:that|with|containing|having)\b/i,
-    /\b([a-z]+s?)'?s?\s+[a-z]+/i
-  ];
-  for (const pattern of entityPatterns) {
-    const match = normalizedQuery.match(pattern);
-    if (match && match[1]) {
-      let entityType = match[1].toLowerCase();
-      if (entityType.endsWith("ies")) {
-        entityType = entityType.slice(0, -3) + "y";
-      } else if (entityType.endsWith("es")) {
-        entityType = entityType.slice(0, -2);
-      } else if (entityType.endsWith("s") && entityType.length > 3) {
-        entityType = entityType.slice(0, -1);
-      }
-      const excludeWords = ["this", "that", "the", "and", "or", "but", "with", "from", "by", "at", "in", "on", "to", "for", "of", "as", "is", "are", "was", "were", "be", "been", "have", "has", "had", "do", "does", "did", "will", "would", "could", "should", "may", "might", "can", "all", "any", "some", "more", "most", "less", "least", "first", "last", "next", "previous"];
-      if (!excludeWords.includes(entityType) && entityType.length > 2) {
-        return entityType;
-      }
-    }
-  }
-  return "item";
-}
-function handleCommonPatterns(query) {
-  let normalizedQuery = query.trim().toLowerCase();
-  if (normalizedQuery.includes("start with") || normalizedQuery.includes("starts with") || normalizedQuery.includes("beginning with") || normalizedQuery.includes("begins with")) {
-    const pattern = /(?:starts?|begins?|beginning) with\s+(?:the letter\s+)?['"]?([a-zA-Z0-9]+)['"]?/i;
-    const match = query.match(pattern);
-    if (match && match[1]) {
-      const prefix = match[1];
-      normalizedQuery = normalizedQuery.replace(/(?:starts?|begins?|beginning) with\s+(?:the letter\s+)?['"]?([a-z0-9]+)['"]?/i, `matches /^${prefix}/`);
-    }
-  }
-  if (normalizedQuery.includes("end with") || normalizedQuery.includes("ends with") || normalizedQuery.includes("ending with")) {
-    const pattern = /(?:ends?|ending) with\s+(?:the letter\s+)?['"]?([a-zA-Z0-9]+)['"]?/i;
-    const match = query.match(pattern);
-    if (match && match[1]) {
-      const suffix = match[1];
-      normalizedQuery = normalizedQuery.replace(/(?:ends?|ending) with\s+(?:the letter\s+)?['"]?([a-z0-9]+)['"]?/i, `matches /${suffix}$/`);
-    }
-  }
-  if (normalizedQuery.includes("contain") || normalizedQuery.includes("having") || normalizedQuery.includes("with") && normalizedQuery.includes("in the name")) {
-    const patterns = [
-      /containing\s+(?:the text\s+)?['"]([^'"]+)['"]/i,
-      /contains\s+(?:the text\s+)?['"]([^'"]+)['"]/i,
-      /with\s+['"]([^'"]+)['"]\s+in the (?:name|title|text)/i,
-      /having\s+['"]([^'"]+)['"]\s+in/i
-    ];
-    for (const pattern of patterns) {
-      const match = query.match(pattern);
-      if (match && match[1]) {
-        const text = match[1];
-        normalizedQuery = normalizedQuery.replace(pattern, `matches /${text}/`);
-        break;
-      }
-    }
-  }
-  return normalizedQuery;
-}
-var IntentSchema, ActionSchema, TaskTypeSchema, ComplexitySchema, SentimentSchema, ToneSchema, MetaSchema, PlanSchema, PlanVoteSchema, OrchestratorOptionsSchema, OrchestratorOk, OrchestratorErr, OrchestratorResultSchema, DEFAULT_MODEL, CLASSIFICATION_PROMPT, processQuery = async (query, context) => {
-  try {
-    const processedQuery = handleCommonPatterns(query);
-    const entityType = identifyEntityType(processedQuery);
-    const attributes = Array.isArray(context.catalog) ? context.catalog.map((a) => a.attribute).filter(Boolean) : [];
-    const aliasPairs = [];
-    const findAttr = (needle) => attributes.find((a) => needle.test(a));
-    const questionAttr = findAttr(/question$/i);
-    const responseAttr = findAttr(/response$/i);
-    const cotAttr = findAttr(/(complex[_\-.]?cot|chain[_\-.]?of[_\-.]?thought)/i);
-    if (questionAttr)
-      aliasPairs.push({ alias: "question", attr: questionAttr });
-    if (responseAttr)
-      aliasPairs.push({ alias: "response", attr: responseAttr });
-    if (cotAttr)
-      aliasPairs.push({ alias: "reasoning", attr: cotAttr });
-    const aliasInfo = aliasPairs.map(({ alias, attr }) => `- ${alias} ⇒ ${attr}`).join(`
-`);
-    const catalogInfo = context.catalog.map((attr) => `- ${attr.attribute}:${attr.type} e.g. ${attr.examples.join(", ")}`).join(`
-`);
-    const prompt = `You are an expert at converting natural language queries to EQL-S (EAV Query Language - Strict).
-
-Available attributes in the dataset:
-${catalogInfo}
-
-Attribute aliases you MUST use if the user mentions the alias term:
-${aliasInfo || "- (none)"}
-
-Data statistics: ${JSON.stringify(context.dataStats, null, 2)}
-
-EQL-S Grammar Rules:
-- Use FIND <type> AS ?var to specify entity type and variable
-- Use WHERE clause for conditions
-- Use RETURN clause to specify output fields
-- Use ORDER BY for sorting, LIMIT for result limits
-- Operators: = != > >= < <= BETWEEN ... AND ... CONTAINS MATCHES
-- For string pattern matching use MATCHES with regex patterns: MATCHES /pattern/
-- For "starts with", use MATCHES /^prefix/
-- For "ends with", use MATCHES /suffix$/
-- For "contains", use MATCHES /text/ or CONTAINS "text"
-- Regex literals must use forward slashes: /pattern/
-
-STRICT formatting rules for this dataset:
-- Entity type MUST be "default" unless explicitly specified. Use: FIND default AS ?e
-- Only use attribute names EXACTLY as listed above (e.g., ${attributes.slice(0, 3).join(", ")} ...). Do not invent attributes.
-- NEVER use numeric property access like ?e.0 or ?e.6 — that is invalid.
-- If the user refers to "question", "answer/response", or "reasoning/chain of thought",
-  use these attributes if available: ${[
-      questionAttr,
-      responseAttr,
-      cotAttr
-    ].filter(Boolean).join(", ") || "(none)"}
-
-Entity type detected: ${entityType || "item"}
-- Avoid using the IN operator for string matching
-- Variables must start with ? (e.g., ?p, ?user)
-- Strings must be in double quotes
-- Regex patterns should be in /pattern/ format but PREFER CONTAINS when possible
-
-Query Pattern Examples (adapt to available attributes):
-- "show me [entities] with more than X [numeric_attribute]" → FIND <type> AS ?e WHERE ?e.<attribute> > X RETURN ?e
-- "find [entities] containing [text]" → FIND <type> AS ?e WHERE ?e.<text_attribute> CONTAINS "text" RETURN ?e
-- "[entities] tagged with [value]" → FIND <type> AS ?e WHERE ?e.<tag_attribute> = "value" RETURN ?e
-- "[entities] between X and Y [units]" → FIND <type> AS ?e WHERE ?e.<numeric_attribute> BETWEEN X AND Y RETURN ?e
-- "[entities] that start with [prefix]" → FIND <type> AS ?e WHERE ?e.<text_attribute> MATCHES /^prefix/ RETURN ?e.<text_attribute>
-- "list [category] [entities]" → FIND <type> AS ?e WHERE ?e.<category_attribute> = "category" RETURN ?e
-
-Convert this natural language query to EQL-S: "${processedQuery}"
-
-Output ONLY the EQL-S query, no explanations or additional text.`;
-    const result = await generateText({
-      model: openai("gpt-4o-mini"),
-      prompt,
-      temperature: 0.1
-    });
-    let eqlsQuery = result.text.trim();
-    if (eqlsQuery.startsWith("```") && eqlsQuery.endsWith("```")) {
-      eqlsQuery = eqlsQuery.slice(3, -3).trim();
-      const firstLine = eqlsQuery.split(`
-`)[0];
-      if (firstLine && !firstLine.includes(" ") && firstLine.length < 20) {
-        eqlsQuery = eqlsQuery.split(`
-`).slice(1).join(`
-`).trim();
-      }
-    }
-    if (!eqlsQuery.startsWith("FIND")) {
-      return { error: "Generated query does not start with FIND" };
-    }
-    eqlsQuery = eqlsQuery.replace(/^(FIND)\s+([A-Za-z_][A-Za-z0-9_-]*)\s+AS\s+\?[A-Za-z_][A-Za-z0-9_]*/i, (m, findKw) => {
-      const varMatch = eqlsQuery.match(/AS\s+(\?[A-Za-z_][A-Za-z0-9_]*)/i);
-      const v = varMatch ? varMatch[1] : "?e";
-      return `${findKw} default AS ${v}`;
-    });
-    if (/\?[a-zA-Z_]\w*\.\d+/.test(eqlsQuery)) {
-      const wantsQuestion = /hallucinat|question|prompt/i.test(processedQuery);
-      const replacementAttr = wantsQuestion ? questionAttr : responseAttr || questionAttr || attributes[0];
-      if (replacementAttr) {
-        eqlsQuery = eqlsQuery.replace(/(\?[a-zA-Z_]\w*)\.\d+/g, `$1.${replacementAttr}`);
-      } else {
-        return { error: "Generated query used numeric property access (invalid)" };
-      }
-    }
-    const attrRefs = Array.from(eqlsQuery.matchAll(/\?[a-zA-Z_]\w*\.([A-Za-z0-9_.-]+)/g)).map((m) => m[1]).filter((a) => typeof a === "string");
-    const unknown = attrRefs.filter((a) => !attributes.includes(a));
-    if (unknown.length) {
-      let repaired = eqlsQuery;
-      for (const unk of unknown) {
-        const lower = unk.toLowerCase();
-        const alias = aliasPairs.find(({ alias: alias2 }) => lower.includes(alias2));
-        if (alias) {
-          repaired = repaired.replace(new RegExp(`(?[a-zA-Z_]\\w*.)${unk.replace(/[-/\\.^$*+?()|[\]{}]/g, "\\$&")}`, "g"), `$1${alias.attr}`);
-        }
-      }
-      if (repaired !== eqlsQuery) {
-        eqlsQuery = repaired;
-      }
-    }
-    return { eqlsQuery };
-  } catch (error) {
-    return {
-      error: `Failed to process query: ${error instanceof Error ? error.message : "Unknown error"}`
-    };
-  }
-};
-var init_orchestrator = __esm(() => {
-  IntentSchema = z2.enum([
-    "conversation",
-    "question",
-    "task",
-    "query",
-    "command",
-    "help",
-    "error"
-  ]);
-  ActionSchema = z2.enum([
-    "streamResponse",
-    "generateResponse",
-    "executeTask",
-    "runQuery",
-    "showHelp",
-    "none"
-  ]);
-  TaskTypeSchema = z2.enum([
-    "creative_writing",
-    "analysis",
-    "calculation",
-    "code_generation",
-    "data_processing",
-    "general"
-  ]);
-  ComplexitySchema = z2.enum(["simple", "moderate", "complex"]);
-  SentimentSchema = z2.enum(["positive", "negative", "neutral"]).optional();
-  ToneSchema = z2.enum(["formal", "casual", "urgent", "friendly", "technical"]).optional();
-  MetaSchema = z2.object({
-    intent: IntentSchema,
-    reason: z2.string(),
-    action: ActionSchema,
-    confidence: z2.number().min(0).max(1),
-    sentiment: SentimentSchema,
-    tone: ToneSchema,
-    taskType: TaskTypeSchema.optional(),
-    complexity: ComplexitySchema.optional(),
-    estimatedTime: z2.number().optional()
-  });
-  PlanSchema = z2.object({
-    rationale: z2.string(),
-    steps: z2.array(z2.string()).min(1),
-    assumptions: z2.array(z2.string()).optional(),
-    risks: z2.array(z2.string()).optional(),
-    revisedPrompt: z2.string().optional(),
-    toolHints: z2.array(z2.string()).optional()
-  });
-  PlanVoteSchema = z2.object({
-    winningIndex: z2.number().int().min(0),
-    reason: z2.string()
-  });
-  OrchestratorOptionsSchema = z2.object({
-    stream: z2.boolean().optional(),
-    maxRetries: z2.number().min(0).max(5).default(2),
-    timeoutMs: z2.number().positive().default(30000),
-    includeAnalysis: z2.boolean().default(true),
-    fallbackToConversation: z2.boolean().default(true),
-    useToT: z2.boolean().default(false),
-    plannerModel: z2.string().default("gpt-4o-mini"),
-    numThoughts: z2.number().int().min(2).max(8).default(3)
-  }).passthrough();
-  OrchestratorOk = z2.object({
-    status: z2.literal("ok"),
-    meta: MetaSchema,
-    payload: z2.object({
-      requestId: z2.string().uuid(),
-      prompt: z2.string(),
-      options: z2.record(z2.string(), z2.unknown()),
-      response: z2.any(),
-      processingTimeMs: z2.number(),
-      planning: z2.object({
-        winningIndex: z2.number(),
-        reason: z2.string(),
-        plan: PlanSchema,
-        allPlansCount: z2.number()
-      }).optional()
-    })
-  });
-  OrchestratorErr = z2.object({
-    status: z2.literal("error"),
-    meta: MetaSchema,
-    payload: z2.object({
-      requestId: z2.string().uuid(),
-      prompt: z2.string(),
-      options: z2.record(z2.string(), z2.unknown()),
-      error: z2.string(),
-      processingTimeMs: z2.number(),
-      planning: z2.object({
-        winningIndex: z2.number(),
-        reason: z2.string(),
-        plan: PlanSchema,
-        allPlansCount: z2.number()
-      }).optional()
-    })
-  });
-  OrchestratorResultSchema = z2.union([OrchestratorOk, OrchestratorErr]);
-  DEFAULT_MODEL = openai("gpt-4o-mini");
-  CLASSIFICATION_PROMPT = `You are an intent classifier for a conversational AI orchestrator.
-Analyze the user prompt and return ONLY a JSON object with these fields:
-
-- intent: one of ${IntentSchema.options.join(", ")}
-- reason: brief explanation (max 50 chars)
-- action: one of ${ActionSchema.options.join(", ")}
-- confidence: number 0-1
-- sentiment: optional, one of positive/negative/neutral
-- tone: optional, one of formal/casual/urgent/friendly/technical
-- taskType: optional, one of ${TaskTypeSchema.options.join(", ")} (only for task intent)
-- complexity: optional, one of ${ComplexitySchema.options.join(", ")} (only for task intent)
-- estimatedTime: optional, rough time estimate in seconds (only for task intent)
-
-Guidelines:
-- "conversation": general chat, greetings, casual talk → streamResponse
-- "question": seeking information → streamResponse
-- "task": action requests → executeTask (include taskType, complexity, estimatedTime)
-- "query": data/search requests → runQuery
-- "command": system commands → executeTask
-- "help": assistance requests → showHelp
-
-Task type guidelines:
-- "creative_writing": stories, poems, creative content
-- "analysis": data analysis, research, evaluation
-- "calculation": math, computations, formulas
-- "code_generation": programming, scripts, technical solutions
-- "data_processing": data manipulation, transformation
-- "general": other tasks
-
-User prompt: """{{PROMPT}}"""
-
-Respond with valid JSON only:`;
-});
-
-// src/ai/nl-query-provider.ts
-var exports_nl_query_provider = {};
-__export(exports_nl_query_provider, {
-  DefaultNLQueryProvider: () => DefaultNLQueryProvider
-});
-
-class DefaultNLQueryProvider {
-  options;
-  name = "default-orchestrator";
-  constructor(options = {}) {
-    this.options = options;
-  }
-  async translate(nl, context) {
-    const catalog = context?.catalog || this.options.catalog || [];
-    const dataStats = context?.dataStats || this.options.dataStats || { totalFacts: 0 };
-    const result = await processQuery(nl, { catalog, dataStats });
-    if (result.error) {
-      throw new Error(`NL translation failed: ${result.error}`);
-    }
-    if (!result.eqlsQuery) {
-      throw new Error("NL translation failed: no query generated");
-    }
-    return result.eqlsQuery;
-  }
-}
-var init_nl_query_provider = __esm(() => {
-  init_orchestrator();
-});
-
-// src/cli/server.ts
-import { join as join2 } from "node:path";
-
-// src/kernel/trellis-kernel.ts
-import { randomUUID } from "crypto";
-
-// 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/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/kernel/operations.ts
-async function hashOp(op) {
-  const content = JSON.stringify({
-    kind: op.kind,
-    timestamp: op.timestamp,
-    agentId: op.agentId,
-    previousHash: op.previousHash,
-    facts: op.facts,
-    links: op.links
-  });
-  const msgUint8 = new TextEncoder().encode(content);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", msgUint8);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  return `trellis:op:${hashHex}`;
-}
-async function createOp(kind, params) {
-  const opBase = {
-    kind,
-    timestamp: new Date().toISOString(),
-    agentId: params.agentId,
-    previousHash: params.previousHash,
-    facts: params.facts,
-    links: params.links
-  };
-  const hash = await hashOp(opBase);
-  return { ...opBase, hash };
-}
-
-// src/kernel/workspace.ts
-import { z } from "zod";
-var PropertyTypeSchema = z.enum([
-  "title",
-  "rich_text",
-  "number",
-  "select",
-  "multi_select",
-  "status",
-  "date",
-  "people",
-  "files",
-  "checkbox",
-  "url",
-  "email",
-  "phone_number",
-  "relation",
-  "rollup",
-  "formula",
-  "ai_generated"
-]);
-var PropertyValueSpecificationSchema = z.object({
-  name: z.string(),
-  valueType: PropertyTypeSchema,
-  required: z.boolean().optional(),
-  description: z.string().optional(),
-  selectOptions: z.array(z.any()).optional(),
-  relation: z.object({
-    targetSchema: z.string().optional(),
-    cardinality: z.enum(["one", "many"]).optional(),
-    syncedProperty: z.string().optional()
-  }).optional(),
-  formula: z.string().optional(),
-  rollup: z.object({
-    relationProperty: z.string(),
-    targetProperty: z.string(),
-    aggregation: z.enum([
-      "count",
-      "sum",
-      "avg",
-      "min",
-      "max",
-      "median",
-      "mode"
-    ])
-  }).optional(),
-  aiGenerated: z.object({
-    prompt: z.string(),
-    model: z.string().optional()
-  }).optional()
-});
-var SchemaDefinitionSchema = z.object({
-  "@id": z.string(),
-  "@type": z.literal("trellis:Schema"),
-  version: z.string(),
-  fields: z.array(PropertyValueSpecificationSchema)
-});
-var ProjectionDefinitionSchema = z.object({
-  "@id": z.string(),
-  "@type": z.literal("trellis:Projection"),
-  name: z.string(),
-  type: z.enum([
-    "card-grid",
-    "table",
-    "timeline",
-    "dashboard",
-    "kanban",
-    "graph"
-  ]),
-  query: z.string(),
-  config: z.record(z.string(), z.any()).optional()
-});
-var WorkspaceConfigSchema = z.object({
-  workspace: z.object({
-    name: z.string().optional(),
-    description: z.string().optional(),
-    ontologies: z.record(z.string(), SchemaDefinitionSchema).optional(),
-    graph: z.object({
-      nodes: z.array(z.any()).optional(),
-      edges: z.array(z.any()).optional()
-    }).optional(),
-    projections: z.record(z.string(), ProjectionDefinitionSchema).optional()
-  })
-});
-
-// src/kernel/trellis-kernel.ts
-var stableCompare = (a, b) => {
-  if (a === b)
-    return 0;
-  if (a === undefined || a === null)
-    return 1;
-  if (b === undefined || b === null)
-    return -1;
-  if (typeof a === "number" && typeof b === "number")
-    return a - b;
-  if (a instanceof Date && b instanceof Date)
-    return a.getTime() - b.getTime();
-  return String(a).localeCompare(String(b));
-};
-
-class TrellisKernel {
-  store;
-  evaluator;
-  eqls;
-  backend;
-  middleware = [];
-  sync;
-  opened = false;
-  ontologies = new Map;
-  projections = new Map;
-  constructor(storeOrOpts) {
-    const opts = storeOrOpts instanceof EAVStore ? { store: storeOrOpts } : storeOrOpts ?? {};
-    this.store = opts.store ?? new EAVStore;
-    this.evaluator = new DatalogEvaluator(this.store);
-    this.eqls = new EQLSProcessor;
-    this.backend = opts.backend;
-    this.middleware = opts.middleware ?? [];
-    this.sync = opts.sync;
-    if (this.sync) {
-      this.sync.onRemoteOp(async (op) => {
-        await this.applyRemoteOperation(op);
-      });
-    }
-    const autoReplay = opts.autoReplay ?? true;
-    if (this.backend && autoReplay) {
-      this.open();
-    }
-  }
-  open() {
-    if (!this.backend || this.opened)
-      return;
-    this.backend.init();
-    const snapshot = this.backend.loadLatestSnapshot();
-    let ops = [];
-    if (snapshot) {
-      this.store.restore(snapshot.data);
-      ops = this.backend.readAfter(snapshot.lastOpHash);
-    } else {
-      ops = this.backend.readAll();
-    }
-    for (const op of ops) {
-      this.applyOp(op, { system: true });
-    }
-    this.opened = true;
-  }
-  async checkpoint() {
-    if (!this.backend)
-      return;
-    const lastOp = this.backend.getLastOp();
-    if (!lastOp)
-      return;
-    const snapshotData = this.store.snapshot();
-    this.backend.saveSnapshot(lastOp.hash, snapshotData);
-  }
-  close() {
-    this.backend?.close?.();
-  }
-  getStore() {
-    return this.store;
-  }
-  async boot(data, opts) {
-    if (this.backend) {
-      this.open();
-    }
-    const wsParse = WorkspaceConfigSchema.safeParse(data);
-    if (wsParse.success) {
-      const config = wsParse.data;
-      await this.bootWorkspace(config);
-      return;
-    }
-    if (Array.isArray(data)) {
-      const entityType = opts?.entityType ?? "item";
-      const idKey = opts?.idKey ?? "id";
-      const results = [];
-      for (let i = 0;i < data.length; i++) {
-        const item = data[i];
-        const idVal = item && typeof item === "object" ? item[idKey] : undefined;
-        const entityId = `${entityType}:${idVal ?? i}`;
-        const facts2 = jsonEntityFacts(entityId, item, entityType);
-        results.push(this.appendFacts(facts2));
-      }
-      await Promise.all(results);
-      this.eqls.setSchema(this.store.getCatalog());
-      return;
-    }
-    const rootEntityId = opts?.rootEntityId ?? "root";
-    const rootEntityType = opts?.rootEntityType ?? "root";
-    const facts = jsonEntityFacts(rootEntityId, data, rootEntityType);
-    await this.appendFacts(facts);
-    this.eqls.setSchema(this.store.getCatalog());
-  }
-  async bootWorkspace(config) {
-    const ws = config.workspace;
-    if (ws.ontologies) {
-      for (const [id, schema] of Object.entries(ws.ontologies)) {
-        this.ontologies.set(id, schema);
-      }
-    }
-    if (ws.projections) {
-      for (const [id, projection] of Object.entries(ws.projections)) {
-        this.projections.set(id, projection);
-      }
-    }
-    if (ws.graph) {
-      const mutationPromises = [];
-      if (ws.graph.nodes) {
-        for (const node of ws.graph.nodes) {
-          const entityId = node["@id"] || `node:${randomUUID()}`;
-          const type = node["@type"] || "default";
-          mutationPromises.push(this.createNode(entityId, node, type));
-        }
-      }
-      if (ws.graph.edges) {
-        for (const edge of ws.graph.edges) {
-          const source = edge.source?.["@id"] || edge.source;
-          const target = edge.target?.["@id"] || edge.target;
-          const relation = edge.relationType || edge.relation;
-          if (source && target && relation) {
-            mutationPromises.push(this.link(source, relation, target));
-          }
-        }
-      }
-      await Promise.all(mutationPromises);
-    }
-    this.eqls.setSchema(this.store.getCatalog());
-  }
-  getProjection(id) {
-    return this.projections.get(id);
-  }
-  listProjections() {
-    return Array.from(this.projections.values());
-  }
-  getOntology(id) {
-    return this.ontologies.get(id);
-  }
-  async exportWorkspace() {
-    const ontologies = {};
-    for (const [id, schema] of this.ontologies.entries()) {
-      ontologies[id] = schema;
-    }
-    const projections = {};
-    for (const [id, proj] of this.projections.entries()) {
-      projections[id] = proj;
-    }
-    const nodes = [];
-    const entities = new Set;
-    for (const fact of this.store.getAllFacts()) {
-      if (fact)
-        entities.add(fact.e);
-    }
-    for (const entityId of entities) {
-      const facts = this.store.getFactsByEntity(entityId);
-      const node = { "@id": entityId };
-      for (const f of facts) {
-        if (f.a === "type") {
-          node["@type"] = f.v;
-        } else {
-          node[f.a] = f.v;
-        }
-      }
-      nodes.push(node);
-    }
-    const edges = [];
-    for (const link of this.store.getAllLinks()) {
-      edges.push({
-        source: { "@id": link.e1 },
-        target: { "@id": link.e2 },
-        relationType: link.a
-      });
-    }
-    return {
-      workspace: {
-        ontologies: Object.keys(ontologies).length > 0 ? ontologies : undefined,
-        projections: Object.keys(projections).length > 0 ? projections : undefined,
-        graph: {
-          nodes: nodes.length > 0 ? nodes : undefined,
-          edges: edges.length > 0 ? edges : undefined
-        }
-      }
-    };
-  }
-  async executeProjection(id, ctx = {}) {
-    const projection = this.getProjection(id);
-    if (!projection) {
-      throw new Error(`Projection ${id} not found`);
-    }
-    return this.query(projection.query, ctx);
-  }
-  async appendFacts(facts, ctx = {}) {
-    const lastOp = this.backend?.getLastOp();
-    const op = await createOp("addFacts", {
-      agentId: ctx.agentId || "system",
-      facts,
-      previousHash: lastOp?.hash
-    });
-    if (this.backend) {
-      this.open();
-      this.backend.append(op);
-    }
-    return this.applyOp(op, ctx);
-  }
-  applyOp(op, ctx = {}) {
-    const runMiddleware = (index) => {
-      if (index >= this.middleware.length) {
-        if (op.kind === "addFacts" && op.facts) {
-          this.store.addFacts(op.facts);
-        } else if (op.kind === "addLinks" && op.links) {
-          this.store.addLinks(op.links);
-        } else if (op.kind === "deleteFacts" && op.facts) {
-          this.store.deleteFacts(op.facts);
-        } else if (op.kind === "deleteLinks" && op.links) {
-          this.store.deleteLinks(op.links);
-        }
-        return;
-      }
-      const mw = this.middleware[index];
-      if (mw && mw.handleOp) {
-        return mw.handleOp(op, ctx, (nextOp, nextCtx) => runMiddleware(index + 1));
-      } else {
-        return runMiddleware(index + 1);
-      }
-    };
-    return runMiddleware(0);
-  }
-  async mutate(op, ctx = {}) {
-    if (this.backend) {
-      this.open();
-      this.backend.append(op);
-    }
-    await this.applyOp(op, ctx);
-    if (this.sync && !ctx.remote && !ctx.system) {
-      await this.sync.broadcast(op);
-    }
-  }
-  async applyRemoteOperation(op, ctx = {}) {
-    return this.mutate(op, { ...ctx, remote: true });
-  }
-  async _mutate(kind, params, ctx) {
-    const lastOp = this.backend?.getLastOp();
-    const op = await createOp(kind, {
-      agentId: ctx.agentId || "system",
-      facts: params.facts,
-      links: params.links,
-      previousHash: lastOp?.hash
-    });
-    return this.mutate(op, ctx);
-  }
-  async createNode(entityId, data, type, ctx = {}) {
-    const facts = jsonEntityFacts(entityId, data, type);
-    await this._mutate("addFacts", { facts }, ctx);
-  }
-  async updateNode(entityId, data, type, ctx = {}) {
-    const existingFacts = this.store.getFactsByEntity(entityId);
-    if (existingFacts.length > 0) {
-      await this._mutate("deleteFacts", { facts: existingFacts }, ctx);
-    }
-    const facts = jsonEntityFacts(entityId, data, type);
-    await this._mutate("addFacts", { facts }, ctx);
-  }
-  async deleteNode(entityId, ctx = {}) {
-    const facts = this.store.getFactsByEntity(entityId);
-    if (facts.length > 0) {
-      await this._mutate("deleteFacts", { facts }, ctx);
-    }
-  }
-  async link(e1, a, e2, ctx = {}) {
-    await this._mutate("addLinks", { links: [{ e1, a, e2 }] }, ctx);
-  }
-  query(eqlsQuery, ctx = {}) {
-    return this.runQueryMiddleware(eqlsQuery, ctx);
-  }
-  async queryNatural(nl, opts) {
-    const eqlsQuery = await opts.provider.translate(nl, opts.context);
-    return this.query(eqlsQuery, opts.context);
-  }
-  async queryDatalog(query, ctx = {}) {
-    return this.runQueryMiddleware(query, ctx);
-  }
-  runQueryMiddleware(query, ctx) {
-    if (this.backend) {
-      this.open();
-    }
-    const runMiddleware = (index, currentQuery, currentCtx) => {
-      if (index >= this.middleware.length) {
-        if (this.backend && (currentCtx.atHash || currentCtx.atTimestamp)) {
-          const ephemeralStore = new EAVStore;
-          const ops = currentCtx.atHash ? this.backend.readUntil(currentCtx.atHash) : this.backend.readUntilTimestamp(currentCtx.atTimestamp);
-          for (const op of ops) {
-            if (op.kind === "addFacts" && op.facts) {
-              ephemeralStore.addFacts(op.facts);
-            } else if (op.kind === "addLinks" && op.links) {
-              ephemeralStore.addLinks(op.links);
-            } else if (op.kind === "deleteFacts" && op.facts) {
-              ephemeralStore.deleteFacts(op.facts);
-            } else if (op.kind === "deleteLinks" && op.links) {
-              ephemeralStore.deleteLinks(op.links);
-            }
-          }
-          return this.executeBaseQuery(currentQuery, ephemeralStore);
-        }
-        return this.executeBaseQuery(currentQuery);
-      }
-      const mw = this.middleware[index];
-      if (mw && mw.handleQuery) {
-        return mw.handleQuery(currentQuery, currentCtx, (q, c) => runMiddleware(index + 1, q, c));
-      } else {
-        return runMiddleware(index + 1, currentQuery, currentCtx);
-      }
-    };
-    return runMiddleware(0, query, ctx);
-  }
-  executeBaseQuery(queryOrEqls, storeOverride) {
-    const store = storeOverride || this.store;
-    const evaluator = storeOverride ? new DatalogEvaluator(storeOverride) : this.evaluator;
-    this.eqls.setSchema(store.getCatalog());
-    if (typeof queryOrEqls !== "string") {
-      const exec = evaluator.evaluate(queryOrEqls);
-      return {
-        rows: exec.bindings,
-        executionTime: exec.executionTime,
-        plan: exec.plan,
-        bindings: exec.bindings
-      };
-    }
-    const processed = this.eqls.process(queryOrEqls);
-    if (processed.errors.length > 0 || !processed.query) {
-      const message = processed.errors.map((e) => e.message).join("; ");
-      throw new Error(message || "Query parsing failed");
-    }
-    const compiledQueries = processed.queries && processed.queries.length > 0 ? processed.queries : [processed.query];
-    const projectionMap = processed.projectionMap || new Map;
-    const mergedRows = [];
-    const seen = new Set;
-    let totalTime = 0;
-    const plans = [];
-    const allTraces = [];
-    for (const q of compiledQueries) {
-      const exec = evaluator.evaluate(q);
-      totalTime += exec.executionTime;
-      if (exec.plan)
-        plans.push(exec.plan);
-      if (exec.trace)
-        allTraces.push(...exec.trace);
-      for (const binding of exec.bindings) {
-        const row = projectionMap.size === 0 ? binding : (() => {
-          const projected = {};
-          for (const [field, varName] of projectionMap.entries()) {
-            projected[field] = binding[varName];
-          }
-          return projected;
-        })();
-        const k = JSON.stringify(row);
-        if (!seen.has(k)) {
-          seen.add(k);
-          mergedRows.push(row);
-        }
-      }
-    }
-    const orderBy = processed.meta?.orderBy;
-    if (orderBy?.field) {
-      const dir = orderBy.direction === "DESC" ? -1 : 1;
-      mergedRows.sort((ra, rb) => dir * stableCompare(ra[orderBy.field], rb[orderBy.field]));
-    }
-    const limit = processed.meta?.limit;
-    const finalRows = typeof limit === "number" && limit >= 0 ? mergedRows.slice(0, limit) : mergedRows;
-    return {
-      rows: finalRows,
-      executionTime: totalTime,
-      plan: plans.length > 0 ? plans.join(" | ") : undefined,
-      trace: allTraces.length > 0 ? allTraces : undefined
-    };
-  }
-}
-
-// src/persist/sqlite-backend.ts
-import { createRequire as createRequire2 } from "module";
-var require2 = createRequire2(import.meta.url);
-var encodeAtom = (v) => {
-  if (v instanceof Date)
-    return { $type: "date", value: v.toISOString() };
-  return v;
-};
-var decodeAtom = (v) => {
-  if (v && typeof v === "object" && "$type" in v && v.$type === "date" && typeof v.value === "string") {
-    return new Date(v.value);
-  }
-  return v;
-};
-var encodeOp = (op) => {
-  const encoded = { ...op };
-  if (encoded.facts) {
-    encoded.facts = encoded.facts.map((f) => ({
-      ...f,
-      v: encodeAtom(f.v)
-    }));
-  }
-  return encoded;
-};
-var decodeOp = (raw) => {
-  const decoded = { ...raw };
-  if (decoded.facts) {
-    decoded.facts = decoded.facts.map((f) => ({
-      ...f,
-      v: decodeAtom(f.v)
-    }));
-  }
-  return decoded;
-};
-
-class SqliteKernelBackend {
-  opts;
-  db;
-  constructor(opts) {
-    this.opts = opts;
-    const mod = require2(["bun", "sqlite"].join(":"));
-    const DatabaseCtor = mod?.Database;
-    if (!DatabaseCtor) {
-      throw new Error("bun:sqlite is not available in this runtime");
-    }
-    this.db = new DatabaseCtor(opts.filename);
-  }
-  init() {
-    this.db.exec(`
-      PRAGMA journal_mode = WAL;
-      CREATE TABLE IF NOT EXISTS ops (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        hash TEXT NOT NULL UNIQUE,
-        ts INTEGER NOT NULL,
-        kind TEXT NOT NULL,
-        payload TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_ops_hash ON ops(hash);
-
-      CREATE TABLE IF NOT EXISTS snapshots (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        last_op_hash TEXT NOT NULL,
-        ts INTEGER NOT NULL,
-        data TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_snapshots_ts ON snapshots(ts);
-    `);
-  }
-  append(op) {
-    const stmt = this.db.prepare("INSERT INTO ops (hash, ts, kind, payload) VALUES (?, ?, ?, ?)");
-    stmt.run(op.hash, new Date(op.timestamp).getTime(), op.kind, JSON.stringify(encodeOp(op)));
-  }
-  readAll() {
-    const rows = this.db.prepare("SELECT payload FROM ops ORDER BY id ASC").all();
-    return rows.map((r) => decodeOp(JSON.parse(r.payload)));
-  }
-  readUntil(hash) {
-    const target = this.db.prepare("SELECT id FROM ops WHERE hash = ?").get(hash);
-    if (!target) {
-      throw new Error(`Operation with hash ${hash} not found`);
-    }
-    const rows = this.db.prepare("SELECT payload FROM ops WHERE id <= ? ORDER BY id ASC").all(target.id);
-    return rows.map((r) => decodeOp(JSON.parse(r.payload)));
-  }
-  readAfter(hash) {
-    const target = this.db.prepare("SELECT id FROM ops WHERE hash = ?").get(hash);
-    if (!target) {
-      throw new Error(`Operation with hash ${hash} not found`);
-    }
-    const rows = this.db.prepare("SELECT payload FROM ops WHERE id > ? ORDER BY id ASC").all(target.id);
-    return rows.map((r) => decodeOp(JSON.parse(r.payload)));
-  }
-  readUntilTimestamp(isoTimestamp) {
-    const ts = new Date(isoTimestamp).getTime();
-    const rows = this.db.prepare("SELECT payload FROM ops WHERE ts <= ? ORDER BY id ASC").all(ts);
-    return rows.map((r) => decodeOp(JSON.parse(r.payload)));
-  }
-  getLastOp() {
-    const row = this.db.prepare("SELECT payload FROM ops ORDER BY id DESC LIMIT 1").get();
-    if (!row)
-      return;
-    return decodeOp(JSON.parse(row.payload));
-  }
-  saveSnapshot(lastOpHash, data) {
-    const stmt = this.db.prepare("INSERT INTO snapshots (last_op_hash, ts, data) VALUES (?, ?, ?)");
-    stmt.run(lastOpHash, Date.now(), JSON.stringify(data));
-  }
-  loadLatestSnapshot() {
-    const row = this.db.prepare("SELECT last_op_hash, data FROM snapshots ORDER BY ts DESC LIMIT 1").get();
-    if (!row)
-      return;
-    return {
-      lastOpHash: row.last_op_hash,
-      data: JSON.parse(row.data)
-    };
-  }
-  close() {
-    this.db.close();
-  }
-}
-
-// src/server/tenant-registry.ts
-import { createRequire as createRequire3 } from "module";
-import { randomUUID as randomUUID2 } from "crypto";
-import { join } from "node:path";
-var require3 = createRequire3(import.meta.url);
-function generateApiKey() {
-  return "tql_" + randomUUID2().replace(/-/g, "").slice(0, 32);
-}
-
-class TenantRegistry {
-  db;
-  constructor(registryDbPath) {
-    const mod = require3(["bun", "sqlite"].join(":"));
-    this.db = new mod.Database(registryDbPath);
-    this.init();
-  }
-  init() {
-    this.db.run("PRAGMA journal_mode = WAL");
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS api_keys (
-        key        TEXT PRIMARY KEY,
-        label      TEXT NOT NULL,
-        db_path    TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      )
-    `);
-  }
-  provision(dataDir, label) {
-    const key = generateApiKey();
-    const dbPath = join(dataDir, `${key}.db`);
-    const createdAt = new Date().toISOString();
-    const effectiveLabel = label ?? key;
-    this.db.run("INSERT INTO api_keys (key, label, db_path, created_at) VALUES (?, ?, ?, ?)", [key, effectiveLabel, dbPath, createdAt]);
-    return { key, label: effectiveLabel, dbPath, createdAt };
-  }
-  lookup(key) {
-    const row = this.db.query("SELECT key, label, db_path, created_at FROM api_keys WHERE key = ?").get(key);
-    if (!row)
-      return;
-    return { key: row.key, label: row.label, dbPath: row.db_path, createdAt: row.created_at };
-  }
-  revoke(key) {
-    const existing = this.lookup(key);
-    if (!existing)
-      return false;
-    this.db.run("DELETE FROM api_keys WHERE key = ?", [key]);
-    return true;
-  }
-  list() {
-    const rows = this.db.query("SELECT key, label, db_path, created_at FROM api_keys ORDER BY created_at ASC").all();
-    return rows.map((r) => ({
-      key: r.key,
-      label: r.label,
-      dbPath: r.db_path,
-      createdAt: r.created_at
-    }));
-  }
-  close() {
-    this.db.close();
-  }
-}
-
-// src/server/kernel-pool.ts
-class KernelPool {
-  pool = new Map;
-  getOrCreate(dbPath) {
-    const existing = this.pool.get(dbPath);
-    if (existing)
-      return existing;
-    const backend = new SqliteKernelBackend({ filename: dbPath });
-    const kernel = new TrellisKernel({ backend });
-    this.pool.set(dbPath, kernel);
-    return kernel;
-  }
-  close(dbPath) {
-    const kernel = this.pool.get(dbPath);
-    if (kernel) {
-      kernel.close();
-      this.pool.delete(dbPath);
-    }
-  }
-  closeAll() {
-    for (const [dbPath] of this.pool) {
-      this.close(dbPath);
-    }
-  }
-}
-
-// src/cli/server.ts
-var DEFAULT_PORT = 8080;
-function jsonResponse(data, status = 200) {
-  return new Response(JSON.stringify(data, null, 2), {
-    status,
-    headers: {
-      "Content-Type": "application/json",
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-      "Access-Control-Allow-Headers": "Content-Type, Authorization"
-    }
-  });
-}
-function errorResponse(message, status = 400) {
-  return jsonResponse({ error: message }, status);
-}
-async function parseBody(req) {
-  const body = await req.json();
-  return body;
-}
-
-class TQLServer {
-  kernel;
-  port;
-  adminKey;
-  dataDir;
-  registry;
-  pool;
-  constructor(opts = {}) {
-    this.port = opts.port ?? DEFAULT_PORT;
-    this.adminKey = opts.adminKey;
-    this.dataDir = opts.dataDir;
-    if (opts.adminKey) {
-      if (!opts.dataDir) {
-        throw new Error("dataDir is required when adminKey is provided");
-      }
-      const registryDb = opts.registryDb ?? join2(opts.dataDir, "registry.db");
-      this.registry = new TenantRegistry(registryDb);
-      this.pool = new KernelPool;
-      this.kernel = null;
-    } else {
-      this.registry = null;
-      this.pool = null;
-      if (opts.db) {
-        const backend = new SqliteKernelBackend({ filename: opts.db });
-        this.kernel = new TrellisKernel({ backend });
-      } else {
-        this.kernel = new TrellisKernel;
-      }
-    }
-  }
-  getKernel() {
-    return this.kernel;
-  }
-  extractBearerToken(req) {
-    const auth = req.headers.get("Authorization") ?? req.headers.get("authorization");
-    if (!auth?.startsWith("Bearer "))
-      return null;
-    return auth.slice(7).trim();
-  }
-  getEntitiesFrom(kernel) {
-    const entities = new Set;
-    for (const fact of kernel.getStore().getAllFacts()) {
-      entities.add(fact.e);
-    }
-    return Array.from(entities).sort();
-  }
-  async handleRequest(req) {
-    const url = new URL(req.url);
-    const path = url.pathname;
-    const method = req.method;
-    if (method === "OPTIONS") {
-      return jsonResponse({ ok: true });
-    }
-    if (this.adminKey !== undefined) {
-      const token = this.extractBearerToken(req);
-      if (path === "/instances" || path.startsWith("/instances/")) {
-        if (token !== this.adminKey) {
-          return errorResponse("Unauthorized", 401);
-        }
-        return this.handleAdminRequest(req, path, method);
-      }
-      if (!token) {
-        return errorResponse("Unauthorized", 401);
-      }
-      const tenant = this.registry.lookup(token);
-      if (!tenant) {
-        return errorResponse("Unauthorized", 401);
-      }
-      const kernel = this.pool.getOrCreate(tenant.dbPath);
-      return this.handleTenantRequest(req, url, path, method, kernel);
-    }
-    return this.handleTenantRequest(req, url, path, method, this.kernel);
-  }
-  async handleAdminRequest(req, path, method) {
-    if (path === "/instances" && method === "POST") {
-      const body = await req.json();
-      const record = this.registry.provision(this.dataDir, body.label);
-      return jsonResponse({ apiKey: record.key, label: record.label, dbPath: record.dbPath, createdAt: record.createdAt }, 201);
-    }
-    if (path === "/instances" && method === "GET") {
-      const tenants = this.registry.list().map((r) => ({
-        apiKey: r.key,
-        label: r.label,
-        dbPath: r.dbPath,
-        createdAt: r.createdAt
-      }));
-      return jsonResponse({ tenants });
-    }
-    if (path.startsWith("/instances/") && method === "DELETE") {
-      const key = decodeURIComponent(path.slice("/instances/".length));
-      const tenant = this.registry.lookup(key);
-      if (!tenant) {
-        return errorResponse(`Not found: ${key}`, 404);
-      }
-      this.pool.close(tenant.dbPath);
-      this.registry.revoke(key);
-      return jsonResponse({ revoked: true });
-    }
-    return errorResponse(`Not found: ${method} ${path}`, 404);
-  }
-  async handleTenantRequest(req, url, path, method, kernel) {
-    try {
-      if (path === "/" && method === "GET") {
-        return jsonResponse({
-          name: "TQL HTTP API",
-          version: "1.0.0",
-          description: "REST API for the Trellis Query Language kernel",
-          endpoints: {
-            "GET  /": "This index",
-            "GET  /health": "Health check and uptime",
-            "GET  /stats": "Fact/link/entity counts",
-            "GET  /catalog": "Attribute catalog with types and examples",
-            "GET  /nodes": "List all entity IDs",
-            "POST /nodes": "Create a node  { id, data, type? }",
-            "GET  /nodes/:id": "Get all facts for an entity",
-            "PUT  /nodes/:id": "Update a node  { data, type? }",
-            "DELETE /nodes/:id": "Delete a node and its facts",
-            "GET  /links": "List all links",
-            "POST /links": "Create a link  { source, relation, target }",
-            "POST /query": "Run an EQL-S query  { q, natural?, context? }",
-            "GET  /query?q=": "Run an EQL-S query via GET",
-            "POST /query/datalog": "Run a raw Datalog query  { query }",
-            "GET  /workspace": "Export workspace config",
-            "POST /workspace": "Boot from workspace config",
-            "POST /workspace/checkpoint": "Save a state snapshot",
-            "GET  /openapi.json": "OpenAPI 3.0 spec"
-          },
-          query_syntax: "FIND <type> AS ?var [WHERE <conditions>] RETURN <fields>",
-          examples: {
-            create_node: 'POST /nodes  {"id":"alice","data":{"name":"Alice","age":30},"type":"person"}',
-            create_link: 'POST /links  {"source":"alice","relation":"works_at","target":"acme"}',
-            query: 'POST /query  {"q":"FIND person AS ?e RETURN ?e.name, ?e.age"}',
-            query_filter: 'POST /query  {"q":"FIND person AS ?e WHERE ?e.age > 25 RETURN ?e.name"}'
-          }
-        });
-      }
-      if (path === "/health" && method === "GET") {
-        return jsonResponse({ status: "ok", uptime: process.uptime() });
-      }
-      if (path === "/stats" && method === "GET") {
-        return jsonResponse(kernel.getStore().getStats());
-      }
-      if (path === "/catalog" && method === "GET") {
-        return jsonResponse(kernel.getStore().getCatalog());
-      }
-      if (path === "/nodes" && method === "GET") {
-        return jsonResponse({ entities: this.getEntitiesFrom(kernel) });
-      }
-      if (path === "/nodes" && method === "POST") {
-        const body = await parseBody(req);
-        const { id, data, type } = body;
-        if (!id || !data) {
-          return errorResponse("Missing required fields: id, data");
-        }
-        await kernel.createNode(id, data, type ?? "default");
-        return jsonResponse({ id, created: true }, 201);
-      }
-      if (path.startsWith("/nodes/") && method === "GET") {
-        const id = decodeURIComponent(path.slice(7));
-        const facts = kernel.getStore().getFactsByEntity(id);
-        return jsonResponse({ id, facts });
-      }
-      if (path.startsWith("/nodes/") && method === "PUT") {
-        const id = decodeURIComponent(path.slice(7));
-        const body = await parseBody(req);
-        const { data, type } = body;
-        if (!data) {
-          return errorResponse("Missing required field: data");
-        }
-        await kernel.updateNode(id, data, type ?? "default");
-        return jsonResponse({ id, updated: true });
-      }
-      if (path.startsWith("/nodes/") && method === "DELETE") {
-        const id = decodeURIComponent(path.slice(7));
-        await kernel.deleteNode(id);
-        return jsonResponse({ id, deleted: true });
-      }
-      if (path === "/links" && method === "GET") {
-        return jsonResponse({ links: kernel.getStore().getAllLinks() });
-      }
-      if (path === "/links" && method === "POST") {
-        const body = await parseBody(req);
-        const { source, target, relation } = body;
-        if (!source || !target || !relation) {
-          return errorResponse("Missing required fields: source, target, relation");
-        }
-        await kernel.link(source, relation, target);
-        return jsonResponse({ source, target, relation, created: true }, 201);
-      }
-      if (path === "/query" && method === "POST") {
-        const body = await parseBody(req);
-        const { q, natural, context } = body;
-        if (!q) {
-          return errorResponse("Missing required field: q");
-        }
-        const start = performance.now();
-        let result;
-        if (natural) {
-          const { DefaultNLQueryProvider: DefaultNLQueryProvider2 } = await Promise.resolve().then(() => (init_nl_query_provider(), exports_nl_query_provider));
-          const nlProvider = new DefaultNLQueryProvider2({
-            catalog: kernel.getStore().getCatalog(),
-            dataStats: kernel.getStore().getStats()
-          });
-          result = await kernel.queryNatural(q, { provider: nlProvider, context });
-        } else {
-          const queryResult = kernel.query(q);
-          result = queryResult instanceof Promise ? await queryResult : queryResult;
-        }
-        const elapsed = performance.now() - start;
-        return jsonResponse({
-          rows: result.rows,
-          executionTime: result.executionTime ?? elapsed,
-          plan: result.plan,
-          rowCount: result.rows.length
-        });
-      }
-      if (path === "/query" && method === "GET") {
-        const q = url.searchParams.get("q");
-        const natural = url.searchParams.get("natural") === "true";
-        if (!q) {
-          return errorResponse("Missing query parameter: q");
-        }
-        const start = performance.now();
-        let result;
-        if (natural) {
-          const { DefaultNLQueryProvider: DefaultNLQueryProvider2 } = await Promise.resolve().then(() => (init_nl_query_provider(), exports_nl_query_provider));
-          const nlProvider = new DefaultNLQueryProvider2({
-            catalog: kernel.getStore().getCatalog(),
-            dataStats: kernel.getStore().getStats()
-          });
-          result = await kernel.queryNatural(q, { provider: nlProvider });
-        } else {
-          const queryResult = kernel.query(q);
-          result = queryResult instanceof Promise ? await queryResult : queryResult;
-        }
-        const elapsed = performance.now() - start;
-        return jsonResponse({
-          rows: result.rows,
-          executionTime: result.executionTime ?? elapsed,
-          plan: result.plan,
-          rowCount: result.rows.length
-        });
-      }
-      if (path === "/query/datalog" && method === "POST") {
-        const body = await parseBody(req);
-        const { query } = body;
-        if (!query) {
-          return errorResponse("Missing required field: query");
-        }
-        const result = await kernel.queryDatalog(query);
-        return jsonResponse({
-          rows: result.rows,
-          executionTime: result.executionTime,
-          plan: result.plan,
-          rowCount: result.rows.length
-        });
-      }
-      if (path === "/workspace" && method === "POST") {
-        const body = await req.json();
-        await kernel.boot(body);
-        return jsonResponse({ booted: true });
-      }
-      if (path === "/workspace" && method === "GET") {
-        const workspace = await kernel.exportWorkspace();
-        return jsonResponse(workspace);
-      }
-      if (path === "/workspace/checkpoint" && method === "POST") {
-        await kernel.checkpoint();
-        return jsonResponse({ checkpoint: true });
-      }
-      if (path === "/openapi.json" && method === "GET") {
-        return jsonResponse(this.generateOpenAPI());
-      }
-      return errorResponse(`Not found: ${method} ${path}`, 404);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Internal error";
-      console.error(`Error handling ${method} ${path}:`, err);
-      return errorResponse(message, 500);
-    }
-  }
-  generateOpenAPI() {
-    const securitySchemes = this.adminKey ? { BearerAuth: { type: "http", scheme: "bearer" } } : undefined;
-    const security = this.adminKey ? [{ BearerAuth: [] }] : undefined;
-    return {
-      openapi: "3.0.0",
-      info: {
-        title: "TQL HTTP API",
-        version: "1.0.0",
-        description: "REST API for Trellis Query Language kernel"
-      },
-      servers: [{ url: `http://localhost:${this.port}` }],
-      ...securitySchemes ? { components: { securitySchemes } } : {},
-      ...security ? { security } : {},
-      paths: {
-        "/instances": {
-          get: {
-            summary: "List all tenants (admin only)",
-            responses: { "200": { description: "Tenant list" } }
-          },
-          post: {
-            summary: "Provision a new tenant (admin only)",
-            requestBody: {
-              content: {
-                "application/json": {
-                  schema: { type: "object", properties: { label: { type: "string" } } }
-                }
-              }
-            },
-            responses: { "201": { description: "Provisioned" } }
-          }
-        },
-        "/instances/{key}": {
-          delete: {
-            summary: "Revoke a tenant key (admin only)",
-            parameters: [{ name: "key", in: "path", required: true, schema: { type: "string" } }],
-            responses: { "200": { description: "Revoked" } }
-          }
-        },
-        "/health": {
-          get: { summary: "Health check", responses: { "200": { description: "OK" } } }
-        },
-        "/stats": {
-          get: { summary: "Get store statistics", responses: { "200": { description: "Store stats" } } }
-        },
-        "/catalog": {
-          get: { summary: "Get data catalog", responses: { "200": { description: "Attribute catalog" } } }
-        },
-        "/nodes": {
-          get: { summary: "List all entities", responses: { "200": { description: "Entity list" } } },
-          post: {
-            summary: "Create a node",
-            requestBody: {
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    required: ["id", "data"],
-                    properties: { id: { type: "string" }, data: {}, type: { type: "string" } }
-                  }
-                }
-              }
-            },
-            responses: { "201": { description: "Created" } }
-          }
-        },
-        "/nodes/{id}": {
-          get: {
-            summary: "Get entity facts",
-            parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
-            responses: { "200": { description: "Entity facts" } }
-          },
-          put: {
-            summary: "Update a node",
-            parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
-            requestBody: {
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    required: ["data"],
-                    properties: { data: {}, type: { type: "string" } }
-                  }
-                }
-              }
-            },
-            responses: { "200": { description: "Updated" } }
-          },
-          delete: {
-            summary: "Delete a node",
-            parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
-            responses: { "200": { description: "Deleted" } }
-          }
-        },
-        "/links": {
-          get: { summary: "List all links", responses: { "200": { description: "Link list" } } },
-          post: {
-            summary: "Create a link",
-            requestBody: {
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    required: ["source", "target", "relation"],
-                    properties: {
-                      source: { type: "string" },
-                      target: { type: "string" },
-                      relation: { type: "string" }
-                    }
-                  }
-                }
-              }
-            },
-            responses: { "201": { description: "Created" } }
-          }
-        },
-        "/query": {
-          get: {
-            summary: "Execute query via GET",
-            parameters: [
-              { name: "q", in: "query", required: true, schema: { type: "string" } },
-              { name: "natural", in: "query", schema: { type: "boolean" } }
-            ],
-            responses: { "200": { description: "Query results" } }
-          },
-          post: {
-            summary: "Execute EQL-S or natural language query",
-            requestBody: {
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    required: ["q"],
-                    properties: {
-                      q: { type: "string" },
-                      natural: { type: "boolean" },
-                      context: { type: "object" }
-                    }
-                  }
-                }
-              }
-            },
-            responses: { "200": { description: "Query results" } }
-          }
-        },
-        "/query/datalog": {
-          post: {
-            summary: "Execute raw Datalog query",
-            requestBody: {
-              content: {
-                "application/json": {
-                  schema: { type: "object", required: ["query"], properties: { query: {} } }
-                }
-              }
-            },
-            responses: { "200": { description: "Query results" } }
-          }
-        },
-        "/workspace": {
-          get: {
-            summary: "Export workspace config",
-            responses: { "200": { description: "Workspace config" } }
-          },
-          post: {
-            summary: "Boot from workspace config or data",
-            requestBody: { content: { "application/json": {} } },
-            responses: { "200": { description: "Booted" } }
-          }
-        },
-        "/workspace/checkpoint": {
-          post: { summary: "Save state snapshot", responses: { "200": { description: "Checkpoint saved" } } }
-        },
-        "/openapi.json": {
-          get: { summary: "OpenAPI spec", responses: { "200": { description: "OpenAPI 3.0 document" } } }
-        }
-      }
-    };
-  }
-  start() {
-    return new Promise((resolve) => {
-      const self = this;
-      const server = Bun.serve({
-        port: this.port,
-        async fetch(req) {
-          return self.handleRequest(req);
-        }
-      });
-      const actualPort = server.port ?? this.port;
-      const mode = this.adminKey ? "multi-tenant" : "single-tenant";
-      console.log(`\uD83D\uDE80 TQL HTTP server running at http://localhost:${actualPort} [${mode}]`);
-      resolve({ port: actualPort });
-    });
-  }
-}
-if (__require.main == __require.module) {
-  const port = parseInt(process.argv[2] ?? String(DEFAULT_PORT));
-  const db = process.argv.find((a) => a.startsWith("--db="))?.split("=")[1];
-  const adminKey = process.env.ADMIN_KEY;
-  const dataDir = process.env.DATA_DIR;
-  const server = new TQLServer({ port, db, adminKey, dataDir });
-  server.start();
-}
-export {
-  TQLServer
-};