@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-clojure-analyzer-4OH7IWLB.js

@@ -0,0 +1,2818 @@
+import {
+  clojureExecutionHead,
+  clojureSymName
+} from "./chunk-2DE27DVC.js";
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-clojure-analyzer.ts
+var CLOJURE_CORE_BUILTINS = (function() {
+  const r = /* @__PURE__ */ Object.create(null);
+  const arr = [
+    "*",
+    "*'",
+    "*1",
+    "*2",
+    "*3",
+    "*data-readers*",
+    "*default-data-reader-fn*",
+    "*e",
+    "*print-length*",
+    "*print-level*",
+    "*print-namespace-maps*",
+    "*repl*",
+    "*verbose-defrecords*",
+    "+",
+    "+'",
+    "-",
+    "-'",
+    "->",
+    "->>",
+    "-cache-protocol-fn",
+    "-reset-methods",
+    ".",
+    "..",
+    "/",
+    "<",
+    "<=",
+    "=",
+    "==",
+    ">",
+    ">=",
+    "Double/parseDouble",
+    "EMPTY-NODE",
+    "Integer/parseInt",
+    "Long/parseLong",
+    "Math/abs",
+    "Math/ceil",
+    "Math/floor",
+    "Math/max",
+    "Math/min",
+    "Math/pow",
+    "Math/random",
+    "Math/round",
+    "Math/sqrt",
+    "NaN?",
+    "PrintWriter-on",
+    "StackTraceElement->vec",
+    "String/format",
+    "String/join",
+    "String/split",
+    "String/valueOf",
+    "System/currentTimeMillis",
+    "System/exit",
+    "System/gc",
+    "System/getProperty",
+    "System/nanoTime",
+    "Thread/currentThread",
+    "Thread/sleep",
+    "Throwable->map",
+    "UUID/randomUUID",
+    "abs",
+    "accessor",
+    "aclone",
+    "add-classpath",
+    "add-doc-and-meta",
+    "add-tap",
+    "add-watch",
+    "agent",
+    "agent-error",
+    "agent-errors",
+    "agent?",
+    "aget",
+    "alength",
+    "alias",
+    "all-ns",
+    "alter",
+    "alter-meta!",
+    "alter-var-root",
+    "amap",
+    "ancestors",
+    "and",
+    "any?",
+    "append!",
+    "apply",
+    "areduce",
+    "array-map",
+    "as->",
+    "aset",
+    "assert",
+    "assoc",
+    "assoc!",
+    "assoc-in",
+    "associative?",
+    "atom",
+    "atom?",
+    "await",
+    "await-for",
+    "await1",
+    "bases",
+    "bean",
+    "bigdec",
+    "bigint",
+    "biginteger",
+    "binding",
+    "binding-conveyor-fn",
+    "bit-and",
+    "bit-and-not",
+    "bit-clear",
+    "bit-count",
+    "bit-flip",
+    "bit-not",
+    "bit-or",
+    "bit-set",
+    "bit-shift-left",
+    "bit-shift-right",
+    "bit-test",
+    "bit-xor",
+    "boolean",
+    "boolean-array",
+    "boolean?",
+    "booleans",
+    "bound-fn",
+    "bound-fn*",
+    "bound?",
+    "bounded-count",
+    "butlast",
+    "byte",
+    "byte-array",
+    "byte?",
+    "bytes",
+    "bytes?",
+    "case",
+    "cast",
+    "cat",
+    "catch",
+    "char",
+    "char-array",
+    "char-escape-string",
+    "char-name-string",
+    "char?",
+    "chars",
+    "chunk",
+    "chunk-append",
+    "chunk-buffer",
+    "chunk-cons",
+    "chunk-first",
+    "chunk-next",
+    "chunk-rest",
+    "chunked-seq?",
+    "class",
+    "class?",
+    "clear-agent-errors",
+    "clojure-version",
+    "code-char",
+    "coll?",
+    "comment",
+    "commute",
+    "comp",
+    "comparator",
+    "compare",
+    "compare-and-set!",
+    "compile",
+    "complement",
+    "completing",
+    "concat",
+    "cond",
+    "cond->",
+    "cond->>",
+    "condp",
+    "conj",
+    "conj!",
+    "cons",
+    "constantly",
+    "construct-proxy",
+    "contains?",
+    "count",
+    "counted?",
+    "create-ns",
+    "create-struct",
+    "cycle",
+    "dec",
+    "dec'",
+    "decimal?",
+    "declare",
+    "dedupe",
+    "def",
+    "default-data-readers",
+    "definline",
+    "definterface",
+    "defmacro",
+    "defmethod",
+    "defmulti",
+    "defn",
+    "defn-",
+    "defonce",
+    "defprotocol",
+    "defrecord",
+    "defstruct",
+    "deftest",
+    "deftype",
+    "delay",
+    "delay?",
+    "delayed?",
+    "deliver",
+    "denominator",
+    "deref",
+    "derive",
+    "descendants",
+    "destructure",
+    "disj",
+    "disj!",
+    "dissoc",
+    "dissoc!",
+    "distinct",
+    "distinct?",
+    "do",
+    "doall",
+    "dorun",
+    "doseq",
+    "dosync",
+    "dotimes",
+    "doto",
+    "double",
+    "double-array",
+    "double?",
+    "doubles",
+    "drop",
+    "drop-last",
+    "drop-while",
+    "eduction",
+    "empty",
+    "empty?",
+    "ensure",
+    "ensure-reduced",
+    "enumeration-seq",
+    "equiv",
+    "error-handler",
+    "error-mode",
+    "eval",
+    "even?",
+    "every-pred",
+    "every?",
+    "ex-cause",
+    "ex-data",
+    "ex-info",
+    "ex-message",
+    "extend",
+    "extend-protocol",
+    "extend-type",
+    "extenders",
+    "extends?",
+    "false?",
+    "ffirst",
+    "file-seq",
+    "filter",
+    "filterv",
+    "finally",
+    "find",
+    "find-keyword",
+    "find-ns",
+    "find-protocol-impl",
+    "find-protocol-method",
+    "find-var",
+    "first",
+    "fjtask",
+    "flatten",
+    "float",
+    "float-array",
+    "float?",
+    "floats",
+    "flush",
+    "fn",
+    "fn?",
+    "fnext",
+    "fnil",
+    "fold",
+    "foldcat",
+    "folder",
+    "for",
+    "force",
+    "format",
+    "frequencies",
+    "future",
+    "future-call",
+    "future-cancel",
+    "future-cancelled?",
+    "future-done?",
+    "future?",
+    "gen-class",
+    "gen-interface",
+    "gensym",
+    "get",
+    "get-in",
+    "get-method",
+    "get-proxy-class",
+    "get-thread-bindings",
+    "get-validator",
+    "global-hierarchy",
+    "group-by",
+    "halt-when",
+    "hash",
+    "hash-combine",
+    "hash-map",
+    "hash-ordered-coll",
+    "hash-set",
+    "hash-unordered-coll",
+    "ident?",
+    "identical?",
+    "identity",
+    "if",
+    "if-let",
+    "if-not",
+    "if-some",
+    "ifn?",
+    "import",
+    "in-ns",
+    "inc",
+    "inc'",
+    "indexed?",
+    "infinite?",
+    "init-proxy",
+    "inst-ms",
+    "inst?",
+    "instance?",
+    "int",
+    "int-array",
+    "int?",
+    "integer?",
+    "interleave",
+    "intern",
+    "interpose",
+    "into",
+    "into-array",
+    "ints",
+    "io!",
+    "is",
+    "isa?",
+    "iterate",
+    "iteration",
+    "iterator-reduce!",
+    "iterator-seq",
+    "java.util.Date",
+    "join",
+    "juxt",
+    "keep",
+    "keep-indexed",
+    "key",
+    "keys",
+    "keyword",
+    "keyword?",
+    "last",
+    "lazy-cat",
+    "lazy-seq",
+    "let",
+    "letfn",
+    "line-seq",
+    "list",
+    "list*",
+    "list?",
+    "load",
+    "load-file",
+    "load-reader",
+    "load-string",
+    "loaded-libs",
+    "locking",
+    "long",
+    "long-array",
+    "longs",
+    "loop",
+    "lower-case",
+    "macroexpand",
+    "macroexpand-1",
+    "make-array",
+    "make-hierarchy",
+    "map",
+    "map-entry?",
+    "map-indexed",
+    "map?",
+    "mapcat",
+    "mapv",
+    "max",
+    "max-key",
+    "memfn",
+    "memoize",
+    "merge",
+    "merge-with",
+    "meta",
+    "method-sig",
+    "methods",
+    "min",
+    "min-key",
+    "mix-collection-hash",
+    "mk-am",
+    "mk-bound-fn",
+    "mod",
+    "monitor-enter",
+    "monitor-exit",
+    "monoid",
+    "munge",
+    "name",
+    "namespace",
+    "namespace-munge",
+    "nat-int?",
+    "neg-int?",
+    "neg?",
+    "new",
+    "newline",
+    "next",
+    "nfirst",
+    "nil?",
+    "nnext",
+    "not",
+    "not-any?",
+    "not-empty",
+    "not-every?",
+    "not=",
+    "ns",
+    "ns-aliases",
+    "ns-imports",
+    "ns-interns",
+    "ns-map",
+    "ns-name",
+    "ns-publics",
+    "ns-refers",
+    "ns-resolve",
+    "ns-unalias",
+    "ns-unmap",
+    "nth",
+    "nthnext",
+    "nthrest",
+    "num",
+    "number?",
+    "numerator",
+    "object-array",
+    "odd?",
+    "or",
+    "parents",
+    "parse-boolean",
+    "parse-double",
+    "parse-long",
+    "parse-uuid",
+    "partial",
+    "partition",
+    "partition-all",
+    "partition-by",
+    "partitionv",
+    "partitionv-all",
+    "pcalls",
+    "peek",
+    "persistent!",
+    "pmap",
+    "pool",
+    "pop",
+    "pop!",
+    "pop-thread-bindings",
+    "pos-int?",
+    "pos?",
+    "pr",
+    "pr-on",
+    "pr-str",
+    "prefer-method",
+    "prefers",
+    "primitives-classnames",
+    "print",
+    "print-ctor",
+    "print-simple",
+    "print-str",
+    "printf",
+    "println",
+    "println-str",
+    "prn",
+    "prn-str",
+    "process-annotation",
+    "promise",
+    "promise?",
+    "proxy",
+    "proxy-call-with-super",
+    "proxy-mappings",
+    "proxy-name",
+    "proxy-super",
+    "push-thread-bindings",
+    "pvalues",
+    "qualified-ident?",
+    "qualified-keyword?",
+    "qualified-symbol?",
+    "quot",
+    "quote",
+    "rand",
+    "rand-int",
+    "rand-nth",
+    "random-sample",
+    "random-uuid",
+    "range",
+    "ratio?",
+    "rational?",
+    "rationalize",
+    "re-find",
+    "re-groups",
+    "re-matcher",
+    "re-matches",
+    "re-pattern",
+    "re-seq",
+    "read",
+    "read+string",
+    "read-line",
+    "read-string",
+    "reader-conditional",
+    "reader-conditional?",
+    "realized?",
+    "record?",
+    "recur",
+    "reduce",
+    "reduce-kv",
+    "reduced",
+    "reduced?",
+    "reducer",
+    "reductions",
+    "ref",
+    "ref-history-count",
+    "ref-max-history",
+    "ref-min-history",
+    "ref-set",
+    "ref?",
+    "refer",
+    "refer-clojure",
+    "regexp?",
+    "reify",
+    "release-pending-sends",
+    "rem",
+    "remove",
+    "remove-all-methods",
+    "remove-method",
+    "remove-ns",
+    "remove-tap",
+    "remove-watch",
+    "repeat",
+    "repeatedly",
+    "replace",
+    "replicate",
+    "req!",
+    "require",
+    "requiring-resolve",
+    "reset!",
+    "reset-meta!",
+    "reset-vals!",
+    "resolve",
+    "rest",
+    "restart-agent",
+    "resultset-seq",
+    "reverse",
+    "reversible?",
+    "rseq",
+    "rsubseq",
+    "run!",
+    "satisfies?",
+    "second",
+    "select-keys",
+    "send",
+    "send-off",
+    "send-via",
+    "seq",
+    "seq-to-map-for-destructuring",
+    "seq?",
+    "seqable?",
+    "seque",
+    "sequence",
+    "sequential?",
+    "set",
+    "set!",
+    "set-agent-send-executor!",
+    "set-agent-send-off-executor!",
+    "set-error-handler!",
+    "set-error-mode!",
+    "set-validator!",
+    "set?",
+    "shift-left",
+    "shift-right",
+    "short",
+    "short-array",
+    "short?",
+    "shorts",
+    "shuffle",
+    "shutdown-agents",
+    "simple-ident?",
+    "simple-keyword?",
+    "simple-symbol?",
+    "slurp",
+    "some",
+    "some->",
+    "some->>",
+    "some-fn",
+    "some-vals",
+    "some?",
+    "sort",
+    "sort-by",
+    "sorted-map",
+    "sorted-map-by",
+    "sorted-set",
+    "sorted-set-by",
+    "sorted?",
+    "special-symbol?",
+    "spit",
+    "split",
+    "split-at",
+    "split-with",
+    "splitv-at",
+    "spread",
+    "str",
+    "stream-into!",
+    "stream-reduce!",
+    "stream-seq!",
+    "stream-transduce!",
+    "string?",
+    "struct",
+    "struct-map",
+    "subs",
+    "subseq",
+    "subvec",
+    "supers",
+    "swap!",
+    "swap-vals!",
+    "symbol",
+    "symbol?",
+    "sync",
+    "syntax-quote",
+    "tagged-literal",
+    "tagged-literal?",
+    "take",
+    "take-last",
+    "take-nth",
+    "take-while",
+    "tap->",
+    "tap>",
+    "test",
+    "testing",
+    "the-ns",
+    "thread-bound?",
+    "throw",
+    "time",
+    "to-array",
+    "to-array-2d",
+    "trampoline",
+    "transduce",
+    "transient",
+    "tree-seq",
+    "trim",
+    "trim-newline",
+    "triml",
+    "trimr",
+    "true?",
+    "try",
+    "type",
+    "unchecked-add",
+    "unchecked-add-int",
+    "unchecked-byte",
+    "unchecked-char",
+    "unchecked-dec",
+    "unchecked-dec-int",
+    "unchecked-divide",
+    "unchecked-divide-int",
+    "unchecked-double",
+    "unchecked-float",
+    "unchecked-inc",
+    "unchecked-inc-int",
+    "unchecked-int",
+    "unchecked-long",
+    "unchecked-multiply",
+    "unchecked-multiply-int",
+    "unchecked-negate",
+    "unchecked-negate-int",
+    "unchecked-remainder",
+    "unchecked-remainder-int",
+    "unchecked-short",
+    "unchecked-subtract",
+    "unchecked-subtract-int",
+    "underive",
+    "unquote",
+    "unquote-splicing",
+    "unreduced",
+    "unsigned-bit-shift-right",
+    "update",
+    "update-in",
+    "update-keys",
+    "update-proxy",
+    "update-vals",
+    "upper-case",
+    "uri?",
+    "use",
+    "uuid?",
+    "val",
+    "vals",
+    "var",
+    "var-get",
+    "var-set",
+    "var?",
+    "vary-meta",
+    "vec",
+    "vector",
+    "vector-of",
+    "vector?",
+    "volatile!",
+    "volatile?",
+    "vreset!",
+    "vswap!",
+    "when",
+    "when-first",
+    "when-let",
+    "when-not",
+    "when-some",
+    "while",
+    "with-bindings",
+    "with-bindings*",
+    "with-in-str",
+    "with-loading-context",
+    "with-local-vars",
+    "with-meta",
+    "with-open",
+    "with-out-str",
+    "with-precision",
+    "with-redefs",
+    "with-redefs-fn",
+    "xml-seq",
+    "zero?",
+    "zipmap"
+  ];
+  for (let i = 0; i < arr.length; i++) r[arr[i]] = true;
+  return r;
+})();
+var HOF_BUILTINS = (function() {
+  const r = /* @__PURE__ */ Object.create(null);
+  const arr = ["apply", "map", "reduce", "filter", "comp", "partial"];
+  for (let i = 0; i < arr.length; i++) r[arr[i]] = true;
+  return r;
+})();
+var STM_BUILTINS = (function() {
+  const r = /* @__PURE__ */ Object.create(null);
+  const arr = ["swap!", "reset!", "deref", "alter", "commute", "dosync", "ref", "atom", "agent", "send", "send-off"];
+  for (let i = 0; i < arr.length; i++) r[arr[i]] = true;
+  return r;
+})();
+var COMPLEXITY_BUILTINS = (function() {
+  const r = /* @__PURE__ */ Object.create(null);
+  const arr = ["if", "if-not", "if-let", "if-some", "when", "when-not", "when-let", "when-some", "cond", "condp", "case", "for", "while", "loop", "cond->", "cond->>", "some->", "some->>"];
+  for (let i = 0; i < arr.length; i++) r[arr[i]] = true;
+  return r;
+})();
+var IMPURE_BUILTINS = (function() {
+  const r = /* @__PURE__ */ Object.create(null);
+  const arr = ["println", "print", "def", "alter-var-root", "with-redefs", "set!", "swap!", "reset!", "alter"];
+  for (let i = 0; i < arr.length; i++) r[arr[i]] = true;
+  return r;
+})();
+var METHOD_IMPL_PARENT_FORMS = (function() {
+  const r = /* @__PURE__ */ Object.create(null);
+  const arr = ["defrecord", "deftype", "reify", "extend-type", "extend-protocol", "proxy", "defprotocol", "definterface"];
+  for (let i = 0; i < arr.length; i++) r[arr[i]] = true;
+  return r;
+})();
+function defNameNodeOf(node) {
+  let head = 0;
+  while (head < node.namedChildCount && node.namedChild(head)?.type === "meta_lit") head++;
+  let i = head + 1;
+  while (i < node.namedChildCount) {
+    const c = node.namedChild(i);
+    if (!c) return null;
+    if (c.type === "meta_lit") {
+      let inner = null;
+      for (let k = 0; k < c.namedChildCount; k++) {
+        const cand = c.namedChild(k);
+        if (cand && cand.type === "sym_lit") {
+          inner = cand;
+          break;
+        }
+      }
+      if (inner) return inner;
+      i++;
+      continue;
+    }
+    return c.type === "sym_lit" ? c : null;
+  }
+  return null;
+}
+function isPublishableName(name) {
+  if (name.length === 0) return false;
+  for (let i = 0; i < name.length; i++) {
+    const c = name.charCodeAt(i);
+    if (c === 32 || c === 9 || c === 10 || c === 13) return false;
+    if (c === 34 || c === 40 || c === 41 || c === 91 || c === 93 || c === 123 || c === 125 || c === 35 || c === 59) return false;
+  }
+  return true;
+}
+function isDefLikeHead(head) {
+  if (head.length < 3) return false;
+  if (head.charCodeAt(0) !== 100 || head.charCodeAt(1) !== 101 || head.charCodeAt(2) !== 102) return false;
+  if (head.length === 3) return true;
+  const c3 = head.charCodeAt(3);
+  if (c3 !== 45 && c3 !== 95) {
+    if (head.startsWith("default") || head.startsWith("define")) return false;
+    return true;
+  }
+  return true;
+}
+function staticInteropMember(head) {
+  const slash = head.lastIndexOf("/");
+  if (slash <= 0) return null;
+  const member = head.slice(slash + 1);
+  if (member.length === 0) return null;
+  const afterDot = head.charCodeAt(slash + 1) === 46;
+  const beforeDot = head.charCodeAt(slash - 1) === 46;
+  if (afterDot) {
+    const m = head.slice(slash + 2);
+    return m.length > 0 && head.slice(0, slash).length > 0 ? m : null;
+  }
+  if (beforeDot) {
+    const cls = head.slice(0, slash - 1);
+    return member.length > 0 && cls.length > 0 ? member : null;
+  }
+  return null;
+}
+function staticInteropClass(head) {
+  const slash = head.lastIndexOf("/");
+  if (slash <= 0) return null;
+  if (staticInteropMember(head) === null) return null;
+  const cls = head.charCodeAt(slash + 1) === 46 ? head.slice(0, slash) : head.slice(0, slash - 1);
+  return cls.length > 0 ? cls : null;
+}
+var isAnonArgShorthand = (s) => {
+  if (s.length === 0) return false;
+  if (s.charCodeAt(0) !== 37) return false;
+  if (s.length === 1) return true;
+  const c1 = s.charCodeAt(1);
+  if (c1 === 38) return s.length === 2;
+  if (c1 < 48 || c1 > 57) return false;
+  for (let i = 2; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 48 || c > 57) return false;
+  }
+  return true;
+};
+var CLOJURE_SPECIAL_FORMS = /* @__PURE__ */ new Set([
+  "def",
+  "do",
+  "fn",
+  "fn*",
+  "if",
+  "if*",
+  "let",
+  "let*",
+  "quote",
+  "quote*",
+  "var",
+  "var*",
+  "recur",
+  "recur*",
+  "throw",
+  "throw*",
+  "try",
+  "try*",
+  "catch",
+  "catch*",
+  "finally",
+  "new",
+  "new*",
+  "set!",
+  "monitor-enter",
+  "monitor-exit",
+  "case*",
+  "letfn*",
+  "loop*",
+  ".",
+  "&"
+]);
+function endsWithIgnoreCase(s, suffix) {
+  if (s.length < suffix.length) return false;
+  return s.slice(s.length - suffix.length).toLowerCase() === suffix.toLowerCase();
+}
+function whitespaceTokens(s) {
+  const out = [];
+  let cur = "";
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code <= 32 || code === 160) {
+      if (cur.length > 0) {
+        out.push(cur);
+        cur = "";
+      }
+    } else cur += s[i];
+  }
+  if (cur.length > 0) out.push(cur);
+  return out;
+}
+function carriesPrivateToken(s) {
+  for (const tok of whitespaceTokens(s)) {
+    let t = tok;
+    while (t.startsWith("^")) t = t.slice(1);
+    while (t.endsWith("}")) t = t.slice(0, -1);
+    if (t === ":private" || t === "private") return true;
+  }
+  return false;
+}
+function splitOnNamespaceSeparators(s) {
+  const out = [];
+  let start = 0;
+  let i = 0;
+  while (i < s.length) {
+    const c = s[i];
+    let len = 0;
+    if (c === "/" || c === ".") len = 1;
+    else if (c === ":") len = s[i + 1] === ":" ? 2 : 1;
+    if (len > 0) {
+      out.push(s.slice(start, i));
+      i += len;
+      start = i;
+    } else i += 1;
+  }
+  out.push(s.slice(start));
+  return out;
+}
+var RealClojureAnalyzer = class {
+  analyze(rootNode, content, filePath) {
+    if (endsWithIgnoreCase(filePath, ".edn")) return this.dataOnlyResult(content);
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const exportNamespaces = [];
+    const overrideCandidates = [];
+    const renderCandidates = [];
+    const errors = [];
+    const frameworks = {};
+    const patterns = {};
+    let currentNamespace = "user";
+    let sawNamespaceForm = false;
+    let namespaceAliases = /* @__PURE__ */ Object.create(null);
+    const referSegments = [];
+    const openReferSegment = (start) => {
+      let seg = referSegments[referSegments.length - 1];
+      if (!seg || seg.start !== start || seg.end !== Infinity) {
+        seg = { start, end: Infinity, names: /* @__PURE__ */ Object.create(null) };
+        referSegments.push(seg);
+      }
+      return seg.names;
+    };
+    let referTable = openReferSegment(0);
+    const referAt = (name, pos) => {
+      for (const seg of referSegments) if (pos >= seg.start && pos < seg.end) return seg.names[name] || "";
+      return "";
+    };
+    let activeFunction = null;
+    let totalCyclomaticComplexity = 0;
+    const readCondRanges = [];
+    const readCondOf = (pos) => {
+      for (let i = 0; i < readCondRanges.length; i++) {
+        const r = readCondRanges[i];
+        if (pos >= r.start && pos <= r.end) return r.start;
+      }
+      return 0;
+    };
+    if (rootNode.hasError) {
+      errors.push({
+        message: "Syntax Error bypassed",
+        range: this.nodeToRange(rootNode),
+        severity: "warning"
+      });
+    }
+    const symName = (node) => {
+      return clojureSymName(node);
+    };
+    const attrMapHasPrivate = (node, nameNode) => {
+      if (!nameNode) return false;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c || c.startIndex <= nameNode.startIndex) continue;
+        if (c.type === "vec_lit" || c.type === "list_lit") break;
+        if (c.type === "str_lit") continue;
+        if (c.type === "map_lit") {
+          const hasKey = (n) => {
+            if (n.type === "kwd_lit" && n.text === ":private") return true;
+            for (let k = 0; k < n.namedChildCount; k++) {
+              const kk = n.namedChild(k);
+              if (kk && hasKey(kk)) return true;
+            }
+            return false;
+          };
+          if (hasKey(c)) return true;
+        }
+      }
+      return false;
+    };
+    const metaHasPrivate = (nd) => {
+      if (!nd) return false;
+      const scan = (n) => {
+        if (n.type === "kwd_lit" && n.text === ":private") return true;
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c && scan(c)) return true;
+        }
+        return false;
+      };
+      if ((nd.type === "sym_lit" || nd.type === "sym_name") && carriesPrivateToken(nd.text ?? "")) return true;
+      for (let i = 0; i < nd.namedChildCount; i++) {
+        const c = nd.namedChild(i);
+        if (c && (c.type === "meta_lit" || c.type === "old_meta_lit") && scan(c)) return true;
+      }
+      if (nd.type === "meta_lit" || nd.type === "old_meta_lit") return scan(nd);
+      return false;
+    };
+    const formNameOf = (listNode) => {
+      const first = executionHead(listNode);
+      if (!first) return "";
+      if (first.type !== "sym_lit") return "";
+      return symName(first);
+    };
+    const clauseNameOf = (listNode) => {
+      const first = executionHead(listNode);
+      if (first && first.type === "kwd_lit") return first.childForFieldName("name")?.text || "";
+      return "";
+    };
+    const extractParams = (fnNode) => {
+      const params = [];
+      if (!fnNode) return params;
+      const seen = /* @__PURE__ */ new Set();
+      const collectBinding = (binding) => {
+        if (binding.type === "sym_lit") {
+          const name = symName(binding);
+          if (!name || name === "&" || seen.has(name)) return;
+          seen.add(name);
+          params.push({ name, type: "Any" });
+          return;
+        }
+        if (binding.type === "vec_lit") {
+          for (let i = 0; i < binding.namedChildCount; i++) {
+            const c = binding.namedChild(i);
+            if (c) collectBinding(c);
+          }
+          return;
+        }
+        if (binding.type === "map_lit") {
+          for (let i = 0; i < binding.namedChildCount; i++) {
+            const k = binding.namedChild(i);
+            if (!k) continue;
+            if (k.type === "kwd_lit") {
+              const kw = k.childForFieldName("name")?.text || "";
+              if (kw === "keys" || kw === "strs" || kw === "syms") {
+                const v = binding.namedChild(i + 1);
+                if (v && (v.type === "vec_lit" || v.type === "sym_lit")) {
+                  collectBinding(v);
+                  i++;
+                }
+              } else if (kw === "as") {
+                const v = binding.namedChild(i + 1);
+                if (v) {
+                  collectBinding(v);
+                  i++;
+                }
+              } else if (kw === "or") {
+                i++;
+              }
+            } else if (k.type === "sym_lit") {
+              collectBinding(k);
+            }
+          }
+          return;
+        }
+      };
+      let directVec = null;
+      const arityVecs = [];
+      for (let i = 0; i < fnNode.namedChildCount; i++) {
+        const c = fnNode.namedChild(i);
+        if (!c) continue;
+        if (c.type === "vec_lit") {
+          if (!directVec) directVec = c;
+        } else if (c.type === "list_lit" && c.namedChild(0)?.type === "vec_lit") arityVecs.push(c.namedChild(0));
+      }
+      if (directVec) collectBinding(directVec);
+      else for (const v of arityVecs) collectBinding(v);
+      return params;
+    };
+    const REQUIRED_LIB_PATTERNS = [
+      ["ring.adapter", "Ring"],
+      ["ring.util", "Ring"],
+      ["ring.middleware", "Ring"],
+      ["compojure.core", "Compojure"],
+      ["compojure.route", "Compojure"],
+      ["reagent.core", "Reagent"],
+      ["re-frame.core", "Re-frame"],
+      ["datomic.api", "Datomic"],
+      ["clojure.test", "Clojure.test"],
+      ["clojure.core.async", "Core.async"]
+    ];
+    const seenRelKeys = /* @__PURE__ */ new Set();
+    const relOrigins = /* @__PURE__ */ new Map();
+    const pushRel = (source, target, type, confidence, metadata = {}, line, callArity, origin) => {
+      const key = `${source}|${type}|${target}|${callArity ?? ""}|${line ?? ""}`;
+      if (seenRelKeys.has(key)) return;
+      seenRelKeys.add(key);
+      if (typeof origin === "number") relOrigins.set(relationships.length, origin);
+      const rel = {
+        source,
+        target,
+        type,
+        confidence,
+        metadata: callArity === void 0 ? metadata : { ...metadata, callArity },
+        ...typeof line === "number" && line > 0 ? { line_number: line } : {}
+      };
+      relationships.push(rel);
+    };
+    const resolveQualified = (name) => {
+      const slash = name.indexOf("/");
+      if (slash <= 0) return name;
+      const alias = name.slice(0, slash);
+      const rest = name.slice(slash + 1);
+      const resolved = namespaceAliases[alias];
+      return resolved ? `${resolved}/${rest}` : name;
+    };
+    const resolveCallee = (head, formName) => {
+      if (head && head.type === "sym_lit") {
+        const nsNode = head.childForFieldName("namespace");
+        const nameNode = head.childForFieldName("name");
+        if (nsNode && nameNode) {
+          const alias = nsNode.text;
+          const nm = nameNode.text;
+          const resolved = namespaceAliases[alias];
+          return { alias, name: nm, target: resolved ? `${resolved}/${nm}` : `${alias}/${nm}` };
+        }
+      }
+      return { alias: "", name: formName, target: formName };
+    };
+    const callArityOf = (list) => {
+      const head = executionHead(list);
+      if (!head) return 0;
+      let n = 0;
+      for (let i = 0; i < list.namedChildCount; i++) {
+        const c = list.namedChild(i);
+        if (!c || c.type === "comment" || c.type === "dis_expr") continue;
+        if (c.startIndex > head.startIndex) n++;
+      }
+      return n;
+    };
+    const stripCommentText = (text) => {
+      let i = 0;
+      while (i < text.length && text[i] === ";") i++;
+      return text.slice(i).trim();
+    };
+    const stripDocstringText = (text) => {
+      const t = text.trim();
+      if (t.length >= 2 && t.startsWith('"') && t.endsWith('"')) return t.slice(1, -1);
+      return t;
+    };
+    const leadingCommentTexts = (n) => {
+      const out = [];
+      let prev = n.previousNamedSibling;
+      let anchorRow = n.startPosition.row;
+      while (prev && prev.type === "comment") {
+        if (prev.startPosition.row !== anchorRow - 1) break;
+        if (!prev.text.startsWith(";;")) break;
+        const before = prev.previousNamedSibling;
+        if (before) {
+          const beforeEndRow = before.type === "comment" ? before.endPosition.row - 1 : before.endPosition.row;
+          if (before.startPosition.row === prev.startPosition.row) break;
+          if (beforeEndRow === prev.startPosition.row) break;
+        }
+        const t = stripCommentText(prev.text);
+        if (t.length > 0) out.unshift(t);
+        anchorRow = prev.startPosition.row;
+        prev = prev.previousNamedSibling;
+      }
+      return out;
+    };
+    const docstringOf = (formNode, style) => {
+      if (style === "always") {
+        const c2 = formNode.namedChild(2);
+        return c2 && c2.type === "str_lit" ? stripDocstringText(c2.text) : "";
+      }
+      if (style === "def") {
+        const c2 = formNode.namedChild(2);
+        const c3 = formNode.namedChild(3);
+        return c2 && c2.type === "str_lit" && c3 ? stripDocstringText(c2.text) : "";
+      }
+      for (let i = 2; i < formNode.namedChildCount; i++) {
+        const c = formNode.namedChild(i);
+        if (!c) continue;
+        if (c.type === "str_lit") {
+          const next = formNode.namedChild(i + 1);
+          const beforeParams = next !== null && (next.type === "vec_lit" || next.type === "list_lit" && next.namedChild(0)?.type === "vec_lit");
+          return beforeParams ? stripDocstringText(c.text) : "";
+        }
+        if (c.type === "vec_lit" || c.type === "list_lit") return "";
+      }
+      return "";
+    };
+    const attachDocs = (sym, formNode, style) => {
+      const doc = docstringOf(formNode, style);
+      const comments = leadingCommentTexts(formNode);
+      if (doc) {
+        sym.comments = comments.length > 0 ? [...comments, doc] : [doc];
+        sym.docstring = doc;
+      } else if (comments.length > 0) {
+        sym.comments = comments;
+        sym.docstring = comments.join(" ");
+      }
+    };
+    const pushImport = (fromNs, lib, line, extra) => {
+      if (!fromNs || !lib || fromNs === lib) return;
+      pushRel(
+        fromNs,
+        lib,
+        ASTEngine.RelationshipType.Imports,
+        1,
+        { clojureSpecific: true, isLibraryDep: true, isImport: true, evidenceClass: "structural", ...extra ?? {} },
+        line
+      );
+    };
+    const isTopLevelDirective = (n) => {
+      for (let p = n.parent; p; p = p.parent) {
+        if (p.type === "source") return true;
+        if (p.type === "list_lit" || p.type === "vec_lit" || p.type === "map_lit" || p.type === "set_lit") return false;
+      }
+      return false;
+    };
+    const handleLibNode = (rawNode) => {
+      const spec = rawNode.type === "quoting_lit" ? rawNode.namedChild(0) ?? rawNode : rawNode;
+      if (spec.type === "read_cond_lit" || spec.type === "splicing_read_cond_lit") {
+        for (let i = 0; i < spec.namedChildCount; i++) {
+          const c = spec.namedChild(i);
+          if (!c) continue;
+          if (c.type === "vec_lit" || c.type === "list_lit" || c.type === "sym_lit" || c.type === "quoting_lit" || c.type === "read_cond_lit" || c.type === "splicing_read_cond_lit") handleLibNode(c);
+        }
+        return;
+      }
+      if (spec.type === "vec_lit") {
+        let libNameNode = spec.namedChild(0);
+        while (libNameNode && libNameNode.type === "meta_lit") {
+          let inner = null;
+          for (let k = 0; k < libNameNode.namedChildCount; k++) {
+            const cand = libNameNode.namedChild(k);
+            if (cand && cand.type === "sym_lit") {
+              inner = cand;
+              break;
+            }
+          }
+          libNameNode = inner;
+        }
+        const libName = libNameNode && libNameNode.type === "str_lit" ? stripDocstringText(libNameNode.text) : symName(libNameNode);
+        if (!libName) return;
+        let alias = "";
+        let referNames = [];
+        const subNames = [];
+        let sawKwd = false;
+        let hasAsAlias = false;
+        for (let k = 1; k < spec.namedChildCount; k++) {
+          const part = spec.namedChild(k);
+          if (!part) continue;
+          if (part.type === "kwd_lit") {
+            sawKwd = true;
+            const kw = part.childForFieldName("name")?.text || "";
+            if ((kw === "as" || kw === "as-alias") && k + 1 < spec.namedChildCount) {
+              alias = symName(spec.namedChild(k + 1));
+              if (kw === "as-alias") hasAsAlias = true;
+            } else if ((kw === "refer" || kw === "only") && k + 1 < spec.namedChildCount) {
+              const refVec = spec.namedChild(k + 1);
+              if (refVec && (refVec.type === "vec_lit" || refVec.type === "list_lit")) {
+                for (let r = 0; r < refVec.namedChildCount; r++) {
+                  const rn = refVec.namedChild(r);
+                  if (rn && rn.type === "sym_lit") referNames.push(symName(rn));
+                }
+              }
+            } else if (kw === "rename" && k + 1 < spec.namedChildCount) {
+              const renameMap = spec.namedChild(k + 1);
+              if (renameMap && renameMap.type === "map_lit") {
+                for (let r = 1; r < renameMap.namedChildCount; r += 2) {
+                  const v = renameMap.namedChild(r);
+                  if (v && v.type === "sym_lit") referNames.push(symName(v));
+                }
+              }
+            }
+          } else if (part.type === "sym_lit") {
+            subNames.push(symName(part));
+          } else if (part.type === "vec_lit") {
+            const prev = spec.namedChild(k - 1);
+            if (prev && prev.type === "kwd_lit") continue;
+            const sub = symName(part.namedChild(0));
+            if (!sub) continue;
+            const full = `${libName}.${sub}`;
+            let subAlias = "";
+            for (let q = 1; q < part.namedChildCount; q++) {
+              const pp = part.namedChild(q);
+              if (pp && pp.type === "kwd_lit" && (pp.childForFieldName("name")?.text || "") === "as") {
+                const av = part.namedChild(q + 1);
+                if (av) subAlias = symName(av);
+              }
+            }
+            if (subAlias) namespaceAliases[subAlias] = full;
+            if (full !== currentNamespace) pushRel(currentNamespace, full, ASTEngine.RelationshipType.References, 0.9, { clojureSpecific: true, isLibraryDep: true }, part.startPosition.row + 1);
+            pushImport(currentNamespace, full, part.startPosition.row + 1);
+          }
+        }
+        if (alias) namespaceAliases[alias] = libName;
+        if (referNames.length > 0 && libName) for (const rn of referNames) referTable[rn] = libName;
+        const items = referNames.length > 0 ? referNames : subNames.length > 0 && !sawKwd ? subNames : alias ? [alias] : ["*"];
+        if (!hasAsAlias) {
+          imports.push({ module: libName, items: [...items], type: "named", isExternal: true, line: (libNameNode ?? spec).startPosition.row + 1 });
+          if (libName !== currentNamespace) pushRel(currentNamespace, libName, ASTEngine.RelationshipType.References, 0.9, { clojureSpecific: true, isLibraryDep: true }, (libNameNode ?? spec).startPosition.row + 1);
+          pushImport(currentNamespace, libName, (libNameNode ?? spec).startPosition.row + 1);
+          for (const [needle, fw] of REQUIRED_LIB_PATTERNS) {
+            if (libName.startsWith(needle)) frameworks[fw] = true;
+          }
+        }
+        if (subNames.length > 0 && !sawKwd) patterns["Java Interoperability"] = true;
+      } else if (spec.type === "list_lit") {
+        const pkgNode = spec.namedChild(0);
+        const pkg = symName(pkgNode);
+        if (!pkg) return;
+        if (pkg !== currentNamespace) pushRel(currentNamespace, pkg, ASTEngine.RelationshipType.References, 0.9, { clojureSpecific: true, isLibraryDep: true, isImport: true }, (pkgNode ?? spec).startPosition.row + 1);
+        pushImport(currentNamespace, pkg, (pkgNode ?? spec).startPosition.row + 1);
+        for (let k = 1; k < spec.namedChildCount; k++) {
+          const cls = spec.namedChild(k);
+          if (!cls) continue;
+          if (cls.type === "list_lit") {
+            const subName = symName(cls.namedChild(0));
+            if (!subName) continue;
+            const full = `${pkg}.${subName}`;
+            for (let q = 1; q < cls.namedChildCount; q++) {
+              const pp = cls.namedChild(q);
+              if (pp && pp.type === "kwd_lit" && (pp.childForFieldName("name")?.text || "") === "as") {
+                const av = cls.namedChild(q + 1);
+                const subAlias = av ? symName(av) : "";
+                if (subAlias) namespaceAliases[subAlias] = full;
+              }
+            }
+            if (full !== currentNamespace) pushRel(currentNamespace, full, ASTEngine.RelationshipType.References, 0.9, { clojureSpecific: true, isLibraryDep: true }, cls.startPosition.row + 1);
+            pushImport(currentNamespace, full, cls.startPosition.row + 1);
+          } else if (cls.type === "sym_lit") {
+            imports.push({ module: pkg, items: [symName(cls)], type: "named", isExternal: true, line: cls.startPosition.row + 1 });
+            patterns["Java Interoperability"] = true;
+          }
+        }
+      } else if (spec.type === "sym_lit") {
+        const libName = symName(spec);
+        if (libName) {
+          imports.push({ module: libName, items: ["*"], type: "named", isExternal: true, line: spec.startPosition.row + 1 });
+          if (libName !== currentNamespace) pushRel(currentNamespace, libName, ASTEngine.RelationshipType.References, 0.9, { clojureSpecific: true, isLibraryDep: true }, spec.startPosition.row + 1);
+          pushImport(currentNamespace, libName, spec.startPosition.row + 1);
+          for (const [needle, fw] of REQUIRED_LIB_PATTERNS) {
+            if (libName.startsWith(needle)) frameworks[fw] = true;
+          }
+        }
+      }
+    };
+    const protocolsOfExtendingForm = (parent, parentForm) => {
+      if (!parent) return [];
+      const out = [];
+      if (parentForm === "extend-protocol") {
+        const p = symName(parent.namedChild(1));
+        return p ? [p] : [];
+      }
+      if (parentForm === "defrecord" || parentForm === "deftype") {
+        let sawFields = false;
+        for (let i = 2; i < parent.namedChildCount; i++) {
+          const c = parent.namedChild(i);
+          if (!c) continue;
+          if (!sawFields) {
+            if (c.type === "vec_lit") sawFields = true;
+            continue;
+          }
+          if (c.type === "sym_lit") {
+            const n = symName(c);
+            if (n) out.push(n);
+          }
+        }
+        return out;
+      }
+      if (parentForm === "extend-type") {
+        for (let i = 2; i < parent.namedChildCount; i++) {
+          const c = parent.namedChild(i);
+          if (c && c.type === "sym_lit") {
+            const n = symName(c);
+            if (n) out.push(n);
+          }
+        }
+        return out;
+      }
+      return [];
+    };
+    const typeNameOf = (n) => {
+      if (!n) return "";
+      if (n.type === "nil_lit") return "nil";
+      if (n.type === "meta_lit") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const inner = typeNameOf(n.namedChild(i));
+          if (inner) return inner;
+        }
+        return "";
+      }
+      if (n.type !== "sym_lit") return "";
+      return symName(n);
+    };
+    const methodImplOwner = (implNode, parentForm) => {
+      const parent = implNode.parent;
+      if ((parentForm === "defrecord" || parentForm === "deftype" || parentForm === "extend-type") && parent) {
+        return typeNameOf(parent.namedChild(1));
+      }
+      if (parentForm === "extend-protocol") {
+        let prev = implNode.previousNamedSibling;
+        while (prev && prev.type !== "sym_lit" && prev.type !== "nil_lit") prev = prev.previousNamedSibling;
+        return prev ? typeNameOf(prev) : "";
+      }
+      return activeFunction ? activeFunction.name : currentNamespace;
+    };
+    const executionHead = (list) => {
+      return clojureExecutionHead(list);
+    };
+    const headStartIndex = (list) => {
+      const h = executionHead(list);
+      return h ? h.startIndex : list.startIndex;
+    };
+    const shadowRanges = [];
+    const shadowIndex = /* @__PURE__ */ new Map();
+    const indexShadowRange = (name, start, end) => {
+      const list = shadowIndex.get(name);
+      if (list) list.push({ start, end });
+      else shadowIndex.set(name, [{ start, end }]);
+    };
+    const DEF_NAME_HEADS = /* @__PURE__ */ Object.create(null);
+    for (const h of ["def", "defn", "defn-", "defmacro", "defonce", "defmulti", "defmethod", "deftest", "declare"]) DEF_NAME_HEADS[h] = true;
+    const PROTO_SIG_PARENTS = /* @__PURE__ */ Object.create(null);
+    for (const h of ["defprotocol", "definterface"]) PROTO_SIG_PARENTS[h] = true;
+    const BINDING_VEC_HEADS = /* @__PURE__ */ Object.create(null);
+    for (const h of ["let", "let*", "loop", "loop*", "when-let", "if-let", "when-some", "if-some", "when-first", "binding", "for", "doseq", "dotimes", "with-open", "with-local-vars", "with-bindings", "letfn"]) BINDING_VEC_HEADS[h] = true;
+    const FN_PARAM_HEADS = /* @__PURE__ */ Object.create(null);
+    for (const h of ["fn", "defn", "defn-", "defmacro", "defmethod", "deftest"]) FN_PARAM_HEADS[h] = true;
+    const shadowRangeOf = (candidate) => {
+      const nm = symName(candidate);
+      const parent = candidate.parent;
+      if (!parent) return null;
+      if (parent.type === "list_lit") {
+        const head = formNameOf(parent);
+        if (DEF_NAME_HEADS[head] && parent.namedChild(1)?.startIndex === candidate.startIndex) {
+          return { name: nm, start: parent.endIndex, end: Infinity };
+        }
+        if (parent.namedChild(0)?.startIndex === candidate.startIndex) {
+          const specVec = parent.parent;
+          if (specVec && specVec.type === "vec_lit") {
+            const letfnForm = specVec.parent;
+            if (letfnForm && letfnForm.type === "list_lit" && formNameOf(letfnForm) === "letfn" && letfnForm.namedChild(1)?.startIndex === specVec.startIndex) {
+              return { name: nm, start: letfnForm.startIndex, end: letfnForm.endIndex };
+            }
+          }
+          const declForm = parent.parent;
+          if (declForm && declForm.type === "list_lit" && PROTO_SIG_PARENTS[formNameOf(declForm)] && declForm.namedChild(0)?.startIndex !== parent.startIndex) {
+            return { name: nm, start: declForm.endIndex, end: Infinity };
+          }
+        }
+        return null;
+      }
+      if (parent.type === "vec_lit") {
+        const gp = parent.parent;
+        if (!gp || gp.type !== "list_lit") return null;
+        const head = formNameOf(gp);
+        if (FN_PARAM_HEADS[head]) {
+          for (let i = 0; i < gp.namedChildCount; i++) {
+            const c = gp.namedChild(i);
+            if (c?.type === "vec_lit") return c.startIndex === parent.startIndex ? { name: nm, start: gp.startIndex, end: gp.endIndex } : null;
+          }
+          return null;
+        }
+        if (BINDING_VEC_HEADS[head] && gp.namedChild(1)?.startIndex === parent.startIndex) {
+          return { name: nm, start: gp.startIndex, end: gp.endIndex };
+        }
+        if (gp.namedChild(0)?.startIndex === parent.startIndex) {
+          const ggp = gp.parent;
+          if (ggp && ggp.type === "list_lit" && FN_PARAM_HEADS[formNameOf(ggp)]) {
+            return { name: nm, start: gp.startIndex, end: gp.endIndex };
+          }
+        }
+        {
+          const specVec = gp.parent;
+          if (specVec && specVec.type === "vec_lit") {
+            const letfnForm = specVec.parent;
+            if (letfnForm && letfnForm.type === "list_lit" && formNameOf(letfnForm) === "letfn" && letfnForm.namedChild(1)?.startIndex === specVec.startIndex) {
+              return { name: nm, start: gp.startIndex, end: gp.endIndex };
+            }
+          }
+        }
+        return null;
+      }
+      return null;
+    };
+    const bindingStack = [rootNode];
+    while (bindingStack.length > 0) {
+      const candidate = bindingStack.pop();
+      if (candidate.type === "dis_expr" || candidate.type === "quoting_lit") continue;
+      if (candidate.type === "sym_lit" && CLOJURE_CORE_BUILTINS[symName(candidate)]) {
+        const range = shadowRangeOf(candidate);
+        if (range) {
+          shadowRanges.push(range);
+          indexShadowRange(range.name, range.start, range.end);
+        }
+      }
+      for (let i = 0; i < candidate.namedChildCount; i++) {
+        const child = candidate.namedChild(i);
+        if (child) bindingStack.push(child);
+      }
+    }
+    const isShadowedAt = (name, pos) => {
+      const list = shadowIndex.get(name);
+      if (list === void 0) return false;
+      for (let i = 0; i < list.length; i++) {
+        const r = list[i];
+        if (pos >= r.start && pos < r.end) return true;
+      }
+      return false;
+    };
+    const isCoreCallSuppressed = (name, pos) => {
+      if (!name || !CLOJURE_CORE_BUILTINS[name]) return false;
+      if (referAt(name, pos)) return false;
+      return !isShadowedAt(name, pos);
+    };
+    const threadedSteps = /* @__PURE__ */ new Set();
+    const walkStack = [{ node: rootNode, isExit: false, previousActiveFunction: activeFunction, quoteDepth: 0 }];
+    while (walkStack.length > 0) {
+      const { node, isExit, previousActiveFunction: savedActiveFunction, quoteDepth } = walkStack.pop();
+      if (!node) continue;
+      if (isExit) {
+        activeFunction = savedActiveFunction;
+        continue;
+      }
+      if (node.type === "dis_expr") continue;
+      if (node.type === "read_cond_lit" || node.type === "splicing_read_cond_lit") {
+        readCondRanges.push({ start: node.startIndex, end: node.endIndex });
+      }
+      if (node.type === "meta_lit") continue;
+      if (node.type === "syn_quoting_lit" || quoteDepth > 0) {
+        let childDepth = quoteDepth;
+        if (node.type === "syn_quoting_lit") childDepth++;
+        else if (node.type === "unquoting_lit" || node.type === "unquote_splicing_lit") childDepth--;
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) walkStack.push({ node: child, isExit: false, previousActiveFunction: null, quoteDepth: childDepth });
+        }
+        continue;
+      }
+      if (node.type === "quoting_lit") continue;
+      if (node.type === "tagged_or_ctor_lit") {
+        const tagNode = node.namedChild(0);
+        const payload = node.namedChild(1);
+        const tag = symName(tagNode);
+        const bareTag = tag.includes("/") ? tag.slice(tag.indexOf("/") + 1) : tag;
+        if ((bareTag === "js" || bareTag === "JS") && payload) {
+          const walkJsValues = (nd) => {
+            if (nd.type === "kwd_lit") return;
+            if (nd.type === "map_lit") {
+              for (let i = 0; i < nd.namedChildCount; i++) {
+                const c = nd.namedChild(i);
+                if (!c) continue;
+                const isKey = i % 2 === 0;
+                if (!isKey) walkStack.push({ node: c, isExit: false, previousActiveFunction: null, quoteDepth });
+              }
+              return;
+            }
+            if (nd.type === "vec_lit" || nd.type === "set_lit") {
+              for (let i = 0; i < nd.namedChildCount; i++) {
+                const c = nd.namedChild(i);
+                if (c) walkStack.push({ node: c, isExit: false, previousActiveFunction: null, quoteDepth });
+              }
+              return;
+            }
+          };
+          walkJsValues(payload);
+          continue;
+        }
+        if (tag && payload && (payload.type === "vec_lit" || payload.type === "map_lit")) {
+          const namePart = tag.includes("/") ? tag.slice(tag.indexOf("/") + 1) : tag;
+          const lastSeg = namePart.includes(".") ? namePart.slice(namePart.lastIndexOf(".") + 1) : namePart;
+          const c0 = lastSeg.charCodeAt(0);
+          if (c0 >= 65 && c0 <= 90) {
+            const src = activeFunction ? activeFunction.name : currentNamespace;
+            pushRel(src, resolveQualified(tag), ASTEngine.RelationshipType.Instantiates, 0.8, { clojureSpecific: true, isCtorLiteral: true, ...activeFunction ? {} : { isTopLevel: true } }, tagNode ? tagNode.startPosition.row + 1 : void 0, payload.type === "vec_lit" ? payload.namedChildCount : void 0);
+          }
+        }
+        continue;
+      }
+      if (node.type === "list_lit") {
+        let site = null;
+        for (let anc = node.parent; anc; anc = anc.parent) {
+          if (anc.type !== "list_lit") continue;
+          const pf = clauseNameOf(anc) || formNameOf(anc);
+          if (pf === "require" || pf === "use" || pf === "import" || pf === "refer" || pf === "refer-macros" || pf === "use-macros" || pf === "refer-clojure") {
+            site = anc;
+            break;
+          }
+        }
+        if (site) continue;
+      }
+      if (node.type === "list_lit") {
+        const form = formNameOf(node);
+        const canon = resolveQualified(form);
+        if (canon === "quote" || canon === "clojure.core/quote" || canon === "clojure.core/comment" || canon === "comment" && !isShadowedAt("comment", node.startIndex)) continue;
+      }
+      if (node.type === "vec_lit") {
+        const tag = node.namedChild(0);
+        if (tag && tag.type === "kwd_lit") {
+          for (let i = 1; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (!c) continue;
+            let component = null;
+            if (c.type === "sym_lit") component = c;
+            else if (c.type === "vec_lit") {
+              const inner = c.namedChild(0);
+              if (inner && inner.type === "sym_lit") component = inner;
+            }
+            if (!component) continue;
+            const target = resolveQualified(symName(component));
+            if (!target) continue;
+            renderCandidates.push({
+              source: activeFunction ? activeFunction.name : currentNamespace,
+              target,
+              line: component.startPosition.row + 1,
+              topLevel: !activeFunction
+            });
+          }
+        }
+      }
+      const previousActiveFunction = activeFunction;
+      walkStack.push({ node, isExit: true, previousActiveFunction, quoteDepth });
+      if (node.type === "anon_fn_lit") {
+        const name = `lambda_${node.startPosition.row}_${node.startPosition.column}`;
+        const lambdaSymbol = {
+          name,
+          kind: ASTEngine.SymbolKind.Function,
+          range: this.nodeToRange(node),
+          scope: currentNamespace,
+          ownerName: "",
+          visibility: "local",
+          parameters: [],
+          metadata: { isAnonymous: true, isPure: true, complexity: 1, clojureSpecific: true }
+        };
+        symbols.push(lambdaSymbol);
+        activeFunction = lambdaSymbol;
+        const anonHead = node.namedChild(0);
+        if (anonHead && anonHead.type === "sym_lit") {
+          const hName = symName(anonHead);
+          const anonMember = hName && hName.startsWith(".") && hName !== ".." ? hName.startsWith(".-") ? hName.slice(2) : hName.slice(1) : null;
+          const anonStatic = hName ? staticInteropMember(hName) : null;
+          if (anonMember) {
+            const mLine = anonHead.startPosition.row + 1;
+            pushRel(
+              name,
+              anonMember,
+              ASTEngine.RelationshipType.Uses,
+              0.7,
+              { clojureSpecific: true, isFieldAccess: true, isAnonShorthand: true },
+              mLine,
+              Math.max(0, node.namedChildCount - 1),
+              anonHead.startIndex
+            );
+            patterns["Java Interoperability"] = true;
+          } else if (anonStatic !== null) {
+            const mLine = anonHead.startPosition.row + 1;
+            const mArity = Math.max(0, node.namedChildCount - 1);
+            pushRel(
+              name,
+              anonStatic,
+              ASTEngine.RelationshipType.Uses,
+              0.7,
+              { clojureSpecific: true, isFieldAccess: true, isAnonShorthand: true },
+              mLine,
+              mArity,
+              anonHead.startIndex
+            );
+            const anonCls = staticInteropClass(hName);
+            if (anonCls) {
+              pushRel(
+                name,
+                resolveQualified(anonCls),
+                ASTEngine.RelationshipType.Uses,
+                0.8,
+                { clojureSpecific: true, isClassReference: true, isAnonShorthand: true },
+                mLine,
+                0,
+                anonHead.startIndex
+              );
+            }
+            patterns["Java Interoperability"] = true;
+          } else if (hName && !isAnonArgShorthand(hName) && !isCoreCallSuppressed(hName, anonHead.startIndex)) {
+            const line = anonHead.startPosition.row + 1;
+            const arity = Math.max(0, node.namedChildCount - 1);
+            const q = resolveCallee(anonHead, hName);
+            if (q.alias) {
+              const resolvedNs = namespaceAliases[q.alias] || q.alias;
+              pushRel(name, q.target, ASTEngine.RelationshipType.Calls, 0.9, { clojureSpecific: true, isGeneralCall: true, isAnonShorthand: true }, line, arity, anonHead.startIndex);
+              if (resolvedNs !== currentNamespace) pushRel(currentNamespace, resolvedNs, ASTEngine.RelationshipType.References, 0.8, { clojureSpecific: true, isLibraryDep: true }, line);
+            } else {
+              pushRel(name, hName, ASTEngine.RelationshipType.Calls, 0.9, { clojureSpecific: true, isGeneralCall: true, isAnonShorthand: true }, line, arity, anonHead.startIndex);
+            }
+          }
+        }
+      } else if (node.type === "list_lit") {
+        const formName = formNameOf(node);
+        const bareForm = formName.includes("/") ? formName.slice(formName.lastIndexOf("/") + 1) : formName;
+        if (formName === "fn") {
+          const name = `lambda_${node.startPosition.row}_${node.startPosition.column}`;
+          const lambdaSymbol = {
+            name,
+            kind: ASTEngine.SymbolKind.Function,
+            range: this.nodeToRange(node),
+            scope: currentNamespace,
+            ownerName: "",
+            visibility: "local",
+            parameters: extractParams(node),
+            metadata: { isAnonymous: true, isPure: true, complexity: 1, clojureSpecific: true }
+          };
+          symbols.push(lambdaSymbol);
+          activeFunction = lambdaSymbol;
+        } else if (formName === "ns" || formName === "in-ns") {
+          sawNamespaceForm = true;
+          const argNode = node.namedChild(1);
+          let nsName = "";
+          if (argNode) {
+            if (argNode.type === "sym_lit") nsName = symName(argNode);
+            else if (argNode.type === "quoting_lit" || argNode.type === "syn_quoting_lit") {
+              const inner = executionHead(argNode);
+              const innerName = inner && inner.type === "sym_lit" ? symName(inner) : "";
+              nsName = innerName;
+            }
+          }
+          if (nsName) currentNamespace = nsName;
+          if (formName === "ns") {
+            namespaceAliases = /* @__PURE__ */ Object.create(null);
+            if (referSegments.length > 0) referSegments[referSegments.length - 1].end = node.startIndex;
+            referTable = openReferSegment(node.startIndex);
+          }
+          const modSym = {
+            name: currentNamespace,
+            kind: ASTEngine.SymbolKind.Module,
+            range: this.nodeToRange(node),
+            scope: "",
+            visibility: "public",
+            metadata: { clojureSpecific: true }
+          };
+          symbols.push(modSym);
+          attachDocs(modSym, node, "always");
+          exports.push({ name: currentNamespace, kind: ASTEngine.SymbolKind.Module, range: this.nodeToRange(node), visibility: "public" });
+          exportNamespaces.push(currentNamespace);
+          const clauses = [];
+          for (let i = 1; i < node.namedChildCount; i++) {
+            const clause = node.namedChild(i);
+            if (!clause) continue;
+            if (clause.type === "list_lit") clauses.push(clause);
+            else if (clause.type === "read_cond_lit" || clause.type === "splicing_read_cond_lit") {
+              for (let c = 0; c < clause.namedChildCount; c++) {
+                const inner = clause.namedChild(c);
+                if (inner && inner.type === "list_lit") clauses.push(inner);
+              }
+            }
+          }
+          for (const clause of clauses) {
+            const clauseType = clauseNameOf(clause);
+            if (clauseType !== "require" && clauseType !== "use" && clauseType !== "import" && clauseType !== "require-macros") continue;
+            for (let j = 1; j < clause.namedChildCount; j++) {
+              const libNode = clause.namedChild(j);
+              if (libNode) handleLibNode(libNode);
+            }
+          }
+        } else if ((formName === "require" || formName === "use" || formName === "import" || formName === "refer" || formName === "require-macros") && executionHead(node)?.type === "sym_lit" && isTopLevelDirective(node)) {
+          for (let j = 1; j < node.namedChildCount; j++) {
+            const libNode = node.namedChild(j);
+            if (!libNode) continue;
+            if (libNode.type === "sym_lit" && !libNode.text.includes(".") && !libNode.text.includes("/")) continue;
+            handleLibNode(libNode);
+          }
+        } else if (bareForm === "defn" || bareForm === "defn-" || bareForm === "defmacro" || bareForm === "s/defn" || formName === "mu/defn") {
+          const isMacro = bareForm === "defmacro";
+          const nameNode2 = defNameNodeOf(node);
+          const rawName = nameNode2 ? symName(nameNode2) : "";
+          const name = isPublishableName(rawName) ? rawName : "";
+          const isPrivate = formName === "defn-" || metaHasPrivate(node.namedChild(1)) || metaHasPrivate(nameNode2) || attrMapHasPrivate(node, nameNode2);
+          if (name) {
+            const funcSymbol = {
+              name,
+              kind: ASTEngine.SymbolKind.Function,
+              range: this.nodeToRange(node),
+              scope: currentNamespace,
+              ownerName: currentNamespace,
+              visibility: isPrivate ? "private" : "public",
+              parameters: extractParams(node),
+              metadata: { clojureSpecific: true, isPure: true, complexity: 1, isMacro: isMacro || void 0 }
+            };
+            symbols.push(funcSymbol);
+            activeFunction = funcSymbol;
+            attachDocs(funcSymbol, node, "fn");
+          }
+          if (isMacro) patterns["Metaprogramming"] = true;
+          if (name) {
+            exports.push({ name, kind: ASTEngine.SymbolKind.Function, range: this.nodeToRange(node), visibility: isPrivate ? "private" : "public" });
+            exportNamespaces.push(currentNamespace);
+          }
+        } else if (formName === "deftest") {
+          const testNameNode = defNameNodeOf(node);
+          const name = (testNameNode ? symName(testNameNode) : "") || `test_${node.startPosition.row}`;
+          const testSym = {
+            name,
+            kind: ASTEngine.SymbolKind.Function,
+            range: this.nodeToRange(node),
+            scope: currentNamespace,
+            ownerName: currentNamespace,
+            visibility: "public",
+            parameters: [],
+            metadata: { clojureSpecific: true, isTest: true, isPure: true, complexity: 1 }
+          };
+          symbols.push(testSym);
+          activeFunction = testSym;
+          attachDocs(testSym, node, "fn");
+        } else if (formName === "defprotocol") {
+          const name = symName(node.namedChild(1)) || "unknown";
+          const typeVisibility = metaHasPrivate(node.namedChild(1)) ? "private" : "public";
+          const protoSym = {
+            name,
+            kind: ASTEngine.SymbolKind.Interface,
+            range: this.nodeToRange(node),
+            scope: currentNamespace,
+            ownerName: currentNamespace,
+            visibility: typeVisibility,
+            metadata: { clojureSpecific: true, isProtocol: true }
+          };
+          symbols.push(protoSym);
+          attachDocs(protoSym, node, "always");
+          patterns["Protocol-based Polymorphism"] = true;
+          exports.push({ name, kind: ASTEngine.SymbolKind.Interface, range: this.nodeToRange(node), visibility: typeVisibility });
+          exportNamespaces.push(currentNamespace);
+          for (let i = 2; i < node.namedChildCount; i++) {
+            const m = node.namedChild(i);
+            if (!m || m.type !== "list_lit") continue;
+            const mName = symName(m.namedChild(0));
+            if (!mName) continue;
+            symbols.push({
+              name: mName,
+              kind: ASTEngine.SymbolKind.Function,
+              range: this.nodeToRange(m),
+              scope: `${currentNamespace}.${name}`,
+              ownerName: name,
+              visibility: "public",
+              parameters: extractParams(m),
+              metadata: { clojureSpecific: true, isProtocolMethod: true }
+            });
+          }
+        } else if (formName === "definterface") {
+          const name = symName(node.namedChild(1)) || "unknown";
+          const typeVisibility = metaHasPrivate(node.namedChild(1)) ? "private" : "public";
+          const ifaceSym = {
+            name,
+            kind: ASTEngine.SymbolKind.Interface,
+            range: this.nodeToRange(node),
+            scope: currentNamespace,
+            ownerName: currentNamespace,
+            visibility: typeVisibility,
+            metadata: { clojureSpecific: true, isInterface: true }
+          };
+          symbols.push(ifaceSym);
+          attachDocs(ifaceSym, node, "always");
+          exports.push({ name, kind: ASTEngine.SymbolKind.Interface, range: this.nodeToRange(node), visibility: typeVisibility });
+          exportNamespaces.push(currentNamespace);
+          for (let i = 2; i < node.namedChildCount; i++) {
+            const m = node.namedChild(i);
+            if (!m || m.type !== "list_lit") continue;
+            const mName = symName(m.namedChild(0));
+            if (!mName) continue;
+            symbols.push({
+              name: mName,
+              kind: ASTEngine.SymbolKind.Function,
+              range: this.nodeToRange(m),
+              scope: `${currentNamespace}.${name}`,
+              ownerName: name,
+              visibility: "public",
+              parameters: extractParams(m),
+              metadata: { clojureSpecific: true, isInterfaceMethod: true }
+            });
+          }
+        } else if (formName === "defrecord" || formName === "deftype") {
+          const name = symName(node.namedChild(1)) || "unknown";
+          const typeVisibility = metaHasPrivate(node.namedChild(1)) ? "private" : "public";
+          const classSym = {
+            name,
+            kind: ASTEngine.SymbolKind.Class,
+            range: this.nodeToRange(node),
+            scope: currentNamespace,
+            ownerName: currentNamespace,
+            visibility: typeVisibility,
+            metadata: { clojureSpecific: true, isRecord: formName === "defrecord", isType: formName === "deftype" }
+          };
+          symbols.push(classSym);
+          attachDocs(classSym, node, "always");
+          exports.push({ name, kind: ASTEngine.SymbolKind.Class, range: this.nodeToRange(node), visibility: typeVisibility });
+          exportNamespaces.push(currentNamespace);
+          let fieldsVec = null;
+          for (let i = 2; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (c && c.type === "vec_lit") {
+              fieldsVec = c;
+              break;
+            }
+          }
+          if (fieldsVec) {
+            for (let i = 0; i < fieldsVec.namedChildCount; i++) {
+              const field = fieldsVec.namedChild(i);
+              if (field && field.type === "sym_lit") {
+                symbols.push({
+                  name: symName(field),
+                  kind: ASTEngine.SymbolKind.Property,
+                  range: this.nodeToRange(field),
+                  scope: `${currentNamespace}.${name}`,
+                  ownerName: name,
+                  visibility: "public",
+                  metadata: { clojureSpecific: true }
+                });
+              }
+            }
+          }
+          for (let pi = 3; pi < node.namedChildCount; pi++) {
+            const protoNode = node.namedChild(pi);
+            if (!protoNode || protoNode.type !== "sym_lit") continue;
+            const protoName = resolveQualified(symName(protoNode));
+            if (protoName) {
+              pushRel(name, protoName, ASTEngine.RelationshipType.Implements, 0.85, { clojureSpecific: true, isRecord: formName === "defrecord" }, protoNode.startPosition.row + 1);
+            }
+          }
+        } else if (formName === "reify" || formName === "extend-type" || formName === "extend-protocol" || formName === "proxy") {
+          const ctxName = activeFunction ? activeFunction.name : currentNamespace;
+          const topMeta = activeFunction ? {} : { isTopLevel: true };
+          if (formName === "reify") {
+            for (let i = 1; i < node.namedChildCount; i++) {
+              const c = node.namedChild(i);
+              if (c && c.type === "sym_lit") {
+                const proto = resolveQualified(symName(c));
+                if (proto) pushRel(ctxName, proto, ASTEngine.RelationshipType.Implements, 0.85, { clojureSpecific: true, isReify: true, ...topMeta }, c.startPosition.row + 1);
+              }
+            }
+            patterns["Protocol-based Polymorphism"] = true;
+          } else if (formName === "extend-protocol") {
+            const proto = resolveQualified(symName(node.namedChild(1)));
+            for (let i = 2; i < node.namedChildCount; i++) {
+              const c = node.namedChild(i);
+              const type = typeNameOf(c);
+              if (type && proto) {
+                pushRel(type, proto, ASTEngine.RelationshipType.Implements, 0.85, { clojureSpecific: true, isExtendProtocol: true }, c.startPosition.row + 1);
+              }
+            }
+            patterns["Protocol-based Polymorphism"] = true;
+          } else if (formName === "extend-type") {
+            const typeName = typeNameOf(node.namedChild(1));
+            for (let i = 2; i < node.namedChildCount; i++) {
+              const c = node.namedChild(i);
+              if (c && c.type === "sym_lit") {
+                const proto = resolveQualified(symName(c));
+                if (proto && typeName) pushRel(typeName, proto, ASTEngine.RelationshipType.Implements, 0.85, { clojureSpecific: true, isExtendType: true }, c.startPosition.row + 1);
+              }
+            }
+            patterns["Protocol-based Polymorphism"] = true;
+          } else {
+            const ifaces = node.namedChild(1);
+            if (ifaces && ifaces.type === "vec_lit") {
+              for (let i = 0; i < ifaces.namedChildCount; i++) {
+                const c = ifaces.namedChild(i);
+                if (c && c.type === "sym_lit") {
+                  const iface = resolveQualified(symName(c));
+                  if (iface) pushRel(ctxName, iface, i === 0 ? ASTEngine.RelationshipType.Extends : ASTEngine.RelationshipType.Implements, 0.8, { clojureSpecific: true, isProxy: true, ...topMeta }, c.startPosition.row + 1);
+                }
+              }
+            }
+            patterns["Java Interoperability"] = true;
+          }
+        } else if (formName === "gen-class" || formName === "gen-interface") {
+          const ctxName = activeFunction ? activeFunction.name : currentNamespace;
+          const topMeta = activeFunction ? {} : { isTopLevel: true };
+          let genName = "";
+          let extendsNode = null;
+          let implementsNode = null;
+          for (let i = 1; i < node.namedChildCount; i++) {
+            const k = node.namedChild(i);
+            if (!k || k.type !== "kwd_lit") continue;
+            const kw = k.childForFieldName("name")?.text || "";
+            const val = node.namedChild(i + 1);
+            if (!val) continue;
+            if (kw === "name" && val.type === "sym_lit") genName = symName(val);
+            else if (kw === "extends") extendsNode = val;
+            else if (kw === "implements") implementsNode = val;
+          }
+          const genMeta = { clojureSpecific: true, isGenClass: true, ...genName ? { genClassName: genName } : {}, ...topMeta };
+          if (extendsNode) {
+            const targets = extendsNode.type === "vec_lit" ? Array.from({ length: extendsNode.namedChildCount }, (_, k2) => extendsNode.namedChild(k2)).filter((x) => !!x && x.type === "sym_lit") : extendsNode.type === "sym_lit" ? [extendsNode] : [];
+            for (const c of targets) {
+              const superName = resolveQualified(symName(c));
+              if (superName) pushRel(ctxName, superName, ASTEngine.RelationshipType.Extends, 0.8, genMeta, c.startPosition.row + 1);
+            }
+            patterns["Java Interoperability"] = true;
+          }
+          if (implementsNode && implementsNode.type === "vec_lit") {
+            for (let k2 = 0; k2 < implementsNode.namedChildCount; k2++) {
+              const c = implementsNode.namedChild(k2);
+              if (!c || c.type !== "sym_lit") continue;
+              const iface = resolveQualified(symName(c));
+              if (iface) pushRel(ctxName, iface, ASTEngine.RelationshipType.Implements, 0.85, genMeta, c.startPosition.row + 1);
+            }
+          }
+          if (genName) patterns["AOT Compilation"] = true;
+        } else if (formName === "defmulti") {
+          const multiNameNode = defNameNodeOf(node);
+          const name = multiNameNode ? symName(multiNameNode) : "unknown";
+          const multiVisibility = metaHasPrivate(node.namedChild(1)) || metaHasPrivate(multiNameNode) ? "private" : "public";
+          const multiSym = {
+            name,
+            kind: ASTEngine.SymbolKind.Function,
+            range: this.nodeToRange(node),
+            scope: currentNamespace,
+            ownerName: currentNamespace,
+            visibility: multiVisibility,
+            metadata: { clojureSpecific: true, isMultimethod: true }
+          };
+          symbols.push(multiSym);
+          attachDocs(multiSym, node, "always");
+          patterns["Multimethods"] = true;
+          exports.push({ name, kind: ASTEngine.SymbolKind.Function, range: this.nodeToRange(node), visibility: multiVisibility });
+          exportNamespaces.push(currentNamespace);
+        } else if (formName === "defmethod") {
+          const multiName = symName(node.namedChild(1)) || "unknown";
+          const methodSym = {
+            name: multiName,
+            kind: ASTEngine.SymbolKind.Function,
+            range: this.nodeToRange(node),
+            scope: currentNamespace,
+            ownerName: currentNamespace,
+            visibility: "public",
+            parameters: extractParams(node),
+            metadata: { clojureSpecific: true, isMethodImpl: true }
+          };
+          symbols.push(methodSym);
+          activeFunction = methodSym;
+          patterns["Multimethods"] = true;
+        } else if (formName === "def" || formName === "defonce") {
+          const nameNode = node.namedChild(1);
+          if (nameNode && nameNode.type === "sym_lit") {
+            const name = symName(nameNode);
+            const varVisibility = metaHasPrivate(nameNode) ? "private" : "public";
+            const varSym = {
+              name,
+              kind: ASTEngine.SymbolKind.Variable,
+              range: this.nodeToRange(node),
+              scope: currentNamespace,
+              ownerName: currentNamespace,
+              visibility: varVisibility,
+              metadata: { clojureSpecific: true }
+            };
+            symbols.push(varSym);
+            attachDocs(varSym, node, "def");
+            exports.push({ name, kind: ASTEngine.SymbolKind.Variable, range: this.nodeToRange(node), visibility: varVisibility });
+            exportNamespaces.push(currentNamespace);
+          }
+        } else if (formName === "declare") {
+          for (let i = 1; i < node.namedChildCount; i++) {
+            const nameNode = node.namedChild(i);
+            if (!nameNode) continue;
+            if (nameNode.type === "sym_lit") {
+              const name = symName(nameNode);
+              if (!name || CLOJURE_CORE_BUILTINS[name]) continue;
+              symbols.push({
+                name,
+                kind: ASTEngine.SymbolKind.Variable,
+                range: this.nodeToRange(node),
+                scope: currentNamespace,
+                ownerName: currentNamespace,
+                visibility: metaHasPrivate(nameNode) ? "private" : "public",
+                metadata: { clojureSpecific: true, isForwardDeclaration: true }
+              });
+            } else if (nameNode.type === "vec_lit") {
+              continue;
+            }
+          }
+        } else if (isDefLikeHead(formName)) {
+          const nameNode = defNameNodeOf(node);
+          const name = nameNode ? symName(nameNode) : "";
+          if (name) {
+            let hasArglist = false;
+            for (let i = 2; i < node.namedChildCount; i++) {
+              const c = node.namedChild(i);
+              if (c && c.type === "vec_lit") {
+                hasArglist = true;
+                break;
+              }
+              if (c && c.type === "str_lit") continue;
+              if (c && c.type === "map_lit") continue;
+              if (c && c.type === "meta_lit") continue;
+              break;
+            }
+            const inferredKind = hasArglist ? ASTEngine.SymbolKind.Function : ASTEngine.SymbolKind.Variable;
+            const visibility = metaHasPrivate(nameNode) ? "private" : "public";
+            const sym = {
+              name,
+              kind: inferredKind,
+              range: this.nodeToRange(node),
+              scope: currentNamespace,
+              ownerName: currentNamespace,
+              visibility,
+              ...hasArglist ? { parameters: extractParams(node) } : {},
+              metadata: { clojureSpecific: true, isPure: true, complexity: 1, isUnknownDefMacro: true, definedBy: formName }
+            };
+            symbols.push(sym);
+            activeFunction = sym;
+            attachDocs(sym, node, "fn");
+            exports.push({ name, kind: inferredKind, range: this.nodeToRange(node), visibility });
+            exportNamespaces.push(currentNamespace);
+          }
+        } else if ((formName === "s/def" || formName === "s/fdef" || formName === "clojure.spec.alpha/def" || formName === "clojure.spec.alpha/fdef") && node.namedChild(1)) {
+          const child = node.namedChild(1);
+          const raw = symName(child);
+          const specName = child.type === "kwd_lit" && raw.startsWith("::") ? `:${currentNamespace}/${raw.slice(2)}` : raw;
+          if (!specName || child.type === "num_lit" || child.type === "str_lit" || child.type === "bool_lit" || child.type === "char_lit") {
+          } else {
+            symbols.push({
+              name: specName,
+              kind: ASTEngine.SymbolKind.Interface,
+              range: this.nodeToRange(node),
+              scope: currentNamespace,
+              ownerName: currentNamespace,
+              visibility: "public",
+              metadata: { isSpec: true, clojureSpecific: true }
+            });
+          }
+        } else if (node.parent?.type === "list_lit" && METHOD_IMPL_PARENT_FORMS[formNameOf(node.parent)] && executionHead(node.parent)?.startIndex !== node.startIndex) {
+          const parentForm = formNameOf(node.parent);
+          if (parentForm !== "defprotocol" && parentForm !== "definterface") {
+            const mName = symName(node.namedChild(0));
+            if (mName) {
+              const owner = methodImplOwner(node, parentForm);
+              const isRecord = parentForm === "defrecord" || parentForm === "deftype";
+              const methodSym = {
+                name: mName,
+                kind: ASTEngine.SymbolKind.Function,
+                range: this.nodeToRange(node),
+                scope: owner ? `${currentNamespace}.${owner}` : currentNamespace,
+                ownerName: owner || currentNamespace,
+                visibility: "public",
+                parameters: extractParams(node),
+                metadata: { clojureSpecific: true, isProtocolMethodImpl: true, ...isRecord ? { isRecordMethod: true } : {} }
+              };
+              symbols.push(methodSym);
+              activeFunction = methodSym;
+              const implProtos = protocolsOfExtendingForm(node.parent, parentForm);
+              if (implProtos.length > 0 && owner) {
+                overrideCandidates.push({ type: owner, protos: implProtos, method: mName, line: node.startPosition.row + 1, form: parentForm });
+              }
+            }
+          }
+        } else if (node.parent?.type === "vec_lit" && node.parent.parent?.type === "list_lit" && formNameOf(node.parent.parent) === "letfn") {
+          const fName = symName(node.namedChild(0));
+          if (fName) {
+            const fnSym = {
+              name: fName,
+              kind: ASTEngine.SymbolKind.Function,
+              range: this.nodeToRange(node),
+              scope: currentNamespace,
+              ownerName: "",
+              visibility: "local",
+              parameters: extractParams(node),
+              metadata: { clojureSpecific: true, isLocalFn: true, isPure: true, complexity: 1 }
+            };
+            symbols.push(fnSym);
+            activeFunction = fnSym;
+          }
+        } else if (formName.startsWith("->") && formName.length > 2 && formName !== "->>") {
+          const cls = formName.slice(2);
+          const namePart = cls.includes("/") ? cls.slice(cls.indexOf("/") + 1) : cls;
+          const lastSeg = namePart.includes(".") ? namePart.slice(namePart.lastIndexOf(".") + 1) : namePart;
+          const c0 = lastSeg.charCodeAt(0);
+          if (c0 >= 65 && c0 <= 90) {
+            const src = activeFunction ? activeFunction.name : currentNamespace;
+            const headNode = executionHead(node);
+            pushRel(src, resolveQualified(cls), ASTEngine.RelationshipType.Instantiates, 0.8, { clojureSpecific: true, isConstructor: true, ...activeFunction ? {} : { isTopLevel: true } }, headNode ? headNode.startPosition.row + 1 : void 0, callArityOf(node));
+          }
+        } else if (formName === "new") {
+          const clsNode = node.namedChild(1);
+          const clsName = symName(clsNode);
+          if (clsName) {
+            const src = activeFunction ? activeFunction.name : currentNamespace;
+            pushRel(src, resolveQualified(clsName), ASTEngine.RelationshipType.Instantiates, 0.8, { clojureSpecific: true, isJavaInterop: true, ...activeFunction ? {} : { isTopLevel: true } }, clsNode ? clsNode.startPosition.row + 1 : void 0, Math.max(0, node.namedChildCount - 2));
+            patterns["Java Interoperability"] = true;
+            if (activeFunction?.metadata) activeFunction.metadata.isPure = false;
+          }
+        } else if (formName.endsWith(".") && formName.length > 1 && !formName.startsWith(".")) {
+          const cls = resolveQualified(formName.slice(0, -1));
+          const src = activeFunction ? activeFunction.name : currentNamespace;
+          const headNode = executionHead(node);
+          pushRel(src, cls, ASTEngine.RelationshipType.Instantiates, 0.8, { clojureSpecific: true, isJavaInterop: true, ...activeFunction ? {} : { isTopLevel: true } }, headNode ? headNode.startPosition.row + 1 : void 0, callArityOf(node));
+          patterns["Java Interoperability"] = true;
+        } else if (formName.startsWith(".") && formName !== "..") {
+          const target = formName.startsWith(".-") ? formName.slice(2) : formName.slice(1);
+          const src = activeFunction ? activeFunction.name : currentNamespace;
+          const headNode = executionHead(node);
+          if (target) pushRel(src, target, ASTEngine.RelationshipType.Uses, 0.7, { clojureSpecific: true, isFieldAccess: true, ...activeFunction ? {} : { isTopLevel: true } }, headNode ? headNode.startPosition.row + 1 : void 0, callArityOf(node));
+          patterns["Java Interoperability"] = true;
+        } else if (staticInteropMember(formName) !== null) {
+          const member = staticInteropMember(formName);
+          const clsName = staticInteropClass(formName);
+          const src = activeFunction ? activeFunction.name : currentNamespace;
+          const headNode = executionHead(node);
+          const line = headNode ? headNode.startPosition.row + 1 : void 0;
+          const topMeta = activeFunction ? {} : { isTopLevel: true };
+          if (member) {
+            pushRel(src, member, ASTEngine.RelationshipType.Uses, 0.7, { clojureSpecific: true, isFieldAccess: true, isStaticInterop: true, ...topMeta }, line, callArityOf(node));
+          }
+          if (clsName) {
+            const clsNode = headNode;
+            pushRel(src, resolveQualified(clsName), ASTEngine.RelationshipType.Uses, 0.8, { clojureSpecific: true, isStaticInteropClass: true, ...topMeta }, clsNode ? clsNode.startPosition.row + 1 : void 0, 0);
+          }
+          patterns["Java Interoperability"] = true;
+        } else if (formName === "->" || formName === "->>" || formName === "some->" || formName === "some->>" || formName === "cond->" || formName === "cond->>" || formName === "doto") {
+          if (activeFunction) patterns["Threading Macros"] = true;
+          if ((formName === "cond->" || formName === "cond->>" || formName === "some->" || formName === "some->>") && activeFunction?.metadata) {
+            activeFunction.metadata.complexity = (activeFunction.metadata.complexity || 1) + 1;
+            totalCyclomaticComplexity++;
+          }
+          const isCond = formName === "cond->" || formName === "cond->>";
+          const tSrc = activeFunction ? activeFunction.name : currentNamespace;
+          const tTop = activeFunction ? {} : { isTopLevel: true };
+          for (let i = 2; i < node.namedChildCount; i++) {
+            if (isCond && i % 2 === 0) continue;
+            const step = node.namedChild(i);
+            if (!step) continue;
+            const emitStep = (hName, line, arity, bare, stepPos, alias = "") => {
+              if (!hName || isCoreCallSuppressed(hName, stepPos) || hName.startsWith(".") || hName.startsWith("->") || hName.endsWith(".")) return;
+              pushRel(tSrc, alias ? hName : resolveQualified(hName), ASTEngine.RelationshipType.Calls, 0.9, { clojureSpecific: true, isGeneralCall: true, isThreadedStep: true, ...bare ? { isBareStep: true } : {}, ...tTop }, line, arity, stepPos);
+              if (alias) {
+                const resolvedNs = namespaceAliases[alias] || alias;
+                if (resolvedNs !== currentNamespace) pushRel(currentNamespace, resolvedNs, ASTEngine.RelationshipType.References, 0.8, { clojureSpecific: true, isLibraryDep: true }, line);
+              }
+            };
+            if (step.type === "list_lit") {
+              const h = executionHead(step);
+              if (!h || h.type !== "sym_lit") continue;
+              const qh = resolveCallee(h, symName(h));
+              emitStep(qh.alias ? qh.target : symName(h), h.startPosition.row + 1, callArityOf(step) + 1, false, h.startIndex, qh.alias);
+              threadedSteps.add(step.startIndex);
+            } else if (step.type === "sym_lit") {
+              const qs = resolveCallee(step, symName(step));
+              emitStep(qs.alias ? qs.target : symName(step), step.startPosition.row + 1, 1, true, step.startIndex, qs.alias);
+            }
+          }
+        } else if (threadedSteps.has(node.startIndex) && formName && !isCoreCallSuppressed(formName, node.startIndex)) {
+        } else if (formName && !CLOJURE_SPECIAL_FORMS.has(formName) && !isCoreCallSuppressed(formName, headStartIndex(node))) {
+          const src = activeFunction ? activeFunction.name : currentNamespace;
+          const topMeta = activeFunction ? {} : { isTopLevel: true };
+          const headNode = executionHead(node);
+          const line = headNode ? headNode.startPosition.row + 1 : void 0;
+          const arity = callArityOf(node);
+          const q = resolveCallee(headNode, formName);
+          if (q.alias) {
+            const resolvedNs = namespaceAliases[q.alias] || q.alias;
+            pushRel(src, q.target, ASTEngine.RelationshipType.Calls, 0.9, { clojureSpecific: true, isGeneralCall: true, ...topMeta }, line, arity, headStartIndex(node));
+            if (resolvedNs !== currentNamespace) pushRel(currentNamespace, resolvedNs, ASTEngine.RelationshipType.References, 0.8, { clojureSpecific: true, isLibraryDep: true }, line);
+            if (q.name.endsWith("!") && activeFunction) activeFunction.metadata.isPure = false;
+          } else {
+            pushRel(src, formName, ASTEngine.RelationshipType.Calls, 0.9, { clojureSpecific: true, isGeneralCall: true, ...topMeta }, line, arity, headStartIndex(node));
+            if (formName.endsWith("!") && activeFunction) activeFunction.metadata.isPure = false;
+          }
+        } else if (formName && activeFunction && activeFunction.metadata) {
+          if (COMPLEXITY_BUILTINS[formName]) {
+            activeFunction.metadata.complexity = (activeFunction.metadata.complexity || 1) + 1;
+            totalCyclomaticComplexity++;
+          }
+          if (HOF_BUILTINS[formName]) {
+            activeFunction.metadata.isHigherOrder = true;
+            patterns["Higher-Order Functions"] = true;
+          }
+          if (STM_BUILTINS[formName]) {
+            activeFunction.metadata.usesSTM = true;
+            patterns["Software Transactional Memory"] = true;
+          }
+          if (IMPURE_BUILTINS[formName] || formName.endsWith("!") || formName.startsWith(".") || formName.endsWith(".")) {
+            activeFunction.metadata.isPure = false;
+          }
+          if (formName === "recur") {
+            activeFunction.metadata.isRecursive = true;
+          } else if (formName === activeFunction.name) {
+            activeFunction.metadata.isRecursive = true;
+          }
+          if (formName === "lazy-seq") patterns["Lazy Evaluation"] = true;
+        }
+      }
+      const isCaseForm = node.type === "list_lit" && formNameOf(node) === "case";
+      let caseSkip = null;
+      if (isCaseForm) {
+        const exec = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const c = node.namedChild(i);
+          if (!c || c.type === "comment" || c.type === "dis_expr") continue;
+          exec.push(i);
+        }
+        const hasDefault = exec.length % 2 === 1;
+        const defaultIdx = hasDefault ? exec[exec.length - 1] : -1;
+        caseSkip = /* @__PURE__ */ new Set();
+        for (let pos = 2; pos < exec.length; pos += 2) {
+          const childIdx = exec[pos];
+          if (childIdx === defaultIdx) continue;
+          const c = node.namedChild(childIdx);
+          if (c && c.type === "list_lit") caseSkip.add(childIdx);
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (!child) continue;
+        if (caseSkip !== null && caseSkip.has(i)) continue;
+        walkStack.push({ node: child, isExit: false, previousActiveFunction: null, quoteDepth });
+      }
+    }
+    if (!sawNamespaceForm) {
+      const implicitNs = {
+        name: currentNamespace,
+        kind: ASTEngine.SymbolKind.Module,
+        range: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startIndex: 0, endIndex: 0 },
+        scope: "",
+        visibility: "public",
+        metadata: { clojureSpecific: true, isImplicitNamespace: true }
+      };
+      symbols.push(implicitNs);
+      exports.push({ name: currentNamespace, kind: ASTEngine.SymbolKind.Module, range: implicitNs.range, visibility: "public" });
+      exportNamespaces.push(currentNamespace);
+    }
+    const PLACEHOLDER_NAMES = /* @__PURE__ */ new Set(["unknown", "unnamed", "anonymous", "<unknown>"]);
+    {
+      const isPlaceholder = (n) => typeof n !== "string" || n.trim() === "" || PLACEHOLDER_NAMES.has(n.trim().toLowerCase());
+      let droppedSymbols = 0;
+      for (let i = symbols.length - 1; i >= 0; i--) {
+        if (isPlaceholder(symbols[i].name)) {
+          symbols.splice(i, 1);
+          droppedSymbols++;
+        }
+      }
+      for (let i = exports.length - 1; i >= 0; i--) {
+        if (isPlaceholder(exports[i].name)) exports.splice(i, 1);
+      }
+      let droppedEdges = 0;
+      for (let i = relationships.length - 1; i >= 0; i--) {
+        const r = relationships[i];
+        if (isPlaceholder(r.source) || isPlaceholder(r.target)) {
+          if (isPlaceholder(r.source) || isPlaceholder(r.target)) {
+            errors.push({
+              message: `Placeholder relationship endpoint dropped (CLJ-D57): ${r.type} "${r.source}" -> "${r.target}"`,
+              line: (r.line_number ?? 0) > 0 ? r.line_number : void 0,
+              severity: "warning"
+            });
+          }
+          relationships.splice(i, 1);
+          droppedEdges++;
+        }
+      }
+      if (droppedSymbols > 0) {
+        const live = new Set(symbols.map((s) => s));
+        if (activeFunction && !live.has(activeFunction)) activeFunction = null;
+      }
+    }
+    {
+      const callableNames = /* @__PURE__ */ new Set();
+      for (const s of symbols) {
+        const k = s.kind;
+        if (k === "function" || k === "method" || k === "macro") callableNames.add(s.name);
+      }
+      let published = 0;
+      for (const cand of renderCandidates) {
+        const bare = cand.target.includes("/") ? cand.target.slice(cand.target.lastIndexOf("/") + 1) : cand.target;
+        if (!callableNames.has(bare) && !callableNames.has(cand.target)) continue;
+        pushRel(cand.source, cand.target, ASTEngine.RelationshipType.Renders, 0.8, { clojureSpecific: true, isRenderElement: true, ...cand.topLevel ? { isTopLevel: true } : {} }, cand.line);
+        published++;
+      }
+      void published;
+    }
+    const isDefinition = (s) => s.metadata?.isForwardDeclaration !== true && s.metadata?.isSpec !== true;
+    const containsPick = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      const _owner = s.ownerName;
+      if (!_owner || s.metadata?.isAnonymous) continue;
+      const key = `${_owner}->${s.name}`;
+      const prev = containsPick.get(key);
+      if (prev === void 0) {
+        containsPick.set(key, s);
+        continue;
+      }
+      if (!isDefinition(prev) && isDefinition(s)) {
+        containsPick.set(key, s);
+        continue;
+      }
+      if (isDefinition(prev) && !isDefinition(s)) continue;
+      if (s.range.startLine < prev.range.startLine) containsPick.set(key, s);
+    }
+    for (const s of containsPick.values()) {
+      if (s.metadata?.isForwardDeclaration === true) continue;
+      if (!isPublishableName(s.name)) continue;
+      pushRel(s.ownerName, s.name, ASTEngine.RelationshipType.Contains, 1, {}, s.range.startLine);
+    }
+    const isNsLevelDefinition = (s) => {
+      if (!s.ownerName) return false;
+      if (s.metadata?.isAnonymous === true) return false;
+      if (s.metadata?.isForwardDeclaration === true || s.metadata?.isSpec === true) return false;
+      if (s.metadata?.isMethodImpl === true) return false;
+      if (s.ownerName !== s.scope) return false;
+      return s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.Variable || s.kind === ASTEngine.SymbolKind.Class || s.kind === ASTEngine.SymbolKind.Interface;
+    };
+    const nsDefGroups = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (!isNsLevelDefinition(s)) continue;
+      const cond = readCondOf(s.range.startIndex ?? 0);
+      const groupId = cond !== 0 ? `c${cond}` : `f${s.range.startIndex ?? 0}`;
+      const key = `${s.ownerName}->${s.name}`;
+      let byCond = nsDefGroups.get(key);
+      if (!byCond) {
+        byCond = [];
+        nsDefGroups.set(key, byCond);
+      }
+      const existing = byCond.find((g) => g.groupId === groupId);
+      if (existing) existing.syms.push(s);
+      else byCond.push({ groupId, syms: [s] });
+    }
+    for (const byCond of nsDefGroups.values()) {
+      if (byCond.length < 2) continue;
+      const ordered = byCond.map((g) => g.syms.reduce((a, b) => a.range.startLine <= b.range.startLine ? a : b)).sort((a, b) => a.range.startLine - b.range.startLine);
+      const first = ordered[0];
+      for (let i = 1; i < ordered.length; i++) {
+        const later = ordered[i];
+        pushRel(later.ownerName, later.name, ASTEngine.RelationshipType.Overrides, 1, {
+          clojureSpecific: true,
+          evidenceClass: "structural",
+          redefinition: true,
+          overridesLine: first.range.startLine,
+          definitionCount: ordered.length
+        }, later.range.startLine);
+      }
+    }
+    const exportedKinds = /* @__PURE__ */ new Set([
+      ASTEngine.SymbolKind.Function,
+      ASTEngine.SymbolKind.Variable,
+      ASTEngine.SymbolKind.Class,
+      ASTEngine.SymbolKind.Interface,
+      ASTEngine.SymbolKind.Module
+    ]);
+    const seenExports = /* @__PURE__ */ new Set();
+    const finalExports = [];
+    const finalExportNs = [];
+    const definedNames = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (s.metadata?.isForwardDeclaration) continue;
+      if (s.metadata?.isSpec) continue;
+      definedNames.add(s.name);
+    }
+    for (const s of symbols) {
+      if (s.metadata?.isMethodImpl === true || s.metadata?.isProtocolMethodImpl === true || s.metadata?.isRecordMethod === true) continue;
+      if (!isPublishableName(s.name)) continue;
+      const isNSLevel = !s.scope || s.scope === currentNamespace || s.ownerName === currentNamespace;
+      if (s.metadata?.isForwardDeclaration) continue;
+      if (s.metadata?.isSpec && definedNames.has(s.name)) continue;
+      if (isNSLevel && s.visibility === "public" && exportedKinds.has(s.kind)) {
+        const key = `${s.name}|${s.kind}`;
+        if (seenExports.has(key)) continue;
+        seenExports.add(key);
+        finalExports.push({ name: s.name, kind: s.kind, range: s.range, visibility: s.visibility });
+        finalExportNs.push(s.ownerName ? s.ownerName : s.kind === ASTEngine.SymbolKind.Module ? s.name : currentNamespace);
+      }
+    }
+    for (let _i = 0; _i < exports.length; _i++) {
+      const e = exports[_i];
+      if (e.visibility && e.visibility !== "public") continue;
+      if (!isPublishableName(e.name)) continue;
+      const key = `${e.name}|${e.kind}`;
+      if (seenExports.has(key)) continue;
+      seenExports.add(key);
+      finalExports.push(e);
+      finalExportNs.push(exportNamespaces[_i] ?? currentNamespace);
+    }
+    exports.length = 0;
+    exports.push(...finalExports);
+    const exportEdgeSeen = /* @__PURE__ */ new Set();
+    for (let _i = 0; _i < finalExports.length; _i++) {
+      const e = finalExports[_i];
+      const ns = finalExportNs[_i] ?? currentNamespace;
+      if (!ns || !e.name) continue;
+      if (ns === e.name) continue;
+      const key = `${ns}->${e.name}`;
+      if (exportEdgeSeen.has(key)) continue;
+      exportEdgeSeen.add(key);
+      pushRel(
+        ns,
+        e.name,
+        ASTEngine.RelationshipType.Exports,
+        1,
+        { clojureSpecific: true, isNamespaceExport: true, evidenceClass: "structural" },
+        e.range?.startLine ?? 0
+      );
+    }
+    const protoDeclares = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (!(s.metadata?.isProtocolMethod || s.metadata?.isInterfaceMethod)) continue;
+      const owner = s.ownerName;
+      if (!owner) continue;
+      let set = protoDeclares.get(owner);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        protoDeclares.set(owner, set);
+      }
+      set.add(s.name);
+    }
+    const protoBySimple = /* @__PURE__ */ new Map();
+    for (const pn of protoDeclares.keys()) {
+      const seg = pn.indexOf(".") >= 0 ? pn.slice(pn.lastIndexOf(".") + 1) : pn;
+      const cur = protoBySimple.get(seg);
+      if (cur) cur.push(pn);
+      else protoBySimple.set(seg, [pn]);
+    }
+    const overrideSeen = /* @__PURE__ */ new Set();
+    for (const cand of overrideCandidates) {
+      let proto = "";
+      for (const p of cand.protos) {
+        if (protoDeclares.has(p)) {
+          proto = p;
+          break;
+        }
+        if (p.indexOf(".") < 0) continue;
+        const cands = protoBySimple.get(p.slice(p.lastIndexOf(".") + 1)) ?? [];
+        if (cands.length === 1) {
+          proto = cands[0];
+          break;
+        }
+      }
+      if (!proto) continue;
+      const declares = protoDeclares.get(proto);
+      if (!declares || !declares.has(cand.method)) continue;
+      const src = `${cand.type}.${cand.method}`;
+      const tgt = `${proto}.${cand.method}`;
+      if (src === tgt) continue;
+      const key = `${src}->${tgt}`;
+      if (overrideSeen.has(key)) continue;
+      overrideSeen.add(key);
+      pushRel(
+        src,
+        tgt,
+        ASTEngine.RelationshipType.Override,
+        1,
+        {
+          clojureSpecific: true,
+          evidenceClass: "structural",
+          isProtocolMethodOverride: true,
+          isReify: cand.form === "reify",
+          isProxy: cand.form === "proxy",
+          isExtendType: cand.form === "extend-type",
+          isExtendProtocol: cand.form === "extend-protocol",
+          isRecord: cand.form === "defrecord",
+          isType: cand.form === "deftype"
+        },
+        cand.line
+      );
+    }
+    let pureCount = 0;
+    let funcCount = 0;
+    for (let _i = 0; _i < symbols.length; _i++) {
+      const s = symbols[_i];
+      if (s.kind === ASTEngine.SymbolKind.Function && !s.metadata?.isMultimethod) {
+        funcCount++;
+        if (s.metadata?.isPure) pureCount++;
+      }
+    }
+    const immutabilityScore = funcCount > 0 ? Math.round(pureCount / funcCount * 100) : 0;
+    const patternsArray = [];
+    for (const p in patterns) patternsArray.push(p);
+    const frameworksArray = [];
+    for (const f in frameworks) frameworksArray.push(f);
+    let score = 50 + immutabilityScore * 0.3;
+    if (!!patterns["Metaprogramming"]) score += 10;
+    if (!!patterns["Protocol-based Polymorphism"]) score += 10;
+    if (!!patterns["Software Transactional Memory"]) score += 5;
+    if (!!patterns["Immutable Data Structures"]) score += 5;
+    if (totalCyclomaticComplexity === 0) totalCyclomaticComplexity = funcCount;
+    {
+      const localDecls = /* @__PURE__ */ new Set();
+      for (const s of symbols) {
+        if (s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.Macro || s.kind === ASTEngine.SymbolKind.Variable) localDecls.add(s.name);
+      }
+      for (let i = 0; i < relationships.length; i++) {
+        const r = relationships[i];
+        if (r.type !== ASTEngine.RelationshipType.Calls) continue;
+        if (typeof r.target !== "string" || r.target.indexOf("/") !== -1 || r.target.indexOf(".") !== -1) continue;
+        if (localDecls.has(r.target)) continue;
+        const lib = referAt(r.target, relOrigins.get(i) ?? 0);
+        if (lib) r.target = `${lib}/${r.target}`;
+      }
+      const seenFinal = /* @__PURE__ */ new Set();
+      for (let i = relationships.length - 1; i >= 0; i--) {
+        const r = relationships[i];
+        const key = `${r.source}|${r.type}|${r.target}|${r.metadata?.callArity ?? ""}|${r.line_number ?? ""}`;
+        if (seenFinal.has(key)) relationships.splice(i, 1);
+        else seenFinal.add(key);
+      }
+    }
+    for (const s of symbols) {
+      const cx = s.metadata?.complexity;
+      if (typeof cx === "number" && s.complexity === void 0) s.complexity = cx;
+    }
+    for (const s of symbols) {
+      const sc = typeof s.scope === "string" ? s.scope : "";
+      if (sc.length === 0 || sc === s.name) continue;
+      s.qualifiedName = `${sc}/${s.name}`;
+    }
+    const LANGUAGE_NAMESPACE_ROOTS = ["clojure", "cljs", "js", "goog", "java", "javax"];
+    {
+      const rootOf = (target) => {
+        if (target.length === 0) return null;
+        const segs = splitOnNamespaceSeparators(target);
+        for (let n = segs.length; n >= 1; n--) {
+          const cand = segs.slice(0, n).join(".");
+          if (LANGUAGE_NAMESPACE_ROOTS.includes(cand)) return cand;
+        }
+        return null;
+      };
+      const declaredHere = /* @__PURE__ */ new Set();
+      for (const s2 of symbols) {
+        if (typeof s2.name === "string" && s2.name.length > 0) declaredHere.add(s2.name);
+      }
+      for (const r of relationships) {
+        const md = r.metadata;
+        if (!md || md.languageNamespace !== void 0) continue;
+        const tgt = typeof r.target === "string" ? r.target : "";
+        if (tgt.length === 0 || declaredHere.has(tgt)) continue;
+        const root = rootOf(tgt);
+        if (root === null) continue;
+        md.languageNamespace = LANGUAGE_NAMESPACE_ROOTS;
+        md.languageNamespacePolicy = "strict-absent";
+        md.languageNamespaceSlash = true;
+        if (md.isExternalTarget !== true) {
+          md.isExternalTarget = true;
+          md.externalReason = "language-platform-namespace";
+          md.externalSpecifier = root;
+        }
+      }
+    }
+    {
+      const libspecs = /* @__PURE__ */ new Set();
+      for (const im of imports) {
+        const m = String(im?.module ?? "");
+        if (m.length > 0) libspecs.add(m);
+      }
+      const libspecList = [...libspecs].sort((a, b) => b.length - a.length);
+      for (const r of relationships) {
+        const md = r.metadata;
+        if (!md || md.packageScope !== void 0) continue;
+        const tgt = typeof r.target === "string" ? r.target : "";
+        if (tgt.length === 0) continue;
+        let member = "";
+        let lib = "";
+        for (const l of libspecList) {
+          if (tgt === l) {
+            member = l;
+            lib = l;
+            break;
+          }
+          if (tgt.startsWith(l + "/")) {
+            member = tgt.slice(l.length + 1);
+            lib = l;
+            break;
+          }
+        }
+        if (member.length === 0 || lib.length === 0) continue;
+        const root = lib.split(".")[0];
+        if (LANGUAGE_NAMESPACE_ROOTS.includes(root)) continue;
+        md.packageScope = { package: lib, name: member };
+      }
+    }
+    this.classifyEvidenceTier(relationships);
+    return {
+      language: "clojure",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        complexity: symbols.length + relationships.length || 1,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity: totalCyclomaticComplexity || 1,
+        framework: frameworksArray[0],
+        patterns: patternsArray,
+        detectedFrameworks: frameworksArray,
+        frameworkPatterns: frameworksArray.length > 0 ? [{ framework: frameworksArray[0], patterns: patternsArray }] : [],
+        architecturalInsights: [],
+        architecturalScore: Math.min(100, Math.round(score)),
+        codeQuality: score >= 80 ? "Excellent" : score >= 60 ? "Good" : "Fair",
+        hasTypeInference: false,
+        hasFrameworkIntelligence: true,
+        immutabilityScore,
+        concurrencyComplexity: !!patterns["Software Transactional Memory"] ? 1 : 0,
+        replDrivenScore: !!patterns["REPL-driven Development"] ? 100 : 0,
+        analysisVersion: "6.0-clojure-yogthos-grammar-pure-ast-single-pass"
+      }
+    };
+  }
+  /**
+   * CLJ-EX3: the EMPTY result for a data file. `.edn` is a data format; this lane
+   * publishes no symbols and no relationships for it (Lead ruling 2026-10-20). The
+   * metadata is the honest zero: one line count, no complexity, no framework, no
+   * type inference, no REPL-driven score, and the same analysisVersion the code
+   * path carries so a consumer can tell a data file from a fallback parser.
+   */
+  dataOnlyResult(content) {
+    return {
+      language: "clojure",
+      symbols: [],
+      relationships: [],
+      imports: [],
+      exports: [],
+      errors: [],
+      metadata: {
+        complexity: 1,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity: 1,
+        framework: void 0,
+        patterns: [],
+        detectedFrameworks: [],
+        frameworkPatterns: [],
+        architecturalInsights: [],
+        architecturalScore: 0,
+        codeQuality: "Fair",
+        hasTypeInference: false,
+        hasFrameworkIntelligence: false,
+        immutabilityScore: 0,
+        concurrencyComplexity: 0,
+        replDrivenScore: 0,
+        analysisVersion: "6.0-clojure-yogthos-grammar-pure-ast-single-pass"
+      }
+    };
+  }
+  /**
+   * M14.0.SPEC SECTION D — EVIDENCE TIERS. Before this pass the lane set `evidenceClass` on exactly
+   * three emission sites (exports/imports/overrides, all `structural`), so section D's ">=2 distinct
+   * tiers pinned" could not be satisfied truthfully and every other relationship carried no tier at
+   * all. The mapping below is the FAMILY convention, copied from `real-typescript-analyzer.ts`
+   * (`classifyEvidenceTier`) rather than invented: contains/exports structural, imports import_based,
+   * references reference_qualified, extends/implements structural (or inferred below confidence 1),
+   * overrides structural/usage_contextual/inferred by confidence, instantiates structural/usage_contextual,
+   * everything else usage_contextual. METADATA ONLY: it adds no relationship, removes none, and
+   * changes no endpoint — the graph is identical before and after (measured: 72/72 clojure fixtures
+   * pass on both sides).
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? r.relationshipType ?? "");
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (t === "contains" || t === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = "reference_qualified";
+        continue;
+      }
+      if (t === "extends" || t === "implements") {
+        md.evidenceClass = conf >= 1 ? "structural" : "inferred";
+        continue;
+      }
+      if (t === "overrides") {
+        md.evidenceClass = conf >= 1 ? "structural" : conf >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = conf >= 0.9 ? "structural" : "usage_contextual";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+};
+export {
+  CLOJURE_CORE_BUILTINS,
+  CLOJURE_SPECIAL_FORMS,
+  RealClojureAnalyzer,
+  carriesPrivateToken,
+  endsWithIgnoreCase,
+  isAnonArgShorthand,
+  isPublishableName,
+  splitOnNamespaceSeparators,
+  whitespaceTokens
+};