@remnic/coding-graph 9.3.759

package/dist/chunk-5I2DBHOQ.js

@@ -0,0 +1,1042 @@
+import {
+  MAX_TRAVERSE_PATHS_HOPS
+} from "./chunk-CPYJACC5.js";
+
+// src/cypher/query-parser.ts
+var CYPHER_LABEL_TO_DB_LABEL = {
+  Project: "project",
+  Package: "package",
+  Folder: "folder",
+  File: "file",
+  Module: "module",
+  Class: "class",
+  Function: "function",
+  Method: "method",
+  Interface: "interface",
+  Enum: "enum",
+  Type: "type",
+  Route: "route",
+  Resource: "resource"
+};
+var VALID_CYPHER_LABELS = Object.keys(
+  CYPHER_LABEL_TO_DB_LABEL
+).sort();
+var KEYWORDS = {
+  match: true,
+  where: true,
+  return: true,
+  limit: true,
+  and: true,
+  or: true,
+  true: true,
+  false: true,
+  null: true
+};
+var WRITE_OR_OUTSIDE_CLAUSES = {
+  create: "CREATE is a write clause; this Cypher layer is read-only (MATCH/WHERE/RETURN/LIMIT only).",
+  merge: "MERGE is a write clause; this Cypher layer is read-only.",
+  set: "SET is a write clause; this Cypher layer is read-only.",
+  delete: "DELETE is a write clause; this Cypher layer is read-only.",
+  detach: "DETACH DELETE is a write clause; this Cypher layer is read-only.",
+  remove: "REMOVE is a write clause; this Cypher layer is read-only.",
+  drop: "DROP is a write clause; this Cypher layer is read-only.",
+  call: "CALL { ... } subqueries are outside the read subset.",
+  yield: "YIELD is outside the read subset (only MATCH/WHERE/RETURN/LIMIT).",
+  union: "UNION combinator is outside the read subset.",
+  with: "WITH is outside the read subset (only MATCH/WHERE/RETURN/LIMIT).",
+  order: "ORDER BY is outside the read subset (use LIMIT, or post-sort in the caller).",
+  by: "ORDER BY is outside the read subset.",
+  skip: "SKIP is outside the read subset (use LIMIT).",
+  optional: "OPTIONAL MATCH is outside the read subset.",
+  explain: "EXPLAIN is outside the read subset.",
+  profile: "PROFILE is outside the read subset.",
+  use: "USE (graph routing) is outside the read subset.",
+  foreach: "FOREACH is a write clause; this Cypher layer is read-only.",
+  load: "LOAD CSV / LOAD FROM is outside the read subset.",
+  constraint: "CONSTRAINT is a DDL clause; this Cypher layer is read-only.",
+  index: "INDEX is a DDL clause; this Cypher layer is read-only.",
+  graph: "GRAPH is outside the read subset.",
+  unwind: "UNWIND is outside the read subset.",
+  distinct: "DISTINCT is outside the read subset (this layer does not dedupe).",
+  exists: "EXISTS is outside the read subset (use property comparisons).",
+  in: "IN is outside the read subset (use a property comparison).",
+  is_: "IS NULL / IS NOT NULL is outside the read subset.",
+  not: "NOT is outside the read subset (use positive comparisons or <>).",
+  starts: "STARTS WITH is outside the read subset.",
+  ends: "ENDS WITH is outside the read subset.",
+  contains: "CONTAINS is outside the read subset.",
+  regex: "=~ regex is outside the read subset.",
+  count: "COUNT(...) aggregation is outside the read subset.",
+  sum: "SUM(...) aggregation is outside the read subset.",
+  min: "MIN(...) aggregation is outside the read subset.",
+  max: "MAX(...) aggregation is outside the read subset.",
+  avg: "AVG(...) aggregation is outside the read subset.",
+  collect: "COLLECT(...) aggregation is outside the read subset.",
+  case: "CASE expressions are outside the read subset.",
+  when: "CASE expressions are outside the read subset.",
+  then: "CASE expressions are outside the read subset.",
+  else: "CASE expressions are outside the read subset.",
+  end: "CASE ... END is outside the read subset.",
+  as: "AS aliasing is outside the read subset (RETURN items project under their literal text).",
+  reduce: "REDUCE is outside the read subset.",
+  shortestpath: "shortestPath() is outside the read subset.",
+  all: "ALL(...) pattern predicate is outside the read subset.",
+  any: "ANY(...) pattern predicate is outside the read subset.",
+  none: "NONE(...) pattern predicate is outside the read subset.",
+  single: "SINGLE(...) pattern predicate is outside the read subset.",
+  size: "SIZE() is outside the read subset."
+};
+var Tokenizer = class {
+  src;
+  i = 0;
+  tokens = [];
+  constructor(src) {
+    this.src = src;
+  }
+  tokenize() {
+    while (this.i < this.src.length) {
+      const ch = this.src[this.i];
+      if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+        this.i += 1;
+        continue;
+      }
+      if (ch === "/" && this.src[this.i + 1] === "/") {
+        const nl = this.src.indexOf("\n", this.i);
+        this.i = nl === -1 ? this.src.length : nl + 1;
+        continue;
+      }
+      if (ch === "/" && this.src[this.i + 1] === "*") {
+        const end = this.src.indexOf("*/", this.i + 2);
+        if (end === -1) {
+          throw parseError(
+            this.i,
+            "Unterminated block comment. Supported grammar: MATCH/WHERE/RETURN/LIMIT."
+          );
+        }
+        this.i = end + 2;
+        continue;
+      }
+      const start = this.i;
+      if (ch === '"' || ch === "'") {
+        this.readString(ch, start);
+        continue;
+      }
+      if (isDigit(ch) || ch === "." && isDigit(this.src[this.i + 1])) {
+        this.readNumber(start);
+        continue;
+      }
+      if (isIdentStart(ch)) {
+        this.readWord(start);
+        continue;
+      }
+      const two = this.src.slice(this.i, this.i + 2);
+      const three = this.src.slice(this.i, this.i + 3);
+      if (three === "-->") {
+        this.push("ARROW_R", three, start);
+        continue;
+      }
+      if (three === "<--") {
+        this.push("ARROW_L", three, start);
+        continue;
+      }
+      if (two === "->") {
+        this.push("ARROW_R", two, start);
+        continue;
+      }
+      if (two === "<-") {
+        this.push("ARROW_L", two, start);
+        continue;
+      }
+      if (two === "--") {
+        this.push("DASHDASH", two, start);
+        continue;
+      }
+      if (two === "..") {
+        this.push("DOTDOT", two, start);
+        continue;
+      }
+      if (two === "<>" || two === "!=") {
+        this.push("NE", two, start);
+        continue;
+      }
+      if (two === ">=") {
+        this.push("GE", two, start);
+        continue;
+      }
+      if (two === "<=") {
+        this.push("LE", two, start);
+        continue;
+      }
+      switch (ch) {
+        case "(":
+          this.push("LPAREN", ch, start);
+          break;
+        case ")":
+          this.push("RPAREN", ch, start);
+          break;
+        case "[":
+          this.push("LBRACK", ch, start);
+          break;
+        case "]":
+          this.push("RBRACK", ch, start);
+          break;
+        case "{":
+          this.push("LBRACE", ch, start);
+          break;
+        case "}":
+          this.push("RBRACE", ch, start);
+          break;
+        case ":":
+          this.push("COLON", ch, start);
+          break;
+        case "|":
+          this.push("PIPE", ch, start);
+          break;
+        case ",":
+          this.push("COMMA", ch, start);
+          break;
+        case ".":
+          this.push("DOT", ch, start);
+          break;
+        case "*":
+          this.push("STAR", ch, start);
+          break;
+        case "-":
+          this.push("DASH", ch, start);
+          break;
+        case "=":
+          this.push("EQ", ch, start);
+          break;
+        case ">":
+          this.push("GT", ch, start);
+          break;
+        case "<":
+          this.push("LT", ch, start);
+          break;
+        default:
+          throw parseError(
+            start,
+            `Unexpected character ${JSON.stringify(ch)}. Supported grammar: MATCH (a:Label {p: "v"})-[:TYPE*1..3]->(b) WHERE ... RETURN ... LIMIT n.`
+          );
+      }
+    }
+    this.push("EOF", "", this.i);
+    return this.tokens;
+  }
+  push(type, text, pos) {
+    this.tokens.push({ type, text, pos });
+    this.i = pos + text.length;
+  }
+  readString(quote, start) {
+    let j = start + 1;
+    const chars = [];
+    while (j < this.src.length) {
+      const c = this.src[j];
+      if (c === "\\") {
+        chars.push(c);
+        chars.push(this.src[j + 1] ?? "");
+        j += 2;
+        continue;
+      }
+      if (c === quote) {
+        const text = chars.join("");
+        this.tokens.push({ type: "STRING", text, pos: start });
+        this.i = j + 1;
+        return;
+      }
+      chars.push(c);
+      j += 1;
+    }
+    throw parseError(start, "Unterminated string literal.");
+  }
+  readNumber(start) {
+    let j = start;
+    while (j < this.src.length && isDigit(this.src[j])) j += 1;
+    if (this.src[j] === "." && isDigit(this.src[j + 1])) {
+      j += 1;
+      while (j < this.src.length && isDigit(this.src[j])) j += 1;
+    }
+    if (this.src[j] === "e" || this.src[j] === "E") {
+      j += 1;
+      if (this.src[j] === "+" || this.src[j] === "-") j += 1;
+      while (j < this.src.length && isDigit(this.src[j])) j += 1;
+    }
+    const text = this.src.slice(start, j);
+    this.tokens.push({ type: "NUMBER", text, pos: start });
+    this.i = j;
+  }
+  readWord(start) {
+    let j = start;
+    while (j < this.src.length && isIdentPart(this.src[j])) j += 1;
+    const text = this.src.slice(start, j);
+    this.tokens.push({ type: "WORD", text, pos: start });
+    this.i = j;
+  }
+};
+function isDigit(c) {
+  return c >= "0" && c <= "9";
+}
+function isIdentStart(c) {
+  return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+}
+function isIdentPart(c) {
+  return isIdentStart(c) || isDigit(c);
+}
+var Parser = class {
+  tokens;
+  i = 0;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  parse() {
+    this.expectKeyword("match");
+    const match = this.parseMatch();
+    let where;
+    if (this.consumeKeyword("where")) {
+      where = this.parseWhere();
+    }
+    this.expectKeyword("return");
+    const returnItems = this.parseReturn();
+    let limit;
+    if (this.consumeKeyword("limit")) {
+      limit = this.parseNonNegativeInt("LIMIT");
+    }
+    const tok = this.peek();
+    if (tok.type !== "EOF") {
+      throw this.unsupportedAfter(tok);
+    }
+    this.validateAst(match, where, returnItems);
+    return { match, where, return: returnItems, limit };
+  }
+  // ── MATCH / pattern ────────────────────────────────────────────────────
+  parseMatch() {
+    const nodes = [this.parseNode()];
+    const rels = [];
+    while (this.startsWithRelationship()) {
+      const rel = this.parseRelationship();
+      nodes.push(this.parseNode());
+      rels.push(rel);
+    }
+    return { nodes, rels };
+  }
+  startsWithRelationship() {
+    const t = this.peek();
+    return t.type === "ARROW_L" || t.type === "DASHDASH" || t.type === "DASH";
+  }
+  parseNode() {
+    this.expect("LPAREN", 'a node pattern `(var:Label {p: "v"})`');
+    let varName;
+    const first = this.peek();
+    if (first.type === "WORD" && !this.isKeyword(first.text)) {
+      varName = first.text;
+      this.advance();
+    }
+    let label;
+    if (this.peek().type === "COLON") {
+      this.advance();
+      const lt = this.expect("WORD", "a label after `:`");
+      label = lt.text;
+    }
+    const properties = [];
+    if (this.peek().type === "LBRACE") {
+      this.advance();
+      if (this.peek().type !== "RBRACE") {
+        properties.push(this.parseProp());
+        while (this.peek().type === "COMMA") {
+          this.advance();
+          properties.push(this.parseProp());
+        }
+      }
+      this.expect("RBRACE", "closing `}` of the property map");
+    }
+    this.expect("RPAREN", "closing `)` of the node pattern");
+    return { varName, label, properties };
+  }
+  parseProp() {
+    const keyTok = this.expect("WORD", "a property key");
+    this.expect("COLON", "`:` between property key and value");
+    const value = this.parseLiteral();
+    return { key: keyTok.text, value };
+  }
+  /**
+   * Parse `<leftDash> [bracket] <rightDash>`. Direction is resolved from
+   * the two dash runs: `-[...]->` outgoing, `<-[...]-` incoming,
+   * `-[...]-` / `--[...]--` both. The bracket is required.
+   */
+  parseRelationship() {
+    const leftDir = this.consumeLeftDashRun();
+    if (this.peek().type !== "LBRACK") {
+      throw parseError(
+        this.peek().pos,
+        "Relationships must use a bracketed form, e.g. `-[:CALLS]->` or `-[:CALLS*1..3]->`. Bare arrows without `[...]` are not in the subset."
+      );
+    }
+    this.advance();
+    const types = [];
+    if (this.peek().type === "COLON") {
+      this.advance();
+      types.push(this.expect("WORD", "an edge type after `:[`").text);
+      while (this.peek().type === "PIPE") {
+        this.advance();
+        if (this.peek().type === "COLON") this.advance();
+        types.push(this.expect("WORD", "an edge type after `|`").text);
+      }
+    }
+    let minHops = 1;
+    let maxHops = 1;
+    let isVarLength = false;
+    if (this.peek().type === "STAR") {
+      this.advance();
+      const range = this.parseRange();
+      minHops = range.min;
+      maxHops = range.max;
+      isVarLength = true;
+    }
+    this.expect("RBRACK", "closing `]` of the relationship bracket");
+    const rightDir = this.consumeRightDashRun();
+    if (leftDir === "none" && rightDir === "none") {
+      throw parseError(
+        this.peek().pos,
+        "Relationships require dashes around the bracket, e.g. `-[:CALLS]->`, `<-[:CALLS]-`, or `-[:CALLS]-`. Bare `[...]` between nodes is not valid."
+      );
+    }
+    const direction = resolveDirection(leftDir, rightDir);
+    if (maxHops < minHops) {
+      throw parseError(
+        this.peek().pos,
+        `Relationship range max (${maxHops}) is less than min (${minHops}).`
+      );
+    }
+    return { direction, types, minHops, maxHops, isVarLength };
+  }
+  parseRange() {
+    const tok = this.peek();
+    const hasLower = tok.type === "NUMBER";
+    let min = 1;
+    let max = Infinity;
+    if (hasLower) {
+      const n = this.parseNonNegativeInt("the minimum hop count");
+      min = n;
+      max = n;
+    }
+    if (this.peek().type === "DOTDOT") {
+      this.advance();
+      if (this.peek().type === "NUMBER") {
+        max = this.parseNonNegativeInt("the maximum hop count");
+      } else {
+        throw parseError(
+          this.peek().pos,
+          "Unbounded variable-length `*..` is not supported. Specify a maximum, e.g. `*1..3`. The read subset rejects unbounded traversal.",
+          "unsupported_clause"
+        );
+      }
+    } else if (!hasLower) {
+      throw parseError(
+        tok.pos,
+        "Unbounded variable-length `*` is not supported. Specify a range, e.g. `*1..3` or `*2`. The read subset rejects unbounded traversal.",
+        "unsupported_clause"
+      );
+    }
+    if (min < 0 || max < 0) {
+      throw parseError(tok.pos, "Hop counts must be non-negative integers.");
+    }
+    return { min, max };
+  }
+  // ── dash-run consumption ───────────────────────────────────────────────
+  /**
+   * Left-side dash-run result. `"incoming"` = `<-` arrow; `"dash"` = bare
+   * `-`/`--` (direction-neutral — the OTHER side's arrow wins, or undirected
+   * if neither side has an arrow); `"none"` = nothing present.
+   */
+  consumeLeftDashRun() {
+    const t = this.peek();
+    if (t.type === "ARROW_L") {
+      this.advance();
+      return "incoming";
+    }
+    if (t.type === "DASHDASH" || t.type === "DASH") {
+      this.advance();
+      return "dash";
+    }
+    return "none";
+  }
+  /**
+   * Right-side dash-run result. `"outgoing"` = `->`/`-->` arrow; `"dash"`
+   * = bare `-`/`--` (direction-neutral); `"none"` = nothing present.
+   */
+  consumeRightDashRun() {
+    const t = this.peek();
+    if (t.type === "ARROW_R") {
+      this.advance();
+      return "outgoing";
+    }
+    if (t.type === "DASHDASH" || t.type === "DASH") {
+      this.advance();
+      return "dash";
+    }
+    return "none";
+  }
+  // ── WHERE ──────────────────────────────────────────────────────────────
+  parseWhere() {
+    const orGroups = [];
+    orGroups.push(this.parseAndGroup());
+    while (this.consumeKeyword("or")) {
+      orGroups.push(this.parseAndGroup());
+    }
+    return { orGroups };
+  }
+  parseAndGroup() {
+    const terms = [this.parseComparison()];
+    while (this.consumeKeyword("and")) {
+      terms.push(this.parseComparison());
+    }
+    return terms;
+  }
+  parseComparison() {
+    const varTok = this.expect(
+      "WORD",
+      'a variable in WHERE (e.g. `a.name = "foo"`)'
+    );
+    if (this.isKeyword(varTok.text)) {
+      throw parseError(
+        varTok.pos,
+        `Expected a variable name in WHERE but found keyword ${JSON.stringify(varTok.text)}.`
+      );
+    }
+    this.expect("DOT", "`.` between variable and property in WHERE");
+    const keyTok = this.expect("WORD", "a property name after `var.`");
+    const op = this.parseOp();
+    const value = this.parseLiteral();
+    return { varName: varTok.text, key: keyTok.text, op, value };
+  }
+  parseOp() {
+    const t = this.peek();
+    switch (t.type) {
+      case "EQ":
+        this.advance();
+        return "=";
+      case "NE":
+        this.advance();
+        return "<>";
+      case "GT":
+        this.advance();
+        return ">";
+      case "LT":
+        this.advance();
+        return "<";
+      case "GE":
+        this.advance();
+        return ">=";
+      case "LE":
+        this.advance();
+        return "<=";
+      default:
+        throw parseError(
+          t.pos,
+          "Expected a comparison operator (=, <>, !=, >, <, >=, <=) in WHERE."
+        );
+    }
+  }
+  // ── RETURN ─────────────────────────────────────────────────────────────
+  parseReturn() {
+    if (this.peek().type === "STAR") {
+      throw parseError(
+        this.peek().pos,
+        "`RETURN *` is outside the read subset. List the items to project explicitly, e.g. `RETURN a, b.name`.",
+        "unsupported_clause"
+      );
+    }
+    const items = [this.parseReturnItem()];
+    while (this.peek().type === "COMMA") {
+      this.advance();
+      items.push(this.parseReturnItem());
+    }
+    if (items.length === 0) {
+      throw parseError(this.peek().pos, "RETURN requires at least one item.");
+    }
+    return items;
+  }
+  parseReturnItem() {
+    const varTok = this.expect(
+      "WORD",
+      "a variable (or var.prop) in RETURN"
+    );
+    if (this.isKeyword(varTok.text)) {
+      throw parseError(
+        varTok.pos,
+        `Expected a variable name in RETURN but found keyword ${JSON.stringify(varTok.text)}.`
+      );
+    }
+    if (this.peek().type === "DOT") {
+      this.advance();
+      const keyTok = this.expect("WORD", "a property name after `var.`");
+      return { kind: "prop", varName: varTok.text, key: keyTok.text };
+    }
+    return { kind: "var", varName: varTok.text };
+  }
+  // ── numeric helpers ────────────────────────────────────────────────────
+  parseNonNegativeInt(label) {
+    const tok = this.peek();
+    if (tok.type === "NUMBER") {
+      const n = Number(tok.text);
+      if (!Number.isInteger(n) || n < 0) {
+        throw parseError(
+          tok.pos,
+          `${label} must be a non-negative integer; got ${JSON.stringify(tok.text)}.`
+        );
+      }
+      this.advance();
+      return n;
+    }
+    throw parseError(tok.pos, `Expected a non-negative integer for ${label}.`);
+  }
+  // ── literals ───────────────────────────────────────────────────────────
+  parseLiteral() {
+    const tok = this.peek();
+    let negate = false;
+    if (tok.type === "DASH") {
+      negate = true;
+      this.advance();
+    }
+    const t = negate ? this.peek() : tok;
+    if (t.type === "STRING") {
+      if (negate) {
+        throw parseError(t.pos, "Cannot negate a string literal.");
+      }
+      this.advance();
+      return t.text;
+    }
+    if (t.type === "NUMBER") {
+      this.advance();
+      const n = Number(t.text);
+      return negate ? -n : n;
+    }
+    if (t.type === "WORD") {
+      if (t.text.toLowerCase() === "true") {
+        if (negate) {
+          throw parseError(t.pos, "Cannot negate `true`.");
+        }
+        this.advance();
+        return true;
+      }
+      if (t.text.toLowerCase() === "false") {
+        if (negate) {
+          throw parseError(t.pos, "Cannot negate `false`.");
+        }
+        this.advance();
+        return false;
+      }
+      if (t.text.toLowerCase() === "null") {
+        if (negate) {
+          throw parseError(t.pos, "Cannot negate `null`.");
+        }
+        this.advance();
+        return null;
+      }
+      const outside = WRITE_OR_OUTSIDE_CLAUSES[t.text.toLowerCase()];
+      if (outside) {
+        throw parseError(t.pos, outside);
+      }
+    }
+    throw parseError(
+      tok.pos,
+      "Expected a literal value (string, number, true, false, or null)."
+    );
+  }
+  // ── AST validation ─────────────────────────────────────────────────────
+  validateAst(match, where, returnItems) {
+    const bound = /* @__PURE__ */ new Set();
+    for (const n of match.nodes) {
+      if (n.varName) bound.add(n.varName);
+    }
+    for (const n of match.nodes) {
+      if (n.label !== void 0 && !(n.label in CYPHER_LABEL_TO_DB_LABEL)) {
+        throw parseError(
+          0,
+          `Unknown label ${JSON.stringify(n.label)}. Valid labels: ${VALID_CYPHER_LABELS.join(", ")}.`,
+          "unknown_label",
+          [...VALID_CYPHER_LABELS]
+        );
+      }
+    }
+    if (where) {
+      for (const group of where.orGroups) {
+        for (const term of group) {
+          if (!bound.has(term.varName)) {
+            throw parseError(
+              0,
+              `WHERE references variable ${JSON.stringify(term.varName)} which is not bound by MATCH. Bound variables: ${[...bound].join(", ") || "(none)"}.`,
+              "unbound_variable"
+            );
+          }
+        }
+      }
+    }
+    for (const item of returnItems) {
+      if (!bound.has(item.varName)) {
+        throw parseError(
+          0,
+          `RETURN references variable ${JSON.stringify(item.varName)} which is not bound by MATCH. Bound variables: ${[...bound].join(", ") || "(none)"}.`,
+          "unbound_variable"
+        );
+      }
+    }
+  }
+  // ── token helpers ──────────────────────────────────────────────────────
+  peek() {
+    return this.tokens[this.i];
+  }
+  advance() {
+    const t = this.tokens[this.i];
+    if (this.i < this.tokens.length - 1) this.i += 1;
+    return t;
+  }
+  expect(type, what) {
+    const t = this.peek();
+    if (t.type !== type) {
+      throw parseError(
+        t.pos,
+        `Expected ${what} but found ${describeToken(t)}. Supported grammar: MATCH (a:Label {p: "v"})-[:TYPE*1..3]->(b) WHERE ... RETURN ... LIMIT n.`
+      );
+    }
+    return this.advance();
+  }
+  expectKeyword(kw) {
+    const t = this.peek();
+    if (t.type === "WORD" && t.text.toLowerCase() === kw) {
+      return this.advance();
+    }
+    if (t.type === "WORD") {
+      const outside = WRITE_OR_OUTSIDE_CLAUSES[t.text.toLowerCase()];
+      if (outside) {
+        throw parseError(t.pos, outside, "unsupported_clause");
+      }
+    }
+    throw parseError(
+      t.pos,
+      `Expected keyword ${kw.toUpperCase()} but found ${describeToken(t)}. Queries must start with MATCH and use only MATCH/WHERE/RETURN/LIMIT.`,
+      "parse_error"
+    );
+  }
+  consumeKeyword(kw) {
+    const t = this.peek();
+    if (t.type === "WORD" && t.text.toLowerCase() === kw) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  isKeyword(text) {
+    return KEYWORDS[text.toLowerCase()] === true;
+  }
+  unsupportedAfter(tok) {
+    const outside = WRITE_OR_OUTSIDE_CLAUSES[tok.text.toLowerCase()];
+    if (outside) {
+      return parseError(tok.pos, outside, "unsupported_clause");
+    }
+    return parseError(
+      tok.pos,
+      `Unexpected token ${describeToken(tok)} after the query. Only MATCH/WHERE/RETURN/LIMIT are supported.`,
+      "parse_error"
+    );
+  }
+};
+function resolveDirection(left, right) {
+  const leftArrow = left === "incoming";
+  const rightArrow = right === "outgoing";
+  if (leftArrow && rightArrow) {
+    throw parseError(
+      0,
+      "Conflicting relationship direction (e.g. `<-[...]->`). Use a consistent direction."
+    );
+  }
+  if (leftArrow) return "incoming";
+  if (rightArrow) return "outgoing";
+  return "both";
+}
+var CypherParseError = class extends Error {
+  code;
+  pos;
+  validLabels;
+  constructor(pos, message, code = "parse_error", validLabels) {
+    super(message);
+    this.name = "CypherParseError";
+    this.pos = pos;
+    this.code = code;
+    this.validLabels = validLabels;
+  }
+};
+function parseError(pos, message, code = "parse_error", validLabels) {
+  return new CypherParseError(pos, message, code, validLabels);
+}
+function describeToken(t) {
+  if (t.type === "EOF") return "end of input";
+  if (t.type === "WORD") return `identifier ${JSON.stringify(t.text)}`;
+  if (t.type === "STRING") return `string ${JSON.stringify(t.text)}`;
+  if (t.type === "NUMBER") return `number ${t.text}`;
+  return JSON.stringify(t.text);
+}
+function parseCypher(query) {
+  if (typeof query !== "string") {
+    return {
+      ok: false,
+      code: "invalid_query",
+      message: "Cypher query must be a string."
+    };
+  }
+  if (query.length === 0 || query.trim().length === 0) {
+    return {
+      ok: false,
+      code: "parse_error",
+      message: 'Empty query. Supported grammar: MATCH (a:Label {p: "v"})-[:TYPE*1..3]->(b) WHERE ... RETURN ... LIMIT n.'
+    };
+  }
+  try {
+    const tokens = new Tokenizer(query).tokenize();
+    const ast = new Parser(tokens).parse();
+    return { ok: true, ast };
+  } catch (e) {
+    if (e instanceof CypherParseError) {
+      return {
+        ok: false,
+        code: e.code,
+        message: e.message,
+        ...e.validLabels ? { validLabels: e.validLabels } : {}
+      };
+    }
+    return {
+      ok: false,
+      code: "parse_error",
+      message: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+var PROP_ALIASES = {
+  name: "name",
+  qualifiedname: "qualifiedName",
+  qualified_name: "qualifiedName",
+  label: "label",
+  kind: "label",
+  filepath: "filePath",
+  file_path: "filePath",
+  nodeid: "nodeId",
+  node_id: "nodeId",
+  id: "nodeId"
+};
+function nodeToValue(hit) {
+  return {
+    nodeId: hit.nodeId,
+    qualifiedName: hit.qualifiedName,
+    name: hit.name,
+    label: hit.label,
+    filePath: hit.filePath
+  };
+}
+function readProperty(node, key) {
+  const alias = PROP_ALIASES[key.toLowerCase()];
+  if (!alias) {
+    return null;
+  }
+  return node[alias];
+}
+function compareValues(a, op, b) {
+  if (a === null || b === null) {
+    if (op === "=" || op === "<>" || op === "!=") {
+      return false;
+    }
+    return false;
+  }
+  if (op === "=") return a === b;
+  if (op === "<>" || op === "!=") return a !== b;
+  if (typeof a !== typeof b) return false;
+  if (typeof a === "boolean") {
+    return false;
+  }
+  if (op === ">") return a > b;
+  if (op === "<") return a < b;
+  if (op === ">=") return a >= b;
+  if (op === "<=") return a <= b;
+  return false;
+}
+function pushFilterToSearch(query, key, value) {
+  if (typeof value !== "string") return;
+  if (value.includes("%") || value.includes("_")) return;
+  const k = key.toLowerCase();
+  if (k === "name" && query.namePattern === void 0) {
+    query.namePattern = value;
+  } else if ((k === "filepath" || k === "file_path") && query.filePattern === void 0) {
+    query.filePattern = value;
+  }
+}
+function executeAst(store, ast) {
+  const firstNode = ast.match.nodes[0];
+  const searchQuery = { limit: 1e3 };
+  if (firstNode.label !== void 0) {
+    searchQuery.label = CYPHER_LABEL_TO_DB_LABEL[firstNode.label];
+  }
+  for (const { key, value } of firstNode.properties) {
+    pushFilterToSearch(searchQuery, key, value);
+  }
+  if (ast.where && ast.where.orGroups.length === 1 && firstNode.varName) {
+    for (const term of ast.where.orGroups[0]) {
+      if (term.varName === firstNode.varName && term.op === "=") {
+        pushFilterToSearch(searchQuery, term.key, term.value);
+      }
+    }
+  }
+  const search = store.searchGraph(searchQuery);
+  if (!search.ok) {
+    return storeFailureToCypher(search);
+  }
+  let bindings = search.hits.map((hit) => nodeToValue(hit)).filter((node) => matchesNodePattern(node, firstNode)).map((node) => {
+    const varByName = /* @__PURE__ */ new Map();
+    if (firstNode.varName) varByName.set(firstNode.varName, node);
+    return { varByName, lastNode: node };
+  });
+  let truncated = false;
+  for (let idx = 0; idx < ast.match.rels.length; idx += 1) {
+    const rel = ast.match.rels[idx];
+    const nodePattern = ast.match.nodes[idx + 1];
+    const nextBindings = [];
+    if (rel.isVarLength && rel.maxHops > MAX_TRAVERSE_PATHS_HOPS) {
+      const range = rel.minHops === rel.maxHops ? `*${rel.maxHops}` : `*${rel.minHops}..${rel.maxHops}`;
+      return {
+        ok: false,
+        code: "invalid_query",
+        message: `Variable-length ${range} exceeds the maximum supported traversal depth (${MAX_TRAVERSE_PATHS_HOPS}). Narrow the range.`
+      };
+    }
+    for (const binding of bindings) {
+      const candidates = [];
+      if (rel.isVarLength) {
+        const tp = store.traversePaths({
+          start: binding.lastNode.nodeId,
+          direction: rel.direction,
+          ...rel.types.length > 0 ? { edgeTypes: rel.types } : {},
+          // Push minHops into the store so its maxPaths cap counts only
+          // in-range paths, not the shorter prefixes an exact *N must walk
+          // (cursor Bugbot: 'Path cap ignores hop minimum').
+          minHops: Math.max(1, rel.minHops),
+          maxHops: rel.maxHops
+        });
+        if (!tp.ok) {
+          if (tp.code === "unknown_start" || tp.code === "ambiguous_start" || tp.code === "invalid_query") {
+            continue;
+          }
+          return storeFailureToCypher(tp);
+        }
+        if (tp.truncated) truncated = true;
+        if (rel.minHops === 0) candidates.push(binding.lastNode);
+        for (const hit of tp.hits) {
+          candidates.push(nodeToValue(hit));
+        }
+      } else {
+        const t = store.traverse({
+          start: binding.lastNode.nodeId,
+          direction: rel.direction,
+          ...rel.types.length > 0 ? { edgeTypes: rel.types } : {},
+          maxDepth: rel.maxHops
+        });
+        if (!t.ok) {
+          if (t.code === "unknown_start" || t.code === "ambiguous_start" || t.code === "invalid_query") {
+            continue;
+          }
+          return storeFailureToCypher(t);
+        }
+        for (const hit of t.hits) {
+          if (hit.depth < rel.minHops || hit.depth > rel.maxHops) continue;
+          candidates.push(nodeToValue(hit));
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const node of candidates) {
+        if (seen.has(node.nodeId)) continue;
+        seen.add(node.nodeId);
+        if (!matchesNodePattern(node, nodePattern)) continue;
+        const varByName = new Map(binding.varByName);
+        if (nodePattern.varName) {
+          const existing = varByName.get(nodePattern.varName);
+          if (existing && existing.nodeId !== node.nodeId) continue;
+          varByName.set(nodePattern.varName, node);
+        }
+        nextBindings.push({ varByName, lastNode: node });
+      }
+    }
+    bindings = nextBindings;
+    if (bindings.length === 0) break;
+  }
+  if (ast.where) {
+    bindings = bindings.filter((b) => matchesWhere(b.varByName, ast.where));
+  }
+  if (ast.limit !== void 0) {
+    bindings = bindings.slice(0, ast.limit);
+  }
+  const columns = ast.return.map(
+    (item) => item.kind === "var" ? item.varName : `${item.varName}.${item.key}`
+  );
+  const rows = bindings.map((b) => {
+    const row = {};
+    ast.return.forEach((item) => {
+      const col = item.kind === "var" ? item.varName : `${item.varName}.${item.key}`;
+      const node = b.varByName.get(item.varName);
+      if (!node) {
+        row[col] = null;
+        return;
+      }
+      row[col] = item.kind === "var" ? node : readProperty(node, item.key);
+    });
+    return row;
+  });
+  return truncated ? { ok: true, columns, rows, truncated: true } : { ok: true, columns, rows };
+}
+function matchesNodePattern(node, pattern) {
+  if (pattern.label !== void 0) {
+    const dbLabel = CYPHER_LABEL_TO_DB_LABEL[pattern.label];
+    if (dbLabel !== void 0 && node.label !== dbLabel) return false;
+  }
+  for (const { key, value } of pattern.properties) {
+    const actual = readProperty(node, key);
+    if (!compareValues(actual, "=", value)) return false;
+  }
+  return true;
+}
+function matchesWhere(varByName, where) {
+  return where.orGroups.some(
+    (group) => group.every((term) => {
+      const node = varByName.get(term.varName);
+      if (!node) return false;
+      const actual = readProperty(node, term.key);
+      return compareValues(actual, term.op, term.value);
+    })
+  );
+}
+function storeFailureToCypher(f) {
+  switch (f.code) {
+    case "db_locked":
+      return { ok: false, code: "db_locked", message: "Database is locked." };
+    case "db_corrupt":
+      return { ok: false, code: "db_corrupt", message: "Database is corrupt." };
+    case "store_closed":
+      return { ok: false, code: "store_closed", message: "The graph store is closed." };
+    default:
+      return {
+        ok: false,
+        code: "db_error",
+        message: `Database error: ${f.code}`
+      };
+  }
+}
+function executeCypher(store, query) {
+  const parsed = parseCypher(query);
+  if (!parsed.ok) return parsed;
+  return executeAst(store, parsed.ast);
+}
+
+export {
+  CYPHER_LABEL_TO_DB_LABEL,
+  VALID_CYPHER_LABELS,
+  parseCypher,
+  executeAst,
+  executeCypher
+};
+//# sourceMappingURL=chunk-5I2DBHOQ.js.map