trellis 1.0.8 → 2.0.5

package/dist/workflows/index.js

@@ -1,3160 +0,0 @@
-// src/workflows/types.ts
-class WorkflowValidationError extends Error {
-  stepId;
-  constructor(message, stepId) {
-    super(message);
-    this.stepId = stepId;
-    this.name = "WorkflowValidationError";
-  }
-}
-
-class WorkflowRuntimeError extends Error {
-  stepId;
-  constructor(message, stepId) {
-    super(message);
-    this.stepId = stepId;
-    this.name = "WorkflowRuntimeError";
-  }
-}
-// src/workflows/schema.ts
-var WORKFLOW_SCHEMA = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  type: "object",
-  properties: {
-    version: {
-      type: "number",
-      const: 1,
-      description: "Workflow specification version. Must be 1."
-    },
-    name: {
-      type: "string",
-      minLength: 1,
-      description: "Human-readable workflow name"
-    },
-    env: {
-      type: "object",
-      additionalProperties: {
-        type: "string"
-      },
-      description: "Environment variables merged with process.env and --var"
-    },
-    steps: {
-      type: "array",
-      minItems: 1,
-      items: {
-        $ref: "#/definitions/step"
-      },
-      description: "Workflow execution steps"
-    }
-  },
-  required: ["version", "name", "steps"],
-  additionalProperties: false,
-  definitions: {
-    step: {
-      type: "object",
-      properties: {
-        id: {
-          type: "string",
-          pattern: "^[a-zA-Z][a-zA-Z0-9_]*$",
-          description: "Unique step identifier"
-        },
-        type: {
-          enum: ["source", "query", "output"],
-          description: "Step type"
-        },
-        needs: {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          description: "Dependencies on other steps"
-        },
-        out: {
-          type: "string",
-          description: "Output dataset name"
-        },
-        source: {
-          oneOf: [
-            { $ref: "#/definitions/httpSource" },
-            { $ref: "#/definitions/fileSource" }
-          ]
-        },
-        from: { type: "string" },
-        eqls: { type: "string" },
-        output: { $ref: "#/definitions/output" }
-      },
-      required: ["id", "type"],
-      additionalProperties: false,
-      allOf: [
-        {
-          if: { properties: { type: { const: "source" } } },
-          then: {
-            required: ["source", "out"]
-          }
-        },
-        {
-          if: { properties: { type: { const: "query" } } },
-          then: {
-            required: ["needs", "eqls", "out"]
-          }
-        },
-        {
-          if: { properties: { type: { const: "output" } } },
-          then: {
-            required: ["needs", "output"]
-          }
-        }
-      ]
-    },
-    fileSource: {
-      type: "object",
-      properties: {
-        kind: {
-          const: "file",
-          description: "Source kind"
-        },
-        path: {
-          type: "string",
-          description: "Path to local file, relative to the workflow file"
-        },
-        format: {
-          enum: ["json", "csv"],
-          description: "File format (defaults to json)"
-        }
-      },
-      required: ["kind", "path"],
-      additionalProperties: false
-    },
-    httpSource: {
-      type: "object",
-      properties: {
-        kind: {
-          const: "http",
-          description: "Source kind"
-        },
-        url: {
-          type: "string",
-          description: "HTTP URL with optional template variables"
-        },
-        headers: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          },
-          description: "HTTP headers"
-        },
-        mode: {
-          enum: ["batch", "map"],
-          description: "Execution mode: batch (single request) or map (per-row requests)"
-        },
-        mapFrom: {
-          type: "string",
-          description: "Dataset to iterate over in map mode"
-        }
-      },
-      required: ["kind", "url", "mode"],
-      allOf: [
-        {
-          if: { properties: { mode: { const: "map" } } },
-          then: {
-            required: ["mapFrom"]
-          }
-        }
-      ],
-      additionalProperties: false
-    },
-    output: {
-      oneOf: [
-        {
-          type: "object",
-          properties: {
-            kind: { const: "file" },
-            format: { enum: ["json", "csv"] },
-            path: { type: "string" }
-          },
-          required: ["kind", "format", "path"],
-          additionalProperties: false
-        },
-        {
-          type: "object",
-          properties: {
-            kind: { const: "stdout" },
-            format: { enum: ["json", "csv"] }
-          },
-          required: ["kind", "format"],
-          additionalProperties: false
-        }
-      ]
-    }
-  }
-};
-// src/workflows/parser.ts
-import { parse } from "yaml";
-import Ajv from "ajv";
-var ajv = new Ajv({ allErrors: true });
-var validateWorkflow = ajv.compile(WORKFLOW_SCHEMA);
-function parseWorkflow(yamlContent) {
-  try {
-    const spec = parse(yamlContent, {
-      prettyErrors: true,
-      strict: true
-    });
-    if (!validateWorkflow(spec)) {
-      const errors = validateWorkflow.errors?.map((err) => {
-        const path = err.instancePath || err.schemaPath;
-        const message = err.message;
-        return `${path}: ${message}`;
-      }).join("; ") || "Unknown validation error";
-      throw new WorkflowValidationError(`Workflow validation failed: ${errors}`);
-    }
-    return spec;
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("line") && error.message.includes("column")) {
-        throw new WorkflowValidationError(`YAML parsing failed: ${error.message}`);
-      }
-      throw new WorkflowValidationError(`Failed to parse workflow: ${error.message}`);
-    }
-    throw new WorkflowValidationError("Failed to parse workflow: Unknown error");
-  }
-}
-function interpolateTemplate(template, context, options = {}) {
-  return template.replace(/(\$)?\{\{\s*([^}]+)\s*\}\}/g, (match, dollar, expression) => {
-    const trimmed = expression.trim();
-    if (trimmed.includes("__proto__") || trimmed.includes("constructor") || trimmed.includes("prototype")) {
-      throw new Error(`Invalid template expression (security): ${trimmed}`);
-    }
-    let value;
-    if (trimmed.startsWith("env.") || trimmed.startsWith("secrets.")) {
-      const key = trimmed.split(".").slice(1).join(".");
-      const envValue = context.env[key];
-      if (envValue === undefined) {
-        throw new Error(`Environment variable not found: ${key}`);
-      }
-      value = envValue;
-    } else if (trimmed.startsWith("var.")) {
-      const key = trimmed.substring(4);
-      const varValue = context.vars[key];
-      if (varValue === undefined) {
-        throw new Error(`Variable not found: ${key}`);
-      }
-      value = varValue;
-    } else if (trimmed.startsWith("row.")) {
-      if (!context.row) {
-        throw new Error("Row variables are only available in map mode");
-      }
-      const path = trimmed.substring(4);
-      const rowValue = getNestedValue(context.row, path);
-      if (rowValue === undefined) {
-        throw new Error(`Row attribute not found: ${path}`);
-      }
-      value = String(rowValue);
-    } else {
-      throw new Error(`Invalid template expression: ${trimmed}`);
-    }
-    return options.urlEncode ? encodeURIComponent(value) : value;
-  });
-}
-function interpolateObject(obj, context) {
-  if (typeof obj === "string") {
-    return interpolateTemplate(obj, context);
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => interpolateObject(item, context));
-  }
-  if (obj && typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = interpolateObject(value, context);
-    }
-    return result;
-  }
-  return obj;
-}
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  for (const part of parts) {
-    if (part === "__proto__" || part === "constructor" || part === "prototype") {
-      throw new Error(`Invalid property access (security): ${part}`);
-    }
-  }
-  return parts.reduce((current, key) => {
-    return current && typeof current === "object" ? current[key] : undefined;
-  }, obj);
-}
-function validateWorkflowSemantics(spec) {
-  const stepIds = new Set;
-  const outputs = new Set;
-  const outputNames = new Set;
-  for (const step of spec.steps) {
-    if (stepIds.has(step.id)) {
-      throw new WorkflowValidationError(`Duplicate step ID: ${step.id}`);
-    }
-    stepIds.add(step.id);
-    if (step.out) {
-      if (outputNames.has(step.out)) {
-        throw new WorkflowValidationError(`duplicate output name: ${step.out}`, step.id);
-      }
-      if (stepIds.has(step.out)) {
-        throw new WorkflowValidationError(`Output name "${step.out}" conflicts with step ID. Use different names to avoid ambiguity.`, step.id);
-      }
-      outputNames.add(step.out);
-      outputs.add(step.out);
-    }
-  }
-  const graph = new Map;
-  for (const step of spec.steps) {
-    graph.set(step.id, step.needs || []);
-    if (step.type === "source" && step.source.mode === "map") {
-      if (!step.source.mapFrom || !outputs.has(step.source.mapFrom)) {
-        throw new WorkflowValidationError(`Step ${step.id} map mode requires valid mapFrom dataset`, step.id);
-      }
-    }
-    if (step.type === "query" && step.from) {
-      if (!outputs.has(step.from)) {
-        throw new WorkflowValidationError(`Step ${step.id} references unknown dataset: ${step.from}`, step.id);
-      }
-    }
-  }
-  const visited = new Set;
-  const recursionStack = new Set;
-  function hasCycle(nodeId) {
-    if (recursionStack.has(nodeId)) {
-      return true;
-    }
-    if (visited.has(nodeId)) {
-      return false;
-    }
-    visited.add(nodeId);
-    recursionStack.add(nodeId);
-    const dependencies = graph.get(nodeId) || [];
-    for (const dep of dependencies) {
-      if (hasCycle(dep)) {
-        return true;
-      }
-    }
-    recursionStack.delete(nodeId);
-    return false;
-  }
-  for (const stepId of stepIds) {
-    if (hasCycle(stepId)) {
-      throw new WorkflowValidationError("Circular dependency detected in workflow");
-    }
-  }
-}
-// src/workflows/planner.ts
-function createExecutionPlan(spec) {
-  const steps = spec.steps;
-  const stepMap = new Map;
-  for (const step of steps) {
-    stepMap.set(step.id, step);
-  }
-  validateNeedsReferences(steps);
-  const order = topologicalSort(steps);
-  return {
-    steps,
-    order
-  };
-}
-function validateNeedsReferences(steps) {
-  const stepIds = new Set(steps.map((s) => s.id));
-  const outputs = new Map(steps.map((s) => [s.out, s.id]).filter(([out, id]) => out && id));
-  for (const step of steps) {
-    for (const need of step.needs ?? []) {
-      if (!stepIds.has(need)) {
-        let hint = "";
-        if (outputs.has(need)) {
-          hint = ` Did you mean step id "${outputs.get(need)}"?`;
-        } else {
-          const stepList = Array.from(stepIds).join(", ");
-          const datasetList = Array.from(outputs.keys()).join(", ");
-          hint = ` Steps: ${stepList}. Datasets: ${datasetList}.`;
-        }
-        throw new WorkflowValidationError(`Step ${step.id} depends on unknown step: ${need}.${hint}`, step.id);
-      }
-    }
-  }
-}
-function topologicalSort(steps) {
-  const graph = new Map;
-  const inDegree = new Map;
-  const result = [];
-  for (const step of steps) {
-    graph.set(step.id, []);
-    inDegree.set(step.id, 0);
-  }
-  for (const step of steps) {
-    const dependencies = step.needs || [];
-    for (const dep of dependencies) {
-      if (!graph.has(dep)) {
-        throw new WorkflowValidationError(`Step ${step.id} depends on unknown step: ${dep}`, step.id);
-      }
-      graph.get(dep).push(step.id);
-      inDegree.set(step.id, (inDegree.get(step.id) || 0) + 1);
-    }
-  }
-  const queue = [];
-  for (const [stepId, degree] of inDegree) {
-    if (degree === 0) {
-      queue.push(stepId);
-    }
-  }
-  while (queue.length > 0) {
-    queue.sort((a, b) => {
-      const stepA = steps.find((s) => s.id === a);
-      const stepB = steps.find((s) => s.id === b);
-      if (stepA.type === "source" && stepB.type !== "source")
-        return -1;
-      if (stepB.type === "source" && stepA.type !== "source")
-        return 1;
-      return a.localeCompare(b);
-    });
-    const current = queue.shift();
-    result.push(current);
-    const dependents = graph.get(current) || [];
-    for (const dependent of dependents) {
-      const newDegree = (inDegree.get(dependent) || 0) - 1;
-      inDegree.set(dependent, newDegree);
-      if (newDegree === 0) {
-        queue.push(dependent);
-      }
-    }
-  }
-  if (result.length !== steps.length) {
-    const remaining = steps.filter((step) => !result.includes(step.id)).map((step) => step.id);
-    const cycle = findMinimalCycle(remaining, graph);
-    const cycleStr = cycle ? cycle.join(" → ") : remaining.join(", ");
-    throw new WorkflowValidationError(`Workflow has circular dependencies: ${cycleStr}`);
-  }
-  return result;
-}
-function findMinimalCycle(remaining, graph) {
-  const visited = new Set;
-  const recursionStack = new Set;
-  const path = [];
-  function dfs(node) {
-    if (recursionStack.has(node)) {
-      const cycleStart = path.indexOf(node);
-      return path.slice(cycleStart).concat([node]);
-    }
-    if (visited.has(node)) {
-      return null;
-    }
-    visited.add(node);
-    recursionStack.add(node);
-    path.push(node);
-    const dependencies = graph.get(node) || [];
-    for (const dep of dependencies) {
-      if (remaining.includes(dep)) {
-        const cycle = dfs(dep);
-        if (cycle) {
-          return cycle;
-        }
-      }
-    }
-    path.pop();
-    recursionStack.delete(node);
-    return null;
-  }
-  for (const node of remaining) {
-    if (!visited.has(node)) {
-      const cycle = dfs(node);
-      if (cycle) {
-        return cycle;
-      }
-    }
-  }
-  return null;
-}
-function validateExecutionPlan(plan) {
-  const { steps, order } = plan;
-  const stepMap = new Map(steps.map((s) => [s.id, s]));
-  const availableDatasets = new Set;
-  for (const stepId of order) {
-    const step = stepMap.get(stepId);
-    if (!step) {
-      throw new WorkflowValidationError(`Step not found in plan: ${stepId}`);
-    }
-    const dependencies = step.needs || [];
-    for (const dep of dependencies) {
-      const depStep = stepMap.get(dep);
-      if (!depStep || !depStep.out) {
-        throw new WorkflowValidationError(`Step ${stepId} depends on ${dep} which doesn't produce output`, stepId);
-      }
-      if (!availableDatasets.has(depStep.out)) {
-        throw new WorkflowValidationError(`Step ${stepId} depends on dataset ${depStep.out} which is not yet available`, stepId);
-      }
-    }
-    validateStepRequirements(step, availableDatasets);
-    if (step.out) {
-      availableDatasets.add(step.out);
-    }
-  }
-}
-function validateStepRequirements(step, availableDatasets) {
-  switch (step.type) {
-    case "source":
-      if (step.source.mode === "map") {
-        const mapFrom = step.source.mapFrom;
-        if (!mapFrom || !availableDatasets.has(mapFrom)) {
-          throw new WorkflowValidationError(`Step ${step.id} map mode requires dataset ${mapFrom} to be available`, step.id);
-        }
-      }
-      break;
-    case "query":
-      if (step.from && !availableDatasets.has(step.from)) {
-        throw new WorkflowValidationError(`Step ${step.id} references unavailable dataset: ${step.from}`, step.id);
-      }
-      break;
-    case "output":
-      break;
-  }
-}
-function getStepDependencies(step, plan) {
-  const { steps, order } = plan;
-  const stepMap = new Map(steps.map((s) => [s.id, s]));
-  const dependencies = [];
-  const stepIndex = order.indexOf(step.id);
-  if (stepIndex === -1) {
-    throw new WorkflowValidationError(`Step ${step.id} not found in execution plan`);
-  }
-  for (let i = 0;i < stepIndex; i++) {
-    const stepIdAtIndex = order[i];
-    if (!stepIdAtIndex)
-      continue;
-    const depStep = stepMap.get(stepIdAtIndex);
-    if (depStep && (step.needs || []).includes(depStep.id)) {
-      dependencies.push(depStep);
-    }
-  }
-  return dependencies;
-}
-function getParallelGroups(plan) {
-  const { steps, order } = plan;
-  const stepMap = new Map(steps.map((s) => [s.id, s]));
-  const groups = [];
-  const processed = new Set;
-  for (const stepId of order) {
-    if (processed.has(stepId))
-      continue;
-    const step = stepMap.get(stepId);
-    const group = [step];
-    processed.add(stepId);
-    for (const otherStepId of order) {
-      if (processed.has(otherStepId))
-        continue;
-      const otherStep = stepMap.get(otherStepId);
-      if (canRunInParallel(step, otherStep, stepMap)) {
-        group.push(otherStep);
-        processed.add(otherStepId);
-      }
-    }
-    groups.push(group);
-  }
-  return groups;
-}
-function canRunInParallel(stepA, stepB, stepMap) {
-  const depsA = new Set(stepA.needs || []);
-  const depsB = new Set(stepB.needs || []);
-  if (depsA.has(stepB.id) || depsB.has(stepA.id)) {
-    return false;
-  }
-  if (stepA.out && depsB.has(stepA.id))
-    return false;
-  if (stepB.out && depsA.has(stepB.id))
-    return false;
-  if (stepA.type === "source" && stepA.source.mode === "map") {
-    if (stepA.source.mapFrom === stepB.out)
-      return false;
-  }
-  if (stepB.type === "source" && stepB.source.mode === "map") {
-    if (stepB.source.mapFrom === stepA.out)
-      return false;
-  }
-  return true;
-}
-// src/workflows/runners.ts
-import { writeFile, mkdir, readFile } from "fs/promises";
-import { dirname, resolve } from "path";
-
-// 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/workflows/runners.ts
-class HttpSourceRunner {
-  validate(spec) {
-    if (!spec.url) {
-      throw new WorkflowRuntimeError("HTTP source requires url");
-    }
-    if (spec.mode === "map" && !spec.mapFrom) {
-      throw new WorkflowRuntimeError("Map mode requires mapFrom dataset");
-    }
-  }
-  async run(spec, ctx) {
-    this.validate(spec);
-    const templateContext = {
-      env: ctx.env,
-      vars: ctx.vars
-    };
-    switch (spec.mode) {
-      case "batch":
-        return this.runBatch(spec, templateContext, ctx);
-      case "map":
-        return this.runMap(spec, templateContext, ctx);
-      default:
-        throw new WorkflowRuntimeError(`Unsupported HTTP mode: ${spec.mode}`);
-    }
-  }
-  async runBatch(spec, templateContext, ctx) {
-    const interpolatedSpec = interpolateObject(spec, templateContext);
-    const url = interpolatedSpec.url;
-    ctx.log({ message: `HTTP GET ${url}` });
-    try {
-      const response = await this.fetchWithTimeout(url, {
-        headers: interpolatedSpec.headers || {}
-      });
-      if (!response.ok) {
-        throw new WorkflowRuntimeError(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      const data = await response.json();
-      const rows = this.extractDataArray(data);
-      const limitedRows = ctx.dry && ctx.limit ? rows.slice(0, ctx.limit) : rows;
-      return {
-        name: spec.mapFrom || "batch_result",
-        rows: limitedRows
-      };
-    } catch (error) {
-      if (error instanceof WorkflowRuntimeError) {
-        throw error;
-      }
-      throw new WorkflowRuntimeError(`HTTP request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  async runMap(spec, templateContext, ctx) {
-    if (!spec.mapFrom) {
-      throw new WorkflowRuntimeError("Map mode requires mapFrom dataset");
-    }
-    const sourceDataset = ctx.getDataset(spec.mapFrom);
-    if (!sourceDataset) {
-      throw new WorkflowRuntimeError(`Dataset not found: ${spec.mapFrom}`);
-    }
-    const allRows = [];
-    const sourceRows = ctx.dry && ctx.limit ? sourceDataset.rows.slice(0, ctx.limit) : sourceDataset.rows;
-    for (const row of sourceRows) {
-      const rowContext = {
-        ...templateContext,
-        row
-      };
-      const interpolatedSpec = interpolateObject(spec, rowContext);
-      const url = interpolatedSpec.url;
-      try {
-        const response = await this.fetchWithTimeout(url, {
-          headers: interpolatedSpec.headers || {}
-        });
-        if (!response.ok) {
-          throw new WorkflowRuntimeError(`HTTP ${response.status} for row ${JSON.stringify(row)}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        const rows = this.extractDataArray(data);
-        allRows.push(...rows);
-      } catch (error) {
-        if (error instanceof WorkflowRuntimeError) {
-          throw error;
-        }
-        throw new WorkflowRuntimeError(`HTTP request failed for row ${JSON.stringify(row)}: ${error instanceof Error ? error.message : "Unknown error"}`);
-      }
-    }
-    return {
-      name: `${spec.mapFrom}_mapped`,
-      rows: allRows
-    };
-  }
-  async fetchWithTimeout(url, options = {}, timeoutMs = 15000) {
-    const maxBytes = parseInt(process.env.TQL_HTTP_MAX_BYTES || "10485760");
-    const controller = new AbortController;
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      const response = await fetch(url, {
-        ...options,
-        signal: controller.signal
-      });
-      const contentLength = response.headers.get("content-length");
-      if (contentLength && parseInt(contentLength) > maxBytes) {
-        throw new WorkflowRuntimeError(`Response too large: ${contentLength} bytes (max: ${maxBytes})`);
-      }
-      return response;
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  extractDataArray(data) {
-    if (data === null || data === undefined) {
-      return [];
-    }
-    if (Array.isArray(data)) {
-      return data;
-    }
-    for (const key of ["items", "data", "results", "rows"]) {
-      if (data[key] && Array.isArray(data[key])) {
-        return data[key];
-      }
-    }
-    return [data];
-  }
-}
-
-class FileSourceRunner {
-  validate(spec) {
-    if (!spec.path) {
-      throw new WorkflowRuntimeError("File source requires path");
-    }
-  }
-  async run(spec, ctx) {
-    this.validate(spec);
-    const filePath = resolve(ctx.workingDir, spec.path);
-    ctx.log({ message: `Reading file: ${filePath}` });
-    try {
-      const content = await readFile(filePath, "utf-8");
-      const format = spec.format || "json";
-      const rows = format === "json" ? this.parseJSON(content) : this.parseCSV(content);
-      const limitedRows = ctx.dry && ctx.limit ? rows.slice(0, ctx.limit) : rows;
-      return {
-        name: "file_data",
-        rows: limitedRows
-      };
-    } catch (error) {
-      throw new WorkflowRuntimeError(`Failed to read file ${spec.path}: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  parseJSON(content) {
-    const data = JSON.parse(content);
-    if (Array.isArray(data)) {
-      return data;
-    }
-    if (data.rows && Array.isArray(data.rows)) {
-      return data.rows;
-    }
-    return [data];
-  }
-  parseCSV(content) {
-    const lines = content.trim().split(`
-`);
-    if (lines.length === 0)
-      return [];
-    const headers = lines[0].split(",").map((h) => h.trim());
-    const rows = [];
-    for (let i = 1;i < lines.length; i++) {
-      const values = lines[i].split(",").map((v) => v.trim());
-      const row = {};
-      for (let j = 0;j < headers.length; j++) {
-        row[headers[j]] = values[j] || "";
-      }
-      rows.push(row);
-    }
-    return rows;
-  }
-}
-
-class QueryRunner {
-  validate(spec) {
-    if (!spec.eqls || spec.eqls.trim().length === 0) {
-      throw new WorkflowRuntimeError("Query step requires non-empty eqls");
-    }
-    if (!spec.needs || spec.needs.length === 0) {
-      throw new WorkflowRuntimeError("Query step requires at least one dependency");
-    }
-  }
-  async run(spec, ctx) {
-    this.validate(spec);
-    const store = new EAVStore;
-    const inputDatasets = this.resolveInputDatasets(spec, ctx);
-    const entityType = inputDatasets[0]?.name || "item";
-    for (const dataset of inputDatasets) {
-      if (!dataset)
-        continue;
-      for (let i = 0;i < dataset.rows.length; i++) {
-        const row = dataset.rows[i];
-        const entityId = `${dataset.name}:${i}`;
-        const facts = jsonEntityFacts(entityId, row, dataset.name);
-        store.addFacts(facts);
-      }
-    }
-    let eqls = spec.eqls;
-    if (entityType !== "item") {
-      eqls = this.transformEQLForType(eqls, entityType, ctx.verbose);
-    }
-    try {
-      const processor = new EQLSProcessor;
-      const catalog = store.getCatalog();
-      processor.setSchema(catalog);
-      const evaluator = new DatalogEvaluator(store);
-      const parseResult = processor.process(eqls);
-      if (parseResult.errors.length > 0) {
-        throw new WorkflowRuntimeError(`Query parsing failed: ${parseResult.errors.map((e) => e.message).join("; ")}`);
-      }
-      const results = evaluator.evaluate(parseResult.query, parseResult.meta?.limit);
-      const rows = this.resultsToRows(results, parseResult.projectionMap);
-      const limitedRows = ctx.dry && ctx.limit ? rows.slice(0, ctx.limit) : rows;
-      return {
-        name: spec.out,
-        rows: limitedRows
-      };
-    } catch (error) {
-      throw new WorkflowRuntimeError(`Query execution failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  transformEQLForType(eqls, entityType, verbose) {
-    let transformed = eqls.replace(/FIND\s+item\s+AS/g, `FIND ${entityType} AS`);
-    if (verbose && transformed !== eqls) {
-      console.log(`  [QUERY TRANSFORM] 'item' -> '${entityType}'`);
-    }
-    return transformed;
-  }
-  resultsToRows(results, projectionMap) {
-    if (!results || !results.bindings || !Array.isArray(results.bindings)) {
-      return [];
-    }
-    const inverseMap = new Map;
-    if (projectionMap) {
-      for (const [original, bound] of projectionMap.entries()) {
-        inverseMap.set(bound, original);
-      }
-    }
-    return results.bindings.map((binding) => {
-      const row = {};
-      for (const [key, value] of Object.entries(binding)) {
-        const originalField = inverseMap.get(key) || key;
-        const cleanKey = originalField.replace(/^\?/, "");
-        row[cleanKey] = value;
-      }
-      return row;
-    });
-  }
-  resolveInputDatasets(spec, ctx) {
-    const datasets = [];
-    const seen = new Set;
-    if (spec.from) {
-      const dataset = ctx.getDataset(spec.from);
-      if (!dataset) {
-        throw new WorkflowRuntimeError(`Dataset '${spec.from}' not found for query step`);
-      }
-      datasets.push(dataset);
-      seen.add(dataset.name ?? spec.from);
-      ctx.log({ message: `from: ${spec.from}` });
-    } else {
-      for (const dependency of spec.needs) {
-        const dataset = ctx.getDatasetByStepId(dependency) || ctx.getDataset(dependency);
-        if (!dataset) {
-          throw new WorkflowRuntimeError(`Dependency '${dependency}' has no available dataset for query step`);
-        }
-        const key = dataset.name || dependency;
-        if (!seen.has(key)) {
-          datasets.push(dataset);
-          seen.add(key);
-        }
-      }
-    }
-    if (datasets.length === 0) {
-      const available = Object.keys(ctx.datasets).join(", ") || "none";
-      throw new WorkflowRuntimeError(`No input datasets resolved for query step. Available datasets: ${available}`);
-    }
-    return datasets;
-  }
-}
-
-class OutputRunner {
-  validate(spec) {
-    if (!spec.output) {
-      throw new WorkflowRuntimeError("Output step requires output configuration");
-    }
-    if (!spec.needs || spec.needs.length === 0) {
-      throw new WorkflowRuntimeError("Output step requires at least one dependency");
-    }
-  }
-  async run(spec, ctx) {
-    this.validate(spec);
-    const inputDataset = this.resolveOutputDataset(spec, ctx);
-    ctx.log({
-      message: `Using dataset '${inputDataset.name}' with ${inputDataset.rows.length} rows`
-    });
-    const allRows = inputDataset.rows;
-    const content = spec.output.format === "json" ? this.formatJSON(allRows) : this.formatCSV(allRows);
-    if (spec.output.kind === "file") {
-      await this.writeToFile(spec.output.path, content, ctx);
-    } else {
-      console.log(content);
-    }
-  }
-  formatJSON(rows) {
-    return JSON.stringify(rows, null, 2);
-  }
-  formatCSV(rows) {
-    if (rows.length === 0) {
-      return "";
-    }
-    const allKeys = new Set;
-    for (const row of rows) {
-      Object.keys(row).forEach((key) => allKeys.add(key));
-    }
-    const headers = Array.from(allKeys);
-    const csvRows = [headers.join(",")];
-    for (const row of rows) {
-      const values = headers.map((header) => {
-        const value = row[header];
-        if (value === null || value === undefined) {
-          return "";
-        }
-        const stringValue = String(value);
-        if (stringValue.includes(",") || stringValue.includes('"') || stringValue.includes(`
-`)) {
-          return `"${stringValue.replace(/"/g, '""')}"`;
-        }
-        return stringValue;
-      });
-      csvRows.push(values.join(","));
-    }
-    return csvRows.join(`
-`);
-  }
-  async writeToFile(path, content, ctx) {
-    try {
-      const dir = dirname(path);
-      await mkdir(dir, { recursive: true });
-      await writeFile(path, content, "utf-8");
-    } catch (error) {
-      throw new WorkflowRuntimeError(`Failed to write file ${path}: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  resolveOutputDataset(spec, ctx) {
-    const candidates = [];
-    for (const dependency of spec.needs) {
-      const datasetName = ctx.stepOutputs[dependency];
-      const dataset = datasetName && ctx.getDatasetByName(datasetName) || ctx.getDatasetByStepId(dependency) || ctx.getDataset(dependency);
-      if (dataset) {
-        candidates.push(dataset);
-      }
-    }
-    if (candidates.length === 0) {
-      const available = Object.keys(ctx.datasets).join(", ") || "none";
-      throw new WorkflowRuntimeError(`No datasets available for output step. Available datasets: ${available}`);
-    }
-    return candidates[candidates.length - 1];
-  }
-}
-var BUILTIN_RUNNERS = {
-  "source:http": new HttpSourceRunner,
-  "source:file": new FileSourceRunner,
-  "query:eqls": new QueryRunner,
-  "output:file": new OutputRunner,
-  "output:stdout": new OutputRunner
-};
-function getRunner(stepType, stepSpec) {
-  switch (stepType) {
-    case "source":
-      if (stepSpec.source?.kind === "http") {
-        return BUILTIN_RUNNERS["source:http"];
-      }
-      if (stepSpec.source?.kind === "file") {
-        return BUILTIN_RUNNERS["source:file"];
-      }
-      break;
-    case "query":
-      return BUILTIN_RUNNERS["query:eqls"];
-    case "output":
-      return BUILTIN_RUNNERS["output:file"];
-  }
-  throw new WorkflowRuntimeError(`No runner found for step type: ${stepType}`);
-}
-// src/workflows/cache.ts
-import { createHash } from "crypto";
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync } from "fs";
-import { dirname as dirname2, join } from "path";
-import { gzip, gunzip } from "zlib";
-import { promisify } from "util";
-var gzipAsync = promisify(gzip);
-var gunzipAsync = promisify(gunzip);
-
-class FileCacheManager {
-  cacheDir;
-  constructor(cacheDir = ".tql-cache") {
-    this.cacheDir = cacheDir;
-  }
-  async get(key) {
-    try {
-      const filePath = this.getCacheFilePath(key);
-      if (!existsSync(filePath)) {
-        return null;
-      }
-      const compressed = await readFile2(filePath);
-      const decompressed = await gunzipAsync(compressed);
-      const dataset = JSON.parse(decompressed.toString("utf-8"));
-      return dataset;
-    } catch (error) {
-      return null;
-    }
-  }
-  async set(key, dataset) {
-    try {
-      const filePath = this.getCacheFilePath(key);
-      await mkdir2(dirname2(filePath), { recursive: true });
-      const json = JSON.stringify(dataset);
-      const compressed = await gzipAsync(Buffer.from(json, "utf-8"));
-      await writeFile2(filePath, compressed);
-    } catch (error) {
-      console.warn(`Cache write failed for key ${key}:`, error);
-    }
-  }
-  getCacheFilePath(key) {
-    return join(this.cacheDir, `${key}.bin`);
-  }
-}
-
-class NoCacheManager {
-  async get() {
-    return null;
-  }
-  async set() {}
-}
-
-class ReadOnlyCacheManager {
-  delegate;
-  constructor(delegate) {
-    this.delegate = delegate;
-  }
-  async get(key) {
-    return this.delegate.get(key);
-  }
-  async set() {}
-}
-function createCacheKey(stepSpec, inputDatasetsHash, secretsHash) {
-  if (!stepSpec || typeof stepSpec !== "object") {
-    throw new Error("Invalid step specification for cache key");
-  }
-  if (!inputDatasetsHash || !/^[a-f0-9]+$/.test(inputDatasetsHash)) {
-    throw new Error("Invalid input datasets hash for cache key");
-  }
-  if (secretsHash && !/^[a-f0-9]+$/.test(secretsHash)) {
-    throw new Error("Invalid secrets hash for cache key");
-  }
-  const normalizedSpec = normalizeSpecForCache(stepSpec);
-  const specHash = createHash("sha256").update(JSON.stringify(normalizedSpec)).digest("hex").substring(0, 16);
-  const inputHash = inputDatasetsHash.substring(0, 16);
-  const secretsPart = secretsHash ? `_${secretsHash.substring(0, 8)}` : "";
-  const cacheKey = `${specHash}_${inputHash}${secretsPart}`;
-  if (!/^[a-f0-9_]+$/.test(cacheKey)) {
-    throw new Error("Generated cache key contains invalid characters");
-  }
-  return cacheKey;
-}
-function createInputDatasetsHash(datasets) {
-  const sortedNames = Object.keys(datasets).sort();
-  const dataToHash = sortedNames.map((name) => {
-    const dataset = datasets[name];
-    return {
-      name: dataset?.name,
-      rowCount: dataset?.rows.length,
-      sample: dataset?.rows.slice(0, 3)
-    };
-  });
-  return createHash("sha256").update(JSON.stringify(dataToHash)).digest("hex");
-}
-function createTemplateVarsHash(env, vars) {
-  const nonSecretVars = { ...vars };
-  for (const [key, value] of Object.entries(env)) {
-    if (!isSecretKey(key)) {
-      nonSecretVars[key] = value;
-    }
-  }
-  const sortedEntries = Object.entries(nonSecretVars).sort(([a], [b]) => a.localeCompare(b));
-  return createHash("sha256").update(JSON.stringify(sortedEntries)).digest("hex");
-}
-function isSecretKey(key) {
-  const secretPatterns = [
-    /^.*key$/i,
-    /^.*secret$/i,
-    /^.*token$/i,
-    /^.*password$/i,
-    /^.*pass$/i,
-    /^api_/i,
-    /^auth_/i
-  ];
-  return secretPatterns.some((pattern) => pattern.test(key));
-}
-function normalizeSpecForCache(spec) {
-  if (spec === null || spec === undefined) {
-    return spec;
-  }
-  if (Array.isArray(spec)) {
-    return spec.map(normalizeSpecForCache);
-  }
-  if (typeof spec === "object") {
-    const normalized = {};
-    const sortedKeys = Object.keys(spec).sort();
-    for (const key of sortedKeys) {
-      const value = spec[key];
-      if (key === "url" && typeof value === "string") {
-        normalized[key] = value.replace(/(\$)?\{\{\s*[^}]+\s*\}\}/g, "{{TEMPLATE_VAR}}");
-      } else {
-        normalized[key] = normalizeSpecForCache(value);
-      }
-    }
-    return normalized;
-  }
-  return spec;
-}
-function createCacheManager(mode, cacheDir) {
-  switch (mode) {
-    case "off":
-      return new NoCacheManager;
-    case "read":
-      return new ReadOnlyCacheManager(new FileCacheManager(cacheDir));
-    case "write":
-    default:
-      return new FileCacheManager(cacheDir);
-  }
-}
-async function withCache(cacheManager, cacheKey, operation, logger) {
-  const cached = await cacheManager.get(cacheKey);
-  if (cached) {
-    logger?.({ cache: "hit" });
-    return { result: cached, cacheHit: true };
-  }
-  logger?.({ cache: "miss" });
-  const result = await operation();
-  if (result && typeof result === "object" && "name" in result && "rows" in result) {
-    await cacheManager.set(cacheKey, result);
-    logger?.({ cache: "write" });
-  }
-  return { result, cacheHit: false };
-}
-// src/workflows/engine.ts
-import { readFile as readFile3 } from "fs/promises";
-import { dirname as dirname3, resolve as resolve2 } from "path";
-
-// src/workflows/log-levels.ts
-var LOG_LEVELS = {
-  DRY: "[DRY]",
-  START: "[START]",
-  RUN: "[RUN]",
-  DONE: "[DONE]",
-  FAIL: "[FAIL]",
-  INFO: "[INFO]",
-  LOG: "[LOG]"
-};
-
-// src/workflows/engine.ts
-class WorkflowEngine {
-  options;
-  datasetsByName = {};
-  datasetsByStepId = {};
-  stepOutputNames = {};
-  runId;
-  cacheManager;
-  events = [];
-  workingDir = process.cwd();
-  constructor(options = {}, cacheDir) {
-    this.options = options;
-    this.runId = `run_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
-    this.cacheManager = createCacheManager(options.cache || "write", cacheDir);
-  }
-  async executeWorkflowFile(filePath) {
-    this.workingDir = dirname3(resolve2(filePath));
-    const yamlContent = await readFile3(filePath, "utf-8");
-    const spec = parseWorkflow(yamlContent);
-    await this.executeWorkflow(spec);
-  }
-  async executeWorkflow(spec) {
-    if (this.options.dry) {
-      const limit = this.options.limit || 50;
-      const mapCap = 20;
-      console.log(`${LOG_LEVELS.DRY} DRY RUN (limit=${limit}, map cap=${mapCap})`);
-      const mapSources = spec.steps.filter((step) => step.type === "source" && step.source.mode === "map");
-      for (const source of mapSources) {
-        console.log(`  mapFrom=${source.source.mapFrom} cap=${mapCap}`);
-      }
-    }
-    this.logEvent("workflow", "started", {});
-    try {
-      validateWorkflowSemantics(spec);
-      const plan = createExecutionPlan(spec);
-      validateExecutionPlan(plan);
-      const env = {
-        ...process.env,
-        ...spec.env,
-        ...this.options.vars
-      };
-      for (const stepId of plan.order) {
-        const step = plan.steps.find((s) => s.id === stepId);
-        if (!step) {
-          throw new WorkflowRuntimeError(`Step not found: ${stepId}`);
-        }
-        await this.executeStep(step, env);
-      }
-      this.logEvent("workflow", "completed", {});
-    } catch (error) {
-      this.logEvent("workflow", "failed", {
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
-      if (error instanceof WorkflowValidationError) {
-        process.exit(1);
-      } else if (error instanceof WorkflowRuntimeError) {
-        process.exit(2);
-      } else {
-        process.exit(2);
-      }
-    }
-  }
-  async executeStep(step, env) {
-    const startTime = Date.now();
-    this.logEvent(step.id, "started", {});
-    try {
-      const ctx = {
-        datasets: this.datasetsByName,
-        stepOutputs: { ...this.stepOutputNames },
-        env,
-        vars: this.options.vars || {},
-        runId: this.runId,
-        dry: this.options.dry || false,
-        limit: this.options.limit,
-        cacheMode: this.options.cache || "write",
-        workingDir: this.workingDir,
-        verbose: this.options.verbose || false,
-        cache: this.cacheManager,
-        getDataset: (ref) => this.resolveDataset(ref),
-        getDatasetByName: (name) => this.datasetsByName[name],
-        getDatasetByStepId: (stepId) => this.datasetsByStepId[stepId],
-        log: (event) => this.logEvent(step.id, "info", event)
-      };
-      if (this.options.verbose) {
-        this.logVerboseInput(step);
-      }
-      const inputDatasetsHash = createInputDatasetsHash(this.datasetsByName);
-      const templateVarsHash = createTemplateVarsHash(env, ctx.vars);
-      const cacheKey = createCacheKey(step, inputDatasetsHash, templateVarsHash);
-      const { result, cacheHit } = await withCache(this.cacheManager, cacheKey, async () => {
-        const runner = getRunner(step.type, step);
-        let runnerSpec;
-        switch (step.type) {
-          case "source":
-            runnerSpec = step.source;
-            break;
-          case "query":
-          case "output":
-            runnerSpec = step;
-            break;
-          default:
-            runnerSpec = step;
-        }
-        return runner.run(runnerSpec, ctx);
-      }, (event) => this.logEvent(step.id, "cache", event));
-      if (result && step.out) {
-        const dataset = result;
-        dataset.name = step.out;
-        this.datasetsByName[step.out] = dataset;
-        this.datasetsByStepId[step.id] = dataset;
-        this.stepOutputNames[step.id] = step.out;
-      }
-      if (this.options.verbose) {
-        this.logVerboseOutput(step, result);
-      }
-      const duration = Date.now() - startTime;
-      const inputRows = this.getInputRowCount(step);
-      const outputRows = result && typeof result === "object" && "rows" in result ? result.rows.length : 0;
-      this.logEvent(step.id, "completed", {
-        durationMs: duration,
-        inputRows,
-        outputRows,
-        cache: cacheHit ? "hit" : "miss",
-        cacheKey
-      });
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      this.logEvent(step.id, "failed", {
-        durationMs: duration,
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
-      throw error;
-    }
-  }
-  getInputRowCount(step) {
-    if (!step.needs || step.needs.length === 0) {
-      return 0;
-    }
-    return step.needs.reduce((total, need) => {
-      const dataset = this.datasetsByStepId[need] || this.datasetsByName[need];
-      return total + (dataset?.rows.length || 0);
-    }, 0);
-  }
-  resolveDataset(ref) {
-    return this.datasetsByName[ref] || this.datasetsByStepId[ref];
-  }
-  logEvent(stepId, event, data = {}) {
-    const workflowEvent = {
-      runId: this.runId,
-      stepId,
-      event,
-      timestamp: Date.now(),
-      ...data
-    };
-    this.events.push(workflowEvent);
-    if (this.options.log === "json") {
-      console.log(JSON.stringify(workflowEvent));
-    } else {
-      this.logPretty(workflowEvent);
-    }
-  }
-  getCacheStatus(stepId) {
-    return "miss";
-  }
-  logPretty(event) {
-    const timestamp = new Date(event.timestamp).toLocaleTimeString();
-    switch (event.event) {
-      case "started":
-        if (event.stepId === "workflow") {
-          console.log(`${LOG_LEVELS.START} [${timestamp}] Starting workflow (${event.runId})`);
-        } else {
-          console.log(`${LOG_LEVELS.RUN} [${timestamp}] ${event.stepId}: Starting...`);
-        }
-        break;
-      case "completed":
-        if (event.stepId === "workflow") {
-          console.log(`${LOG_LEVELS.DONE} [${timestamp}] Workflow completed`);
-        } else {
-          const duration2 = event.durationMs ? `${event.durationMs}ms` : "";
-          const inputRows = event.inputRows !== undefined ? `${event.inputRows} in` : "";
-          const outputRows = event.outputRows !== undefined ? `${event.outputRows} out` : "";
-          const cache = event.cache ? `(${event.cache})` : "";
-          const cacheKey = event.cacheKey ? `[${event.cacheKey.slice(0, 8)}]` : "";
-          const details = [duration2, inputRows, outputRows, cache, cacheKey].filter(Boolean).join(", ");
-          console.log(`${LOG_LEVELS.DONE} [${timestamp}] ${event.stepId}: ${details}`);
-        }
-        break;
-      case "failed":
-        const duration = event.durationMs ? ` (${event.durationMs}ms)` : "";
-        console.log(`${LOG_LEVELS.FAIL} [${timestamp}] ${event.stepId}: Failed${duration}`);
-        if (event.error) {
-          console.log(`   Error: ${event.error}`);
-        }
-        break;
-      case "cache":
-        break;
-      case "info":
-        if ("message" in event && typeof event.message === "string") {
-          console.log(`${LOG_LEVELS.INFO} [${timestamp}] ${event.stepId}: ${event.message}`);
-        } else {
-          console.log(`${LOG_LEVELS.INFO} [${timestamp}] ${event.stepId}: ${JSON.stringify(event)}`);
-        }
-        break;
-      default:
-        console.log(`${LOG_LEVELS.LOG} [${timestamp}] ${event.stepId}: ${event.event}`);
-    }
-  }
-  logVerboseInput(step) {
-    if (!step.needs || step.needs.length === 0) {
-      console.log(`  \uD83D\uDCE5 INPUT: (no dependencies)`);
-      return;
-    }
-    for (const need of step.needs) {
-      const dataset = this.datasetsByStepId[need] || this.datasetsByName[need];
-      if (dataset && dataset.rows.length > 0) {
-        const sample = dataset.rows.slice(0, 3);
-        const schema = this.inferSchema(dataset.rows);
-        console.log(`  \uD83D\uDCE5 INPUT [${need}]: ${dataset.rows.length} rows`);
-        console.log(`     Schema: ${JSON.stringify(schema)}`);
-        console.log(`     Sample: ${JSON.stringify(sample).slice(0, 200)}`);
-      } else {
-        console.log(`  \uD83D\uDCE5 INPUT [${need}]: 0 rows (empty or not found)`);
-      }
-    }
-  }
-  logVerboseOutput(step, result) {
-    if (!result || typeof result !== "object" || !("rows" in result)) {
-      console.log(`  \uD83D\uDCE4 OUTPUT: (no data)`);
-      return;
-    }
-    const dataset = result;
-    if (dataset.rows.length === 0) {
-      console.log(`  \uD83D\uDCE4 OUTPUT: 0 rows (EMPTY - check for issues!)`);
-      return;
-    }
-    const sample = dataset.rows.slice(0, 3);
-    const schema = this.inferSchema(dataset.rows);
-    console.log(`  \uD83D\uDCE4 OUTPUT: ${dataset.rows.length} rows`);
-    console.log(`     Schema: ${JSON.stringify(schema)}`);
-    console.log(`     Sample: ${JSON.stringify(sample).slice(0, 200)}`);
-  }
-  inferSchema(rows) {
-    const schema = {};
-    if (rows.length === 0)
-      return schema;
-    for (const key of Object.keys(rows[0])) {
-      const value = rows[0][key];
-      schema[key] = typeof value;
-    }
-    return schema;
-  }
-  getEvents() {
-    return [...this.events];
-  }
-  getDatasets() {
-    return { ...this.datasetsByName };
-  }
-}
-export {
-  withCache,
-  validateWorkflowSemantics,
-  validateExecutionPlan,
-  parseWorkflow,
-  interpolateTemplate,
-  interpolateObject,
-  getStepDependencies,
-  getRunner,
-  getParallelGroups,
-  WorkflowEngine as default,
-  createTemplateVarsHash,
-  createInputDatasetsHash,
-  createExecutionPlan,
-  createCacheManager,
-  createCacheKey,
-  WorkflowValidationError,
-  WorkflowRuntimeError,
-  WorkflowEngine,
-  WORKFLOW_SCHEMA,
-  ReadOnlyCacheManager,
-  QueryRunner,
-  OutputRunner,
-  NoCacheManager,
-  HttpSourceRunner,
-  FileSourceRunner,
-  FileCacheManager,
-  BUILTIN_RUNNERS
-};