@orangepro/orangepro-mcp 0.1.0

package/dist/local/reprove/scoped.js

@@ -0,0 +1,136 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { runConfirmer } from "../analyze/confirm.js";
+import { isTestFile, languageOf } from "../analyze/classify.js";
+import { classifyTestLayer } from "../analyze/testLayer.js";
+import { extractTestNames } from "../analyze/symbols.js";
+import { makeProofEdges, makeTestCaseNode } from "../graph/factories.js";
+import { confirmedCoverageByLayer } from "../score/coverage.js";
+import { hashString } from "../util/hash.js";
+import { resolveContained, toWorkspaceRel } from "./paths.js";
+const DETECTOR = "repo_analyzer";
+export function tryScopedReprove(input) {
+    if (!input.testPath)
+        return null;
+    const parsed = parseSymId(input.targetSymbol);
+    if (!parsed)
+        return null;
+    const absRoot = resolve(input.root);
+    const testAbs = resolveContained(absRoot, input.testPath);
+    if (!existsSync(testAbs))
+        return null;
+    const testRel = toWorkspaceRel(absRoot, testAbs);
+    if (!isTestFile(testRel))
+        return null;
+    const testLang = languageOf(testRel);
+    if (testLang !== "typescript" && testLang !== "javascript")
+        return null;
+    if (!/\.([cm]?[tj]sx?)$/i.test(parsed.implRel))
+        return null;
+    const implAbs = resolveContained(absRoot, parsed.implRel);
+    if (!existsSync(implAbs))
+        return null;
+    const symbolsByImpl = eligibleSymbolsByImpl(input.graph);
+    const existingSymIds = new Set(input.graph.nodes.filter((n) => n.kind === "CodeSymbol").map((n) => n.external_id));
+    const candidate = { testRel, testAbs, implRel: parsed.implRel, implAbs };
+    let confirmations;
+    try {
+        confirmations = runConfirmer({ candidates: [candidate], symbolsByImpl, existingSymIds, anchorFile: absRoot }).confirmations;
+    }
+    catch {
+        return null;
+    }
+    const matched = confirmations.filter((c) => c.symId === input.targetSymbol);
+    if (matched.length === 0)
+        return null;
+    const next = patchGraph(input.graph, {
+        testRel,
+        testAbs,
+        targetSymbol: input.targetSymbol,
+        now: input.now
+    });
+    const newEdges = [`test:${testRel}->${input.targetSymbol}`].filter((edge) => !input.preEdges.includes(edge));
+    return newEdges.length > 0
+        ? { graph: next, newEdges, reason: "Scoped confirmer produced a static COVERS edge; full re-analysis skipped." }
+        : null;
+}
+function patchGraph(graph, input) {
+    const content = readFileSync(input.testAbs, "utf8");
+    const testNames = extractTestNames(content);
+    const layer = classifyTestLayer(input.testRel, content);
+    const provenance = prov(graph, input.testRel, hashString(testNames.join("\n")));
+    const lastVerified = Date.parse(input.now) || Date.now();
+    const next = {
+        ...graph,
+        updated_at: input.now,
+        nodes: [...graph.nodes],
+        edges: [...graph.edges],
+        ...(graph.analysis ? { analysis: { ...graph.analysis } } : {})
+    };
+    const testExternalId = `test:${input.testRel}`;
+    if (!next.nodes.some((n) => n.external_id === testExternalId)) {
+        next.nodes.push(makeTestCaseNode({
+            testRel: input.testRel,
+            title: basename(input.testRel),
+            testLayer: layer.layer,
+            layerConfidence: layer.confidence,
+            layerSignals: layer.signals,
+            testNames,
+            provenance,
+            contentHash: hashString(content)
+        }));
+    }
+    const edgeIds = new Set(next.edges.map((e) => e.id));
+    const proofEdges = makeProofEdges({
+        testRel: input.testRel,
+        symId: input.targetSymbol,
+        provenance: prov(graph, input.testRel, hashString(input.targetSymbol)),
+        lastVerified
+    });
+    for (const edge of proofEdges) {
+        if (!edgeIds.has(edge.id))
+            next.edges.push(edge);
+    }
+    if (next.analysis) {
+        next.analysis = {
+            ...next.analysis,
+            confirmed_coverage: {
+                confirmed_pairs: (next.analysis.confirmed_coverage?.confirmed_pairs ?? 0) +
+                    proofEdges.filter((e) => e.relationship_type === "COVERS").length,
+                attempted: next.analysis.confirmed_coverage?.attempted ?? 0,
+                capped_downgrades: next.analysis.confirmed_coverage?.capped_downgrades ?? 0,
+                skipped_files_budget: next.analysis.confirmed_coverage?.skipped_files_budget ?? 0
+            },
+            confirmed_by_layer: confirmedCoverageByLayer(next)
+        };
+    }
+    return next;
+}
+function eligibleSymbolsByImpl(graph) {
+    const out = new Map();
+    for (const node of graph.nodes) {
+        if (node.kind !== "CodeSymbol" || node.denominator_eligible !== true || node.properties.member_of)
+            continue;
+        const parsed = parseSymId(node.external_id);
+        if (!parsed)
+            continue;
+        const list = out.get(parsed.implRel);
+        if (list)
+            list.push(parsed.name);
+        else
+            out.set(parsed.implRel, [parsed.name]);
+    }
+    return out;
+}
+function parseSymId(symId) {
+    const m = symId.match(/^sym:(.+)#([^#]+)$/);
+    return m ? { implRel: m[1], name: m[2] } : null;
+}
+function prov(graph, ref, quote_hash) {
+    return {
+        source_scope_id: graph.sources[0]?.source_scope_id ?? graph.workspace.name,
+        source_ref: ref,
+        quote_hash,
+        detector: DETECTOR
+    };
+}

package/dist/local/resolve/barrelWalker.js

@@ -0,0 +1,178 @@
+// Barrel walker (Gate 1 / G-RESOLVE, Phase 1 PR-2).
+//
+// Given a starting file and the name of a binding imported FROM it, follow the
+// re-export chain (`export * from` / `export { x as y } from`) to the TERMINAL
+// file that locally defines the binding. Only a terminal RUNTIME definition
+// reached via RUNTIME hops is COVERS-eligible (`covered === true`); every
+// dead-end (ambiguous star, depth/cycle exhaustion, unresolvable hop) AND every
+// type-only outcome (a type terminal, or a hop through a `export type ... from`)
+// is NOT covered — a false "confirmed" is worse than "inferred"
+// (gate-specs-digest.md §resolver: type-only targets are NOT terminal impl).
+//
+// Resolution rules (TypeScript module semantics, parse-only):
+//   - Local definition          -> terminal here. covered iff the binding kind is
+//                                  runtime (not "type") AND no type-only hop taken.
+//   - Explicit named re-export  -> follow it; it SHADOWS star re-exports for that
+//                                  name (TS: explicit exports win over `export *`).
+//                                  A renamed alias (`export { x as y } from`) is
+//                                  deterministic and stays COVERS-eligible.
+//   - Single `export *`         -> follow it with the SAME binding name.
+//   - 2+ `export *`             -> probe each; exactly one supplying terminal is
+//                                  deterministic; two or more is AMBIGUOUS.
+//   - `default` via `export *`  -> unresolved. TS/Node never forward a default
+//                                  through a star (`import d from barrel` where
+//                                  the barrel only `export *`s = "no default
+//                                  export"); only `export { x as default } from`
+//                                  (the named branch) forwards one.
+//   - Depth > maxDepth (5)      -> depth-exceeded (downgrade).
+//   - Revisited (file, binding) -> cycle (downgrade) — barrels are often cyclic.
+//                                  A cycle is CONCLUSIVE for its own branch (ESM
+//                                  ResolveExport treats circular star paths as
+//                                  contributing nothing), so a sibling star may
+//                                  still supply the binding deterministically.
+//   - Total work > maxExpansions -> budget-exhausted (fail-closed; bounds a wide fan-out).
+//   - Hop resolves to external/null -> unresolved (downgrade).
+//   - In a 2+ star probe, a branch CUT mid-exploration (depth-exceeded or
+//     budget-exhausted) or an unexpandable star POISONS the whole collapse:
+//     we cannot prove the surviving terminal is unique, and a hidden second
+//     supplier would make the barrel ambiguous (TS2308 / ESM "conflicting star
+//     exports" = the binding is NOT delivered). Only conclusively-explored
+//     branches (unresolved = binding absent; cycle; deeper-ambiguous = excluded
+//     by ESM) may be dropped.
+//   - A `.d.ts` terminal is types-only at runtime -> terminal but NOT covered.
+import path from "node:path";
+import { resolveImport } from "./resolver.js";
+import { buildExportIndex } from "./exportIndex.js";
+const DEFAULT_MAX_DEPTH = 5;
+const DEFAULT_MAX_EXPANSIONS = 4000;
+/** Default resolver: only INTERNAL terminals are walkable (a hop into node_modules is a dead-end). */
+function defaultResolve(specifier, containingFile) {
+    const r = resolveImport(specifier, containingFile);
+    if (!r.resolved || r.isExternal)
+        return null;
+    return r.resolvedFileName;
+}
+/** Kinds that denote a concrete RUNTIME implementation binding (COVERS-eligible). */
+function isRuntimeKind(kind) {
+    return kind === "function" || kind === "class" || kind === "const" || kind === "default" || kind === "namespace";
+}
+function fail(status, depth) {
+    return { status, terminalFile: null, terminalBinding: null, terminalKind: null, depth, covered: false };
+}
+function terminalKey(r) {
+    return `${r.terminalFile}::${r.terminalBinding}`;
+}
+/**
+ * Follow the re-export chain from `file` for the binding `binding` to its
+ * terminal defining file. See module docs for the resolution rules.
+ */
+export function walkBarrel(file, binding, opts = {}) {
+    const maxDepth = opts.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const resolve = opts.resolve ?? defaultResolve;
+    const loadIndex = opts.loadIndex ?? buildExportIndex;
+    const budget = { n: 0, max: opts.maxExpansions ?? DEFAULT_MAX_EXPANSIONS };
+    return walkRec(file, binding, 0, new Set(), false, maxDepth, resolve, loadIndex, budget);
+}
+function walkRec(currentFile, binding, depth, visited, typeTainted, maxDepth, resolve, loadIndex, budget) {
+    // Total-work budget (shared across all sibling star branches): a wide fan-out
+    // can branch combinatorially within the depth bound, so cap total nodes
+    // visited and downgrade fail-closed (never a false terminal) on exhaustion.
+    // The status is DISTINCT from "unresolved" so the multi-star collapse can tell
+    // a cut branch apart from a conclusively-absent binding (cuts must poison).
+    if (++budget.n > budget.max)
+        return fail("budget-exhausted", depth);
+    if (depth > maxDepth)
+        return fail("depth-exceeded", depth);
+    // Cycle detection is along THIS path: a per-call copy lets sibling star
+    // branches explore independently while still catching a loop back to a
+    // (file, binding) pair already open on the current chain.
+    const key = `${path.resolve(currentFile)}::${binding}`;
+    if (visited.has(key))
+        return fail("cycle", depth);
+    const pathVisited = new Set(visited);
+    pathVisited.add(key);
+    const index = loadIndex(currentFile);
+    // 1. Defined locally -> terminal. Covered only for a RUNTIME kind reached
+    //    without a type-only hop, and never in a declaration file (a `.d.ts`
+    //    "export declare function" is types-only at runtime — not terminal impl).
+    if (index.local.has(binding)) {
+        const kind = index.local.get(binding) ?? "unknown";
+        const isDeclarationFile = /\.d\.[mc]?ts$/i.test(index.file);
+        return {
+            status: "terminal",
+            terminalFile: index.file,
+            terminalBinding: binding,
+            terminalKind: kind,
+            depth,
+            covered: !typeTainted && !isDeclarationFile && isRuntimeKind(kind)
+        };
+    }
+    // 2. Explicit named re-exports shadow star re-exports for this name.
+    const named = [];
+    for (const re of index.reexports) {
+        if (re.kind === "named") {
+            for (const n of re.names) {
+                if (n.exported === binding)
+                    named.push({ specifier: re.specifier, source: n.source, typeOnly: n.isTypeOnly });
+            }
+        }
+    }
+    if (named.length >= 2)
+        return fail("ambiguous", depth); // duplicate explicit re-export
+    if (named.length === 1) {
+        const target = resolve(named[0].specifier, currentFile);
+        if (!target)
+            return fail("unresolved", depth);
+        return walkRec(target, named[0].source, depth + 1, pathVisited, typeTainted || named[0].typeOnly, maxDepth, resolve, loadIndex, budget);
+    }
+    // A `default` cannot be supplied by `export *` (TS/Node never forward a default
+    // through a star). Having exhausted explicit named re-exports above, a `default`
+    // request that reaches the star section can never be satisfied — downgrade
+    // instead of false-confirming a star target's OWN local default.
+    if (binding === "default")
+        return fail("unresolved", depth);
+    // 3. Star re-exports are the only remaining source.
+    const stars = index.reexports.filter((re) => re.kind === "star");
+    if (stars.length === 0)
+        return fail("unresolved", depth);
+    if (stars.length === 1) {
+        const target = resolve(stars[0].specifier, currentFile);
+        if (!target)
+            return fail("unresolved", depth);
+        return walkRec(target, binding, depth + 1, pathVisited, typeTainted || stars[0].isTypeOnly, maxDepth, resolve, loadIndex, budget);
+    }
+    // 4. 2+ stars: probe each branch independently. Exactly one terminal is
+    //    deterministic; two or more DISTINCT terminals is ambiguous. A branch is
+    //    droppable ONLY when conclusively explored: "unresolved" (binding absent),
+    //    "cycle" (ESM circular star paths contribute nothing), or "ambiguous"
+    //    deeper down (ESM excludes ambiguous star exports from the namespace). A
+    //    CUT branch (depth-exceeded / budget-exhausted) or an unexpandable star
+    //    POISONS the collapse: a hidden second supplier would make this barrel
+    //    ambiguous (TS2308), so a surviving lone terminal cannot be trusted.
+    const hits = [];
+    for (const star of stars) {
+        const target = resolve(star.specifier, currentFile);
+        if (!target)
+            return fail("unresolved", depth); // a star we cannot expand -> cannot prove uniqueness
+        const sub = walkRec(target, binding, depth + 1, new Set(pathVisited), typeTainted || star.isTypeOnly, maxDepth, resolve, loadIndex, budget);
+        if (sub.status === "terminal")
+            hits.push(sub);
+        else if (sub.status === "depth-exceeded" || sub.status === "budget-exhausted")
+            return fail(sub.status, depth);
+    }
+    const distinct = new Map();
+    for (const h of hits) {
+        const k = terminalKey(h);
+        const prev = distinct.get(k);
+        // Same terminal reached via multiple stars: keep the COVERED outcome so the
+        // result is independent of star declaration order (a runtime star and a
+        // type-only star reaching the same def must deterministically be covered).
+        if (!prev || (!prev.covered && h.covered))
+            distinct.set(k, h);
+    }
+    if (distinct.size === 1)
+        return [...distinct.values()][0];
+    if (distinct.size >= 2)
+        return fail("ambiguous", depth);
+    return fail("unresolved", depth);
+}

package/dist/local/resolve/exportIndex.js

@@ -0,0 +1,270 @@
+// Per-file export index (Gate 1 / G-RESOLVE, Phase 1 PR-2).
+//
+// For one file, list (a) the bindings it EXPORTS whose terminal definition is
+// the file itself, and (b) its re-export directives (`export ... from`). The
+// barrel walker (barrelWalker.ts) consumes this to follow re-export chains to a
+// terminal defining file.
+//
+// PARSE-ONLY: a single `ts.createSourceFile` pass, NO `Program`/`TypeChecker`.
+// The confirmed-safety spike proved this parse-only path is false-confirm-safe
+// (see private/spikes/confirmed). A re-export of an IMPORTED binding
+// (`import { x } from "./m"; export { x }`) is synthesized into a named
+// re-export so the walker follows it to the real definition rather than stopping
+// at the re-exporting file. Type-only-ness is tracked per re-exported name and
+// per local binding (kind "type") so the walker never treats a type as a
+// COVERS-eligible runtime terminal (gate-specs-digest.md §resolver: type-only
+// targets are NOT terminal impl).
+import ts from "typescript";
+import fs from "node:fs";
+import path from "node:path";
+const EMPTY_INDEX = (file) => ({
+    file,
+    local: new Map(),
+    reexports: [],
+    isBarrel: false
+});
+// Cache by `absPath + ":" + mtimeMs` so an edited file busts its own entry; a
+// long-lived MCP process never serves a stale index after edits. Mirrors the
+// resolver's scope cache.
+const indexCache = new Map();
+function cacheKey(file) {
+    let mtimeMs = 0;
+    try {
+        mtimeMs = fs.statSync(file).mtimeMs;
+    }
+    catch {
+        /* unreadable file — key on mtime 0 */
+    }
+    return `${path.resolve(file)}:${mtimeMs}`;
+}
+/**
+ * Build (and memoize) the export index for `file`. Returns an empty index for
+ * an unreadable file rather than throwing.
+ */
+export function buildExportIndex(file) {
+    const key = cacheKey(file);
+    const cached = indexCache.get(key);
+    if (cached)
+        return cached;
+    const index = computeExportIndex(file);
+    indexCache.set(key, index);
+    return index;
+}
+/** Clear the process-level export-index cache. Call at the START of an analyze run. */
+export function resetExportIndexCache() {
+    indexCache.clear();
+}
+function modifierFlags(node) {
+    return ts.canHaveModifiers(node) ? ts.getCombinedModifierFlags(node) : ts.ModifierFlags.None;
+}
+/** Collect identifier names from a binding name (identifier or destructuring pattern). */
+function bindingNames(name, out) {
+    if (ts.isIdentifier(name)) {
+        out.push(name.text);
+        return;
+    }
+    for (const el of name.elements) {
+        if (ts.isBindingElement(el))
+            bindingNames(el.name, out);
+    }
+}
+function moduleText(node) {
+    return node && ts.isStringLiteralLike(node) ? node.text : null;
+}
+/**
+ * Kind for a `namespace N { ... }`: "namespace" (runtime object) only when it is
+ * INSTANTIATED. TS erases a namespace whose body holds only interfaces, type
+ * aliases, and uninstantiated nested namespaces — and any ambient (`declare`)
+ * namespace — so those must be kind "type" (never COVERS-eligible).
+ */
+function namespaceKind(node) {
+    if (modifierFlags(node) & ts.ModifierFlags.Ambient)
+        return "type"; // `declare namespace` is erased
+    return isInstantiatedNamespace(node) ? "namespace" : "type";
+}
+function isInstantiatedNamespace(node) {
+    const body = node.body;
+    if (!body)
+        return false;
+    if (ts.isModuleDeclaration(body))
+        return isInstantiatedNamespace(body); // `namespace A.B { ... }`
+    if (!ts.isModuleBlock(body))
+        return false;
+    return body.statements.some((s) => {
+        if (ts.isInterfaceDeclaration(s) || ts.isTypeAliasDeclaration(s))
+            return false;
+        if (ts.isModuleDeclaration(s))
+            return isInstantiatedNamespace(s);
+        return true; // any value declaration or executable statement instantiates
+    });
+}
+function computeExportIndex(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return EMPTY_INDEX(path.resolve(file));
+    }
+    const abs = path.resolve(file);
+    const sourceFile = ts.createSourceFile(abs, text, ts.ScriptTarget.Latest, /*setParentNodes*/ false);
+    // Pass 1: top-level declarations (name -> kind, whether exported or not) and
+    // import bindings — both needed to resolve `export { x }` (no `from`).
+    const declared = new Map();
+    const localImports = new Map();
+    for (const stmt of sourceFile.statements) {
+        collectDeclarations(stmt, declared);
+        collectImports(stmt, localImports);
+    }
+    // Pass 2: exports + re-exports.
+    const local = new Map();
+    const reexports = [];
+    for (const stmt of sourceFile.statements) {
+        collectExports(stmt, declared, localImports, local, reexports);
+    }
+    return { file: abs, local, reexports, isBarrel: reexports.length > 0 };
+}
+function collectDeclarations(node, declared) {
+    // An ambient declaration (`declare function` etc., or anything in a .d.ts) is
+    // erased at emit — its binding is types-only for coverage purposes.
+    const ambient = (modifierFlags(node) & ts.ModifierFlags.Ambient) !== 0;
+    const runtime = (kind) => (ambient ? "type" : kind);
+    if (ts.isFunctionDeclaration(node) && node.name)
+        declared.set(node.name.text, runtime("function"));
+    else if (ts.isClassDeclaration(node) && node.name)
+        declared.set(node.name.text, runtime("class"));
+    else if (ts.isEnumDeclaration(node))
+        declared.set(node.name.text, runtime("const"));
+    else if (ts.isInterfaceDeclaration(node))
+        declared.set(node.name.text, "type");
+    else if (ts.isTypeAliasDeclaration(node))
+        declared.set(node.name.text, "type");
+    else if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name))
+        declared.set(node.name.text, namespaceKind(node));
+    else if (ts.isVariableStatement(node)) {
+        for (const decl of node.declarationList.declarations) {
+            const names = [];
+            bindingNames(decl.name, names);
+            for (const n of names)
+                declared.set(n, runtime("const"));
+        }
+    }
+}
+function collectImports(node, localImports) {
+    if (!ts.isImportDeclaration(node))
+        return;
+    const specifier = moduleText(node.moduleSpecifier);
+    if (specifier === null)
+        return;
+    const clause = node.importClause;
+    if (!clause)
+        return; // side-effect import binds nothing
+    const clauseTypeOnly = clause.isTypeOnly; // `import type ...`
+    if (clause.name)
+        localImports.set(clause.name.text, { specifier, source: "default", typeOnly: clauseTypeOnly });
+    const named = clause.namedBindings;
+    if (named && ts.isNamespaceImport(named)) {
+        localImports.set(named.name.text, { specifier, source: "*", typeOnly: clauseTypeOnly });
+    }
+    else if (named && ts.isNamedImports(named)) {
+        for (const el of named.elements) {
+            localImports.set(el.name.text, {
+                specifier,
+                source: (el.propertyName ?? el.name).text,
+                typeOnly: clauseTypeOnly || el.isTypeOnly // `import { type x }`
+            });
+        }
+    }
+}
+function collectExports(node, declared, localImports, local, reexports) {
+    const flags = modifierFlags(node);
+    const isExported = (flags & ts.ModifierFlags.Export) !== 0;
+    const isDefault = (flags & ts.ModifierFlags.Default) !== 0;
+    // `export default function/class ...` exposes the binding as "default".
+    if (isExported && isDefault) {
+        local.set("default", "default");
+        return;
+    }
+    if (isExported) {
+        // `export declare ...` is ambient: erased at emit, so types-only for coverage.
+        const ambient = (flags & ts.ModifierFlags.Ambient) !== 0;
+        const runtime = (kind) => (ambient ? "type" : kind);
+        if (ts.isFunctionDeclaration(node) && node.name)
+            local.set(node.name.text, runtime("function"));
+        else if (ts.isClassDeclaration(node) && node.name)
+            local.set(node.name.text, runtime("class"));
+        else if (ts.isEnumDeclaration(node))
+            local.set(node.name.text, runtime("const"));
+        else if (ts.isInterfaceDeclaration(node))
+            local.set(node.name.text, "type");
+        else if (ts.isTypeAliasDeclaration(node))
+            local.set(node.name.text, "type");
+        else if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name))
+            local.set(node.name.text, namespaceKind(node));
+        else if (ts.isVariableStatement(node)) {
+            for (const decl of node.declarationList.declarations) {
+                const names = [];
+                bindingNames(decl.name, names);
+                for (const n of names)
+                    local.set(n, runtime("const"));
+            }
+        }
+        return;
+    }
+    // `export default <expr>` (ExportAssignment, not `export =`).
+    if (ts.isExportAssignment(node) && !node.isExportEquals) {
+        local.set("default", "default");
+        return;
+    }
+    // `export = expr` (CommonJS) is intentionally NOT indexed (rare in modern TS-ESM).
+    if (!ts.isExportDeclaration(node))
+        return;
+    // `export * [as ns] from "./m"` / `export { ... } from "./m"`.
+    if (node.moduleSpecifier) {
+        const specifier = moduleText(node.moduleSpecifier);
+        if (specifier === null)
+            return;
+        const isTypeOnly = node.isTypeOnly;
+        const clause = node.exportClause;
+        if (!clause) {
+            reexports.push({ kind: "star", specifier, isTypeOnly });
+        }
+        else if (ts.isNamespaceExport(clause)) {
+            // `export * as ns from "./m"` binds the namespace object HERE.
+            local.set(clause.name.text, isTypeOnly ? "type" : "namespace");
+        }
+        else {
+            const names = clause.elements.map((el) => ({
+                source: (el.propertyName ?? el.name).text,
+                exported: el.name.text,
+                isTypeOnly: isTypeOnly || el.isTypeOnly
+            }));
+            reexports.push({ kind: "named", specifier, isTypeOnly, names });
+        }
+        return;
+    }
+    // `export { a, b as c }` (no `from`): re-export of an imported binding (follow
+    // it) OR a local/ambient binding (terminal here).
+    if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+        for (const el of node.exportClause.elements) {
+            const exported = el.name.text;
+            const localName = (el.propertyName ?? el.name).text;
+            const elementTypeOnly = node.isTypeOnly || el.isTypeOnly;
+            const imported = localImports.get(localName);
+            if (imported) {
+                // A re-export of an imported binding is type-only if the EXPORT marks it
+                // type-only OR the original IMPORT was type-only (`import type {x}; export {x}`
+                // re-exports a type, never a runtime value — must not become COVERS-eligible).
+                reexports.push({
+                    kind: "named",
+                    specifier: imported.specifier,
+                    isTypeOnly: node.isTypeOnly || imported.typeOnly,
+                    names: [{ source: imported.source, exported, isTypeOnly: elementTypeOnly || imported.typeOnly }]
+                });
+            }
+            else {
+                local.set(exported, elementTypeOnly ? "type" : declared.get(localName) ?? "unknown");
+            }
+        }
+    }
+}