universal-ast-mapper 2.0.0 → 2.0.2

package/dist/crosslang.js

@@ -0,0 +1,425 @@
+import fs from "node:fs";
+import path from "node:path";
+const TYPE_KINDS = new Set(["class", "interface", "enum", "struct"]);
+/** Walk a symbol tree and yield each top-level type-like symbol. */
+function topTypeSymbols(symbols) {
+    return symbols.filter((s) => TYPE_KINDS.has(s.kind));
+}
+function getDirectiveValue(skel, prefix) {
+    const hit = (skel.directives ?? []).find((d) => d.startsWith(prefix));
+    return hit ? hit.slice(prefix.length) : null;
+}
+function getAllDirectiveValues(skel, prefix) {
+    return (skel.directives ?? [])
+        .filter((d) => d.startsWith(prefix))
+        .map((d) => d.slice(prefix.length));
+}
+/**
+ * Build Java + C# indexes from already-parsed skeletons.
+ * Cheap: O(symbols), no extra file reads.
+ */
+export function buildCrossLangIndex(skeletons) {
+    const index = {
+        javaFqcn: new Map(),
+        javaPackages: new Map(),
+        csharpNamespaces: new Map(),
+        csharpTypes: new Map(),
+        kotlinFqcn: new Map(),
+        kotlinPackages: new Map(),
+        swiftModules: new Map(),
+    };
+    for (const skel of skeletons) {
+        if (skel.language === "java") {
+            const pkg = getDirectiveValue(skel, "package:");
+            if (!pkg)
+                continue;
+            const pkgFiles = index.javaPackages.get(pkg) ?? [];
+            pkgFiles.push(skel.file);
+            index.javaPackages.set(pkg, pkgFiles);
+            for (const sym of topTypeSymbols(skel.symbols)) {
+                index.javaFqcn.set(`${pkg}.${sym.name}`, skel.file);
+            }
+        }
+        else if (skel.language === "csharp") {
+            const namespaces = getAllDirectiveValues(skel, "namespace:");
+            for (const ns of namespaces) {
+                const arr = index.csharpNamespaces.get(ns) ?? [];
+                if (!arr.includes(skel.file))
+                    arr.push(skel.file);
+                index.csharpNamespaces.set(ns, arr);
+            }
+            // Map every top-level type to <ns>.<TypeName>. For files with multiple
+            // namespaces this is approximate (we don't know per-symbol scoping
+            // without per-symbol namespace tracking) but accurate for the common case
+            // of one namespace per file.
+            for (const sym of topTypeSymbols(skel.symbols)) {
+                for (const ns of namespaces) {
+                    index.csharpTypes.set(`${ns}.${sym.name}`, skel.file);
+                }
+            }
+        }
+        else if (skel.language === "kotlin") {
+            const pkg = getDirectiveValue(skel, "package:");
+            if (!pkg)
+                continue;
+            const pkgFiles = index.kotlinPackages.get(pkg) ?? [];
+            pkgFiles.push(skel.file);
+            index.kotlinPackages.set(pkg, pkgFiles);
+            for (const sym of topTypeSymbols(skel.symbols)) {
+                index.kotlinFqcn.set(`${pkg}.${sym.name}`, skel.file);
+            }
+        }
+        else if (skel.language === "swift") {
+            const mod = swiftModuleOf(skel.file);
+            if (!mod)
+                continue;
+            const arr = index.swiftModules.get(mod) ?? [];
+            arr.push(skel.file);
+            index.swiftModules.set(mod, arr);
+        }
+    }
+    return index;
+}
+/**
+ * Derive a Swift module name from a project-relative file path.
+ * SwiftPM convention: sources live under `Sources/<ModuleName>/...`, so the
+ * module is the path segment right after `Sources`. For flat layouts we fall
+ * back to the immediate parent directory name. Returns null for bare files.
+ */
+function swiftModuleOf(relFile) {
+    const parts = relFile.split("/");
+    const srcIdx = parts.lastIndexOf("Sources");
+    if (srcIdx >= 0 && srcIdx + 1 < parts.length - 1)
+        return parts[srcIdx + 1];
+    if (parts.length >= 2)
+        return parts[parts.length - 2];
+    return null;
+}
+/* ─── Rust module resolution ──────────────────────────────────────────────── */
+function findCargoRoot(fromAbs, projectRoot) {
+    let dir = path.dirname(fromAbs);
+    const stop = path.resolve(projectRoot);
+    while (true) {
+        if (fs.existsSync(path.join(dir, "Cargo.toml")))
+            return dir;
+        if (dir === stop || dir === path.dirname(dir))
+            return null;
+        dir = path.dirname(dir);
+    }
+}
+function existsFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function existsDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Walk module path segments down from a base dir, returning the resolved .rs file. */
+function walkRustModule(base, segs) {
+    if (segs.length === 0) {
+        // base IS the target module dir/file. Try canonical roots.
+        for (const candidate of ["mod.rs", "lib.rs", "main.rs"]) {
+            const p = path.join(base, candidate);
+            if (existsFile(p))
+                return p;
+        }
+        if (existsFile(base + ".rs"))
+            return base + ".rs";
+        return null;
+    }
+    const [head, ...rest] = segs;
+    if (rest.length === 0) {
+        // Terminal segment: `head.rs` or `head/mod.rs`.
+        const p1 = path.join(base, `${head}.rs`);
+        if (existsFile(p1))
+            return p1;
+        const p2 = path.join(base, head, "mod.rs");
+        if (existsFile(p2))
+            return p2;
+        return null;
+    }
+    // Non-terminal: descend into a directory module.
+    const subDir = path.join(base, head);
+    if (existsDir(subDir))
+        return walkRustModule(subDir, rest);
+    // Rust-2018 style: `head.rs` next to a sibling `head/` directory.
+    if (existsFile(path.join(base, `${head}.rs`)) && existsDir(path.join(base, head))) {
+        return walkRustModule(path.join(base, head), rest);
+    }
+    return null;
+}
+/**
+ * Resolve a Rust `use` path to an absolute .rs file.
+ * Handles `crate::`, `self::`, `super::` prefixes; anything else is treated
+ * as an external crate (e.g. `std::`, `tokio::`) and returns null.
+ *
+ * @param importFrom Full use path, e.g. "crate::foo::Bar"
+ * @param fromAbs   Absolute path of the importing file
+ * @param projectRoot Absolute project root (security boundary)
+ */
+export function resolveRustModule(importFrom, fromAbs, projectRoot) {
+    const segs = importFrom.split("::");
+    if (segs.length === 0)
+        return null;
+    // Strip the imported item name (last segment) — leaves the module path.
+    const moduleSegs = segs.slice(0, -1);
+    if (moduleSegs.length === 0)
+        return null;
+    const head = moduleSegs[0];
+    let base;
+    let remaining;
+    if (head === "crate") {
+        const cargoRoot = findCargoRoot(fromAbs, projectRoot);
+        if (!cargoRoot)
+            return null;
+        base = path.join(cargoRoot, "src");
+        if (!existsDir(base))
+            base = cargoRoot;
+        remaining = moduleSegs.slice(1);
+    }
+    else if (head === "self") {
+        base = path.dirname(fromAbs);
+        remaining = moduleSegs.slice(1);
+    }
+    else if (head === "super") {
+        let dir = path.dirname(fromAbs);
+        let i = 0;
+        while (moduleSegs[i] === "super") {
+            dir = path.dirname(dir);
+            i++;
+        }
+        base = dir;
+        remaining = moduleSegs.slice(i);
+    }
+    else {
+        return null; // external crate
+    }
+    return walkRustModule(base, remaining);
+}
+// Cache per project root.
+const goModuleCache = new Map();
+function readGoModulePath(modFile) {
+    try {
+        const txt = fs.readFileSync(modFile, "utf8");
+        const m = /^\s*module\s+(\S+)/m.exec(txt);
+        return m ? m[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Locate the go.mod ancestor (within projectRoot) of `fromAbs`. */
+function findGoModule(fromAbs, projectRoot) {
+    const key = path.resolve(projectRoot);
+    if (goModuleCache.has(key)) {
+        // Cached at the project root level — assumes one go.mod per project root.
+        // For monorepos with multiple modules, ResolveGoImport falls back to a
+        // walk-up search below.
+        const cached = goModuleCache.get(key);
+        if (cached)
+            return cached;
+    }
+    let dir = path.dirname(fromAbs);
+    const stop = key;
+    while (true) {
+        const modFile = path.join(dir, "go.mod");
+        if (existsFile(modFile)) {
+            const modPath = readGoModulePath(modFile);
+            if (modPath) {
+                const result = { modulePath: modPath, moduleDir: dir };
+                if (dir === stop)
+                    goModuleCache.set(key, result);
+                return result;
+            }
+        }
+        if (dir === stop || dir === path.dirname(dir))
+            return null;
+        dir = path.dirname(dir);
+    }
+}
+/**
+ * Resolve a Go import path to a list of .go files in the resolved package
+ * directory. Returns null for stdlib / third-party / unresolvable paths.
+ *
+ * Go semantics:
+ *   - A package is a directory containing one or more .go files.
+ *   - `import "github.com/x/y/z"` maps to <moduleDir>/<subpath> when the prefix
+ *     matches the current module's path.
+ */
+export function resolveGoImport(importFrom, fromAbs, projectRoot) {
+    const mod = findGoModule(fromAbs, projectRoot);
+    if (!mod)
+        return null;
+    let subPath;
+    if (importFrom === mod.modulePath) {
+        subPath = "";
+    }
+    else if (importFrom.startsWith(mod.modulePath + "/")) {
+        subPath = importFrom.slice(mod.modulePath.length + 1);
+    }
+    else {
+        return null; // external / stdlib
+    }
+    const pkgDir = subPath ? path.join(mod.moduleDir, subPath) : mod.moduleDir;
+    if (!existsDir(pkgDir))
+        return null;
+    // Collect every .go file in the directory (Go packages span all files in dir).
+    // Skip _test.go files — call graph cares about production code.
+    let entries;
+    try {
+        entries = fs.readdirSync(pkgDir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    const files = [];
+    for (const e of entries) {
+        if (!e.isFile())
+            continue;
+        if (!e.name.endsWith(".go"))
+            continue;
+        if (e.name.endsWith("_test.go"))
+            continue;
+        const abs = path.join(pkgDir, e.name);
+        const rel = path.relative(projectRoot, abs).split(path.sep).join("/");
+        files.push(rel);
+    }
+    return files.length > 0 ? files : null;
+}
+/** Test/debug hook: drop the cached Go module info. */
+export function clearGoModuleCache() {
+    goModuleCache.clear();
+}
+/* ─── C / C++ #include resolution ─────────────────────────────────────────── */
+const HEADER_EXTS = [".h", ".hpp", ".hxx", ".hh"];
+const IMPL_EXTS = [".c", ".cpp", ".cc", ".cxx"];
+/**
+ * Resolve a C/C++ `#include "foo.h"` to in-project files.
+ * Convention: also pair foo.h with foo.c/.cpp in the same directory so the
+ * graph captures the header → impl relationship.
+ * `#include <foo.h>` (system headers) returns null (external).
+ */
+export function resolveCInclude(importFrom, fromAbs, projectRoot) {
+    // System headers like stdio.h, vector, etc. — leave to external.
+    const isSystemHeader = !importFrom.includes("/") && !importFrom.includes(".") ||
+        /^(stdio|stdlib|string|vector|memory|cstdint|cstdlib|cstring|iostream)/.test(importFrom);
+    // We only check the actual filesystem; if a system header happens to exist
+    // locally we still link it, otherwise it falls through to null.
+    const fromDir = path.dirname(fromAbs);
+    const headerAbs = path.resolve(fromDir, importFrom);
+    const out = [];
+    if (existsFile(headerAbs)) {
+        const rel = path.relative(projectRoot, headerAbs).split(path.sep).join("/");
+        // Reject paths that escape the project root.
+        if (!rel.startsWith(".."))
+            out.push(rel);
+        // Pair foo.h with foo.{c,cpp,cc,cxx} in the same directory.
+        const ext = path.extname(headerAbs).toLowerCase();
+        if (HEADER_EXTS.includes(ext)) {
+            const base = headerAbs.slice(0, -ext.length);
+            for (const implExt of IMPL_EXTS) {
+                const implAbs = base + implExt;
+                if (existsFile(implAbs)) {
+                    const implRel = path.relative(projectRoot, implAbs).split(path.sep).join("/");
+                    if (!implRel.startsWith(".."))
+                        out.push(implRel);
+                }
+            }
+        }
+    }
+    if (isSystemHeader && out.length === 0)
+        return null;
+    return out.length > 0 ? out : null;
+}
+/**
+ * Resolve an ImportRef in a non-relative-path language to a graph target.
+ * Returns null for unresolvable / external imports.
+ */
+export function resolveCrossLangTarget(imp, skel, fromAbs, projectRoot, index) {
+    if (skel.language === "java") {
+        if (imp.symbol === "*") {
+            // wildcard: pull all files in the package
+            const files = index.javaPackages.get(imp.from);
+            if (files && files.length > 0)
+                return { kind: "file", files: files.slice() };
+            return null;
+        }
+        const targetFile = index.javaFqcn.get(imp.from);
+        if (targetFile)
+            return { kind: "symbol", file: targetFile, symbol: imp.symbol };
+        return null;
+    }
+    if (skel.language === "csharp") {
+        const files = index.csharpNamespaces.get(imp.from);
+        if (files && files.length > 0) {
+            // Exclude self — a file `using App;` while declaring in App shouldn't self-edge.
+            const filtered = files.filter((f) => f !== skel.file);
+            if (filtered.length > 0)
+                return { kind: "file", files: filtered };
+        }
+        return null;
+    }
+    if (skel.language === "rust") {
+        const abs = resolveRustModule(imp.from, fromAbs, projectRoot);
+        if (!abs)
+            return null;
+        const rel = path.relative(projectRoot, abs).split(path.sep).join("/");
+        return { kind: "symbol", file: rel, symbol: imp.symbol };
+    }
+    if (skel.language === "go") {
+        const files = resolveGoImport(imp.from, fromAbs, projectRoot);
+        if (!files || files.length === 0)
+            return null;
+        const filtered = files.filter((f) => f !== skel.file);
+        if (filtered.length === 0)
+            return null;
+        return { kind: "file", files: filtered };
+    }
+    if (skel.language === "kotlin") {
+        if (imp.symbol === "*") {
+            const files = index.kotlinPackages.get(imp.from);
+            if (files && files.length > 0) {
+                const filtered = files.filter((f) => f !== skel.file);
+                if (filtered.length > 0)
+                    return { kind: "file", files: filtered };
+            }
+            return null;
+        }
+        const targetFile = index.kotlinFqcn.get(imp.from);
+        if (targetFile && targetFile !== skel.file) {
+            return { kind: "symbol", file: targetFile, symbol: imp.symbol };
+        }
+        return null;
+    }
+    if (skel.language === "c" || skel.language === "cpp") {
+        const files = resolveCInclude(imp.from, fromAbs, projectRoot);
+        if (!files || files.length === 0)
+            return null;
+        const filtered = files.filter((f) => f !== skel.file);
+        if (filtered.length === 0)
+            return null;
+        return { kind: "file", files: filtered };
+    }
+    if (skel.language === "swift") {
+        // `import <Module>` brings in another in-project module's public symbols
+        // (no symbol named). Resolve to that module's files; unknown modules
+        // (Foundation, UIKit, …) are external.
+        const files = index.swiftModules.get(imp.from);
+        if (files && files.length > 0) {
+            const filtered = files.filter((f) => f !== skel.file);
+            if (filtered.length > 0)
+                return { kind: "file", files: filtered };
+        }
+        return null;
+    }
+    return null;
+}

package/dist/dashboard.js

@@ -0,0 +1,259 @@
+function safeJson(obj) {
+    return JSON.stringify(obj)
+        .replace(/</g, "\\u003c")
+        .replace(/>/g, "\\u003e")
+        .replace(/&/g, "\\u0026");
+}
+function flattenSymbols(skeletons) {
+    const out = [];
+    const walk = (syms, file) => {
+        for (const s of syms) {
+            out.push({ name: s.name, kind: s.kind, file, startLine: s.range.startLine, endLine: s.range.endLine, exported: s.exported ?? false });
+            if (s.children.length)
+                walk(s.children, file);
+        }
+    };
+    for (const sk of skeletons)
+        walk(sk.symbols, sk.file);
+    return out;
+}
+const KIND_COLORS = {
+    class: "#7c3aed", interface: "#0ea5e9", struct: "#0d9488",
+    function: "#2563eb", method: "#4f46e5", type: "#db2777",
+    enum: "#ea580c", const: "#65a30d", var: "#ca8a04",
+    field: "#64748b", namespace: "#9333ea",
+};
+export function buildDashboardHtml(reportHtml, skeletonHtml, explorerHtml, skeletons, title, liveReloadPort) {
+    const symbols = flattenSymbols(skeletons);
+    const totalSymbols = skeletons.reduce((n, s) => n + s.symbolCount, 0);
+    const tabsData = safeJson({ overview: reportHtml, files: skeletonHtml, graph: explorerHtml });
+    const symData = safeJson(symbols);
+    const kindColorsData = safeJson(KIND_COLORS);
+    const liveReloadScript = liveReloadPort
+        ? `<script>
+(function(){
+  var es=new EventSource('http://localhost:${liveReloadPort ?? 0}/events');
+  es.addEventListener('reload',function(){location.reload();});
+  es.onerror=function(){setTimeout(function(){location.reload();},2000);};
+})();
+</script>`
+        : "";
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>AST Map Dashboard — ${title}</title>
+<style>
+:root{color-scheme:light dark;--bg:#0d1117;--bg2:#161b22;--fg:#e6edf3;--fg2:#7d8590;--bdr:#21262d;--accent:#6366f1;--accent2:#8b5cf6;--tab-h:44px;}
+@media(prefers-color-scheme:light){:root{--bg:#f6f8fa;--bg2:#fff;--fg:#0f172a;--fg2:#64748b;--bdr:#e2e8f0;}}
+*{box-sizing:border-box;margin:0;padding:0;}
+body{font:13px/1.5 ui-sans-serif,system-ui,sans-serif;background:var(--bg);color:var(--fg);display:flex;flex-direction:column;height:100vh;overflow:hidden;}
+/* Topbar */
+.topbar{display:flex;align-items:center;gap:10px;padding:0 16px;height:48px;background:var(--bg2);border-bottom:1px solid var(--bdr);flex-shrink:0;box-shadow:0 1px 3px rgba(0,0,0,.15);}
+.topbar-logo{display:flex;align-items:center;gap:7px;font-weight:700;font-size:14px;color:var(--accent);text-decoration:none;}
+.topbar-sep{width:1px;height:18px;background:var(--bdr);}
+.topbar-title{font-size:13px;font-weight:600;}
+.topbar-meta{font-size:11px;color:var(--fg2);flex:1;}
+.live-dot{width:7px;height:7px;border-radius:50%;background:#22c55e;display:${liveReloadPort ? "inline-block" : "none"};animation:pulse 2s infinite;}
+@keyframes pulse{0%,100%{opacity:1;}50%{opacity:.4;}}
+/* Tabs */
+.tabs{display:flex;align-items:stretch;background:var(--bg2);border-bottom:1px solid var(--bdr);flex-shrink:0;height:var(--tab-h);padding:0 12px;gap:2px;}
+.tab-btn{font:13px/1 ui-sans-serif,sans-serif;cursor:pointer;border:none;background:transparent;color:var(--fg2);padding:0 14px;border-bottom:2px solid transparent;transition:color .15s,border-color .15s;display:flex;align-items:center;gap:6px;font-weight:500;}
+.tab-btn:hover{color:var(--fg);}
+.tab-btn.active{color:var(--accent);border-bottom-color:var(--accent);font-weight:600;}
+.tab-icon{font-size:14px;}
+/* Content */
+.tab-content{flex:1;display:none;min-height:0;}
+.tab-content.active{display:flex;flex-direction:column;}
+iframe{border:none;flex:1;width:100%;height:100%;}
+/* Symbols tab */
+.sym-pane{display:flex;flex-direction:column;flex:1;min-height:0;overflow:hidden;}
+.sym-toolbar{display:flex;align-items:center;gap:8px;padding:8px 14px;border-bottom:1px solid var(--bdr);background:var(--bg2);flex-shrink:0;flex-wrap:wrap;}
+.sym-search{font:12px ui-monospace,monospace;padding:5px 10px;border:1px solid var(--bdr);border-radius:8px;background:var(--bg);color:var(--fg);outline:none;width:220px;transition:border-color .15s;}
+.sym-search:focus{border-color:var(--accent);}
+.kind-sel{font:12px ui-sans-serif,sans-serif;padding:4px 8px;border:1px solid var(--bdr);border-radius:8px;background:var(--bg);color:var(--fg);outline:none;cursor:pointer;}
+.sym-count{font-size:11px;color:var(--fg2);margin-left:auto;}
+.sym-table-wrap{flex:1;overflow-y:auto;scrollbar-width:thin;}
+table{width:100%;border-collapse:collapse;font-size:12px;}
+th{position:sticky;top:0;background:var(--bg2);border-bottom:2px solid var(--bdr);padding:7px 12px;text-align:left;font-weight:600;font-size:11px;text-transform:uppercase;letter-spacing:.04em;color:var(--fg2);cursor:pointer;user-select:none;white-space:nowrap;}
+th:hover{color:var(--fg);}
+th .sort-arrow{opacity:.5;margin-left:4px;}
+td{padding:5px 12px;border-bottom:1px solid var(--bdr);vertical-align:middle;}
+tr:hover td{background:color-mix(in srgb,var(--accent) 4%,var(--bg));}
+.mono{font-family:ui-monospace,monospace;font-weight:600;}
+.kind-badge{font-size:10px;font-weight:700;padding:2px 7px;border-radius:999px;letter-spacing:.04em;}
+.exp-badge{font-size:10px;color:#16a34a;background:#dcfce7;padding:1px 6px;border-radius:5px;}
+.file-cell{color:var(--fg2);font-size:11px;font-family:ui-monospace,monospace;max-width:240px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
+.line-cell{color:var(--fg2);font-family:ui-monospace,monospace;font-size:11px;white-space:nowrap;}
+.no-results{padding:48px;text-align:center;color:var(--fg2);}
+@media(prefers-color-scheme:dark){.exp-badge{background:#14532d;color:#4ade80;}}
+</style>
+</head>
+<body>
+${liveReloadScript}
+<header class="topbar">
+  <div class="topbar-logo">
+    <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/><polyline points="9 22 9 12 15 12 15 22"/></svg>
+    AST Map
+  </div>
+  <div class="topbar-sep"></div>
+  <span class="topbar-title">${title}</span>
+  <span class="topbar-meta">${skeletons.length} files &middot; ${totalSymbols} symbols</span>
+  <span class="live-dot" title="Live reload active"></span>
+</header>
+
+<nav class="tabs">
+  <button class="tab-btn active" data-tab="overview"><span class="tab-icon">📊</span>Overview</button>
+  <button class="tab-btn" data-tab="files"><span class="tab-icon">📁</span>Files</button>
+  <button class="tab-btn" data-tab="graph"><span class="tab-icon">🕸</span>Dependencies</button>
+  <button class="tab-btn" data-tab="symbols"><span class="tab-icon">⬡</span>Symbols</button>
+</nav>
+
+<div id="tc-overview" class="tab-content active">
+  <iframe id="fr-overview" title="Overview"></iframe>
+</div>
+<div id="tc-files" class="tab-content">
+  <iframe id="fr-files" title="Files"></iframe>
+</div>
+<div id="tc-graph" class="tab-content">
+  <iframe id="fr-graph" title="Dependencies"></iframe>
+</div>
+<div id="tc-symbols" class="tab-content">
+  <div class="sym-pane">
+    <div class="sym-toolbar">
+      <input class="sym-search" id="sym-q" type="search" placeholder="Search symbols…" autocomplete="off">
+      <select class="kind-sel" id="kind-filter">
+        <option value="">All kinds</option>
+        <option>class</option><option>interface</option><option>struct</option>
+        <option>function</option><option>method</option><option>type</option>
+        <option>enum</option><option>const</option><option>var</option>
+        <option>field</option><option>namespace</option>
+      </select>
+      <label style="font-size:11px;color:var(--fg2);display:flex;align-items:center;gap:5px;">
+        <input type="checkbox" id="exp-only"> Exported only
+      </label>
+      <span class="sym-count" id="sym-count"></span>
+    </div>
+    <div class="sym-table-wrap">
+      <table>
+        <thead>
+          <tr>
+            <th data-col="name">Symbol <span class="sort-arrow" id="sa-name"></span></th>
+            <th data-col="kind">Kind <span class="sort-arrow" id="sa-kind"></span></th>
+            <th data-col="file">File <span class="sort-arrow" id="sa-file"></span></th>
+            <th data-col="startLine">Line <span class="sort-arrow" id="sa-startLine"></span></th>
+            <th>Export</th>
+          </tr>
+        </thead>
+        <tbody id="sym-tbody"></tbody>
+      </table>
+      <div id="sym-empty" class="no-results" style="display:none">No symbols match.</div>
+    </div>
+  </div>
+</div>
+
+<script>
+(function(){
+'use strict';
+const TABS=${tabsData};
+const SYMS=${symData};
+const KIND_COLORS=${kindColorsData};
+
+// ── Tab switching ───────────────────────────────────────────
+const loaded={};
+
+function showTab(name){
+  document.querySelectorAll('.tab-btn').forEach(b=>b.classList.toggle('active',b.dataset.tab===name));
+  document.querySelectorAll('.tab-content').forEach(tc=>tc.classList.toggle('active',tc.id==='tc-'+name));
+  if(name!=='symbols'){
+    if(!loaded[name]){
+      const fr=document.getElementById('fr-'+name);
+      if(fr){fr.srcdoc=TABS[name]||'';loaded[name]=true;}
+    }
+  }else{
+    renderSymbols();
+  }
+}
+
+document.querySelectorAll('.tab-btn').forEach(btn=>{
+  btn.addEventListener('click',()=>showTab(btn.dataset.tab));
+});
+
+// Load overview immediately
+showTab('overview');
+
+// ── Symbols table ───────────────────────────────────────────
+let sortCol='name',sortAsc=true,filtered=[];
+
+function esc(s){return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');}
+
+function renderSymbols(){
+  const q=document.getElementById('sym-q').value.trim().toLowerCase();
+  const kind=document.getElementById('kind-filter').value;
+  const expOnly=document.getElementById('exp-only').checked;
+
+  filtered=SYMS.filter(s=>{
+    if(kind&&s.kind!==kind)return false;
+    if(expOnly&&!s.exported)return false;
+    if(q&&!s.name.toLowerCase().includes(q)&&!s.file.toLowerCase().includes(q))return false;
+    return true;
+  });
+
+  filtered.sort((a,b)=>{
+    const va=String(a[sortCol]),vb=String(b[sortCol]);
+    if(sortCol==='startLine')return sortAsc?(a.startLine-b.startLine):(b.startLine-a.startLine);
+    return sortAsc?va.localeCompare(vb):vb.localeCompare(va);
+  });
+
+  const tbody=document.getElementById('sym-tbody');
+  const c=KIND_COLORS;
+  tbody.innerHTML=filtered.slice(0,500).map(s=>{
+    const col=c[s.kind]||'#64748b';
+    return \`<tr>
+      <td class="mono">\${esc(s.name)}</td>
+      <td><span class="kind-badge" style="background:\${col}1a;color:\${col};border:1px solid \${col}44">\${s.kind}</span></td>
+      <td class="file-cell" title="\${esc(s.file)}">\${esc(s.file)}</td>
+      <td class="line-cell">L\${s.startLine}</td>
+      <td>\${s.exported?'<span class="exp-badge">exp</span>':''}</td>
+    </tr>\`;
+  }).join('');
+
+  const extra=filtered.length>500?' (showing 500 of '+filtered.length+')'+'':'';
+  document.getElementById('sym-count').textContent=filtered.length+' symbol(s)'+extra;
+  document.getElementById('sym-empty').style.display=filtered.length?'none':'block';
+  tbody.style.display=filtered.length?'':'none';
+
+  // Update sort arrows
+  ['name','kind','file','startLine'].forEach(col=>{
+    const el=document.getElementById('sa-'+col);
+    if(el)el.textContent=col===sortCol?(sortAsc?'↑':'↓'):'';
+  });
+}
+
+document.getElementById('sym-q').addEventListener('input',renderSymbols);
+document.getElementById('kind-filter').addEventListener('change',renderSymbols);
+document.getElementById('exp-only').addEventListener('change',renderSymbols);
+document.querySelectorAll('th[data-col]').forEach(th=>{
+  th.addEventListener('click',()=>{
+    const col=th.dataset.col;
+    if(sortCol===col)sortAsc=!sortAsc;else{sortCol=col;sortAsc=true;}
+    renderSymbols();
+  });
+});
+
+// Keyboard shortcut
+document.addEventListener('keydown',ev=>{
+  if(ev.key==='/'&&document.activeElement?.tagName!=='INPUT'&&document.activeElement?.tagName!=='SELECT'){
+    const q=document.getElementById('sym-q');
+    if(document.getElementById('tc-symbols').classList.contains('active')){
+      ev.preventDefault();q.focus();q.select();
+    }
+  }
+});
+
+})();
+</script>
+</body>
+</html>`;
+}