@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-2DE27DVC.js

@@ -0,0 +1,1314 @@
+// src/ast/project-index.ts
+import * as fs from "fs";
+var SOLIDITY_DECLARATION_SPEC = {
+  typeNodes: {
+    contract_declaration: "contract",
+    interface_declaration: "interface",
+    library_declaration: "library"
+  },
+  memberNodes: [
+    "function_definition",
+    "modifier_definition",
+    "constructor_definition",
+    "fallback_receive_definition",
+    "state_variable_declaration",
+    "struct_declaration",
+    "enum_declaration",
+    "event_definition",
+    "error_declaration"
+  ],
+  baseNodes: ["inheritance_specifier"]
+};
+var CPP_IDENT_RE = /^[A-Za-z_$][\w$]*$/;
+var cppLeafOfPath = (text) => {
+  let s = text.trim();
+  const lt = s.indexOf("<");
+  if (lt > 0) s = s.slice(0, lt);
+  const cut = s.lastIndexOf("::");
+  const leaf = (cut >= 0 ? s.slice(cut + 2) : s).replace(/^[*&~\s]+/, "");
+  return CPP_IDENT_RE.test(leaf) ? leaf : "";
+};
+var cppDeclaratorName = (n, depth = 0) => {
+  if (!n || depth > 10) return "";
+  const t = n.type;
+  if (t === "identifier" || t === "field_identifier" || t === "type_identifier") return n.text.trim();
+  if (t === "qualified_identifier") return cppLeafOfPath(n.text);
+  if (t === "function_declarator" || t === "abstract_function_declarator" || t === "pointer_declarator" || t === "reference_declarator" || t === "array_declarator" || t === "init_declarator" || t === "parenthesized_declarator" || t === "attributed_declarator") {
+    return cppDeclaratorName(n.childForFieldName("declarator"), depth + 1);
+  }
+  if (t === "template_function" || t === "template_method") {
+    return cppDeclaratorName(n.childForFieldName("name"), depth + 1);
+  }
+  return "";
+};
+var cppDeclaredName = (n) => {
+  const t = n.type;
+  if (t === "class_specifier" || t === "struct_specifier" || t === "union_specifier" || t === "enum_specifier") {
+    const nameField = n.childForFieldName("name");
+    if (nameField) {
+      const direct = nameField.text.trim();
+      if (CPP_IDENT_RE.test(direct)) return direct;
+      const leaf = cppLeafOfPath(nameField.text);
+      if (leaf !== "") return leaf;
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c = n.namedChild(i);
+      if (c && (c.type === "type_identifier" || c.type === "identifier")) return c.text.trim();
+    }
+    return "";
+  }
+  if (t === "enumerator") {
+    const id = n.childForFieldName("name") ?? n.namedChild(0);
+    const name = id?.text.trim() ?? "";
+    return CPP_IDENT_RE.test(name) ? name : "";
+  }
+  if (t === "preproc_def" || t === "preproc_function_def") {
+    const id = n.childForFieldName("name") ?? n.namedChild(0);
+    const name = id?.text.trim() ?? "";
+    return CPP_IDENT_RE.test(name) ? name : "";
+  }
+  if (t === "alias_declaration" || t === "type_definition") {
+    return cppDeclaratorName(n.childForFieldName("declarator"));
+  }
+  return cppDeclaratorName(n.childForFieldName("declarator"));
+};
+var cppBaseNames = (n) => {
+  let clause = null;
+  for (let i = 0; i < n.namedChildCount; i++) {
+    const c = n.namedChild(i);
+    if (c && c.type === "base_class_clause") {
+      clause = c;
+      break;
+    }
+  }
+  if (!clause) return [];
+  const out = [];
+  for (let i = 0; i < clause.namedChildCount; i++) {
+    const c = clause.namedChild(i);
+    if (!c) continue;
+    const t = c.type;
+    if (t === "access_specifier" || t === "virtual") continue;
+    const leaf = t === "type_identifier" ? c.text.trim() : cppLeafOfPath(c.text);
+    if (leaf !== "") out.push(leaf);
+  }
+  return out;
+};
+var CPP_DECLARATION_SPEC = {
+  typeNodes: {
+    class_specifier: "class",
+    struct_specifier: "struct",
+    union_specifier: "union",
+    enum_specifier: "enum"
+  },
+  memberNodes: ["field_declaration", "function_definition", "declaration", "enumerator"],
+  // NO `baseNodes`: the cpp grammar's `base_class_clause` carries no `ancestor` field, so the
+  // baseNodes path reads nothing; `baseResolver` (called on the TYPE node) is the working half.
+  // A FUNCTION BODY IS A SCOPE. Without this, a local declared inside a body would be recorded as a
+  // PROJECT declaration — the fleet rule is that a local is not a project declaration (PY-7's closure
+  // correction). `function_definition` is also a member/nameOnly node: the node's OWN name is read
+  // with the OUTER scope count and only its children see the increment, which is exactly the
+  // behaviour `indexTree` documents for python.
+  scopeNodes: ["function_definition", "lambda_expression"],
+  // Free functions/prototypes and aliases are NAMES the index must carry; they get no DeclarationKind
+  // (the union has no "function" kind and inventing one is a vocabulary decision, not this patch).
+  nameOnlyNodes: ["function_definition", "declaration", "alias_declaration", "type_definition"],
+  nameOnlyIdentifierShaped: true,
+  nameResolver: cppDeclaredName,
+  baseResolver: cppBaseNames
+};
+function staticRubyConstantPath(n) {
+  if (!n) return null;
+  if (n.type === "constant") return n.text;
+  if (n.type === "scope_resolution") {
+    const scope = n.childForFieldName("scope");
+    const name = n.childForFieldName("name");
+    const left = staticRubyConstantPath(scope);
+    const right = name ? name.text : null;
+    if (left && right) return `${left}::${right}`;
+    return right ?? left ?? null;
+  }
+  return null;
+}
+var RUBY_DECLARATION_SPEC = {
+  typeNodes: { class: "class", module: "module" },
+  // `call` is listed for attr_*/alias_method/define_method ONLY; nameResolver returns "" for every other
+  // call, so a call that names nothing is not a member.
+  memberNodes: ["method", "singleton_method", "alias", "call"],
+  scopeNodes: ["method", "singleton_method", "block", "do_block", "lambda"],
+  nameOnlyNodes: ["assignment"],
+  mergeSameKindTypeDecls: true,
+  nameResolver: (node) => {
+    const t = node.type;
+    if (t === "class" || t === "module" || t === "method" || t === "singleton_method") {
+      return node.childForFieldName("name")?.text ?? "";
+    }
+    if (t === "alias") {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && (c.type === "identifier" || c.type === "method_identifier")) return c.text;
+      }
+      return "";
+    }
+    if (t === "assignment") {
+      const left = node.childForFieldName("left");
+      if (!left) return "";
+      const text = left.text;
+      if (text.length === 0) return "";
+      const c0 = text.charCodeAt(0);
+      return c0 >= 65 && c0 <= 90 ? text : "";
+    }
+    if (t === "call") {
+      const m = node.childForFieldName("method")?.text ?? "";
+      const args = node.childForFieldName("arguments");
+      const firstLiteral = () => {
+        if (!args || args.namedChildCount === 0) return "";
+        const a = args.namedChild(0);
+        if (!a) return "";
+        if (a.type === "simple_symbol") {
+          const t2 = a.text;
+          let k = 0;
+          while (k < t2.length && t2[k] === ":") k++;
+          return t2.slice(k);
+        }
+        if (a.type === "string") {
+          const t2 = a.text;
+          return t2.length >= 2 ? t2.slice(1, t2.length - 1) : "";
+        }
+        return "";
+      };
+      if (m === "attr_reader" || m === "attr_writer" || m === "attr_accessor" || m === "attr" || m === "alias_method" || m === "define_method") return firstLiteral();
+      return "";
+    }
+    return "";
+  },
+  baseResolver: (node) => {
+    if (node.type !== "class") return [];
+    const sup = node.childForFieldName("superclass");
+    const inner = sup ? sup.namedChild(0) : null;
+    const path = staticRubyConstantPath(inner);
+    return path ? [path] : [];
+  }
+};
+var TYPESCRIPT_DECLARATION_SPEC = {
+  typeNodes: {
+    class_declaration: "class",
+    interface_declaration: "interface",
+    enum_declaration: "enum",
+    type_alias_declaration: "class"
+  },
+  memberNodes: ["method_definition", "public_field_definition", "method_signature", "property_signature"],
+  memberNodesCallable: ["method_definition", "method_signature"],
+  // FS-P17's name-only channel, applied to the TS declarations whose names a TARGET WRITES but
+  // whose kind this index has no use for: a module-level function, a module/namespace header, and a
+  // top-level binding (`const cloneVNode = …`). The measured gap this closes: a workspace-package
+  // import (`import { cloneVNode } from "@scope/utils"`) names a free FUNCTION in another project
+  // file, and without these names the analyzer can prove the module is the project's own code but
+  // cannot prove the ITEM is declared — the handoff's B-class (55 edges at cap 50, more over the
+  // whole population) stayed unresolved on exactly that. `variable_declarator` brings the
+  // destructuring shapes with it, which is why the identifier-shape guard exists.
+  nameOnlyNodes: [
+    "function_declaration",
+    "generator_function_declaration",
+    "internal_module",
+    "module",
+    "variable_declarator"
+  ],
+  nameOnlyIdentifierShaped: true,
+  scopeNodes: ["function_declaration", "method_definition", "arrow_function", "function_expression"],
+  baseResolver: (node) => {
+    const out = [];
+    let heritage = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "class_heritage") {
+        heritage = c;
+        break;
+      }
+    }
+    if (!heritage) return out;
+    const walk = (n) => {
+      if (n.type === "extends_clause") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c) continue;
+          if (c.type === "identifier" || c.type === "type_identifier") out.push(c.text);
+          else if (c.type === "member_expression" || c.type === "nested_type_identifier") {
+            const leaf = c.childForFieldName("property") ?? c.namedChild(c.namedChildCount - 1);
+            if (leaf && leaf.text) out.push(leaf.text);
+          }
+        }
+        return;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(heritage);
+    return out;
+  }
+};
+var JAVASCRIPT_DECLARATION_SPEC = {
+  typeNodes: {
+    class_declaration: "class"
+  },
+  memberNodes: ["method_definition", "field_definition"],
+  memberNodesCallable: ["method_definition"],
+  nameOnlyNodes: [
+    "function_declaration",
+    "generator_function_declaration",
+    "variable_declarator"
+  ],
+  nameOnlyIdentifierShaped: true,
+  // THE JS GRAMMAR NAMES A FIELD BY `property`, NOT BY `name` (`class C { x = 1 }` is
+  // field_definition { property: (property_identifier) }), so the generic `childForFieldName("name")`
+  // reads "" for every class field and the index held NO field members. Probed: `Panel => render` only,
+  // with `template` missing. Method names use `name`, so both fields are tried in that order.
+  nameResolver: (node) => node.childForFieldName("name")?.text ?? node.childForFieldName("property")?.text ?? "",
+  scopeNodes: [
+    "function_declaration",
+    "generator_function_declaration",
+    "method_definition",
+    "arrow_function",
+    "function_expression"
+  ],
+  baseResolver: (node) => {
+    const out = [];
+    let heritage = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.type === "class_heritage") {
+        heritage = c;
+        break;
+      }
+    }
+    if (!heritage) return out;
+    const walk = (n) => {
+      if (n.type === "class_heritage" || n.type === "extends_clause") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c) continue;
+          if (c.type === "identifier" || c.type === "nested_identifier") out.push(c.text);
+          else if (c.type === "member_expression") {
+            const leaf = c.childForFieldName("property") ?? c.namedChild(c.namedChildCount - 1);
+            if (leaf && leaf.text) out.push(leaf.text);
+          } else if (c.type === "call_expression") {
+            const fn = c.childForFieldName("function");
+            if (fn && (fn.type === "identifier" || fn.type === "member_expression")) {
+              const leaf = fn.type === "member_expression" ? fn.childForFieldName("property") ?? fn.namedChild(fn.namedChildCount - 1) : fn;
+              if (leaf && leaf.text) out.push(leaf.text);
+            }
+          }
+        }
+        return;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(heritage);
+    return out;
+  }
+};
+var PYTHON_DECLARATION_SPEC = {
+  typeNodes: {
+    class_definition: "class"
+  },
+  // Only functions are members. A class-level ASSIGNMENT is a member too, but it is not
+  // inheritable in the sense `overrides` describes — a class variable is not a method, and
+  // indexing it as one repeats PY-21 defect 4, where a base's class variable satisfied the
+  // "base declares this name" test and published fabricated overrides at 0.95. `memberNodesCallable`
+  // is left unset for the same reason: only callable members answer the question.
+  memberNodes: ["function_definition"],
+  scopeNodes: ["function_definition", "lambda"],
+  baseResolver: (node) => {
+    const out = [];
+    const sup = node.childForFieldName("superclasses");
+    if (!sup) return out;
+    for (let i = 0; i < sup.namedChildCount; i++) {
+      const c = sup.namedChild(i);
+      if (!c) continue;
+      if (c.type === "identifier") {
+        out.push(c.text);
+      } else if (c.type === "attribute") {
+        const leaf = c.childForFieldName("attribute") ?? c.namedChild(c.namedChildCount - 1);
+        if (leaf && leaf.text) out.push(leaf.text);
+      }
+    }
+    return out;
+  }
+};
+var DART_DECLARATION_SPEC = {
+  typeNodes: {
+    class_definition: "class",
+    mixin_declaration: "mixin",
+    extension_declaration: "extension",
+    extension_type_declaration: "extension_type",
+    enum_declaration: "enum",
+    // A `type_alias` IS A TYPE DECLARATION IN DART — `typedef ListMixin<E> = ListBase<E>;`
+    // DECLARES the name `ListMixin` for the whole library. The SDK's own `ListMixin` and
+    // `SetMixin` are exactly this (`sdk/lib/collection/list.dart:586` and `set.dart:322`).
+    //
+    // WITHOUT THIS ENTRY THE INDEX HOLDS NOTHING FOR AN ALIAS, and the failure is a REFUTED
+    // CLAIM, not a missing row: a class that applies the alias (`class _BoolArrayList with
+    // ListMixin<bool>`) asks the index whether the base declares the member, the index says
+    // "no such base", the analyzer's first-parent fallback publishes "this base is OUTSIDE the
+    // project", and the arbiter REFUTES it because the project DOES publish the name — as an
+    // alias. MEASURED on the fixed production arm (2026-10-20): 25 refuted rows over 11
+    // distinct targets, every one of them a `ListMixin.*` or `SetMixin.*` member.
+    type_alias: "typedef"
+  },
+  // DART'S MIXIN NAMES LIVE IN A DIRECT `identifier` CHILD, NOT IN A `name` FIELD.
+  //
+  // MEASURED (dart-http, whole project, `--index` arm; the dart lane's diagnosis): the index's
+  // `typeKinds` census was `class 524 · extension_type 278 · extension 183 · enum 16 · unknown 11`
+  // — **mixin 0** — and `typeKinds.has("TerminatableMixin") === false`. The generic
+  // `childForFieldName("name")` reads "" for a `mixin_declaration`, because the grammar puts the
+  // name in a direct `identifier` child (`(mixin_declaration (mixin) (identifier) (class_body))`,
+  // probed). So the spec indexed the right SHAPE and held NOTHING for the name — the failure mode
+  // this file's own header names for a spec that does not match the grammar.
+  //
+  // THE COST WAS A CLAUSE-4 RED, and the arbiter was right: the analyzer's 0.8 first-parent
+  // fallback named the FIRST mixin in a `with A, B` clause, and `isExternalBase` ("the project does
+  // not publish this base") was REFUTED for every row whose base the project does publish. Measured
+  // 5 refuted rows on dart-http (all `TerminatableMixin.*`, whose member is declared by
+  // `ClosableMixin` — the SECOND mixin), and 86 on the whole-population `--index` arm.
+  //
+  // The other Dart declarations DO have a `name` field, so the resolver returns it for them and
+  // changes nothing about them. This is the same `nameResolver` hook the ruby, F#, C++ and protobuf
+  // specs use for exactly this reason.
+  nameResolver: (node) => {
+    if (node.type === "mixin_declaration") {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type === "identifier") return c.text;
+      }
+      return "";
+    }
+    if (node.type === "type_alias") {
+      let first = null;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type === "type_identifier") {
+          first = c;
+          break;
+        }
+      }
+      return first ? first.text : "";
+    }
+    if (node.type === "operator_signature") {
+      const m = /operator\s*([^\s(]+)/.exec(node.text);
+      return m ? `operator ${m[1]}` : "operator";
+    }
+    return node.childForFieldName("name")?.text ?? "";
+  },
+  // Methods and accessors only. `getter_signature` and `setter_signature` count
+  // (Dart overrides both); constructors and fields do not.
+  memberNodes: [
+    "method_signature",
+    "function_signature",
+    "getter_signature",
+    "setter_signature",
+    "operator_signature"
+  ],
+  // NOT the class body. `typeNodes` already resets the member scope when it enters a
+  // declaration, so listing `class_body` here would put every direct member one scope
+  // deep and exclude precisely the members the index exists to record — measured: a
+  // Dart spec with `class_body` in scopeNodes indexed 9 types and ZERO members.
+  // What must be scopes are the BODIES a local function can hide inside, or a local
+  // `function_signature` would be indexed as a member of the enclosing class.
+  scopeNodes: ["function_body", "function_expression_body", "block"],
+  baseResolver: (node) => {
+    const out = [];
+    if (node.type === "type_alias") {
+      let last = null;
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type === "type_identifier") last = c;
+      }
+      if (last && last.text) out.push(last.text);
+      return out;
+    }
+    const pushLeaf = (group) => {
+      if (!group) return;
+      let last = null;
+      for (let i = 0; i < group.namedChildCount; i++) {
+        const c = group.namedChild(i);
+        if (c && c.type === "type_identifier") last = c;
+      }
+      if (last && last.text) out.push(last.text);
+    };
+    for (const c of node.namedChildren) {
+      if (!c) continue;
+      if (c.type === "superclass") {
+        for (const g of c.namedChildren) {
+          if (!g) continue;
+          if (g.type === "type_identifier") out.push(g.text);
+          else if (g.type === "superclass" || g.type === "mixin" || g.type === "interfaces") pushLeaf(g);
+        }
+        continue;
+      }
+      if (c.type === "type_identifier") {
+        out.push(c.text);
+        continue;
+      }
+      if (c.type === "interfaces" || c.type === "mixin_on_clause") pushLeaf(c);
+    }
+    return out;
+  }
+};
+var FSHARP_TYPE_NODES = {
+  // `anon_type_defn` is BOTH a class and an interface — see FSHARP_KIND_RESOLVER below, which is
+  // the whole reason the hook exists. The static entry is the CLASS reading, because a clause
+  // with a constructor is the shape that cannot be an interface, and it is what an index build
+  // with no resolver falls back to.
+  anon_type_defn: "class",
+  record_type_defn: "record",
+  union_type_defn: "union",
+  interface_type_defn: "interface",
+  enum_type_defn: "enum",
+  // An abbreviation (`type Address = int64<address>`) declares a NAME and no kind of its own —
+  // it IS whatever it aliases, which this index cannot see. `unknown` is therefore the accurate
+  // answer here rather than the evasive one it would be for a record.
+  type_abbrev_defn: "unknown",
+  delegate_type_defn: "unknown"
+};
+function fsharpKindResolver(node) {
+  if (node.type !== "anon_type_defn") return void 0;
+  let members = 0;
+  let sawBody = false;
+  const visit = (n) => {
+    for (const c of n.namedChildren) {
+      if (!c) continue;
+      if (FSHARP_TYPE_NODES[c.type] !== void 0) continue;
+      if (c.type === "member_defn") {
+        members++;
+        let abstract = false;
+        for (const inner of c.namedChildren) if (inner?.type === "member_signature") abstract = true;
+        if (!abstract) sawBody = true;
+        continue;
+      }
+      visit(c);
+    }
+  };
+  visit(node);
+  if (members === 0 || sawBody) return void 0;
+  for (const c of node.namedChildren) if (c?.type === "primary_constr_args") return void 0;
+  const parent = node.parent;
+  if (parent) {
+    for (const c of parent.namedChildren) {
+      if (c?.type === "attributes" && /\bAbstractClass\b/.test(c.text)) return void 0;
+    }
+  }
+  return "interface";
+}
+var SCSS_DECLARATION_SPEC = {
+  // The stylesheet root node IS the module declaration, and its name is the file's basename —
+  // which is what `nameFromFile` now makes true. The sentence that used to stand here said
+  // "(handled by the caller via file path)" and NO CALLER EVER PASSED IT, so the extraction was
+  // empty and this spec indexed nothing.
+  nameFromFile: true,
+  typeNodes: {
+    stylesheet: "module"
+  },
+  // Modules are the "types" — the file IS the module
+  nameOnlyNodes: ["use_statement", "forward_statement"],
+  // A Sass module's public surface is EXACTLY its top-level `$variables`, `@mixin`s and
+  // `@function`s — that is what `@use` binds. `declaration` is listed so a top-level `$x: …`
+  // becomes a member; the `nameResolver` below returns "" for any declaration whose
+  // property_name is not `$`-prefixed, so a plain `color: red` at the root is NOT a member.
+  // MEASURED before this list carried `declaration`: `bulma/sass/utilities/initial-variables.scss`
+  // has 65 top-level `$` declarations and the index recorded ZERO members for it, because a
+  // variable is a `declaration` node and no member channel named it.
+  memberNodes: ["mixin_statement", "function_statement", "declaration"],
+  memberNodesCallable: ["mixin_statement", "function_statement"],
+  // Scope nodes: a declaration inside a rule, a mixin/function body, or a control-flow block is
+  // LOCAL to that scope and is not part of the module's surface. `@media` is deliberately ABSENT
+  // for the reason the analyzer records: Sass gives a media query no new variable scope, so a
+  // root-level `@media { $x: 1 }` still assigns the module-level `$x`.
+  scopeNodes: ["mixin_statement", "function_statement", "if_statement", "each_statement", "for_statement", "while_statement", "rule_set"],
+  /**
+   * Read the member name in the spelling the analyzer PUBLISHES, so a cross-file consumer looks up
+   * the same string the declaring file would have published:
+   *   `@mixin button`   -> `button`        (the analyzer's `mixinNames` key is the BARE name, and
+   *                                         `@include ns.button` splits on the dot to reach it)
+   *   `@function double`-> `double`
+   *   `$brand: …`       -> `$brand`        (the analyzer publishes a variable as `$brand`, and a
+   *                                         read edge targets `$brand`, so the `$` is load-bearing)
+   * Anything else (a plain `color: red` declaration, a selector) returns "" and is not a member.
+   */
+  nameResolver: (node) => {
+    const isPrivate = (published) => {
+      const bare = published.startsWith("$") ? published.slice(1) : published;
+      return bare.startsWith("-") || bare.startsWith("_");
+    };
+    if (node.type === "mixin_statement" || node.type === "function_statement") {
+      let bare = "";
+      const viaField = node.childForFieldName("name");
+      if (viaField) bare = viaField.text;
+      else {
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const c = node.namedChild(i);
+          if (c && c.type === "identifier") {
+            bare = c.text;
+            break;
+          }
+        }
+      }
+      return bare !== "" && !isPrivate(bare) ? bare : "";
+    }
+    if (node.type === "declaration") {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type === "property_name") {
+          if (!c.text.startsWith("$")) return "";
+          return isPrivate(c.text) ? "" : c.text;
+        }
+      }
+      return "";
+    }
+    return node.childForFieldName("name")?.text ?? "";
+  }
+};
+var javaTypeOwnName = (n) => {
+  if (n.type === "type_identifier") return n.text.trim();
+  let last = "";
+  const walk = (x) => {
+    if (x.type === "type_arguments") return;
+    if (x.type === "type_identifier") {
+      last = x.text.trim();
+      return;
+    }
+    for (let i = 0; i < x.namedChildCount; i++) {
+      const c = x.namedChild(i);
+      if (c) walk(c);
+    }
+  };
+  walk(n);
+  return last;
+};
+var javaBaseNames = (n) => {
+  const out = [];
+  const push = (name) => {
+    if (name === "" || out.includes(name)) return;
+    out.push(name);
+  };
+  for (let i = 0; i < n.childCount; i++) {
+    const clause = n.child(i);
+    if (!clause) continue;
+    if (clause.type === "superclass") {
+      for (let j = 0; j < clause.childCount; j++) {
+        const c = clause.child(j);
+        if (!c || c.type === "extends" || c.type === "implements") continue;
+        push(javaTypeOwnName(c));
+      }
+      continue;
+    }
+    if (clause.type === "super_interfaces" || clause.type === "extends_interfaces") {
+      for (let j = 0; j < clause.childCount; j++) {
+        const c = clause.child(j);
+        if (!c || c.type === "implements" || c.type === "extends") continue;
+        if (c.type === "type_list") {
+          for (let k = 0; k < c.namedChildCount; k++) {
+            const t = c.namedChild(k);
+            if (t) push(javaTypeOwnName(t));
+          }
+          continue;
+        }
+        push(javaTypeOwnName(c));
+      }
+    }
+  }
+  return out;
+};
+var JAVA_DECLARATION_SPEC = {
+  typeNodes: {
+    class_declaration: "class",
+    interface_declaration: "interface",
+    enum_declaration: "enum",
+    annotation_type_declaration: "interface",
+    record_declaration: "record"
+  },
+  memberNodes: ["method_declaration", "field_declaration", "constructor_declaration", "enum_constant", "annotation_type_element_declaration"],
+  memberNodesCallable: ["method_declaration", "constructor_declaration"],
+  // NO `baseNodes`: tree-sitter-java's `superclass` node carries the base as an UNLABELLED child and
+  // has no `ancestor` field, so the baseNodes path read nothing and java's `typeBases` was EMPTY
+  // (measured: 0 over clojure's 190 files and grails-core's 1,942). `baseResolver` — called on the
+  // TYPE node — is the working half, exactly as it is for cpp.
+  baseResolver: javaBaseNames,
+  qualifyTypeWithFile: true
+};
+var FSHARP_DECLARATION_SPEC = {
+  typeNodes: FSHARP_TYPE_NODES,
+  kindResolver: fsharpKindResolver,
+  // FS-P17, the two named channels. `function_or_value_defn` is F#'s binding node (`let f x = …`,
+  // `let value = 3`) and its identity is the name the analyzer already PUBLISHES for a top-level
+  // binding; `module_defn` and `namespace` are the scope headers, and the analyzer publishes those
+  // as the whole dotted header too (`module Fixture.Project.Domain` names its symbol
+  // `Fixture.Project.Domain`). Both are recorded WITHOUT a kind — see `nameOnlyNodes`.
+  // `named_module` is the FILE-HEADER form (`module Alpha.Beta.Gamma` as the first line) and it is
+  // a DIFFERENT node from `module_defn` entirely — found by dumping the tree, not by reading the
+  // grammar's docs. It is also the most important entry in this list: it is how most F# files
+  // declare their module, and its name is what another file writes targets against.
+  nameOnlyNodes: ["function_or_value_defn", "module_defn", "namespace", "named_module"],
+  // `member this.Speak() = …`, `override this.Speak() = …` and `abstract member Tag : …` are all
+  // `member_defn` — which is exactly the callable surface `overrides` reads. F# properties are
+  // accessors and ARE overridable, so a `member this.Tag` counts; fields are not listed because
+  // they cannot be overridden, the same reasoning PY-21 and DARTD16 record for their grammars.
+  memberNodes: ["member_defn"],
+  memberNodesCallable: ["member_defn"],
+  // A member inside an OBJECT EXPRESSION belongs to the anonymous implementation, not to the
+  // function that encloses it. The fixture has the shape: `let mock = { new System.IDisposable
+  // with override this.Dispose() = () … }` — without this, `Dispose` and `Tag` are published as
+  // members of whatever type the `let` sits in.
+  // FS-P17 adds TWO scope nodes to the object expression, and the second one is a defect the first
+  // draft of this channel shipped rather than a refinement of it. Measured on the lane's own twelve
+  // fixtures (`/tmp/fs-names.mts`): with only `function_or_value_defn` as a scope, the NAME-ONLY
+  // list contained `local` (declared at `call-ownership.fs:67` inside a member body) and `built`
+  // (`call-target-spelling.fs:63`, the same shape) — a local declared in a project DECLARATION, so
+  // every bare call to a name that happens to match a local anywhere in the corpus would be
+  // refined to `in-project-name`. The reason the first draft missed it: a scope node suppresses its
+  // CHILDREN, and a `let` directly inside a member body has no `function_or_value_defn` ABOVE it —
+  // the binding IS the node being visited, so `scopes` was still 0. `member_defn` is what starts
+  // the scope where a body begins.
+  //
+  // Both are scopes for MEMBERS as well as for names: a member inside a nested binding belongs to
+  // the nested binding's object expression, not to the type around it. Neither changes the member
+  // attribution of the member itself — `scopes` is tested BEFORE this increment — which the spec
+  // fixture confirms by reading 22 types-with-members and the same member sets after the change.
+  scopeNodes: ["object_expression", "function_or_value_defn", "member_defn"],
+  nameResolver: (node) => {
+    if (node.type === "namespace" || node.type === "named_module") {
+      for (const c of node.namedChildren) {
+        if (c?.type === "long_identifier" || c?.type === "identifier") return c.text;
+      }
+      return "";
+    }
+    if (node.type === "module_defn") {
+      const ownName = (n) => {
+        const parts = [];
+        for (const c of n.namedChildren) {
+          if (c?.type === "identifier" || c?.type === "long_identifier") parts.push(c.text);
+        }
+        return parts.join(".");
+      };
+      const own = ownName(node);
+      if (own === "") return "";
+      const chain = [own];
+      let p = node.parent;
+      while (p) {
+        if (p.type === "module_defn") {
+          const outer = ownName(p);
+          if (outer !== "") chain.unshift(outer);
+        } else if (p.type === "namespace" || p.type === "named_module") {
+          for (const c of p.namedChildren) {
+            if (c?.type === "long_identifier" || c?.type === "identifier") {
+              chain.unshift(c.text);
+              break;
+            }
+          }
+          break;
+        }
+        p = p.parent;
+      }
+      return chain.join(".");
+    }
+    if (node.type === "function_or_value_defn") {
+      for (const c of node.namedChildren) {
+        if (c?.type !== "function_declaration_left" && c?.type !== "value_declaration_left") continue;
+        const idents = [];
+        const stack = [c];
+        while (stack.length > 0) {
+          const n = stack.shift();
+          if (n.type === "identifier" && n.text) idents.push(n.text);
+          for (const inner of n.namedChildren) if (inner) stack.push(inner);
+        }
+        if (idents.length > 0) return idents[0];
+      }
+      return "";
+    }
+    for (const c of node.namedChildren) {
+      if (!c) continue;
+      if (c.type === "type_name") return c.childForFieldName("type_name")?.text ?? c.text;
+      if (c.type === "method_or_prop_defn") {
+        const method = c.childForFieldName("name")?.childForFieldName("method");
+        if (method?.text) return method.text;
+      }
+      if (c.type === "member_signature") {
+        for (const inner of c.namedChildren) {
+          if (inner && inner.type === "identifier" && inner.text) return inner.text;
+        }
+      }
+    }
+    return node.childForFieldName("name")?.text ?? "";
+  },
+  baseResolver: (node) => {
+    const out = [];
+    const pushLeaf = (n) => {
+      let written = "";
+      for (const c of n.namedChildren) {
+        if (!c) continue;
+        if (c.type === "long_identifier" || c.type === "identifier") {
+          written = c.text;
+          break;
+        }
+      }
+      if (written === "") written = n.text;
+      const segment = written.split(".").filter((s) => s.length > 0).pop() ?? "";
+      const clean = segment.replace(/[<(].*$/, "");
+      if (clean !== "") out.push(clean);
+    };
+    const visit = (n, isRoot) => {
+      for (const c of n.namedChildren) {
+        if (!c) continue;
+        if (c.type === "member_defn" || c.type === "object_expression") continue;
+        if (!isRoot && FSHARP_TYPE_NODES[c.type] !== void 0) continue;
+        if (c.type === "class_inherits_decl" || c.type === "interface_implementation") {
+          for (const inner of c.namedChildren) {
+            if (inner && inner.type === "simple_type") pushLeaf(inner);
+          }
+          continue;
+        }
+        visit(c, false);
+      }
+    };
+    visit(node, true);
+    return out;
+  }
+};
+var clojureExecutionHead = (list) => {
+  for (let i = 0; i < list.namedChildCount; i++) {
+    const child = list.namedChild(i);
+    if (child && child.type !== "comment" && child.type !== "dis_expr" && child.type !== "meta_lit") return child;
+  }
+  return null;
+};
+var clojureSymName = (node) => {
+  if (!node) return "";
+  if (node.type === "sym_lit") {
+    const name = node.childForFieldName("name");
+    const ns = node.childForFieldName("namespace");
+    const nsText = ns && (ns.text ?? "").startsWith("^{") ? ns.childForFieldName("name")?.text ?? ns.text : ns?.text ?? "";
+    if (name && nsText) return `${nsText}/${name.text}`;
+    if (name) return name.text;
+    return node.text;
+  }
+  return node.text;
+};
+var CLOJURE_DECLARATION_FORMS = /* @__PURE__ */ new Set([
+  "def",
+  "defn",
+  "defn-",
+  "defmacro",
+  "defonce",
+  "defmulti",
+  "defmethod",
+  "definterface",
+  "definline",
+  "defprotocol",
+  "defrecord",
+  "deftype",
+  "defstruct",
+  "declare",
+  "defvar"
+]);
+var CLOJURE_TYPE_FORMS = /* @__PURE__ */ new Set([
+  "defprotocol",
+  "defrecord",
+  "deftype",
+  "definterface"
+]);
+var clojureExecutableAfter = (list, after) => {
+  let seen = false;
+  for (let i = 0; i < list.namedChildCount; i++) {
+    const child = list.namedChild(i);
+    if (!child) continue;
+    if (child.type === "comment" || child.type === "dis_expr" || child.type === "meta_lit") continue;
+    if (!seen) {
+      if (child.id === after.id) seen = true;
+      continue;
+    }
+    return child;
+  }
+  return null;
+};
+var clojureFileNamespace = (node) => {
+  let root = node;
+  while (root.parent) root = root.parent;
+  for (let i = 0; i < root.namedChildCount; i++) {
+    const child = root.namedChild(i);
+    if (!child || child.type !== "list_lit") continue;
+    const head = clojureExecutionHead(child);
+    if (!head || head.type !== "sym_lit" || clojureSymName(head) !== "ns") continue;
+    const nameNode = clojureExecutableAfter(child, head);
+    if (!nameNode || nameNode.type !== "sym_lit") return "";
+    return clojureSymName(nameNode);
+  }
+  return "";
+};
+var clojureDeclarationName = (node, _fileName) => {
+  if (node.type !== "list_lit") return "";
+  const head = clojureExecutionHead(node);
+  if (!head || head.type !== "sym_lit") return "";
+  const ns = clojureFileNamespace(node);
+  const parent = node.parent;
+  if (parent && parent.type === "list_lit") {
+    const parentHead = clojureExecutionHead(parent);
+    if (parentHead && parentHead.type === "sym_lit" && CLOJURE_TYPE_FORMS.has(clojureSymName(parentHead))) {
+      const typeNode = clojureExecutableAfter(parent, parentHead);
+      const typeName = typeNode && typeNode.type === "sym_lit" ? clojureSymName(typeNode) : "";
+      const method = clojureSymName(head);
+      if (typeName === "" || method === "") return "";
+      return ns === "" ? method : `${ns}.${typeName}/${method}`;
+    }
+  }
+  if (!CLOJURE_DECLARATION_FORMS.has(clojureSymName(head))) return "";
+  const nameNode = clojureExecutableAfter(node, head);
+  if (!nameNode || nameNode.type !== "sym_lit") return "";
+  const name = clojureSymName(nameNode);
+  if (name === "") return "";
+  if (ns === "") return name;
+  const slash = name.lastIndexOf("/");
+  if (slash > 0) return `${ns}.${name.slice(0, slash)}/${name.slice(slash + 1)}`;
+  return `${ns}/${name}`;
+};
+var CLOJURE_DECLARATION_SPEC = {
+  typeNodes: {},
+  memberNodes: [],
+  nameOnlyNodes: ["list_lit"],
+  nameResolver: clojureDeclarationName
+};
+function addTo(map, key, value) {
+  let set = map.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    map.set(key, set);
+  }
+  set.add(value);
+}
+function indexTree(root, index, spec, fileName) {
+  const stack = [
+    { node: root, owner: null, scopes: 0 }
+  ];
+  const nameOf = (n) => spec.nameResolver !== void 0 ? spec.nameResolver(n, fileName) : n.childForFieldName("name")?.text ?? "";
+  while (stack.length > 0) {
+    const { node, owner, scopes } = stack.pop();
+    let nextOwner = owner;
+    let nextScopes = scopes + (spec.scopeNodes?.includes(node.type) ? 1 : 0);
+    const staticKind = spec.typeNodes[node.type];
+    let kind = staticKind;
+    if (staticKind !== void 0 && spec.kindResolver !== void 0) {
+      const resolved = spec.kindResolver(node);
+      if (resolved !== void 0) kind = resolved;
+    }
+    if (kind !== void 0) {
+      let name = nameOf(node);
+      if (name === "" && spec.nameFromFile === true && fileName !== void 0 && fileName !== "") {
+        name = fileName.split(/[\\/]/).pop() ?? "";
+      }
+      if (name !== "") {
+        if (spec.qualifyTypeWithFile === true && fileName !== void 0 && fileName !== "") {
+          const rel = fileName.split(/[\\/]/).filter((seg) => seg.length > 0);
+          rel.pop();
+          for (let i = 0; i < rel.length; i++) {
+            const prefix = rel.slice(i).join(".");
+            if (prefix === "") continue;
+            const qualified = `${prefix}.${name}`;
+            if (!index.typeKinds.has(qualified)) index.typeKinds.set(qualified, kind);
+            index.symbolNames.add(qualified);
+            index.symbolCounts.set(qualified, (index.symbolCounts.get(qualified) ?? 0) + 1);
+          }
+        }
+        const prior = index.typeKinds.get(name);
+        const reopened = prior !== void 0 && prior === kind && spec.mergeSameKindTypeDecls === true;
+        if (prior === void 0) index.typeKinds.set(name, kind);
+        else if (prior !== kind) index.typeKinds.set(name, "unknown");
+        index.symbolNames.add(name);
+        if (!reopened) index.symbolCounts.set(name, (index.symbolCounts.get(name) ?? 0) + 1);
+        nextOwner = name;
+        nextScopes = 0;
+      }
+    }
+    if (spec.nameOnlyNodes !== void 0 && scopes === 0 && spec.typeNodes[node.type] === void 0 && spec.nameOnlyNodes.includes(node.type)) {
+      const name = nameOf(node);
+      const identifierShaped = !spec.nameOnlyIdentifierShaped || /^[A-Za-z_$][A-Za-z0-9_$]*(\.[A-Za-z_$][A-Za-z0-9_$]*)*$/.test(name);
+      if (name !== "" && identifierShaped) {
+        index.symbolNames.add(name);
+        index.symbolCounts.set(name, (index.symbolCounts.get(name) ?? 0) + 1);
+        const dot = name.lastIndexOf(".");
+        if (dot > 0) {
+          const leaf = name.slice(dot + 1);
+          index.symbolNames.add(leaf);
+          index.symbolCounts.set(leaf, (index.symbolCounts.get(leaf) ?? 0) + 1);
+        }
+      }
+    }
+    if (owner !== null && scopes === 0 && spec.memberNodes.includes(node.type)) {
+      const name = nameOf(node);
+      if (name !== "") {
+        addTo(index.typeMembers, owner, name);
+        index.symbolNames.add(name);
+      }
+    }
+    if (owner !== null && spec.baseNodes?.includes(node.type)) {
+      const ownerName = index.typeKinds.has(owner) ? owner : null;
+      if (ownerName !== null) {
+        const anc = node.childForFieldName("ancestor");
+        let baseName = "";
+        if (anc) {
+          const stack2 = [anc];
+          let last = "";
+          while (stack2.length > 0) {
+            const n = stack2.pop();
+            if (n.type === "identifier") last = n.text;
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c) stack2.push(c);
+            }
+          }
+          baseName = last;
+        }
+        if (baseName !== "") {
+          let list = index.typeBases.get(ownerName);
+          if (!list) {
+            list = [];
+            index.typeBases.set(ownerName, list);
+          }
+          if (!list.includes(baseName)) list.push(baseName);
+        }
+      }
+    }
+    if (spec.baseResolver !== void 0 && kind !== void 0) {
+      const ownerName = nameOf(node);
+      if (ownerName !== "") {
+        for (const baseName of spec.baseResolver(node)) {
+          if (baseName === "") continue;
+          let list = index.typeBases.get(ownerName);
+          if (!list) {
+            list = [];
+            index.typeBases.set(ownerName, list);
+          }
+          if (!list.includes(baseName)) list.push(baseName);
+        }
+      }
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c) stack.push({ node: c, owner: nextOwner, scopes: nextScopes });
+    }
+  }
+}
+function emptyProjectIndex() {
+  return {
+    typeKinds: /* @__PURE__ */ new Map(),
+    typeMembers: /* @__PURE__ */ new Map(),
+    typeBases: /* @__PURE__ */ new Map(),
+    symbolNames: /* @__PURE__ */ new Set(),
+    modules: /* @__PURE__ */ new Set(),
+    symbolCounts: /* @__PURE__ */ new Map(),
+    damagedFiles: /* @__PURE__ */ new Set(),
+    stats: { files: 0, damaged: 0 },
+    // FALSE, NOT undefined: an empty index is the least complete index there is, and a reader that
+    // trusts it would certify every bare name in the corpus as external.
+    complete: false
+  };
+}
+function buildProjectIndex(files, spec = SOLIDITY_DECLARATION_SPEC) {
+  const index = emptyProjectIndex();
+  for (const f of files) {
+    index.stats.files++;
+    index.modules.add(f.path);
+    {
+      const base = f.path.split(/[\\/]/).pop() ?? "";
+      if (base !== "") {
+        index.modules.add(base);
+        const stem = base.replace(/\.[^.]+$/, "");
+        if (stem !== "") index.modules.add(stem);
+      }
+    }
+    if (f.tree.hasError) {
+      index.stats.damaged++;
+      index.damagedFiles.add(f.path);
+    }
+    indexTree(f.tree.rootNode, index, spec, f.path);
+  }
+  return index;
+}
+async function buildProjectIndexFromDisk(wasmPath, files, spec = SOLIDITY_DECLARATION_SPEC) {
+  const WTS = await import("web-tree-sitter");
+  await WTS.Parser.init();
+  const language = await WTS.Language.load(fs.readFileSync(wasmPath));
+  const parser = new WTS.Parser();
+  parser.setLanguage(language);
+  const parsed = [];
+  for (const f of files) {
+    const text = fs.readFileSync(f, "utf8");
+    const tree = parser.parse(text);
+    if (tree === null) throw new Error(`project index: ${f} produced no parse tree`);
+    parsed.push({ path: f, tree });
+  }
+  return buildProjectIndex(parsed, spec);
+}
+async function buildProjectIndexStreaming(wasmPath, files, spec = SOLIDITY_DECLARATION_SPEC, onProgress) {
+  const WTS = await import("web-tree-sitter");
+  await WTS.Parser.init();
+  const language = await WTS.Language.load(fs.readFileSync(wasmPath));
+  const parser = new WTS.Parser();
+  parser.setLanguage(language);
+  const index = emptyProjectIndex();
+  let done = 0;
+  let damaged = 0;
+  const addModuleIdentity = (path) => {
+    index.modules.add(path);
+    const base = path.split(/[\\/]/).pop() ?? "";
+    if (base !== "") {
+      index.modules.add(base);
+      const stem = base.replace(/\.[^.]+$/, "");
+      if (stem !== "") index.modules.add(stem);
+    }
+  };
+  for (const f of files) {
+    let text;
+    try {
+      text = fs.readFileSync(f, "utf8");
+    } catch {
+      damaged++;
+      index.damagedFiles.add(f);
+      done++;
+      continue;
+    }
+    addModuleIdentity(f);
+    let tree = null;
+    try {
+      tree = parser.parse(text);
+      if (tree?.rootNode) {
+        indexTree(tree.rootNode, index, spec, f);
+        if (tree.rootNode.hasError) index.damagedFiles.add(f);
+      } else {
+        damaged++;
+        index.damagedFiles.add(f);
+      }
+    } catch {
+      damaged++;
+      index.damagedFiles.add(f);
+    } finally {
+      try {
+        tree?.delete?.();
+      } catch {
+      }
+    }
+    done++;
+    if (onProgress && done % 500 === 0) onProgress(done, files.length);
+  }
+  index.stats = { files: done - damaged, damaged };
+  return index;
+}
+function buildResolutionTables(index) {
+  const allMembers = /* @__PURE__ */ new Map();
+  const memberOwners = /* @__PURE__ */ new Map();
+  const memberDeclarer = /* @__PURE__ */ new Map();
+  const memberDeclarers = /* @__PURE__ */ new Map();
+  const closure = (typeName, seen = /* @__PURE__ */ new Set()) => {
+    const cached = allMembers.get(typeName);
+    if (cached) return cached;
+    if (seen.has(typeName)) return /* @__PURE__ */ new Set();
+    seen.add(typeName);
+    const out = new Set(index.typeMembers.get(typeName) ?? []);
+    for (const b of index.typeBases.get(typeName) ?? []) {
+      for (const m of closure(b, seen)) out.add(m);
+    }
+    allMembers.set(typeName, out);
+    return out;
+  };
+  const lineage = (typeName, seen = /* @__PURE__ */ new Set()) => {
+    const out = /* @__PURE__ */ new Set();
+    if (seen.has(typeName)) return out;
+    seen.add(typeName);
+    out.add(typeName);
+    for (const b of index.typeBases.get(typeName) ?? []) {
+      for (const t of lineage(b, seen)) out.add(t);
+    }
+    return out;
+  };
+  for (const typeName of index.typeKinds.keys()) {
+    for (const m of closure(typeName)) addTo(memberOwners, m, typeName);
+  }
+  for (const [typeName, members] of index.typeMembers) {
+    for (const m of members) memberDeclarers.set(m, (memberDeclarers.get(m) ?? 0) + 1);
+  }
+  for (const typeName of index.typeKinds.keys()) {
+    const byName = /* @__PURE__ */ new Map();
+    const line = lineage(typeName);
+    for (const m of closure(typeName)) {
+      let declarer = null;
+      for (const t of line) {
+        if (!(index.typeMembers.get(t)?.has(m) ?? false)) continue;
+        if (declarer === null) declarer = t;
+        else if (declarer !== t) {
+          declarer = null;
+          break;
+        }
+      }
+      byName.set(m, declarer);
+    }
+    memberDeclarer.set(typeName, byName);
+  }
+  ;
+  index.__closedMembers = allMembers;
+  return { memberOwners, allMembers, memberDeclarer, memberDeclarers };
+}
+async function enrichWithProjectIndex(files, parse, spec = SOLIDITY_DECLARATION_SPEC, wasmPath) {
+  let index;
+  if (wasmPath) {
+    index = await buildProjectIndexFromDisk(wasmPath, files, spec);
+  } else {
+    throw new Error(
+      "enrichWithProjectIndex needs a wasmPath, or a caller-supplied index. Building the index requires a parser, and this module deliberately does not create one."
+    );
+  }
+  buildResolutionTables(index);
+  const results = [];
+  for (const file of files) {
+    results.push(await parse(file, { projectIndex: index }));
+  }
+  return { results, index };
+}
+function serializeProjectIndex(index) {
+  if (index.__closedMembers === void 0) buildResolutionTables(index);
+  return {
+    version: 1,
+    typeKinds: [...index.typeKinds.entries()],
+    typeMembers: [...index.typeMembers.entries()].map(([k, v]) => [k, [...v]]),
+    typeBases: [...index.typeBases.entries()].map(([k, v]) => [k, [...v]]),
+    // A FIELD THE ANALYZER READS MUST SURVIVE THE WIRE. The index is built in the parent and
+    // deserialised in every worker, so anything omitted here reads `undefined` at the only place it is
+    // used -- the defect this file already records for `__closedMembers`.
+    modules: [...index.modules],
+    symbolCounts: [...index.symbolCounts.entries()],
+    symbolNames: [...index.symbolNames],
+    damagedFiles: [...index.damagedFiles],
+    stats: { ...index.stats },
+    // `=== true` rather than a truthy pass-through: nothing but the literal boolean true may
+    // serialize as complete.
+    complete: index.complete === true,
+    closedMembers: [...index.__closedMembers?.entries() ?? []].map(([k, v]) => [k, [...v]])
+  };
+}
+function deserializeProjectIndex(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const r = raw;
+  if (r.version !== 1) return null;
+  if (!Array.isArray(r.typeKinds) || !Array.isArray(r.typeMembers) || !Array.isArray(r.typeBases) || !Array.isArray(r.symbolNames)) return null;
+  const index = emptyProjectIndex();
+  for (const [k, v] of r.typeKinds) index.typeKinds.set(k, v);
+  for (const [k, v] of r.typeMembers) index.typeMembers.set(k, new Set(v));
+  for (const [k, v] of r.typeBases) index.typeBases.set(k, [...v]);
+  for (const n of r.symbolNames) index.symbolNames.add(n);
+  for (const m of r.modules ?? []) index.modules.add(m);
+  for (const [k, v] of r.symbolCounts ?? []) index.symbolCounts.set(k, v);
+  for (const f of r.damagedFiles ?? []) index.damagedFiles.add(f);
+  index.stats = { files: r.stats?.files ?? 0, damaged: r.stats?.damaged ?? 0 };
+  index.complete = r.complete === true;
+  if (Array.isArray(r.closedMembers)) {
+    ;
+    index.__closedMembers = new Map(r.closedMembers.map(([k, v]) => [k, new Set(v)]));
+  }
+  return index;
+}
+function roundTripProjectIndex(index) {
+  const problems = [];
+  const wire = JSON.parse(JSON.stringify(serializeProjectIndex(index)));
+  const back = deserializeProjectIndex(wire);
+  if (back === null) {
+    problems.push("deserializeProjectIndex returned null for a well-formed payload");
+    return problems;
+  }
+  if (back.typeKinds.size !== index.typeKinds.size) {
+    problems.push(`typeKinds: ${back.typeKinds.size} of ${index.typeKinds.size}`);
+  }
+  if (back.symbolNames.size !== index.symbolNames.size) {
+    problems.push(`symbolNames: ${back.symbolNames.size} of ${index.symbolNames.size}`);
+  }
+  if (back.typeMembers.size !== index.typeMembers.size) {
+    problems.push(`typeMembers: ${back.typeMembers.size} of ${index.typeMembers.size}`);
+  }
+  if (back.typeBases.size !== index.typeBases.size) {
+    problems.push(`typeBases: ${back.typeBases.size} of ${index.typeBases.size}`);
+  }
+  let memberTotal = 0;
+  for (const [k, v] of index.typeMembers) {
+    const got = back.typeMembers.get(k);
+    if (got === void 0) {
+      problems.push(`typeMembers lost the key ${k}`);
+      continue;
+    }
+    if (got.size !== v.size) problems.push(`typeMembers[${k}]: ${got.size} of ${v.size}`);
+    memberTotal += v.size;
+  }
+  for (const [k, v] of index.typeBases) {
+    const got = back.typeBases.get(k);
+    if (got === void 0) {
+      problems.push(`typeBases lost the key ${k}`);
+      continue;
+    }
+    if (got.length !== v.length) problems.push(`typeBases[${k}]: ${got.length} of ${v.length}`);
+  }
+  if (back.stats.files !== index.stats.files) problems.push("stats.files");
+  if (back.stats.damaged !== index.stats.damaged) problems.push("stats.damaged");
+  if (back.damagedFiles.size !== index.damagedFiles.size) problems.push("damagedFiles");
+  {
+    const before = index.__closedMembers;
+    const after = back.__closedMembers;
+    if ((before?.size ?? 0) !== (after?.size ?? 0)) {
+      problems.push(`__closedMembers: ${after?.size ?? 0} of ${before?.size ?? 0}`);
+    } else if (before !== void 0 && after !== void 0) {
+      for (const [k, v] of before) {
+        const got = after.get(k);
+        if (got === void 0) {
+          problems.push(`__closedMembers lost the key ${k}`);
+          continue;
+        }
+        if (got.size !== v.size) problems.push(`__closedMembers[${k}]: ${got.size} of ${v.size}`);
+      }
+    }
+  }
+  const probe = index.typeMembers.keys().next().value;
+  if (probe !== void 0) {
+    const before = [...index.typeMembers.get(probe) ?? []].sort();
+    const after = [...back.typeMembers.get(probe) ?? []].sort();
+    if (JSON.stringify(before) !== JSON.stringify(after)) {
+      problems.push(`typeMembers[${probe}] contents differ after the round trip`);
+    }
+  }
+  return problems;
+}
+
+export {
+  SOLIDITY_DECLARATION_SPEC,
+  CPP_DECLARATION_SPEC,
+  RUBY_DECLARATION_SPEC,
+  TYPESCRIPT_DECLARATION_SPEC,
+  JAVASCRIPT_DECLARATION_SPEC,
+  PYTHON_DECLARATION_SPEC,
+  DART_DECLARATION_SPEC,
+  SCSS_DECLARATION_SPEC,
+  JAVA_DECLARATION_SPEC,
+  FSHARP_DECLARATION_SPEC,
+  clojureExecutionHead,
+  clojureSymName,
+  CLOJURE_DECLARATION_FORMS,
+  clojureFileNamespace,
+  clojureDeclarationName,
+  CLOJURE_DECLARATION_SPEC,
+  indexTree,
+  emptyProjectIndex,
+  buildProjectIndex,
+  buildProjectIndexFromDisk,
+  buildProjectIndexStreaming,
+  buildResolutionTables,
+  enrichWithProjectIndex,
+  serializeProjectIndex,
+  deserializeProjectIndex,
+  roundTripProjectIndex
+};