docsgov 0.1.0

package/dist/codeq/resolvers/java_queries.js

@@ -0,0 +1,63 @@
+// java_queries.ts ports internal/codeq/java_queries.go: the S-expression query
+// text the Java resolver runs against the tree-sitter-java grammar. The query
+// strings are VERBATIM from the Go package — the upstream wasm grammar uses the
+// same node-type and field names, so they compile and capture identically.
+//
+// Unlike Go's package-level `var … = mustJavaQuery(…)` (compiled at init against
+// java.GetLanguage()), the Language here is only available once loaded (async),
+// so these are exported as raw source strings and compiled eagerly in
+// createJavaResolver via compileQuery (which throws on a bad query — the
+// analogue of Go's mustJavaQuery panic).
+/**
+ * SYMBOL matches top-level type declarations (class, interface, enum, record).
+ * Each match has a single capture "name" with the declared identifier.
+ */
+export const SYMBOL = `
+(class_declaration     name: (identifier) @name)
+(interface_declaration name: (identifier) @name)
+(enum_declaration      name: (identifier) @name)
+(record_declaration    name: (identifier) @name)
+`;
+/**
+ * MEMBER matches fields, methods, and enum constants. Each match provides
+ * @owner (the containing class or enum name) and @name (the field, method, or
+ * enum-constant name).
+ */
+export const MEMBER = `
+(class_declaration name: (identifier) @owner
+  body: (class_body (field_declaration (variable_declarator name: (identifier) @name))))
+(class_declaration name: (identifier) @owner
+  body: (class_body (method_declaration name: (identifier) @name)))
+(enum_declaration name: (identifier) @owner
+  body: (enum_body (enum_constant name: (identifier) @name)))
+`;
+/**
+ * MEMBER_DECL matches method declarations inside a class body. Each match
+ * provides @owner (class name), @mname (method name), and @mdecl (the
+ * method_declaration node itself — walked for formal_parameters to disambiguate
+ * overloads by signature).
+ */
+export const MEMBER_DECL = `
+(class_declaration name: (identifier) @owner
+  body: (class_body (method_declaration name: (identifier) @mname) @mdecl))
+`;
+/**
+ * PARAM matches parameters of methods inside a class body. Each match provides
+ * @owner (class), @fn (method name), and @param (parameter name).
+ */
+export const PARAM = `
+(class_declaration name: (identifier) @owner
+  body: (class_body (method_declaration name: (identifier) @fn
+    parameters: (formal_parameters (formal_parameter name: (identifier) @param)))))
+`;
+/**
+ * CONSTRUCTOR_DECL matches constructor declarations inside a class body. @owner
+ * is the class name; @cdecl is the constructor_declaration node (walked for its
+ * parameter types via collectParamTypes). A constructor's name is the class name
+ * by the Java grammar, so @owner == the referenced symbol is the only filter
+ * needed — there is no separate method-name capture.
+ */
+export const CONSTRUCTOR_DECL = `
+(class_declaration name: (identifier) @owner
+  body: (class_body (constructor_declaration) @cdecl))
+`;

package/dist/codeq/resolvers/javascript.js

@@ -0,0 +1,412 @@
+// javascript.ts ports internal/codeq/javascript_lang.go: the per-language
+// Resolver for JavaScript (.js / .jsx). It is a faithful port of jsResolver.Resolve
+// MINUS the cache.Read + ErrFileNotFound prelude (the dispatch layer owns I/O —
+// see resolver.ts). The grammar + compiled queries are bound at factory time
+// (createJSResolver), so resolve() is SYNC: parse + matches only.
+//
+// JavaScript has no type annotations, so a Signature degrades to ARITY-ONLY:
+// only the parameter COUNT is compared (len(sig) == param count), never type
+// text. That is why this module does NOT import signature.ts — there is nothing
+// to normalize.
+import { ParseFailedError } from "../errors.js";
+import { collectCapture, collectOwned, refKind, suggestFromExtractors, } from "../suggest.js";
+import { Parser, compileQuery, nodeText, parseTree, runQuery, } from "../treesitter.js";
+import { jsFuncDeclQuery, jsMemberDeclQuery, jsMemberQuery, jsSymbolQuery, } from "./javascript_queries.js";
+/**
+ * createJSResolver builds the JavaScript Resolver from an already-loaded
+ * tree-sitter Language. It compiles + caches the four queries eagerly (the
+ * analogue of Go's package-level mustJSQuery vars); compileQuery THROWS on a bad
+ * query (the mustQuery-panic contract), surfacing a hard-coded-query bug at
+ * construction time.
+ */
+export function createJSResolver(language) {
+    return new JSResolver(language);
+}
+class JSResolver {
+    language;
+    symbolQuery;
+    memberQuery;
+    memberDeclQuery;
+    funcDeclQuery;
+    constructor(language) {
+        this.language = language;
+        // Compile once, reuse across trees (mirrors Go's package-level mustJSQuery
+        // vars). A bad literal throws here, not at resolve time.
+        this.symbolQuery = compileQuery(language, jsSymbolQuery);
+        this.memberQuery = compileQuery(language, jsMemberQuery);
+        this.memberDeclQuery = compileQuery(language, jsMemberDeclQuery);
+        this.funcDeclQuery = compileQuery(language, jsFuncDeclQuery);
+    }
+    /**
+     * resolve parses `source` and delegates based on which facets of `ref` are set.
+     *
+     * Dispatch precedence (faithful to jsResolver.Resolve):
+     *   - Member && Param           → findMemberParam
+     *   - Member                    → findMember
+     *   - Signature && Param        → findBareSignatureParam (constructor or top-level fn + param)
+     *   - Signature                 → findBareSignature      (constructor or top-level fn by arity)
+     *   - Param                     → findParam              (bare param lookup)
+     *   - default                   → findSymbol             (type-name lookup)
+     *
+     * THROWS ParseFailedError(path) when the parse tree has ERROR nodes. (The Go
+     * `ref.Signature != nil` checks become `ref.Signature !== undefined`: an empty
+     * but defined array — the zero-arg "()" overload — is still a signature.)
+     */
+    resolve(source, path, ref) {
+        const parser = new Parser();
+        parser.setLanguage(this.language);
+        const root = parseTree(parser, source);
+        if (root.hasError) {
+            throw new ParseFailedError(path);
+        }
+        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` —
+     * mirroring the oracle's reach.
+     */
+    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.symbolQuery, "name"),
+            memberNames: (r, owner) => collectOwned(r, this.memberQuery, 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
+     * not name-resolvable (jsParamNames skips them), matching jsParamExists.
+     */
+    collectParamNames(root, fn) {
+        const out = [];
+        for (const m of runQuery(root, this.memberDeclQuery)) {
+            const mname = textOf(m.captures["mname"]);
+            const mdecl = m.captures["mdecl"];
+            if (mname === fn && mdecl !== undefined) {
+                out.push(...jsParamNames(mdecl));
+            }
+        }
+        for (const m of runQuery(root, this.funcDeclQuery)) {
+            const fname = textOf(m.captures["fname"]);
+            const fdecl = m.captures["fdecl"];
+            if (fname === fn && fdecl !== undefined) {
+                out.push(...jsParamNames(fdecl));
+            }
+        }
+        return out;
+    }
+    /**
+     * findSymbol searches for a top-level declaration with the given name. Any
+     * @name capture across the symbol query's patterns that equals `name` is a hit.
+     */
+    findSymbol(root, name) {
+        for (const m of runQuery(root, this.symbolQuery)) {
+            // Each match has one or more @name captures; the Go code scanned every
+            // capture in the match, so check all[name] (one per match here).
+            for (const n of m.all["name"] ?? []) {
+                if (nodeText(n) === name) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * findMember searches for a field or method named `member` on the class named
+     * `symbol`. When `sig` is undefined, name-only matching uses the flat member
+     * query (fields + methods). When `sig` is defined, only method overloads whose
+     * arity matches sig.length are considered (fields have no params, so an
+     * arity-qualified member ref never resolves a field — matching Go).
+     */
+    findMember(root, symbol, member, sig) {
+        if (sig === undefined) {
+            // Name-only: flat member query matches fields and methods.
+            for (const m of runQuery(root, this.memberQuery)) {
+                const owner = textOf(m.captures["owner"]);
+                const name = textOf(m.captures["name"]);
+                if (owner === symbol && name === member) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        // Arity-filtered: iterate method declarations and compare param count.
+        for (const m of runQuery(root, this.memberDeclQuery)) {
+            const owner = textOf(m.captures["owner"]);
+            const mname = textOf(m.captures["mname"]);
+            const mdecl = m.captures["mdecl"];
+            if (owner === symbol && mname === member && mdecl !== undefined) {
+                if (sig.length === jsParamCount(mdecl)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * findMemberParam searches for a parameter named `paramName` on a method named
+     * `member` of the class named `symbol`. When `sig` is defined, only the method
+     * whose arity matches sig.length is considered (arity-only for JS).
+     */
+    findMemberParam(root, symbol, member, paramName, sig) {
+        for (const m of runQuery(root, this.memberDeclQuery)) {
+            const owner = textOf(m.captures["owner"]);
+            const mname = textOf(m.captures["mname"]);
+            const mdecl = m.captures["mdecl"];
+            if (owner !== symbol || mname !== member || mdecl === undefined) {
+                continue;
+            }
+            if (sig !== undefined && sig.length !== jsParamCount(mdecl)) {
+                continue;
+            }
+            if (jsParamExists(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) Method decls: any method on a class with mname == symbol.
+        for (const m of runQuery(root, this.memberDeclQuery)) {
+            const mname = textOf(m.captures["mname"]);
+            const mdecl = m.captures["mdecl"];
+            if (mname === symbol && mdecl !== undefined) {
+                if (jsParamExists(mdecl, paramName)) {
+                    return true;
+                }
+            }
+        }
+        // (b) Top-level function decls: fname == symbol.
+        for (const m of runQuery(root, this.funcDeclQuery)) {
+            const fname = textOf(m.captures["fname"]);
+            const fdecl = m.captures["fdecl"];
+            if (fname === symbol && fdecl !== undefined) {
+                if (jsParamExists(fdecl, paramName)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * findBareSignature resolves a bare-symbol + signature ref (no member). It
+     * matches either a constructor (method_definition named "constructor" on the
+     * class named `symbol`, by arity) OR a top-level function (by arity). Returns
+     * true on the first arity match.
+     */
+    findBareSignature(root, symbol, sig) {
+        // (a) Constructor: method decls on `symbol`, name "constructor".
+        for (const m of runQuery(root, this.memberDeclQuery)) {
+            const owner = textOf(m.captures["owner"]);
+            const mname = textOf(m.captures["mname"]);
+            const mdecl = m.captures["mdecl"];
+            if (owner === symbol && mname === "constructor" && mdecl !== undefined) {
+                if (sig.length === jsParamCount(mdecl)) {
+                    return true;
+                }
+            }
+        }
+        // (b) Top-level function named `symbol`.
+        for (const m of runQuery(root, this.funcDeclQuery)) {
+            const fname = textOf(m.captures["fname"]);
+            const fdecl = m.captures["fdecl"];
+            if (fname === symbol && fdecl !== undefined) {
+                if (sig.length === jsParamCount(fdecl)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * findBareSignatureParam resolves a bare-symbol + signature + param ref. Same
+     * two sources as findBareSignature (constructor or top-level function), arity
+     * must match, then reports whether `paramName` exists in the matching decl.
+     */
+    findBareSignatureParam(root, symbol, paramName, sig) {
+        // (a) Constructor.
+        for (const m of runQuery(root, this.memberDeclQuery)) {
+            const owner = textOf(m.captures["owner"]);
+            const mname = textOf(m.captures["mname"]);
+            const mdecl = m.captures["mdecl"];
+            if (owner === symbol && mname === "constructor" && mdecl !== undefined) {
+                if (sig.length === jsParamCount(mdecl)) {
+                    return jsParamExists(mdecl, paramName);
+                }
+            }
+        }
+        // (b) Top-level function.
+        for (const m of runQuery(root, this.funcDeclQuery)) {
+            const fname = textOf(m.captures["fname"]);
+            const fdecl = m.captures["fdecl"];
+            if (fname === symbol && fdecl !== undefined) {
+                if (sig.length === jsParamCount(fdecl)) {
+                    return jsParamExists(fdecl, paramName);
+                }
+            }
+        }
+        return false;
+    }
+}
+/** textOf returns a node's text, or "" when the capture is absent (Go's zero-value string). */
+function textOf(n) {
+    return n === undefined ? "" : nodeText(n);
+}
+/**
+ * formalParameters returns the `formal_parameters` child of `decl`, or null.
+ * Both jsParamCount and jsParamExists locate the param list this way (Go scanned
+ * decl's children for the first formal_parameters node).
+ */
+function formalParameters(decl) {
+    for (let i = 0; i < decl.childCount; i++) {
+        const c = decl.child(i);
+        if (c !== null && c.type === "formal_parameters") {
+            return c;
+        }
+    }
+    return null;
+}
+/**
+ * jsParamCount returns the number of parameters in the formal_parameters child
+ * of `decl`. Counts identifier, rest_pattern, assignment_pattern, object_pattern,
+ * and array_pattern nodes — all param shapes in JS.
+ */
+function jsParamCount(decl) {
+    const fp = formalParameters(decl);
+    if (fp === null) {
+        return 0;
+    }
+    let count = 0;
+    for (let i = 0; i < fp.childCount; i++) {
+        const c = fp.child(i);
+        if (c === null) {
+            continue;
+        }
+        switch (c.type) {
+            case "identifier":
+            case "rest_pattern":
+            case "assignment_pattern":
+            case "object_pattern":
+            case "array_pattern":
+                count++;
+                break;
+        }
+    }
+    return count;
+}
+/**
+ * jsParamNames lists the resolvable parameter names in the formal_parameters of
+ * `decl`, in document order. It mirrors jsParamExists's resolvable set exactly —
+ * plain identifiers, rest_pattern, and assignment_pattern left-hand identifiers;
+ * destructured params (object/array_pattern) are skipped — so a name suggested
+ * here is always one jsParamExists would have matched.
+ */
+function jsParamNames(decl) {
+    const fp = formalParameters(decl);
+    if (fp === null) {
+        return [];
+    }
+    const names = [];
+    for (let i = 0; i < fp.childCount; i++) {
+        const c = fp.child(i);
+        if (c === null) {
+            continue;
+        }
+        switch (c.type) {
+            case "identifier":
+                names.push(nodeText(c));
+                break;
+            case "rest_pattern":
+                for (let j = 0; j < c.childCount; j++) {
+                    const inner = c.child(j);
+                    if (inner !== null && inner.type === "identifier") {
+                        names.push(nodeText(inner));
+                    }
+                }
+                break;
+            case "assignment_pattern": {
+                const left = c.childForFieldName("left");
+                if (left !== null && left.type === "identifier") {
+                    names.push(nodeText(left));
+                }
+                break;
+            }
+        }
+    }
+    return names;
+}
+/**
+ * jsParamExists reports whether a parameter named `name` exists in the
+ * formal_parameters of `decl`. Matches plain identifiers, rest_pattern, and
+ * assignment_pattern (left-hand identifier). Destructured params
+ * (object_pattern/array_pattern) count toward arity in jsParamCount but are NOT
+ * name-resolvable here (existence-only non-goal per the plan).
+ */
+function jsParamExists(decl, name) {
+    const fp = formalParameters(decl);
+    if (fp === null) {
+        return false;
+    }
+    for (let i = 0; i < fp.childCount; i++) {
+        const c = fp.child(i);
+        if (c === null) {
+            continue;
+        }
+        switch (c.type) {
+            case "identifier":
+                if (nodeText(c) === name) {
+                    return true;
+                }
+                break;
+            case "rest_pattern":
+                // rest_pattern wraps an identifier: ...args → identifier child.
+                for (let j = 0; j < c.childCount; j++) {
+                    const inner = c.child(j);
+                    if (inner !== null &&
+                        inner.type === "identifier" &&
+                        nodeText(inner) === name) {
+                        return true;
+                    }
+                }
+                break;
+            case "assignment_pattern": {
+                // assignment_pattern: left = default → left is the identifier.
+                const left = c.childForFieldName("left");
+                if (left !== null &&
+                    left.type === "identifier" &&
+                    nodeText(left) === name) {
+                    return true;
+                }
+                break;
+            }
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,125 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { ParseFailedError } from "../errors.js";
+import { loadGrammar } from "../treesitter.js";
+import { createJSResolver } from "./javascript.js";
+// WHY: the JS resolver is the existence oracle for .js/.jsx refs. JavaScript has
+// no type annotations, so signature matching is ARITY-ONLY (param count) — a sig
+// with the wrong count must NOT match, the right count must. Name resolution for
+// symbol/member/param must work; the param-shape branches (rest_pattern,
+// assignment_pattern) must be name-resolvable while still counting toward arity.
+// These cases are the behavior-encoding cases ported from
+// internal/codeq/javascript_lang_test.go.
+// Same source sample as the Go test (jsSrc). It exercises: top-level function +
+// const + class; a class field; methods with 2 params (get), a constructor with
+// 2 params, a rest param, and a default (assignment) param.
+const jsSrc = `export function top(a, b) { return a + b; }
+export const VERSION = "1";
+export class C {
+  field = 0;
+  get(names, id) { return ""; }
+  constructor(names, req) {}
+  rest(first, ...others) { return first; }
+  def(a, b = 2) { return a + b; }
+}
+`;
+// path is irrelevant to a sync resolver except as the ParseFailedError payload;
+// the Go test ran every case under both "a.js" and "a.jsx" because the dispatch
+// layer routes both extensions to THIS resolver. The resolver itself is
+// extension-blind, so one path suffices here — extension routing is the dispatch
+// layer's concern (resolver.test.ts), not this oracle's.
+const PATH = "a.js";
+let resolver;
+beforeAll(async () => {
+    // Fast: the wasm grammar loads in ms; no env-gating needed.
+    const lang = await loadGrammar("javascript");
+    resolver = createJSResolver(lang);
+});
+/** ref builds a CodeRef with the empty-string/undefined defaults the parser uses. */
+function ref(partial) {
+    return { Path: PATH, Symbol: "", Member: "", Param: "", ...partial };
+}
+describe("JS resolver", () => {
+    // --- top-level symbols (findSymbol) ---
+    it("resolves a class declaration by name", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C" }))).toBe(true);
+    });
+    it("resolves a top-level function by name", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "top" }))).toBe(true);
+    });
+    it("resolves a top-level const by name", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "VERSION" }))).toBe(true);
+    });
+    // --- members (findMember): a missing member must be reported absent so a stale
+    // doc ref fails the guard rather than silently passing. ---
+    it("resolves a method member", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Member: "get" }))).toBe(true);
+    });
+    it("resolves a field member (field_definition, not method)", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Member: "field" }))).toBe(true);
+    });
+    it("reports an absent member as not found", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Member: "nope" }))).toBe(false);
+    });
+    // --- member params (findMemberParam) ---
+    it("resolves a param of a method", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Member: "get", Param: "id" }))).toBe(true);
+    });
+    it("reports an absent method param as not found", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Member: "get", Param: "zzz" }))).toBe(false);
+    });
+    // --- arity-only signature on a method: WHY this matters — JS has no types, so
+    // the ONLY discriminator a {{code:…(a,b)}} ref carries is param count. A wrong
+    // count must miss, a right count must hit. ---
+    it("matches a method by arity (param count)", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Member: "get", Signature: ["x", "y"] }))).toBe(true);
+    });
+    it("rejects a method on arity mismatch", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Member: "get", Signature: ["x"] }))).toBe(false);
+    });
+    // --- bare signature = constructor by arity (findBareSignature) ---
+    it("matches the constructor by arity for a bare signature", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Signature: ["x", "y"] }))).toBe(true);
+    });
+    it("rejects the constructor on arity mismatch", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Signature: ["x"] }))).toBe(false);
+    });
+    // --- bare top-level-function param (findParam path) ---
+    it("resolves a bare top-level-function param", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "top", Param: "a" }))).toBe(true);
+    });
+    it("reports an absent bare-function param as not found", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "top", Param: "zzz" }))).toBe(false);
+    });
+    // --- constructor param by arity-signature (findBareSignatureParam path) ---
+    it("resolves a constructor param under a matching arity signature", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Signature: ["x", "y"], Param: "req" }))).toBe(true);
+    });
+    it("reports an absent constructor param (matching arity) as not found", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Signature: ["x", "y"], Param: "zzz" }))).toBe(false);
+    });
+    // --- top-level-function param by arity-signature (findBareSignatureParam) ---
+    it("resolves a top-level-function param under a matching arity signature", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "top", Signature: ["x", "y"], Param: "a" }))).toBe(true);
+    });
+    it("rejects a top-level-function param under a wrong arity signature", () => {
+        // WHY: arity gates BEFORE param lookup — the wrong-arity overload is not the
+        // one being referenced, so even a real param name must not resolve.
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "top", Signature: ["x", "y", "z"], Param: "a" }))).toBe(false);
+    });
+    // --- param-shape branches in jsParamExists: rest and default (assignment) ---
+    it("resolves a rest param (...others) by name", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Member: "rest", Param: "others" }))).toBe(true);
+    });
+    it("resolves a default param (b = 2) by its identifier", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Member: "def", Param: "b" }))).toBe(true);
+    });
+    // --- zero-arg signature "()" is a DEFINED empty array, not undefined: it must
+    // still take the signature dispatch path (arity 0), not the name-only path. ---
+    it("treats a zero-arg signature () as arity 0, missing a 2-arg constructor", () => {
+        expect(resolver.resolve(jsSrc, PATH, ref({ Symbol: "C", Signature: [] }))).toBe(false);
+    });
+    // --- parse failure → ParseFailedError carrying the path ---
+    it("throws ParseFailedError on invalid JS (ERROR nodes)", () => {
+        expect(() => resolver.resolve("class C { (((", "bad.js", ref({ Symbol: "C" }))).toThrow(ParseFailedError);
+    });
+});

package/dist/codeq/resolvers/javascript_queries.js

@@ -0,0 +1,46 @@
+// javascript_queries.ts ports internal/codeq/javascript_queries.go: the four
+// tree-sitter S-expression queries the JS resolver runs. The S-expression text
+// is VERBATIM from the Go package — the upstream tree-sitter-javascript node-type
+// names match the vendored wasm grammar, so the queries port unchanged.
+//
+// Go compiled these at package init via mustJSQuery (panic on bad query). Here
+// the factory (createJSResolver) compiles them once per loaded Language via
+// compileQuery (which THROWS on a bad query — the mustQuery-panic contract) and
+// caches the resulting Query objects on the resolver instance.
+/**
+ * jsSymbolQuery matches top-level declarations. JS class names are `identifier`
+ * (not `type_identifier` — that is TS-only). Capture: @name.
+ */
+export const jsSymbolQuery = `
+(class_declaration name: (identifier) @name)
+(function_declaration name: (identifier) @name)
+(generator_function_declaration name: (identifier) @name)
+(lexical_declaration (variable_declarator name: (identifier) @name))
+(variable_declaration (variable_declarator name: (identifier) @name))
+`;
+/**
+ * jsMemberQuery matches fields and methods on classes. JS class fields use the
+ * `property` field; methods use the `name` field. Captures: @owner, @name.
+ */
+export const jsMemberQuery = `
+(class_declaration name: (identifier) @owner body: (class_body [
+  (method_definition name: (property_identifier) @name)
+  (field_definition property: (property_identifier) @name)
+]))
+`;
+/**
+ * jsMemberDeclQuery captures method declaration nodes (@mdecl) alongside @owner
+ * and @mname, for param lookup and arity-based signature matching.
+ */
+export const jsMemberDeclQuery = `
+(class_declaration name: (identifier) @owner body: (class_body
+  (method_definition name: (property_identifier) @mname) @mdecl))
+`;
+/**
+ * jsFuncDeclQuery captures top-level function declarations (@fname, @fdecl) for
+ * top-level-function param lookup and constructor/function arity matching.
+ */
+export const jsFuncDeclQuery = `
+(function_declaration name: (identifier) @fname) @fdecl
+(generator_function_declaration name: (identifier) @fname) @fdecl
+`;