devlensio 1.0.4 → 1.1.1

package/dist/extractors/runner.js

@@ -167,6 +167,7 @@ export async function runInlineExtractor(input, onStep) {
         nodes: allNodes,
         edges: allEdges,
         routes,
+        exports: parserResult.exports,
         stats,
         errors: [],
     };

package/dist/extractors/types.d.ts

@@ -1,4 +1,4 @@
-import { Language, BackendRouteNode, CodeEdge, CodeNode, ProjectFingerprint, RouteNode } from "../types.js";
+import { Language, BackendRouteNode, CodeEdge, CodeNode, ProjectFingerprint, RouteNode, GraphExports } from "../types.js";
 export interface ExtractorOptions {
     includeThirdPartyLibs?: string[];
 }
@@ -20,6 +20,7 @@ export interface ExtractorResult {
     nodes: CodeNode[];
     edges: CodeEdge[];
     routes?: (RouteNode | BackendRouteNode)[];
+    exports?: GraphExports;
     stats: ExtractorStats;
     errors: ExtractorError[];
 }

package/dist/graph/edges/callEdges.js

@@ -1,8 +1,89 @@
 import { closestByPath } from "./utils.js";
+// Arity compatibility: a candidate matches when the call provides at least all
+// required (non-optional, non-rest) params, and does not exceed the declared
+// count unless the candidate declares a rest parameter. Candidates without
+// parameters metadata are permissive (unknown shape).
+function arityMatches(candidate, argCount) {
+    const parameters = candidate.metadata?.parameters;
+    const params = candidate.metadata?.params;
+    if (!params && !parameters)
+        return true;
+    const total = parameters?.length ?? params?.length ?? 0;
+    const hasRest = parameters?.some((p) => p.isRest) ?? false;
+    const required = parameters
+        ? parameters.filter((p) => !p.isOptional && !p.isRest).length
+        : total;
+    return argCount >= required && (hasRest || argCount <= total);
+}
+// Loose type agreement between a call-site arg type tag and a declared param
+// type text. Both sides are cheap/heuristic (no type checker), so this scores
+// rather than gates: unknown tags never match, text containment counts.
+function typeAgrees(argType, paramType) {
+    if (!argType || argType === "unknown" || !paramType)
+        return false;
+    const p = paramType.trim();
+    return p === argType || p.includes(argType);
+}
+function typeScore(candidate, argTypes) {
+    const parameters = candidate.metadata?.parameters;
+    if (!parameters)
+        return 0;
+    let score = 0;
+    for (let i = 0; i < argTypes.length; i++) {
+        if (parameters[i] && typeAgrees(argTypes[i], parameters[i].type))
+            score++;
+    }
+    return score;
+}
+// Picks the right overload among same-name candidates using the call site's
+// argument shape. Ladder:
+//   1. no usable call shape (USES edges, spread calls, missing callSites)
+//      → legacy closestByPath behavior
+//   2. arity filter — survivors whose declared params accept argCount
+//   3. type tiebreak — among arity survivors, prefer the candidate with the
+//      highest arg-type agreement (handles same arity, different types)
+//   4. still ambiguous → closestByPath among survivors
+function resolveOverloadTarget(candidates, caller, callSite) {
+    if (candidates.length === 1)
+        return { target: candidates[0], matchedBy: "name" };
+    const usableShape = callSite
+        && typeof callSite.argCount === "number"
+        && !callSite.hasSpread;
+    if (!usableShape)
+        return { target: closestByPath(candidates, caller.filePath), matchedBy: "name" };
+    let pool = candidates.filter((c) => arityMatches(c, callSite.argCount));
+    if (pool.length === 0)
+        pool = candidates; // nothing accepts this arity — keep all
+    if (pool.length === 1)
+        return { target: pool[0], matchedBy: "arity" };
+    const argTypes = callSite.argTypes ?? [];
+    if (argTypes.some((t) => t && t !== "unknown")) {
+        let best = pool[0];
+        let bestScore = typeScore(pool[0], argTypes);
+        let tieAtBest = 1;
+        for (let i = 1; i < pool.length; i++) {
+            const s = typeScore(pool[i], argTypes);
+            if (s > bestScore) {
+                best = pool[i];
+                bestScore = s;
+                tieAtBest = 1;
+            }
+            else if (s === bestScore)
+                tieAtBest++;
+        }
+        if (bestScore > 0 && tieAtBest === 1) {
+            return { target: best, matchedBy: "signature" };
+        }
+    }
+    return { target: closestByPath(pool, caller.filePath), matchedBy: "name" };
+}
 export function detectCallEdges(nodes, lookupMp) {
     const edges = [];
     // Dedup for THIRD_PARTY CALLS edges — one per (caller, target) pair
     const createdThirdPartyEdges = new Set();
+    // Dedup for local CALLS/USES edges — overload call sites can resolve to
+    // the same target through different (name, arity) pairs
+    const createdLocalEdges = new Set();
     // Accumulate resolved calls per node — written back to metadata after edge loop
     const resolvedCallsMap = new Map();
     // Lazily-created method nodes for default/namespace import member-access calls
@@ -34,7 +115,16 @@ export function detectCallEdges(nodes, lookupMp) {
         if (!hasPrimary && !hasHooks)
             continue;
         // ── Primary names: both third-party and local edges ──────────────
-        for (const calledName of (primaryNames ?? [])) {
+        // Structured callSites carry the argument shape for overload-aware
+        // resolution; fall back to bare calls/uses strings when absent.
+        const callSites = node.metadata.callSites;
+        // Each (name, arity) call site iterates separately — a caller that
+        // invokes two overloads of one name gets two edges.
+        const primaryCallSites = (callSites && callSites.length > 0)
+            ? callSites
+            : (primaryNames ?? []).map((name) => ({ name, argCount: -1 }));
+        for (const callSite of primaryCallSites) {
+            const calledName = callSite.name;
             // ── Third-party guard ─────────────────────────────────────────
             // The alias map is keyed by node.filePath (relative) and populated
             // by importEdges.ts (which runs first).
@@ -120,16 +210,18 @@ export function detectCallEdges(nodes, lookupMp) {
             }
             if (!targets || targets.length === 0)
                 continue;
-            const target = targets.length === 1
-                ? targets[0]
-                : closestByPath(targets, node.filePath);
+            const { target, matchedBy } = resolveOverloadTarget(targets, node, callSite.argCount >= 0 ? callSite : undefined);
             if (target.id === node.id)
                 continue; // skip self-reference
+            const localEdgeKey = `${node.id}→${target.id}:${edgeType}`;
+            if (createdLocalEdges.has(localEdgeKey))
+                continue;
+            createdLocalEdges.add(localEdgeKey);
             edges.push({
                 from: node.id,
                 to: target.id,
                 type: edgeType,
-                metadata: { calledName: resolvedName },
+                metadata: { calledName: resolvedName, matchedBy },
             });
             if (!resolvedCallsMap.has(node.id))
                 resolvedCallsMap.set(node.id, []);

package/dist/graph/edges/callEdges.test.js

@@ -198,3 +198,157 @@ describe("detectCallEdges with class methods", () => {
         deleteFakeRepo(repo);
     });
 });
+// ─── Overload-aware resolution (same-name candidates in one file) ─────────────
+describe("detectCallEdges with overloads", () => {
+    // Arity disambiguates same-name functions in one file
+    it("routes each call to the overload matching its argument count", () => {
+        const repo = createFakeRepo({
+            "src/fmt.ts": `
+        export function formatValue(v: string) { return v.trim(); }
+        export function formatValue(v: string, n: number) { return v.repeat(n); }
+        export function caller() {
+          formatValue("a");
+          formatValue("a", 3);
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        const callEdges = edges.filter((e) => e.type === "CALLS" && e.metadata?.calledName === "formatValue");
+        const targets = callEdges.map((e) => e.to).sort();
+        expect(targets).toEqual([
+            "src/fmt.ts::formatValue#1",
+            "src/fmt.ts::formatValue#2",
+        ]);
+        // resolution confidence recorded on the edge
+        expect(callEdges.every((e) => e.metadata?.matchedBy === "arity")).toBe(true);
+        deleteFakeRepo(repo);
+    });
+    // Same arity, different param types — literal arg types break the tie
+    it("resolves same-arity overloads via argument type tags", () => {
+        const repo = createFakeRepo({
+            "src/dec.ts": `
+        export function decode(input: string, mode: string) { return input; }
+        export function decode(input: number, mode: string) { return String(input); }
+        export function caller() {
+          decode("abc", "utf8");
+          decode(42, "utf8");
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        const callEdges = edges.filter((e) => e.type === "CALLS" && e.metadata?.calledName === "decode");
+        // first call (string literal) → string overload; second (number literal) → number overload
+        const stringTargets = callEdges.filter((e) => e.metadata?.matchedBy === "signature").map((e) => e.to).sort();
+        expect(stringTargets.length).toBe(2);
+        expect(stringTargets[0]).not.toBe(stringTargets[1]);
+        deleteFakeRepo(repo);
+    });
+    // A caller can invoke two overloads of one name — two distinct edges
+    it("emits one edge per overload call site, not one per name", () => {
+        const repo = createFakeRepo({
+            "src/multi.ts": `
+        export function send(x: string) { return x; }
+        export function send(x: string, y: string) { return x + y; }
+        export function client() {
+          send("a");
+          send("a", "b");
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        const callEdges = edges.filter((e) => e.type === "CALLS" && e.metadata?.calledName === "send");
+        expect(callEdges.length).toBe(2);
+        expect(new Set(callEdges.map((e) => e.to)).size).toBe(2);
+        deleteFakeRepo(repo);
+    });
+    // Spread calls have unknowable arity — must NOT confidently pick an overload
+    it("falls back to path proximity for spread calls", () => {
+        const repo = createFakeRepo({
+            "src/spread.ts": `
+        export function combine(a: string) { return a; }
+        export function combine(a: string, b: string) { return a + b; }
+        export function caller(...args: string[]) {
+          return combine(...args);
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        const callEdges = edges.filter((e) => e.type === "CALLS" && e.metadata?.calledName === "combine");
+        expect(callEdges.length).toBe(1);
+        expect(callEdges[0].metadata?.matchedBy).toBe("name");
+        deleteFakeRepo(repo);
+    });
+    // Optional params: a 1-arg call may hit a 2-param overload with optional 2nd
+    it("lets optional parameters accept shorter calls via arity fallback", () => {
+        const repo = createFakeRepo({
+            "src/opt.ts": `
+        export function render(template: string, opts?: object) { return template; }
+        export function render(template: string, opts: object, mode: string) { return template; }
+        export function caller() {
+          render("t");
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        const callEdges = edges.filter((e) => e.type === "CALLS" && e.metadata?.calledName === "render");
+        // 1-arg call: renderStrict requires 3 → excluded; render (optional) → match
+        expect(callEdges.length).toBe(1);
+        expect(callEdges[0].to).toBe("src/opt.ts::render#2");
+        deleteFakeRepo(repo);
+    });
+    // Rest params accept any extra arguments
+    it("lets rest parameters accept longer calls", () => {
+        const repo = createFakeRepo({
+            "src/rest.ts": `
+        export function sum(first: number, ...rest: number[]) { return first; }
+        export function pair(a: number, b: number) { return a; }
+        export function caller() {
+          sum(1, 2, 3, 4);
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        const callEdges = edges.filter((e) => e.type === "CALLS" && e.metadata?.calledName === "sum");
+        expect(callEdges.length).toBe(1);
+        expect(callEdges[0].to).toContain("sum");
+        deleteFakeRepo(repo);
+    });
+    // Legacy behavior preserved when no overload shape exists
+    it("still resolves plain single-candidate calls without callSites metadata", () => {
+        const repo = createFakeRepo({
+            "src/plain.ts": `
+        export function helper(x: number) { return x; }
+        export function caller() { return helper(1); }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        expect(edges).toContainEqual(expect.objectContaining({
+            from: "src/plain.ts::caller",
+            to: "src/plain.ts::helper",
+            type: "CALLS",
+        }));
+        deleteFakeRepo(repo);
+    });
+    // Class method overloads resolve through dotted names
+    it("resolves class method overloads by arity through dotted names", () => {
+        const repo = createFakeRepo({
+            "src/svc.ts": `
+        export class Repo {
+          find(id: string) { return id; }
+          find(id: string, depth: number) { return id; }
+        }
+        export function caller() {
+          Repo.find("a");
+          Repo.find("a", 2);
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        const callEdges = edges.filter((e) => e.type === "CALLS" && e.metadata?.calledName === "Repo.find");
+        expect(callEdges.map((e) => e.to).sort()).toEqual([
+            "src/svc.ts::Repo.find#1",
+            "src/svc.ts::Repo.find#2",
+        ]);
+        deleteFakeRepo(repo);
+    });
+});

package/dist/parser/exportsMap.d.ts

@@ -0,0 +1,9 @@
+import type { Project } from "ts-morph";
+import type { CodeNode, GraphExports } from "../types.js";
+export declare function buildExportsMap(project: Project, repoPath: string, nodes: CodeNode[]): GraphExports | undefined;
+export declare function validateExportsMap(map: GraphExports, nodeIds: Set<string>): string[];
+export declare function exportsMapStats(map: GraphExports): {
+    subpaths: number;
+    names: number;
+    ambiguous: number;
+};

package/dist/parser/exportsMap.js

@@ -0,0 +1,349 @@
+// Exports Map builder — the flattened export surface of the repo, shipped in
+// the graph artifact for future cross-repo linking (see docs/EXPORTS_MAP.md).
+//
+// Architecture notes:
+//   - Must live in the parser because binding resolution needs the ts-morph
+//     Project created inside parseRepo(); a second Project would double parse
+//     cost. parseRepo() calls buildExportsMap() after the node loop, so the
+//     map is validated against the FINAL node list (only surviving, deduped,
+//     overload-suffixed ids can appear as values).
+//   - Values are ALWAYS arrays of proper nodeIds — never bare names. The
+//     cloud joins against them in one hash lookup; no second resolution step.
+//   - Overloads: multiple nodes sharing one base id (path::name) are an
+//     overload group — emitted as a plain array. Distinct base ids under one
+//     exported name are a TRUE ambiguity — also flagged in ambiguousNames.
+//   - TS resolves `export *` conflicts by EXCLUDING the name from the module's
+//     exports (same as the JS spec), so star re-exports need no special code.
+//   - Anything without a node representation (plain consts, interfaces,
+//     type aliases, anonymous defaults, namespace re-exports) is OMITTED —
+//     never fabricate an id that won't exist in the nodes array.
+//   - package.json "exports" conditions: v1 resolves one condition per subpath
+//     (import → default → require); "types"-only subpaths are skipped; wildcard
+//     patterns are skipped. Entry targets pointing into dist/build are mapped
+//     back to src/ so ids stay in the same coordinate system as the nodes.
+//   - Failures never break analysis: any error yields an absent map.
+import path from "path";
+import fs from "fs";
+const ENTRY_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+const INDEX_NAMES = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+export function buildExportsMap(project, repoPath, nodes) {
+    try {
+        const pkgPath = path.join(repoPath, "package.json");
+        if (!fs.existsSync(pkgPath))
+            return undefined;
+        let pkg;
+        try {
+            pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        }
+        catch {
+            return undefined;
+        }
+        const entries = resolveEntryPoints(pkg, repoPath, project);
+        if (entries.length === 0)
+            return undefined;
+        const nodeIndex = buildNodeIndex(nodes);
+        const starCache = new Map();
+        const exports = {};
+        const ambiguousNames = {};
+        for (const entry of entries) {
+            let decls;
+            try {
+                decls = entry.file.getExportedDeclarations();
+            }
+            catch {
+                continue;
+            }
+            const explicitNames = explicitExportNames(entry.file);
+            const entryPath = entry.file.getFilePath();
+            const stars = starContributors(entry.file, starCache);
+            const perPath = {};
+            const ambiguous = [];
+            for (const [name, declList] of decls) {
+                const isExplicit = explicitNames.has(name) || declList.some((d) => d.getSourceFile().getFilePath() === entryPath);
+                if (!isExplicit) {
+                    const contributors = stars.get(name);
+                    if (contributors && contributors.size > 1) {
+                        ambiguous.push(name);
+                        continue;
+                    }
+                }
+                const resolved = [];
+                for (const decl of declList) {
+                    const hit = resolveDeclarationToNode(decl, repoPath, nodeIndex);
+                    if (hit)
+                        resolved.push(hit);
+                }
+                const ids = [...new Set(resolved.map((r) => r.id))].sort();
+                if (ids.length === 0)
+                    continue;
+                const bases = [...new Set(resolved.map((r) => r.base))];
+                if (bases.length > 1)
+                    ambiguous.push(name);
+                perPath[name] = ids;
+            }
+            if (Object.keys(perPath).length > 0)
+                exports[entry.subpath] = perPath;
+            if (ambiguous.length > 0)
+                ambiguousNames[entry.subpath] = ambiguous;
+        }
+        if (Object.keys(exports).length === 0)
+            return undefined;
+        return { exports, ambiguousNames };
+    }
+    catch {
+        return undefined;
+    }
+}
+function explicitExportNames(sf) {
+    const names = new Set();
+    for (const ed of sf.getExportDeclarations()) {
+        for (const spec of ed.getNamedExports())
+            names.add(spec.getName());
+    }
+    return names;
+}
+function starContributors(sf, cache) {
+    const key = sf.getFilePath();
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    const result = new Map();
+    const seen = new Set([key]);
+    const stack = [sf];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        for (const ed of current.getExportDeclarations()) {
+            if (ed.getNamedExports().length > 0)
+                continue;
+            const target = ed.getModuleSpecifierSourceFile();
+            if (!target || seen.has(target.getFilePath()))
+                continue;
+            seen.add(target.getFilePath());
+            const targetPath = target.getFilePath();
+            let targetDecls;
+            try {
+                targetDecls = target.getExportedDeclarations();
+            }
+            catch {
+                continue;
+            }
+            for (const [name, declList] of targetDecls) {
+                const isLocal = declList.some((d) => d.getSourceFile().getFilePath() === targetPath);
+                if (isLocal) {
+                    if (!result.has(name))
+                        result.set(name, new Set());
+                    result.get(name).add(targetPath);
+                }
+                else {
+                    const deeper = starContributors(target, cache);
+                    const contributors = deeper.get(name);
+                    if (contributors) {
+                        if (!result.has(name))
+                            result.set(name, new Set());
+                        for (const f of contributors)
+                            result.get(name).add(f);
+                    }
+                }
+            }
+            stack.push(target);
+        }
+    }
+    cache.set(key, result);
+    return result;
+}
+function buildNodeIndex(nodes) {
+    const index = new Map();
+    for (const node of nodes) {
+        const base = `${node.filePath}::${node.name}`;
+        if (!index.has(base))
+            index.set(base, []);
+        index.get(base).push(node);
+    }
+    return index;
+}
+function resolveEntryPoints(pkg, repoPath, project) {
+    const entries = [];
+    if (pkg.exports !== undefined) {
+        const normalized = normalizeExportsField(pkg.exports);
+        for (const [subpath, target] of normalized) {
+            const file = resolveTargetFile(repoPath, target, project);
+            if (file)
+                entries.push({ subpath, file });
+        }
+        return entries;
+    }
+    const fallback = pkg.main ?? pkg.module;
+    if (fallback) {
+        const file = resolveTargetFile(repoPath, fallback, project);
+        if (file)
+            entries.push({ subpath: ".", file });
+    }
+    else {
+        for (const candidate of INDEX_NAMES.map((n) => path.join("src", n)).concat(INDEX_NAMES)) {
+            const file = resolveTargetFile(repoPath, candidate, project);
+            if (file) {
+                entries.push({ subpath: ".", file });
+                break;
+            }
+        }
+    }
+    return entries;
+}
+function normalizeExportsField(field) {
+    const out = [];
+    if (typeof field === "string") {
+        out.push([".", field]);
+        return out;
+    }
+    if (typeof field !== "object" || field === null)
+        return out;
+    for (const [subpath, value] of Object.entries(field)) {
+        if (subpath.includes("*"))
+            continue;
+        if (typeof value === "string") {
+            out.push([subpath, value]);
+            continue;
+        }
+        if (typeof value !== "object" || value === null)
+            continue;
+        const conditions = value;
+        const chosen = (typeof conditions.import === "string" && conditions.import) ||
+            (typeof conditions.default === "string" && conditions.default) ||
+            (typeof conditions.require === "string" && conditions.require);
+        if (typeof chosen === "string" && chosen)
+            out.push([subpath, chosen]);
+    }
+    return out;
+}
+function resolveTargetFile(repoPath, target, project) {
+    if (typeof target !== "string" || !target)
+        return undefined;
+    let rel = target.replace(/^\.\//, "").split(/[?#]/)[0];
+    if (rel.endsWith(".d.ts"))
+        return undefined;
+    const candidates = [rel];
+    const distMatch = rel.match(/^(dist|build)(\/|$)/);
+    if (distMatch) {
+        candidates.push("src" + rel.slice(distMatch[1].length));
+    }
+    for (const candidate of candidates) {
+        const stem = candidate.replace(/\.[^.]+$/, "");
+        const tries = new Set([candidate]);
+        for (const ext of ENTRY_EXTENSIONS)
+            tries.add(stem + ext);
+        for (const idx of INDEX_NAMES)
+            tries.add(path.posix.join(candidate, idx));
+        for (const tryPath of tries) {
+            if (tryPath.endsWith(".d.ts"))
+                continue;
+            const abs = path.resolve(repoPath, tryPath);
+            if (!fs.existsSync(abs) || fs.statSync(abs).isDirectory())
+                continue;
+            const sf = project.getSourceFile(abs);
+            if (sf)
+                return sf;
+        }
+    }
+    return undefined;
+}
+function resolveDeclarationToNode(decl, repoPath, nodeIndex) {
+    const name = declarationName(decl);
+    if (!name)
+        return undefined;
+    const relPath = path.relative(repoPath, decl.getSourceFile().getFilePath()).replace(/\\/g, "/");
+    const base = `${relPath}::${name}`;
+    const candidates = nodeIndex.get(base);
+    if (!candidates || candidates.length === 0)
+        return undefined;
+    if (candidates.length === 1)
+        return { id: candidates[0].id, base };
+    const match = matchOverloadedNode(decl, candidates);
+    return match ? { id: match.id, base } : undefined;
+}
+function declarationName(decl) {
+    const getName = decl.getName;
+    if (typeof getName === "function") {
+        try {
+            const own = getName.call(decl);
+            if (typeof own === "string" && own.length > 0)
+                return own;
+        }
+        catch {
+            // fall through to symbol
+        }
+    }
+    const sym = decl.getSymbol()?.getName();
+    if (sym && sym !== "default" && !sym.startsWith("__"))
+        return sym;
+    return undefined;
+}
+function matchOverloadedNode(decl, candidates) {
+    const paramTypes = declarationParamTypes(decl);
+    if (paramTypes === undefined)
+        return undefined;
+    const declKey = signatureKeyFromTypes(paramTypes);
+    const matches = candidates.filter((node) => {
+        const params = node.metadata?.parameters;
+        if (!Array.isArray(params))
+            return false;
+        return signatureKeyFromNodeParams(params) === declKey;
+    });
+    return matches.length >= 1 ? matches[0] : undefined;
+}
+function declarationParamTypes(decl) {
+    const anyDecl = decl;
+    if (typeof anyDecl.getParameters !== "function")
+        return undefined;
+    try {
+        const params = anyDecl.getParameters();
+        if (!Array.isArray(params))
+            return undefined;
+        return params.map((p) => {
+            const t = p.getTypeNode?.()?.getText() ?? "unknown";
+            if (p.isRest?.())
+                return `...${t}`;
+            if (p.isOptional?.())
+                return `${t}?`;
+            return t;
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function signatureKeyFromTypes(types) {
+    return `(${types.join(",")})`;
+}
+function signatureKeyFromNodeParams(params) {
+    return `(${params
+        .map((p) => {
+        const t = typeof p?.type === "string" && p.type.length > 0 ? p.type : "unknown";
+        if (p?.isRest)
+            return `...${t}`;
+        if (p?.isOptional)
+            return `${t}?`;
+        return t;
+    })
+        .join(",")})`;
+}
+export function validateExportsMap(map, nodeIds) {
+    const dangling = [];
+    for (const perPath of Object.values(map.exports)) {
+        for (const ids of Object.values(perPath)) {
+            for (const id of ids) {
+                if (!nodeIds.has(id))
+                    dangling.push(id);
+            }
+        }
+    }
+    return [...new Set(dangling)];
+}
+export function exportsMapStats(map) {
+    let names = 0;
+    let ambiguous = 0;
+    for (const perPath of Object.values(map.exports))
+        names += Object.keys(perPath).length;
+    for (const list of Object.values(map.ambiguousNames))
+        ambiguous += list.length;
+    return { subpaths: Object.keys(map.exports).length, names, ambiguous };
+}

package/dist/parser/exportsMap.test.d.ts

@@ -0,0 +1 @@
+export {};