@chappibunny/repolens 1.16.3 → 1.16.4

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to RepoLens will be documented in this file.
 
+## 1.16.4 (2026-11-12)
+
+Fix found by the 2026-11-12 gap test of 1.16.3 on lukeautry/tsoa (ce4daec).
+
+### Upgrade notes
+
+- **Fewer cycles and edges in TypeScript repositories.** Imports the TypeScript compiler removes are no longer runtime edges. On tsoa: circular dependencies 10 → 1, import edges 412 → 326, with 108 type-only imports and 17 type-only cycles listed separately. On trpc/trpc: edges 1,533 → 1,531, still no runtime cycles. Architecture baselines and drift reports will show the drop once; it is a measurement fix, not a code change.
+- **Type-only cycles now include mixed cycles.** Before, only cycles made entirely of `import type` edges were listed; a cycle with one `import type` link and runtime links elsewhere was silently dropped. Both are now listed under "Type-only cycles" (trpc: 21 → 40), still Low and not counted.
+- **Fewer orphan files.** A file connected only by type-only imports (a `types.ts` module) is no longer an orphan. On trpc: 126 → 81. The orphan share feeds the architecture health score, so that score can rise.
+
+### Dependency graph
+
+- In `.ts` files, an import whose names are all interfaces or type aliases in the target file, or are all used only in type positions (annotations, generic arguments and constraints, `as` / `satisfies`, `implements`, type aliases, interfaces, `declare` blocks), is type-only (*inferred*). Value uses (`new`, calls, member access, `extends` of a class, `instanceof`, decorators, `typeof` in an expression, object shorthand, default values, `export { X }`, JSX tags) keep the import a runtime edge. A name that is both an interface and a value (declaration merging) is a value.
+- `export { X } from` is type-only when every name is an interface or type alias in the target. `export * from`, side-effect imports, `import()`, and `require()` stay runtime edges. Imports inside `.d.ts` files are type-only.
+- In `.tsx` files only the interface / type-alias check applies, because JSX text can look like code.
+- Inference is off where the compiler keeps the import: `verbatimModuleSyntax`, `preserveValueImports`, `importsNotUsedAsValues: "preserve"`/`"error"`, or `erasableSyntaxOnly` (Node type stripping removes only `import type`) in the nearest `tsconfig.json`, and files with decorators under `emitDecoratorMetadata`. The `extends` chain is followed for relative paths and for packages installed in `node_modules` (bare names, `package.json` `tsconfig` field, parent folders).
+- When part of the `extends` chain is not in the checkout (an uninstalled package, a generated `.nuxt/tsconfig.json`), or the file could not be tokenized cleanly, only interface / type-alias imports count as type-only; usage-based inference is skipped so a class used only as a type stays a runtime edge.
+- Only top-level interfaces and type aliases of the target file count. A nested one (`namespace N { interface Foo }`, inside a function or `declare module`) does not make an import of `Foo` type-only, and names the target re-exports from another module (`export { Foo } from`, `export * as Foo from`) or aliases with `import Foo = require()` are treated as values.
+- `import type`, `export type`, and all-`type` lists (`import { type A, type B }`) are type-only as before (*syntax*). A mixed `import { type A, b }` is type-only only when `b` is used only as a type.
+- The dependency graph page and the MCP `get_dependency_graph` tool list "Type-only cycles" with each type-only link and whether it is *syntax* or *inferred*, plus "Type-only cycles" and "Type-only imports" rows in the overview table. The CLI log says "(N type-only cycle(s) not counted)". Health score, badge, and cycle findings count runtime cycles only.
+- External packages are unchanged: an npm import used only as a type is still listed.
+
+### Output accuracy
+
+- The executive summary insight no longer calls a lone medium-priority cycle "mutual recursion, probably intentional; verify. Priority: Low" (it said that whenever no cycle was high). It now reads "Small cycle; review. Priority: Medium.", matching the dependency graph page.
+
 ## 1.16.3 (2026-11-11)
 
 Fixes found by the 2026-11-11 gap test of 1.16.2 on trpc/trpc, App-vNext/Polly, google/gson, charmbracelet/glow, and pallets/itsdangerous.

package/README.md

@@ -243,9 +243,9 @@ If `npx` reports `Unknown command: mcp`, an `.npmrc` with `min-release-age` (or
 
 ## GitHub Action
 
-`action.yml` is a composite action named **RepoLens Architecture Docs**. `publish`, `demo`, and `doctor` run the published npm package (`npx --force --yes @chappibunny/repolens@1.16.3`). `comment` and `badge` run from the action checkout. Inputs are `command` (`publish`, `demo`, `doctor`, `comment`, or `badge`), `config`, `node-version`, `pr-comment`, `version`, `badge-out`, `badge-url`, and `badge-link`. The action passes `--force` so a repository `devEngines` pin does not stop `npx` on npm versions that enforce `devEngines` (newer npm). Node 20's bundled npm does not enforce that field. From a shell, use the same flag: `npx --force --yes @chappibunny/repolens demo`. `--ignore-engines` does not skip `devEngines`.
+`action.yml` is a composite action named **RepoLens Architecture Docs**. `publish`, `demo`, and `doctor` run the published npm package (`npx --force --yes @chappibunny/repolens@1.16.4`). `comment` and `badge` run from the action checkout. Inputs are `command` (`publish`, `demo`, `doctor`, `comment`, or `badge`), `config`, `node-version`, `pr-comment`, `version`, `badge-out`, `badge-url`, and `badge-link`. The action passes `--force` so a repository `devEngines` pin does not stop `npx` on npm versions that enforce `devEngines` (newer npm). Node 20's bundled npm does not enforce that field. From a shell, use the same flag: `npx --force --yes @chappibunny/repolens demo`. `--ignore-engines` does not skip `devEngines`.
 
-Publishing docs (the npm package at tag `v1.16.3`):
+Publishing docs (the npm package at tag `v1.16.4`):
 
 ```yaml
 name: Architecture docs
@@ -261,7 +261,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
-      - uses: CHAPIBUNNY/repolens@v1.16.3
+      - uses: CHAPIBUNNY/repolens@v1.16.4
         with:
           command: publish
           config: .repolens.yml
@@ -269,7 +269,7 @@ jobs:
           pr-comment: ${{ github.event_name == 'pull_request' && 'true' || 'false' }}
 ```
 
-On `v1.15.2`, `pr-comment: true` runs the architecture diff from the action checkout and turns the published package's older short summary off. The diff lists modules, files, dependencies, the code-health delta, and new hotspots. It edits one sticky comment (`<!-- repolens:architecture-diff -->`) instead of adding a new comment each push. The footer is "Generated by RepoLens" and links to this repository and the [gallery](https://chapibunny.github.io/repolens/). Tag `v1.15.1` does not contain `command: comment`. Pin `v1.16.3` or a commit SHA in production.
+On `v1.15.2`, `pr-comment: true` runs the architecture diff from the action checkout and turns the published package's older short summary off. The diff lists modules, files, dependencies, the code-health delta, and new hotspots. It edits one sticky comment (`<!-- repolens:architecture-diff -->`) instead of adding a new comment each push. The footer is "Generated by RepoLens" and links to this repository and the [gallery](https://chapibunny.github.io/repolens/). Tag `v1.15.1` does not contain `command: comment`. Pin `v1.16.4` or a commit SHA in production.
 
 ```yaml
 name: RepoLens architecture comment
@@ -285,7 +285,7 @@ jobs:
       - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
         with:
           fetch-depth: 0
-      - uses: CHAPIBUNNY/repolens@v1.16.3
+      - uses: CHAPIBUNNY/repolens@v1.16.4
         with:
           command: comment
 ```
@@ -294,7 +294,7 @@ jobs:
 
 `pr-comment: true` on `publish`, `demo`, or `doctor` (when the action ref contains this change) runs the same comment after the package and turns the package's older comment off, so the pull request still gets one comment.
 
-The action is listed on the GitHub Marketplace only after a release is published with **Publish this Action to the GitHub Marketplace** checked. Those steps are in [docs/RELEASE.md](docs/RELEASE.md). The tag `v1.16.3` has to exist before `uses: CHAPIBUNNY/repolens@v1.16.3` resolves, and `@chappibunny/repolens@1.16.3` has to be on npm before `publish` can install it. `command: comment` and `command: badge` do not install that package.
+The action is listed on the GitHub Marketplace only after a release is published with **Publish this Action to the GitHub Marketplace** checked. Those steps are in [docs/RELEASE.md](docs/RELEASE.md). The tag `v1.16.4` has to exist before `uses: CHAPIBUNNY/repolens@v1.16.4` resolves, and `@chappibunny/repolens@1.16.4` has to be on npm before `publish` can install it. `command: comment` and `command: badge` do not install that package.
 
 ## Add the badge to your repo
 
@@ -330,7 +330,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
-      - uses: CHAPIBUNNY/repolens@v1.16.3
+      - uses: CHAPIBUNNY/repolens@v1.16.4
         with:
           command: badge
           badge-url: https://USER.github.io/REPO/repolens-badge.json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chappibunny/repolens",
-  "version": "1.16.3",
+  "version": "1.16.4",
   "mcpName": "io.github.CHAPIBUNNY/repolens",
   "description": "AI-assisted documentation intelligence system for technical and non-technical audiences",
   "license": "MIT",

package/src/analyzers/cycle-priority.js

@@ -162,6 +162,9 @@ export function cycleInsight(stats) {
   if (!hasCyclePriorities(stats)) {
     return `🔴 **Architectural concern** — ${stats.cycles} circular dependenc${stats.cycles === 1 ? "y" : "ies"} detected. These create tight coupling and make testing difficult.`;
   }
+  if ((stats.highCycles || 0) === 0 && (stats.mediumCycles || 0) > 0) {
+    return `🟡 **Circular dependencies** — ${stats.cycles} detected. Small cycle; review. Priority: Medium.`;
+  }
   if ((stats.highCycles || 0) === 0) {
     return `🟡 **Circular dependencies** — ${stats.cycles} detected. mutual recursion, probably intentional; verify. Priority: Low.`;
   }

package/src/analyzers/dependency-graph.js

@@ -1,6 +1,9 @@
 // Dependency graph analysis with cycle detection.
 // JavaScript, TypeScript, Python, and Go imports become edges.
-// Comments and strings are ignored. Type-only TypeScript imports are not runtime edges.
+// Comments and strings are ignored. Type-only TypeScript imports are not runtime edges:
+// `import type` / `export type` / all-`type` specifier lists (syntax), and imports the
+// TypeScript compiler removes because every binding is used only as a type or names
+// an interface or type alias (inferred, see ts-elision.js).
 // Cycle priority is in cycle-priority.js: mutual recursion and type-only cycles are
 // not "Priority: High refactor". Large multi-module cycles stay high.
 
@@ -21,6 +24,7 @@ import {
 import { isNonProductPath } from "../utils/path-roles.js";
 import { computeLanguageCoverage, coverageLine } from "./language-coverage.js";
 import { listWorkspacePackages } from "./workspace-packages.js";
+import { usageByName, declaredKinds, createElisionSettings, isTypeScriptFile } from "./ts-elision.js";
 import {
   classifyRuntimeCycles,
   priorityCounts,
@@ -152,6 +156,7 @@ function emptyResult() {
     cycles: [],
     cycleReports: [],
     typeOnlyReports: [],
+    typeOnlyEdges: [],
     externalDeps: [],
     externalRuntime: [],
     externalDev: [],
@@ -337,7 +342,7 @@ export async function analyzeDependencyGraph(files, repoRoot, { coverageFiles =
   // and are classified on their own so they are never "Priority: High refactor".
   const edgeRecords = new Map();
 
-  function rememberEdge(fromKey, toKey, fromFile, typeOnly, calls) {
+  function rememberEdge(fromKey, toKey, fromFile, typeOnly, calls, reason = null) {
     if (!toKey || toKey === fromKey || !allFileKeys.has(toKey)) return;
     const id = `${fromKey}->${toKey}`;
     let record = edgeRecords.get(id);
@@ -348,16 +353,72 @@ export async function analyzeDependencyGraph(files, repoRoot, { coverageFiles =
         fromFile,
         toFile: fileKeyToFile.get(toKey) || toKey,
         typeOnly: true,
+        typeOnlyReason: null,
         calls: 0,
       };
       edgeRecords.set(id, record);
     }
     if (!typeOnly) {
       record.typeOnly = false;
+      record.typeOnlyReason = null;
       record.calls += calls;
+    } else if (record.typeOnly) {
+      // "syntax" (`import type`) wins over "inferred" when both reach the same file.
+      if (reason === "syntax" || !record.typeOnlyReason) record.typeOnlyReason = reason || "syntax";
     }
   }
 
+  // TypeScript import elision. Contents and declared kinds are cached per file.
+  const elisionFor = createElisionSettings(repoRoot);
+  const contentByKey = new Map();
+  const kindsByKey = new Map();
+  async function contentOf(key) {
+    if (!contentByKey.has(key)) {
+      const file = fileKeyToFile.get(key);
+      contentByKey.set(key, file ? await readFileSafe(path.join(repoRoot, file)) : "");
+    }
+    return contentByKey.get(key);
+  }
+  async function kindsOf(key) {
+    if (!kindsByKey.has(key)) {
+      const file = fileKeyToFile.get(key);
+      kindsByKey.set(key, file && isTypeScriptFile(file) ? declaredKinds(await contentOf(key)) : null);
+    }
+    return kindsByKey.get(key);
+  }
+
+  // True when the compiler drops this import or re-export from the JavaScript output.
+  async function elidedByCompiler(imported, toKey, file, content, state) {
+    // A declaration file (`.d.ts`) never runs: none of its imports load a module.
+    if (/\.d\.[cm]?ts$/.test(file)) return true;
+    if (!isTypeScriptFile(file)) return false;
+    if (imported.kind !== "import" && imported.kind !== "reexport") return false;
+    const bindings = imported.bindings || [];
+    if (bindings.length === 0) return false;
+    if (!state.settings) state.settings = await elisionFor(file);
+    if (!state.settings.elide) return false;
+    // `emitDecoratorMetadata` turns annotations on decorated members into runtime
+    // references (`design:paramtypes`); isolated transpilers (swc, esbuild) keep
+    // even interface imports there. A decorated file under it keeps every import.
+    if (!state.usage) state.usage = usageByName(content, { jsx: /\.[jt]sx$/.test(file) });
+    if (state.settings.decoratorMetadata && state.usage.decorators) return false;
+    const kinds = await kindsOf(toKey);
+    const declaredType = (name) => Boolean(kinds) && name !== "default" && name !== "*" && kinds.types.has(name);
+    if (imported.kind === "reexport") return bindings.every((item) => declaredType(item.imported));
+    // Usage-based inference: .ts/.mts/.cts only. In .tsx, JSX text can look like code
+    // (`list as they're posted`), so only interface / type alias names count there.
+    // When part of the tsconfig `extends` chain is not in the checkout, only
+    // interface / type alias names count (`inferUsage: false`).
+    // A file the tokenizer misread (`malformed`) gets the same treatment.
+    const useInference = !/\.tsx$/.test(file) && state.settings.inferUsage !== false && !state.usage.malformed;
+    return bindings.every((item) => {
+      if (declaredType(item.imported)) return true;
+      if (!useInference || !item.local) return false;
+      const use = state.usage.uses.get(item.local);
+      return !use || use.value === 0;
+    });
+  }
+
   for (const file of jsFiles) {
     const content = await readFileSafe(path.join(repoRoot, file));
     if (!content) continue;
@@ -365,6 +426,7 @@ export async function analyzeDependencyGraph(files, repoRoot, { coverageFiles =
     const importer = await ownPackage(file);
     const selfName = importer ? importer.name : null;
     const grouped = new Map();
+    const state = { settings: null, usage: null };
     for (const imported of extractJsImports(content)) {
       let toKey = null;
       if (!isRelativeImport(imported.specifier)) {
@@ -385,20 +447,28 @@ export async function analyzeDependencyGraph(files, repoRoot, { coverageFiles =
         toKey = resolveImportPath(file, imported.specifier);
       }
       if (!toKey) continue;
+      let typeOnly = imported.typeOnly;
+      let reason = typeOnly ? "syntax" : null;
+      if (!typeOnly && allFileKeys.has(toKey) && toKey !== fromKey && await elidedByCompiler(imported, toKey, file, content, state)) {
+        typeOnly = true;
+        reason = "inferred";
+      }
       const id = `${fromKey}->${toKey}`;
       let slot = grouped.get(id);
       if (!slot) {
-        slot = { toKey, typeOnly: true, names: new Set() };
+        slot = { toKey, typeOnly: true, reason: null, names: new Set() };
         grouped.set(id, slot);
       }
-      if (!imported.typeOnly) {
+      if (!typeOnly) {
         slot.typeOnly = false;
         for (const binding of imported.names || []) slot.names.add(binding);
+      } else if (reason === "syntax" || !slot.reason) {
+        slot.reason = reason;
       }
     }
     for (const slot of grouped.values()) {
       const calls = slot.typeOnly ? 0 : countBindingCalls(content, [...slot.names]);
-      rememberEdge(fromKey, slot.toKey, file, slot.typeOnly, calls);
+      rememberEdge(fromKey, slot.toKey, file, slot.typeOnly, calls, slot.reason);
     }
   }
 
@@ -468,20 +538,49 @@ export async function analyzeDependencyGraph(files, repoRoot, { coverageFiles =
   const runtimeEdgeList = [...edgeRecords.values()].filter((edge) => !edge.typeOnly);
   result.cycleReports = classifyRuntimeCycles(result.cycles, runtimeEdgeList, fileForKey);
 
-  const typeOnlyAdj = new Map();
+  // Type-only cycles: cycles of runtime + type-only edges that need at least one
+  // type-only edge. They are reported on their own and never as runtime cycles.
+  const combinedAdj = new Map();
+  for (const [from, deps] of adjacency) combinedAdj.set(from, new Set(deps));
+  const typeOnlyEdgeById = new Map();
   for (const edge of edgeRecords.values()) {
     if (!edge.typeOnly) continue;
-    if (!typeOnlyAdj.has(edge.from)) typeOnlyAdj.set(edge.from, new Set());
-    if (!typeOnlyAdj.has(edge.to)) typeOnlyAdj.set(edge.to, new Set());
-    typeOnlyAdj.get(edge.from).add(edge.to);
+    typeOnlyEdgeById.set(`${edge.from}->${edge.to}`, edge);
+    if (!combinedAdj.has(edge.from)) combinedAdj.set(edge.from, new Set());
+    if (!combinedAdj.has(edge.to)) combinedAdj.set(edge.to, new Set());
+    combinedAdj.get(edge.from).add(edge.to);
   }
-  result.typeOnlyReports = detectCycles(typeOnlyAdj).map((path) => typeOnlyReport(path));
+  result.typeOnlyReports = typeOnlyEdgeById.size === 0 ? [] : detectCycles(combinedAdj)
+    .map((cyclePath) => {
+      const links = [];
+      for (let i = 0; i + 1 < cyclePath.length; i += 1) {
+        const from = cyclePath[i];
+        const to = cyclePath[i + 1];
+        if (adjacency.get(from)?.has(to)) continue;
+        const edge = typeOnlyEdgeById.get(`${from}->${to}`);
+        if (edge) links.push({ from, to, reason: edge.typeOnlyReason || "syntax" });
+      }
+      if (links.length === 0) return null;
+      return { ...typeOnlyReport(cyclePath), typeOnlyLinks: links };
+    })
+    .filter(Boolean);
+  result.typeOnlyEdges = [...typeOnlyEdgeById.values()].map((edge) => ({
+    from: edge.from,
+    to: edge.to,
+    reason: edge.typeOnlyReason || "syntax",
+  }));
 
   const priorities = priorityCounts(result.cycleReports);
 
   // Stats
   const totalImports = result.edges.length;
-  const orphans = result.nodes.filter(n => n.imports.length === 0 && n.importedBy.length === 0);
+  // A file connected only by type-only imports (a types module) is not dead code.
+  const typeConnected = new Set();
+  for (const edge of result.typeOnlyEdges) {
+    typeConnected.add(edge.from);
+    typeConnected.add(edge.to);
+  }
+  const orphans = result.nodes.filter(n => n.imports.length === 0 && n.importedBy.length === 0 && !typeConnected.has(n.key));
   const sourceNodeCount = result.nodes.filter((n) => !isNonProductPath(n.file || n.key)).length;
   const hubThreshold = Math.max(5, Math.round(sourceNodeCount * 0.07));
   const hubs = aggregateHubs(result.nodes, fileKeyToFile, goModulePath, hubThreshold);
@@ -502,16 +601,22 @@ export async function analyzeDependencyGraph(files, repoRoot, { coverageFiles =
     highCycles: priorities.high,
     mediumCycles: priorities.medium,
     lowCycles: priorities.low,
+    typeOnlyCycles: result.typeOnlyReports.length,
+    typeOnlyEdges: result.typeOnlyEdges.length,
+    inferredTypeOnlyEdges: result.typeOnlyEdges.filter((edge) => edge.reason === "inferred").length,
     orphanFiles: orphans.length,
     hubs,
   };
 
   result.summary = buildSummary(result);
 
+  const typeOnlyNote = result.typeOnlyReports.length > 0
+    ? ` (${result.typeOnlyReports.length} type-only cycle(s) not counted)`
+    : "";
   if (result.cycles.length > 0) {
-    warn(`Dependency graph: ${result.cycles.length} circular dependency cycle(s) detected`);
+    warn(`Dependency graph: ${result.cycles.length} circular dependency cycle(s) detected${typeOnlyNote}`);
   } else {
-    info(`Dependency graph: ${totalImports} edges across ${codeFiles.length} files, no cycles`);
+    info(`Dependency graph: ${totalImports} edges across ${codeFiles.length} files, no cycles${typeOnlyNote}`);
   }
 
   return result;
@@ -631,6 +736,9 @@ function buildSummary(result) {
       ? "✓ no circular dependencies among analyzed files"
       : "✓ no circular dependencies");
   }
+  if (result.stats.typeOnlyCycles > 0) {
+    parts.push(`${result.stats.typeOnlyCycles} type-only cycle(s), not runtime`);
+  }
   if (result.coverage?.status === "partial") {
     parts.push(`partial coverage: ${result.coverage.analyzedBase} of ${result.coverage.totalBase} source files`);
   }

package/src/analyzers/import-parsers.js

@@ -164,6 +164,23 @@ function localNames(inner) {
   return names;
 }
 
+/** `{ a, b as c, type D }` → [{ imported: "a", local: "a" }, { imported: "b", local: "c" }]. */
+function braceBindings(inner) {
+  const out = [];
+  for (const part of splitTopCommas(inner)) {
+    const trimmed = part.trim().replace(/\s+/g, " ");
+    if (!trimmed || /^type\s+/.test(trimmed)) continue;
+    const asMatch = trimmed.match(/^([A-Za-z_$][\w$]*|"[^"]*"|'[^']*')\s+as\s+([A-Za-z_$][\w$]*)$/);
+    if (asMatch) {
+      out.push({ imported: asMatch[1].replace(/^["']|["']$/g, ""), local: asMatch[2] });
+      continue;
+    }
+    const id = trimmed.match(/^([A-Za-z_$][\w$]*)$/);
+    if (id) out.push({ imported: id[1], local: id[1] });
+  }
+  return out;
+}
+
 function readAlias(source, i) {
   let j = skipWs(source, i);
   const word = readWord(source, j);
@@ -206,7 +223,7 @@ function readFromClause(source, i) {
 }
 
 /**
- * @returns {{ specifier: string, typeOnly: boolean, names: string[] }[]}
+ * @returns {{ specifier: string, typeOnly: boolean, names: string[], kind: string, bindings: { imported: string, local: string|null }[] }[]}
  * `names` are the local bindings (`import { a as b }` → `b`) so callers can
  * count `b(` as a use of this import. Type-only imports still list names.
  */
@@ -215,7 +232,12 @@ export function extractJsImports(source) {
   const n = source.length;
   let i = 0;
 
-  function add(specifier, typeOnly, names = []) {
+  // `kind`: "import" (has local bindings), "reexport" (`export { a } from`),
+  // "reexport-all" (`export * from`), "side-effect" (`import "x"`), or "dynamic"
+  // (`import()` / `require()`). `bindings` pair each imported name with its local
+  // name (`*` for a namespace import, `default` for a default import); for a
+  // re-export, `local` is null.
+  function add(specifier, typeOnly, names = [], kind = "import", bindings = []) {
     if (typeof specifier !== "string") return;
     const locals = [];
     const seen = new Set();
@@ -224,7 +246,7 @@ export function extractJsImports(source) {
       seen.add(name);
       locals.push(name);
     }
-    imports.push({ specifier, typeOnly: Boolean(typeOnly), names: locals });
+    imports.push({ specifier, typeOnly: Boolean(typeOnly), names: locals, kind, bindings: typeOnly ? [] : bindings });
   }
 
   function parseRequire(at) {
@@ -234,7 +256,7 @@ export function extractJsImports(source) {
     if (!lit) return at;
     const after = skipWs(source, lit.next);
     if (source[after] !== ")") return at;
-    add(lit.value, false);
+    add(lit.value, false, [], "dynamic");
     return after + 1;
   }
 
@@ -245,7 +267,7 @@ export function extractJsImports(source) {
       if (!lit) return at;
       const after = skipWs(source, lit.next);
       if (source[after] !== ")") return at;
-      add(lit.value, false);
+      add(lit.value, false, [], "dynamic");
       return after + 1;
     }
     if (source[j] === ".") return at;
@@ -264,22 +286,26 @@ export function extractJsImports(source) {
       const clause = readFromClause(source, close + 1);
       if (!clause) return close + 1;
       const onlyTypes = typeOnly || braceIsTypeOnly(inner);
-      add(clause.value, onlyTypes, typeOnly ? [] : localNames(inner));
+      add(clause.value, onlyTypes, typeOnly ? [] : localNames(inner), "import", typeOnly ? [] : braceBindings(inner));
       return clause.next;
     }
 
     if (source[j] === "*" || isIdentStart(source[j]) || source[j] === "'" || source[j] === '"') {
       if (source[j] === "'" || source[j] === '"') {
         const lit = readJsString(source, j);
-        if (lit) add(lit.value, typeOnly);
+        if (lit) add(lit.value, typeOnly, [], "side-effect");
         return lit ? lit.next : j;
       }
       // default binding, namespace, or `name, { ... }`
       let sawValue = !typeOnly;
       const names = [];
+      const bindings = [];
       if (source[j] !== "*") {
         const binding = readWord(source, j);
-        if (binding.word && !typeOnly) names.push(binding.word);
+        if (binding.word && !typeOnly) {
+          names.push(binding.word);
+          bindings.push({ imported: "default", local: binding.word });
+        }
         j = skipWs(source, binding.next);
         if (source[j] === ",") {
           sawValue = !typeOnly;
@@ -288,7 +314,10 @@ export function extractJsImports(source) {
       } else {
         j = skipWs(source, j + 1);
         const alias = readAlias(source, j);
-        if (alias.name && !typeOnly) names.push(alias.name);
+        if (alias.name && !typeOnly) {
+          names.push(alias.name);
+          bindings.push({ imported: "*", local: alias.name });
+        }
         j = skipWs(source, alias.next);
       }
       if (source[j] === "{") {
@@ -298,13 +327,16 @@ export function extractJsImports(source) {
         const clause = readFromClause(source, close + 1);
         if (!clause) return close + 1;
         const onlyTypes = typeOnly || (!sawValue && braceIsTypeOnly(inner));
-        if (!onlyTypes) names.push(...localNames(inner));
-        add(clause.value, onlyTypes, names);
+        if (!onlyTypes) {
+          names.push(...localNames(inner));
+          bindings.push(...braceBindings(inner));
+        }
+        add(clause.value, onlyTypes, names, "import", bindings);
         return clause.next;
       }
       const clause = readFromClause(source, j);
       if (!clause) return at;
-      add(clause.value, typeOnly, typeOnly ? [] : names);
+      add(clause.value, typeOnly, typeOnly ? [] : names, "import", bindings);
       return clause.next;
     }
 
@@ -322,7 +354,7 @@ export function extractJsImports(source) {
     if (source[j] === "*") {
       const clause = readFromClause(source, j + 1);
       if (!clause) return at;
-      add(clause.value, typeOnly);
+      add(clause.value, typeOnly, [], "reexport-all");
       return clause.next;
     }
     if (source[j] === "{") {
@@ -331,7 +363,8 @@ export function extractJsImports(source) {
       const inner = source.slice(j + 1, close);
       const clause = readFromClause(source, close + 1);
       if (!clause) return close + 1;
-      add(clause.value, typeOnly || braceIsTypeOnly(inner));
+      const bindings = braceBindings(inner).map((item) => ({ imported: item.imported, local: null }));
+      add(clause.value, typeOnly || braceIsTypeOnly(inner), [], "reexport", bindings);
       return clause.next;
     }
     return at;