docsgov 0.1.0

package/dist/codeq/resolvers/typescript.js

@@ -0,0 +1,366 @@
+// Port of internal/codeq/typescript_lang.go: the TypeScript per-language
+// Resolver. It resolves CodeRefs against .ts (typescript grammar) / .tsx (tsx
+// grammar) source via tree-sitter.
+//
+// This module is grammar-agnostic in code but grammar-bound in data: the factory
+// createTSResolver(language) is called ONCE PER GRAMMAR (typescript and tsx are
+// distinct Languages), so each resolver carries its own compiled query set
+// (buildTSQueries) bound to the Language it was built from. The dispatch layer
+// (resolver.ts) routes .ts→typescript resolver and .tsx→tsx resolver.
+//
+// DEVIATION from Go (recorded in resolver.ts): resolve() is SYNC and receives
+// the already-read+decoded `source`; the cache.Read + ErrFileNotFound prelude
+// lives in the dispatch layer. `path` is passed ONLY to build ParseFailedError.
+import { ParseFailedError } from "../errors.js";
+import { signaturesMatch } from "../signature.js";
+import { collectCapture, collectOwned, refKind, suggestFromExtractors, } from "../suggest.js";
+import { Parser, nodeText, parseTree, runQuery, } from "../treesitter.js";
+import { buildTSQueries } from "./typescript_queries.js";
+/**
+ * createTSResolver builds a Resolver for one TypeScript dialect grammar,
+ * compiling that grammar's queries eagerly. Called once per grammar (typescript
+ * for .ts, tsx for .tsx). The analogue of Go's newTSResolver.
+ */
+export function createTSResolver(language) {
+    const q = buildTSQueries(language);
+    return new TSResolver(language, q);
+}
+class TSResolver {
+    language;
+    q;
+    constructor(language, q) {
+        this.language = language;
+        this.q = q;
+    }
+    /**
+     * resolve parses `source` and delegates based on which facets of `ref` are
+     * set. Mirrors tsResolver.Resolve's dispatch precedence exactly.
+     *
+     * Throws ParseFailedError(path) when the parse tree has ERROR nodes (Go's
+     * ErrParseFailed). Returns true=found, false=absent otherwise.
+     */
+    resolve(source, path, ref) {
+        const parser = new Parser();
+        parser.setLanguage(this.language);
+        const root = parseTree(parser, source);
+        if (root.hasError) {
+            throw new ParseFailedError(path);
+        }
+        // Dispatch precedence matches typescript_lang.go's Resolve switch.
+        if (ref.Member !== "" && ref.Param !== "") {
+            return this.findMemberParam(root, ref.Symbol, ref.Member, ref.Param, ref.Signature);
+        }
+        if (ref.Member !== "") {
+            return this.findMember(root, ref.Symbol, ref.Member, ref.Signature);
+        }
+        if (ref.Signature !== undefined && ref.Param !== "") {
+            return this.findBareSignatureParam(root, ref.Symbol, ref.Param, ref.Signature);
+        }
+        if (ref.Signature !== undefined) {
+            return this.findBareSignature(root, ref.Symbol, ref.Signature);
+        }
+        if (ref.Param !== "") {
+            return this.findParam(root, ref.Symbol, ref.Param);
+        }
+        return this.findSymbol(root, ref.Symbol);
+    }
+    /**
+     * suggest lists same-kind candidate names for a not-found ref (best-effort; a
+     * parse error yields no candidates). Params are gathered from BOTH sources
+     * findParam scans — methods named `fn` and top-level functions named `fn`.
+     */
+    suggest(source, _path, ref) {
+        const parser = new Parser();
+        parser.setLanguage(this.language);
+        const root = parseTree(parser, source);
+        if (root.hasError) {
+            return { kind: refKind(ref), candidates: [] };
+        }
+        return suggestFromExtractors(root, ref, {
+            symbolNames: (r) => collectCapture(r, this.q.symbol, "name"),
+            memberNames: (r, owner) => collectOwned(r, this.q.member, owner, "owner", "name"),
+            paramNames: (r, fn) => this.collectParamNames(r, fn),
+        });
+    }
+    /**
+     * collectParamNames lists the parameter names of every method or top-level
+     * function named `fn` — the union findParam searches. Destructured params are
+     * skipped (tsParamNames mirrors tsParamExists's identifier-only resolution).
+     */
+    collectParamNames(root, fn) {
+        const out = [];
+        for (const m of runQuery(root, this.q.memberDecl)) {
+            const mname = m.captures["mname"];
+            const mdecl = m.captures["mdecl"];
+            if (mname !== undefined && mdecl !== undefined && nodeText(mname) === fn) {
+                out.push(...tsParamNames(mdecl));
+            }
+        }
+        for (const m of runQuery(root, this.q.funcDecl)) {
+            const fname = m.captures["fname"];
+            const fdecl = m.captures["fdecl"];
+            if (fname !== undefined && fdecl !== undefined && nodeText(fname) === fn) {
+                out.push(...tsParamNames(fdecl));
+            }
+        }
+        return out;
+    }
+    // findSymbol searches for a top-level declaration named `name`.
+    findSymbol(root, name) {
+        for (const m of runQuery(root, this.q.symbol)) {
+            const n = m.captures["name"];
+            if (n !== undefined && nodeText(n) === name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // findMember searches for a field or method named `member` on the container
+    // named `symbol`. When `sig` is given, only method overloads whose param types
+    // satisfy signaturesMatch are considered; fields are matched by name only.
+    findMember(root, symbol, member, sig) {
+        if (sig === undefined) {
+            // Name-only: the flat member query matches fields AND methods.
+            for (const m of runQuery(root, this.q.member)) {
+                const owner = m.captures["owner"];
+                const name = m.captures["name"];
+                if (owner !== undefined &&
+                    name !== undefined &&
+                    nodeText(owner) === symbol &&
+                    nodeText(name) === member) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        // Signature-filtered: iterate method declarations and check param types.
+        for (const m of runQuery(root, this.q.memberDecl)) {
+            const owner = m.captures["owner"];
+            const mname = m.captures["mname"];
+            const mdecl = m.captures["mdecl"];
+            if (owner !== undefined &&
+                mname !== undefined &&
+                mdecl !== undefined &&
+                nodeText(owner) === symbol &&
+                nodeText(mname) === member &&
+                signaturesMatch(sig, collectTSParamTypes(mdecl))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // findMemberParam searches for a parameter named `paramName` on a method named
+    // `member` of the container named `symbol`. When `sig` is given, only the
+    // overload whose param types satisfy signaturesMatch is considered.
+    findMemberParam(root, symbol, member, paramName, sig) {
+        for (const m of runQuery(root, this.q.memberDecl)) {
+            const owner = m.captures["owner"];
+            const mname = m.captures["mname"];
+            const mdecl = m.captures["mdecl"];
+            if (owner === undefined ||
+                mname === undefined ||
+                mdecl === undefined ||
+                nodeText(owner) !== symbol ||
+                nodeText(mname) !== member) {
+                continue;
+            }
+            if (sig !== undefined && !signaturesMatch(sig, collectTSParamTypes(mdecl))) {
+                continue;
+            }
+            if (tsParamExists(mdecl, paramName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // findParam searches for a parameter named `paramName` on any method or
+    // top-level function named `symbol`.
+    findParam(root, symbol, paramName) {
+        // (a) Member decls: any method on a class with mname==symbol.
+        for (const m of runQuery(root, this.q.memberDecl)) {
+            const mname = m.captures["mname"];
+            const mdecl = m.captures["mdecl"];
+            if (mname !== undefined &&
+                mdecl !== undefined &&
+                nodeText(mname) === symbol &&
+                tsParamExists(mdecl, paramName)) {
+                return true;
+            }
+        }
+        // (b) Top-level function decls: fname==symbol.
+        for (const m of runQuery(root, this.q.funcDecl)) {
+            const fname = m.captures["fname"];
+            const fdecl = m.captures["fdecl"];
+            if (fname !== undefined &&
+                fdecl !== undefined &&
+                nodeText(fname) === symbol &&
+                tsParamExists(fdecl, paramName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // findBareSignature resolves a bare-symbol + signature ref (no member): either
+    // a constructor (method named "constructor" on the class) OR a top-level
+    // function named `symbol`. First signature match wins.
+    findBareSignature(root, symbol, sig) {
+        // (a) Constructor: method decls on `symbol` named "constructor".
+        for (const m of runQuery(root, this.q.memberDecl)) {
+            const owner = m.captures["owner"];
+            const mname = m.captures["mname"];
+            const mdecl = m.captures["mdecl"];
+            if (owner !== undefined &&
+                mname !== undefined &&
+                mdecl !== undefined &&
+                nodeText(owner) === symbol &&
+                nodeText(mname) === "constructor" &&
+                signaturesMatch(sig, collectTSParamTypes(mdecl))) {
+                return true;
+            }
+        }
+        // (b) Top-level function named `symbol`.
+        for (const m of runQuery(root, this.q.funcDecl)) {
+            const fname = m.captures["fname"];
+            const fdecl = m.captures["fdecl"];
+            if (fname !== undefined &&
+                fdecl !== undefined &&
+                nodeText(fname) === symbol &&
+                signaturesMatch(sig, collectTSParamTypes(fdecl))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // findBareSignatureParam: same two sources as findBareSignature, requires a
+    // signature match, then reports whether paramName exists in that declaration.
+    findBareSignatureParam(root, symbol, paramName, sig) {
+        // (a) Constructor.
+        for (const m of runQuery(root, this.q.memberDecl)) {
+            const owner = m.captures["owner"];
+            const mname = m.captures["mname"];
+            const mdecl = m.captures["mdecl"];
+            if (owner !== undefined &&
+                mname !== undefined &&
+                mdecl !== undefined &&
+                nodeText(owner) === symbol &&
+                nodeText(mname) === "constructor" &&
+                signaturesMatch(sig, collectTSParamTypes(mdecl))) {
+                return tsParamExists(mdecl, paramName);
+            }
+        }
+        // (b) Top-level function.
+        for (const m of runQuery(root, this.q.funcDecl)) {
+            const fname = m.captures["fname"];
+            const fdecl = m.captures["fdecl"];
+            if (fname !== undefined &&
+                fdecl !== undefined &&
+                nodeText(fname) === symbol &&
+                signaturesMatch(sig, collectTSParamTypes(fdecl))) {
+                return tsParamExists(fdecl, paramName);
+            }
+        }
+        return false;
+    }
+}
+/**
+ * collectTSParamTypes returns the declared parameter types of a method/function
+ * declaration node in document order. The name is irrelevant; the type is the
+ * text of each parameter's type_annotation child with the leading ":" dropped
+ * (i.e. the first named child of the type_annotation). required_parameter and
+ * optional_parameter are both handled; rest params carry their own "T[]"
+ * annotation, so no special varargs handling is needed. An untyped parameter
+ * contributes "".
+ */
+function collectTSParamTypes(decl) {
+    const fp = firstChildOfType(decl, "formal_parameters");
+    if (fp === null) {
+        return [];
+    }
+    const types = [];
+    for (let i = 0; i < fp.childCount; i++) {
+        const c = fp.child(i);
+        if (c === null) {
+            continue;
+        }
+        if (c.type !== "required_parameter" && c.type !== "optional_parameter") {
+            continue;
+        }
+        let ta = c.childForFieldName("type"); // type_annotation node, or null if untyped
+        if (ta === null) {
+            // No "type" field: scan children for a type_annotation.
+            ta = firstChildOfType(c, "type_annotation");
+        }
+        if (ta === null || ta.namedChildCount === 0) {
+            types.push("");
+            continue;
+        }
+        const typeNode = ta.namedChild(0); // the type node after ":"
+        types.push(typeNode === null ? "" : nodeText(typeNode));
+    }
+    return types;
+}
+/**
+ * tsParamNames lists the resolvable parameter names in the formal_parameters of
+ * `decl`, in document order. It mirrors tsParamExists's resolvable set (identifier
+ * patterns only; destructured params skipped), so a suggested name is always one
+ * tsParamExists would have matched.
+ */
+function tsParamNames(decl) {
+    const fp = firstChildOfType(decl, "formal_parameters");
+    if (fp === null) {
+        return [];
+    }
+    const names = [];
+    for (let i = 0; i < fp.childCount; i++) {
+        const c = fp.child(i);
+        if (c === null) {
+            continue;
+        }
+        if (c.type !== "required_parameter" && c.type !== "optional_parameter") {
+            continue;
+        }
+        const pat = c.childForFieldName("pattern");
+        if (pat !== null && pat.type === "identifier") {
+            names.push(nodeText(pat));
+        }
+    }
+    return names;
+}
+/**
+ * tsParamExists reports whether a parameter named `name` exists in the
+ * formal_parameters of `decl`. Only identifier patterns are resolvable by name;
+ * destructured parameters are skipped (existence-only non-goal).
+ */
+function tsParamExists(decl, name) {
+    const fp = firstChildOfType(decl, "formal_parameters");
+    if (fp === null) {
+        return false;
+    }
+    for (let i = 0; i < fp.childCount; i++) {
+        const c = fp.child(i);
+        if (c === null) {
+            continue;
+        }
+        if (c.type !== "required_parameter" && c.type !== "optional_parameter") {
+            continue;
+        }
+        const pat = c.childForFieldName("pattern");
+        if (pat === null) {
+            continue;
+        }
+        if (pat.type === "identifier" && nodeText(pat) === name) {
+            return true;
+        }
+    }
+    return false;
+}
+/** firstChildOfType returns the first direct child of `n` with type `t`, or null. */
+function firstChildOfType(n, t) {
+    for (let i = 0; i < n.childCount; i++) {
+        const c = n.child(i);
+        if (c !== null && c.type === t) {
+            return c;
+        }
+    }
+    return null;
+}

package/dist/codeq/resolvers/typescript.test.js

@@ -0,0 +1,180 @@
+import { describe, expect, it } from "vitest";
+import { ParseFailedError } from "../errors.js";
+import { loadGrammar } from "../treesitter.js";
+import { createTSResolver } from "./typescript.js";
+// WHY: TypeScript is the code guard's existence oracle for .ts/.tsx refs. The
+// hand-authored tree-sitter queries (per-grammar compiled) would silently return
+// false on a wrong node/field name, turning every TS ref into a false "symbol
+// absent" violation. These tests lock symbol/member/param resolution for BOTH
+// the typescript and tsx grammars (distinct Languages), overload signature
+// disambiguation, and that a bad parse surfaces ParseFailedError (not false) so
+// callers distinguish "could not check" from "genuinely missing". Ported from
+// internal/codeq/typescript_lang_test.go.
+//
+// Port-specific: Go runs each matrix against r.Resolve(ctx, fsys, ref) on the
+// full DefaultResolver (which routes by extension). Here the dispatch layer is
+// wired separately (WireGate); we test the per-language Resolver directly,
+// building one resolver per grammar and feeding the source string in — exactly
+// what the dispatch layer will do per extension. The `path` arg is only used to
+// build ParseFailedError, so it is cosmetic for the found/absent cases.
+const tsSrc = `export interface AbRequest { id: number; }
+export type Id = string;
+export enum Color { Red, Green }
+export const VERSION = "1";
+export function top(a: string): void {}
+export abstract class Base { abstract run(): void; }
+export class C {
+  field: number = 0;
+  get(): string { return ""; }
+  get(id: Integer): string { return ""; }
+  get(names: string[], id: Integer, req: AbRequest): string { return ""; }
+  constructor(names: string[], req: AbRequest) {}
+}
+`;
+// Each dialect is a distinct Language and gets its own resolver — mirroring the
+// Go matrix that runs every case against both "a.ts" (typescript grammar) and
+// "a.tsx" (tsx grammar). We label by dialect for clear failure attribution.
+async function resolverFor(dialect) {
+    const lang = await loadGrammar(dialect);
+    return createTSResolver(lang);
+}
+const dialects = [
+    { dialect: "typescript", path: "a.ts" },
+    { dialect: "tsx", path: "a.tsx" },
+];
+describe("TypeScript resolver — symbol/member/param", () => {
+    for (const { dialect, path } of dialects) {
+        describe(dialect, () => {
+            // Build one resolver per dialect; reuse across the matrix.
+            let r;
+            const check = (ref, want) => expect(r.resolve(tsSrc, path, ref)).toBe(want);
+            const ref = (extra) => ({
+                Path: path,
+                Symbol: "",
+                Member: "",
+                Param: "",
+                ...extra,
+            });
+            it("resolves the matrix", async () => {
+                r = await resolverFor(dialect);
+                // Top-level symbols of every declaration kind.
+                check(ref({ Symbol: "C" }), true); // class
+                check(ref({ Symbol: "Base" }), true); // abstract class
+                check(ref({ Symbol: "AbRequest" }), true); // interface
+                check(ref({ Symbol: "Id" }), true); // type alias
+                check(ref({ Symbol: "Color" }), true); // enum
+                check(ref({ Symbol: "top" }), true); // function
+                check(ref({ Symbol: "VERSION" }), true); // const
+                check(ref({ Symbol: "Nope" }), false); // absent symbol
+                // Members.
+                check(ref({ Symbol: "C", Member: "get" }), true); // method
+                check(ref({ Symbol: "C", Member: "field" }), true); // field
+                check(ref({ Symbol: "AbRequest", Member: "id" }), true); // interface member
+                check(ref({ Symbol: "C", Member: "nope" }), false); // absent member
+                // Params.
+                check(ref({ Symbol: "C", Member: "get", Param: "id" }), true); // member param
+                check(ref({ Symbol: "C", Member: "get", Param: "zzz" }), false); // absent param
+                check(ref({ Symbol: "top", Param: "a" }), true); // top-level fn param
+            });
+        });
+    }
+});
+// WHY: "any declared signature" overload matching must filter method_definition
+// AND method_signature declarations by normalized param-type list, or a signature
+// ref matches the wrong overload (or any overload by name) — a silent false pass.
+describe("TypeScript resolver — overload signature on a member", () => {
+    for (const { dialect, path } of dialects) {
+        it(`${dialect}: disambiguates overloads by param types`, async () => {
+            const r = await resolverFor(dialect);
+            const ref = (sig, param) => ({
+                Path: path,
+                Symbol: "C",
+                Member: "get",
+                Param: param,
+                Signature: sig,
+            });
+            const must = (rf, want) => expect(r.resolve(tsSrc, path, rf)).toBe(want);
+            must(ref(["string[]", "Integer", "AbRequest"], ""), true); // 3-arg overload
+            must(ref([], ""), true); // zero-arg overload
+            must(ref(["Integer"], ""), true); // 1-arg overload
+            must(ref(["string[]", "string[]"], ""), false); // no matching overload
+            must(ref(["string[]", "Integer", "AbRequest"], "req"), true); // param of specific overload
+            must(ref(["Integer"], "req"), false); // param absent in that overload
+        });
+    }
+});
+// WHY: a signature on a BARE symbol means a constructor (class) or a function
+// overload (top-level fn) — not the type. Without the dispatch it would fall to
+// findSymbol, which matches the name and ignores the signature.
+describe("TypeScript resolver — bare-symbol signature", () => {
+    for (const { dialect, path } of dialects) {
+        it(`${dialect}: matches constructor or function overload`, async () => {
+            const r = await resolverFor(dialect);
+            const base = (extra) => ({
+                Path: path,
+                Symbol: "",
+                Member: "",
+                Param: "",
+                ...extra,
+            });
+            const must = (rf, want) => expect(r.resolve(tsSrc, path, rf)).toBe(want);
+            // Constructor of class C: (string[], AbRequest).
+            must(base({ Symbol: "C", Signature: ["string[]", "AbRequest"] }), true);
+            must(base({ Symbol: "C", Signature: ["string[]"] }), false); // no matching constructor
+            must(base({ Symbol: "C", Signature: ["string[]", "AbRequest"], Param: "req" }), true); // constructor param
+            // Top-level function overload: top(string).
+            must(base({ Symbol: "top", Signature: ["string"] }), true);
+            must(base({ Symbol: "top", Signature: ["number"] }), false); // wrong sig
+            must(base({ Symbol: "top", Signature: ["string"], Param: "a" }), true); // overload param
+            // Regression: bare symbol, NO signature, still resolves the TYPE.
+            must(base({ Symbol: "C" }), true);
+        });
+    }
+});
+// WHY: tsMemberDeclQuerySrc captures both method_definition (bodied) and
+// method_signature (declaration-only, no body) nodes. The shared tsSrc fixture
+// only has bodied methods, so the method_signature branch was never exercised.
+// This fixture includes declaration-only overload signatures to verify the "any
+// declared signature" behaviour covers both node shapes.
+describe("TypeScript resolver — overload-only (declaration) signatures", () => {
+    const overloadSrc = `
+interface Options {}
+class Svc {
+  fetch(id: number): string;
+  fetch(id: number, opts: Options): string;
+  fetch(id: number, opts?: Options): string { return ""; }
+}
+`;
+    for (const { dialect, path } of dialects) {
+        it(`${dialect}: matches method_signature (bodyless) overloads`, async () => {
+            const r = await resolverFor(dialect);
+            const ref = (sig) => ({
+                Path: path,
+                Symbol: "Svc",
+                Member: "fetch",
+                Param: "",
+                Signature: sig,
+            });
+            const must = (rf, want) => expect(r.resolve(overloadSrc, path, rf)).toBe(want);
+            must(ref(["number", "Options"]), true); // overload-only sig
+            must(ref(["number"]), true); // single-param overload-only sig
+            must(ref(["string", "string", "string"]), false); // non-existent overload
+        });
+    }
+});
+// WHY: a parse with ERROR nodes must surface ParseFailedError, NOT false —
+// otherwise "could not check" is indistinguishable from "genuinely missing".
+describe("TypeScript resolver — parse failure", () => {
+    for (const { dialect, path } of dialects) {
+        it(`${dialect}: throws ParseFailedError on invalid source`, async () => {
+            const r = await resolverFor(dialect);
+            const badPath = path.replace("a.", "bad.");
+            expect(() => r.resolve("class C { (((", badPath, {
+                Path: badPath,
+                Symbol: "C",
+                Member: "",
+                Param: "",
+            })).toThrow(ParseFailedError);
+        });
+    }
+});

package/dist/codeq/resolvers/typescript_queries.js

@@ -0,0 +1,78 @@
+// Port of internal/codeq/typescript_queries.go: the per-grammar compiled query
+// set for one TypeScript dialect. .ts (typescript grammar) and .tsx (tsx
+// grammar) are DISTINCT tree-sitter languages, so a query compiled against one
+// cannot run against a tree parsed with the other — hence per-grammar
+// compilation (a fresh TSQueries per Language), not module-level singletons.
+//
+// The S-expression sources below are copied VERBATIM from the Go *_queries.go;
+// the upstream wasm node-type/field names match, so they compile and match
+// identically (validated by treesitter.test.ts).
+import { compileQuery } from "../treesitter.js";
+// tsSymbolQuerySrc matches top-level declarations. Class/interface/type-alias
+// names are type_identifier; enum/function/const names are identifier.
+const tsSymbolQuerySrc = `
+(class_declaration name: (type_identifier) @name)
+(abstract_class_declaration name: (type_identifier) @name)
+(interface_declaration name: (type_identifier) @name)
+(type_alias_declaration name: (type_identifier) @name)
+(enum_declaration name: (identifier) @name)
+(function_declaration name: (identifier) @name)
+(function_signature name: (identifier) @name)
+(lexical_declaration (variable_declarator name: (identifier) @name))
+(variable_declaration (variable_declarator name: (identifier) @name))
+`;
+// tsMemberQuerySrc matches fields & methods on classes/abstract classes and
+// members on interfaces. @owner = container name, @name = member name. Overload
+// signatures (method_signature, abstract_method_signature) are captured too so
+// name resolution succeeds for declaration-only members.
+const tsMemberQuerySrc = `
+(class_declaration name: (type_identifier) @owner body: (class_body [
+  (method_definition name: (property_identifier) @name)
+  (method_signature name: (property_identifier) @name)
+  (public_field_definition name: (property_identifier) @name)
+]))
+(abstract_class_declaration name: (type_identifier) @owner body: (class_body [
+  (method_definition name: (property_identifier) @name)
+  (method_signature name: (property_identifier) @name)
+  (abstract_method_signature name: (property_identifier) @name)
+  (public_field_definition name: (property_identifier) @name)
+]))
+(interface_declaration name: (type_identifier) @owner body: (interface_body [
+  (method_signature name: (property_identifier) @name)
+  (property_signature name: (property_identifier) @name)
+]))
+`;
+// tsMemberDeclQuerySrc captures the method/signature declaration node (@mdecl)
+// alongside @owner and @mname, so param types can be walked for overload
+// disambiguation and param names for param lookup.
+const tsMemberDeclQuerySrc = `
+(class_declaration name: (type_identifier) @owner body: (class_body [
+  (method_definition name: (property_identifier) @mname) @mdecl
+  (method_signature name: (property_identifier) @mname) @mdecl
+]))
+(abstract_class_declaration name: (type_identifier) @owner body: (class_body [
+  (method_definition name: (property_identifier) @mname) @mdecl
+  (method_signature name: (property_identifier) @mname) @mdecl
+  (abstract_method_signature name: (property_identifier) @mname) @mdecl
+]))
+(interface_declaration name: (type_identifier) @owner body: (interface_body
+  (method_signature name: (property_identifier) @mname) @mdecl))
+`;
+// tsFuncDeclQuerySrc captures top-level function declarations (@fname, @fdecl)
+// for top-level-function param lookup and function-overload signature matching.
+const tsFuncDeclQuerySrc = `
+(function_declaration name: (identifier) @fname) @fdecl
+(function_signature name: (identifier) @fname) @fdecl
+`;
+/**
+ * buildTSQueries compiles all four queries against `language` (one dialect
+ * grammar). compileQuery throws on a bad query (Go's mustLangQuery panic).
+ */
+export function buildTSQueries(language) {
+    return {
+        symbol: compileQuery(language, tsSymbolQuerySrc),
+        member: compileQuery(language, tsMemberQuerySrc),
+        memberDecl: compileQuery(language, tsMemberDeclQuerySrc),
+        funcDecl: compileQuery(language, tsFuncDeclQuerySrc),
+    };
+}

package/dist/codeq/signature.js

@@ -0,0 +1,50 @@
+// signature.ts ports internal/codeq/signature.go: the param-type signature
+// representation used for overload disambiguation. Comparison is existence-only
+// and case-sensitive — no import resolution; the simple text as written is
+// preserved otherwise.
+/**
+ * normalizeType reduces a declared type to its overload-identity form: drop all
+ * whitespace, erase generic type arguments (List<String> → List), map varargs to
+ * an array (T... → T[]).
+ */
+export function normalizeType(s) {
+    // Strip whitespace: collapse the string to its non-whitespace runs, joined.
+    // strings.Join(strings.Fields(s), "") drops ALL whitespace (it splits on any
+    // run of whitespace and rejoins with no separator), so we do the same.
+    s = s.split(/\s+/).filter((f) => f !== "").join("");
+    // Erase generic args: drop everything from the first '<' to the matching end.
+    const i = s.indexOf("<");
+    if (i >= 0) {
+        // A type's generics are a trailing <...>; the base name precedes '<'.
+        // Re-attach any array suffix that follows the closing '>'.
+        let suffix = "";
+        const j = s.lastIndexOf(">");
+        if (j >= 0 && j + 1 < s.length) {
+            suffix = s.slice(j + 1);
+        }
+        s = s.slice(0, i) + suffix;
+    }
+    // Varargs → array.
+    if (s.endsWith("...")) {
+        s = s.slice(0, -"...".length) + "[]";
+    }
+    return s;
+}
+/**
+ * signaturesMatch reports whether two declared parameter-type lists denote the
+ * same overload after normalization: equal length + element-wise normalized
+ * equality. Callers handle the nil (name-only) case before calling this.
+ */
+export function signaturesMatch(want, got) {
+    if (want.length !== got.length) {
+        return false;
+    }
+    for (let i = 0; i < want.length; i++) {
+        // want[i]/got[i] are in-bounds (i < length), but noUncheckedIndexedAccess
+        // widens them to `| undefined`; the bound makes them defined.
+        if (normalizeType(want[i]) !== normalizeType(got[i])) {
+            return false;
+        }
+    }
+    return true;
+}