@event4u/agent-config 17.2.0 → 17.3.0

package/src/scripts/code_graph/map_viewer/viewer.js

@@ -29,6 +29,7 @@
             search: 'Search files and areas',
             files: function (n) { return n === 1 ? '1 file' : n + ' files'; },
             role: 'Role',
+            linkedBy: 'Linked by provider',
             area: 'Area',
             usedBy: 'Used by',
             uses: 'Uses',
@@ -56,6 +57,8 @@
             zoomIn: 'Zoom in',
             zoomOut: 'Zoom out',
             reset: 'Fit',
+            dim3d: '3D',
+            dimHint: 'Show the map as an orb. Drag to turn it, Shift+drag to move it, arrow keys turn it too.',
             none: 'none',
             hint: 'Click an area to open it. Click a file to inspect it. Esc goes back.',
             roles: {
@@ -75,6 +78,7 @@
             search: 'Dateien und Bereiche suchen',
             files: function (n) { return n === 1 ? '1 Datei' : n + ' Dateien'; },
             role: 'Rolle',
+            linkedBy: 'Verbunden durch Provider',
             area: 'Bereich',
             usedBy: 'Verwendet von',
             uses: 'Verwendet',
@@ -102,6 +106,8 @@
             zoomIn: 'Vergrößern',
             zoomOut: 'Verkleinern',
             reset: 'Einpassen',
+            dim3d: '3D',
+            dimHint: 'Karte als Kugel zeigen. Ziehen dreht sie, Shift+Ziehen verschiebt sie, die Pfeiltasten drehen ebenfalls.',
             none: 'keine',
             hint: 'Bereich anklicken zum Öffnen, Datei anklicken zum Ansehen. Esc geht zurück.',
             roles: {
@@ -168,6 +174,10 @@
     var searchInput = document.getElementById('search');
     var results = document.getElementById('results');
 
+    // The orb starts turned a little, so it reads as a sphere and not as a disc.
+    var ORB_YAW = 0.35;
+    var ORB_PITCH = -0.3;
+
     var state = {
         level: 'overview', // overview | area
         area: -1,
@@ -176,7 +186,9 @@
         showGuesses: false,
         showTests: true,
         lens: 'areas', // areas | folders
-        view: { scale: 1, x: 0, y: 0 }
+        view: { scale: 1, x: 0, y: 0 },
+        orb: false,
+        rot: { yaw: ORB_YAW, pitch: ORB_PITCH }
     };
     var drawn = []; // {kind, idx, x, y, r} in screen space, for hit tests
     window.__mapLabelBoxes = { boxes: [], width: 0, height: 0 };
@@ -202,6 +214,31 @@
         return [s.w / 2 + (x * k) + state.view.x, s.h / 2 + (y * k) + state.view.y];
     }
 
+    // The orb: the precomputed 2D layout wrapped onto a sphere with the inverse
+    // Lambert azimuthal equal-area projection, so neighbours stay neighbours and
+    // no region is squeezed — the layout's centre faces the viewer, its rim
+    // wraps to the back. Nothing is simulated; the same layout, turned.
+    function orbPoint(x, y, reach) {
+        var rho = (Math.sqrt(x * x + y * y) / reach) * 1.9;
+        var len = Math.sqrt(x * x + y * y) || 1;
+        var f = Math.sqrt(Math.max(0, 1 - (rho * rho) / 4));
+        var px = (x / len) * rho * f;
+        var py = (y / len) * rho * f;
+        var pz = 1 - (rho * rho) / 2;
+        var cy = Math.cos(state.rot.yaw);
+        var sy = Math.sin(state.rot.yaw);
+        var x1 = px * cy + pz * sy;
+        var z1 = -px * sy + pz * cy;
+        var cp = Math.cos(state.rot.pitch);
+        var sp = Math.sin(state.rot.pitch);
+        return [x1, py * cp - z1 * sp, py * sp + z1 * cp];
+    }
+
+    function orbRadius() {
+        var s = size();
+        return (Math.min(s.w, s.h) / 2 - 48) * state.view.scale;
+    }
+
     // Visible nodes for the current level.
     function currentNodes() {
         var out = [];
@@ -231,12 +268,40 @@
         ctx.clearRect(0, 0, s.w, s.h);
         var nodes = currentNodes();
         var pos = Object.create(null);
-        nodes.forEach(function (n) {
-            var p = toScreen(n.x, n.y);
-            n.sx = p[0];
-            n.sy = p[1];
-            pos[n.kind + n.idx] = n;
-        });
+        if (state.orb) {
+            var reach = 0;
+            nodes.forEach(function (n) { reach = Math.max(reach, Math.sqrt(n.x * n.x + n.y * n.y)); });
+            reach = reach || 1;
+            var k = orbRadius();
+            var cx = s.w / 2 + state.view.x;
+            var cyy = s.h / 2 + state.view.y;
+            nodes.forEach(function (n) {
+                var p = orbPoint(n.x, n.y, reach);
+                n.sx = cx + p[0] * k;
+                n.sy = cyy + p[1] * k;
+                n.depth = p[2];
+                // Nearer is larger and opaque; the far side recedes.
+                n.r = n.r * (0.6 + 0.4 * (p[2] + 1) / 2);
+                pos[n.kind + n.idx] = n;
+            });
+            nodes.sort(function (a, b) { return a.depth - b.depth || a.idx - b.idx; });
+            var glow = ctx.createRadialGradient(cx - k * 0.35, cyy - k * 0.35, k * 0.1, cx, cyy, k);
+            glow.addColorStop(0, cssVar('--orb-light'));
+            glow.addColorStop(1, cssVar('--orb-dark'));
+            ctx.fillStyle = glow;
+            ctx.beginPath();
+            ctx.arc(cx, cyy, k, 0, Math.PI * 2);
+            ctx.fill();
+        } else {
+            nodes.forEach(function (n) {
+                var p = toScreen(n.x, n.y);
+                n.sx = p[0];
+                n.sy = p[1];
+                pos[n.kind + n.idx] = n;
+            });
+        }
+        // 1 on the near side and in 2D, fading to 0.15 on the far side of the orb.
+        function nearness(a) { return state.orb ? 0.15 + 0.85 * (a.depth + 1) / 2 : 1; }
 
         // Edges first.
         var edge = cssVar('--edge');
@@ -252,11 +317,13 @@
                 var hot = state.area === e[0] || state.area === e[1];
                 ctx.strokeStyle = hot ? strong : edge;
                 ctx.lineWidth = 0.5 + 4 * Math.sqrt(e[2] / maxW);
+                ctx.globalAlpha = Math.min(nearness(a), nearness(b));
                 ctx.beginPath();
                 ctx.moveTo(a.sx, a.sy);
                 ctx.lineTo(b.sx, b.sy);
                 ctx.stroke();
             });
+            ctx.globalAlpha = 1;
         } else {
             var drawEdges = function (list, dashed) {
                 ctx.setLineDash(dashed ? [4, 4] : []);
@@ -267,11 +334,13 @@
                     var hot = state.file === e[0] || state.file === e[1];
                     ctx.strokeStyle = hot ? strong : edge;
                     ctx.lineWidth = hot ? 1.8 : 0.8;
+                    ctx.globalAlpha = Math.min(nearness(a), nearness(b));
                     ctx.beginPath();
                     ctx.moveTo(a.sx, a.sy);
                     ctx.lineTo(b.sx, b.sy);
                     ctx.stroke();
                 });
+                ctx.globalAlpha = 1;
                 ctx.setLineDash([]);
             };
             drawEdges(model.edges, false);
@@ -299,7 +368,7 @@
                 var f = files[n.idx];
                 color = f.role === 'test' ? areaColor(state.area, 0.45) : f.role === 'infra' ? grey : areaColor(state.area, 1);
             }
-            ctx.globalAlpha = dim ? 0.35 : 1;
+            ctx.globalAlpha = (dim ? 0.35 : 1) * nearness(n);
             ctx.fillStyle = color;
             ctx.beginPath();
             ctx.arc(n.sx, n.sy, r, 0, Math.PI * 2);
@@ -324,10 +393,11 @@
                 ctx.setLineDash([]);
             }
             ctx.globalAlpha = 1;
-            drawn.push({ kind: n.kind, idx: n.idx, x: n.sx, y: n.sy, r: Math.max(r, 8) });
+            // The far side of the orb is seen through the near side: never a click target.
+            if (!state.orb || n.depth > 0) drawn.push({ kind: n.kind, idx: n.idx, x: n.sx, y: n.sy, r: Math.max(r, 8) });
         });
 
-        drawLabels(nodes, s);
+        drawLabels(state.orb ? nodes.filter(function (n) { return n.depth > 0.15; }) : nodes, s);
     }
 
     // Labels: biggest first, placed only where they fit, flipped near the right
@@ -428,6 +498,7 @@
             kv([
                 [t('area'), f.area >= 0 ? areas[f.area].name : '—'],
                 [t('role'), STR[lang].roles[f.role]],
+                [t('linkedBy'), f.linkedBy ? f.linkedBy.join(', ') : '—'],
                 [t('guesses'), String(f.guesses)],
                 [t('outcome'), outcomeOf[state.file] === undefined ? '—' : String(outcomeOf[state.file])],
                 [t('state'), data.meta.state]
@@ -615,7 +686,10 @@
         renderPanel();
         draw();
     }
-    function resetView() { state.view = { scale: 1, x: 0, y: 0 }; }
+    function resetView() {
+        state.view = { scale: 1, x: 0, y: 0 };
+        state.rot = { yaw: ORB_YAW, pitch: ORB_PITCH };
+    }
     function goHome() { state.level = 'overview'; state.area = -1; state.file = -1; resetView(); refresh(); }
     function openArea(i) { state.level = 'area'; state.area = i; state.file = -1; resetView(); refresh(); }
     function openFile(i) {
@@ -632,7 +706,10 @@
     // Input.
     var drag = null;
     canvas.addEventListener('pointerdown', function (e) {
-        drag = { x: e.clientX, y: e.clientY, vx: state.view.x, vy: state.view.y, moved: false };
+        drag = {
+            x: e.clientX, y: e.clientY, vx: state.view.x, vy: state.view.y,
+            yaw: state.rot.yaw, pitch: state.rot.pitch, turn: state.orb && !e.shiftKey, moved: false
+        };
         canvas.setPointerCapture(e.pointerId);
     });
     canvas.addEventListener('pointermove', function (e) {
@@ -640,8 +717,16 @@
         var dx = e.clientX - drag.x;
         var dy = e.clientY - drag.y;
         if (Math.abs(dx) + Math.abs(dy) > 3) drag.moved = true;
-        if (drag.moved) { state.view.x = drag.vx + dx; state.view.y = drag.vy + dy; draw(); }
+        if (!drag.moved) return;
+        if (drag.turn) turnTo(drag.yaw + dx * 0.008, drag.pitch - dy * 0.008);
+        else { state.view.x = drag.vx + dx; state.view.y = drag.vy + dy; draw(); }
     });
+    // Pitch stops short of the poles, so "up" never flips under the pointer.
+    function turnTo(yaw, pitch) {
+        state.rot.yaw = yaw;
+        state.rot.pitch = Math.max(-1.4, Math.min(1.4, pitch));
+        draw();
+    }
     canvas.addEventListener('pointerup', function (e) {
         var wasDrag = drag && drag.moved;
         drag = null;
@@ -660,7 +745,14 @@
         state.view.scale = Math.min(12, Math.max(0.3, state.view.scale * f));
         draw();
     }
+    var TURN_KEYS = { ArrowLeft: [-0.15, 0], ArrowRight: [0.15, 0], ArrowUp: [0, 0.15], ArrowDown: [0, -0.15] };
     document.addEventListener('keydown', function (e) {
+        var step = TURN_KEYS[e.key];
+        if (step && state.orb && document.activeElement !== searchInput) {
+            e.preventDefault();
+            turnTo(state.rot.yaw + step[0], state.rot.pitch + step[1]);
+            return;
+        }
         if (e.key === 'Escape') {
             if (document.activeElement === searchInput && searchInput.value) { searchInput.value = ''; clear(results); return; }
             if (state.file >= 0) { state.file = -1; refresh(); } else if (state.area >= 0) goHome();
@@ -710,6 +802,13 @@
     document.getElementById('z-in').addEventListener('click', function () { zoom(1.25); });
     document.getElementById('z-out').addEventListener('click', function () { zoom(1 / 1.25); });
     document.getElementById('z-fit').addEventListener('click', function () { resetView(); draw(); });
+    var dimButton = document.getElementById('dim');
+    dimButton.addEventListener('click', function () {
+        state.orb = !state.orb;
+        dimButton.setAttribute('aria-pressed', String(state.orb));
+        resetView();
+        draw();
+    });
 
     var themes = ['system', 'light', 'dark'];
     var theme = 'system';
@@ -744,6 +843,8 @@
         document.getElementById('z-in').setAttribute('aria-label', t('zoomIn'));
         document.getElementById('z-out').setAttribute('aria-label', t('zoomOut'));
         document.getElementById('z-fit').textContent = t('reset');
+        document.getElementById('dim').textContent = t('dim3d');
+        document.getElementById('dim').setAttribute('title', t('dimHint'));
         document.getElementById('lang').textContent = t('lang');
         applyTheme();
     }

package/src/scripts/code_graph/passes.ts

@@ -0,0 +1,173 @@
+/**
+ * The ordered post-extraction passes (ADR-298). The build runs this list and
+ * nothing else after resolution; a pass that throws is reported and skipped,
+ * and the build goes on.
+ *
+ * Order is meaning: convention providers contest base edges they prove false
+ * before anything is added on top, docs add their links, and SCIP last
+ * supersedes the name guesses it duplicates.
+ */
+import type { SourceFile } from './build.js';
+import { conventionsDefault } from './conventions_default.js';
+import { docsLayer } from './docs_layer.js';
+import { activeProviders, type ProjectProbe } from './providers/index.js';
+import type { ResolutionConfig } from './resolution_tiers.js';
+import { type ScipDocument, scipEdges, supersededByScip } from './scip_reader.js';
+import type { ActiveProviderRecord, CodeEdge, CodeNode } from './types.js';
+
+export interface PassContext {
+    files: readonly SourceFile[];
+    docs: readonly SourceFile[];
+    scip: readonly ScipDocument[];
+    resolution: ResolutionConfig;
+    probe: ProjectProbe;
+    /** The graph so far, read-only: a pass proposes, the orchestrator applies. */
+    nodes: readonly CodeNode[];
+    edges: readonly CodeEdge[];
+}
+
+export interface PassFailure {
+    pass: string;
+    reason: string;
+}
+
+export interface Contest {
+    /** Suppressed-edge counter the removed edges are reported under, if any. */
+    key?: string;
+    test: (e: CodeEdge) => boolean;
+}
+
+export interface PassResult {
+    nodes: CodeNode[];
+    edges: CodeEdge[];
+    /** Applied to the existing edges, in order, before this pass's own are added. */
+    contests?: Contest[];
+    /** Failures inside the pass that did not stop it (one provider of several). */
+    failures?: PassFailure[];
+    /** Convention providers that applied, for the graph's record. */
+    providers?: ActiveProviderRecord[];
+}
+
+export interface GraphPass {
+    id: string;
+    applies(ctx: PassContext): boolean;
+    run(ctx: PassContext): PassResult;
+}
+
+const conventionProviders: GraphPass = {
+    id: 'convention-providers',
+    applies: (ctx) => activeProviders(ctx.probe).length > 0,
+    run: (ctx) => {
+        const out: PassResult = { nodes: [], edges: [], contests: [], failures: [], providers: [] };
+        const known = new Set(ctx.nodes.map((n) => n.id));
+        const drawn = new Set<string>();
+        for (const { provider, roots } of activeProviders(ctx.probe)) {
+            out.providers?.push({ id: provider.id, roots });
+            try {
+                const under = (p: string): boolean => roots.includes('') || roots.some((r) => p.startsWith(`${r}/`));
+                const files = ctx.files.filter((f) => under(f.path));
+                const allPaths = ctx.probe.paths.length > 0 ? ctx.probe.paths : ctx.files.map((f) => f.path);
+                const r = provider.build({
+                    files,
+                    baseNodes: ctx.nodes,
+                    baseEdges: ctx.edges,
+                    paths: allPaths.filter(under),
+                    manifests: new Map([...ctx.probe.manifests].filter(([p]) => under(p))),
+                    resolution: ctx.resolution,
+                    roots,
+                });
+                if (r.nodes.length === 0 && r.edges.length === 0) continue;
+                if (r.contest) out.contests?.push({ key: provider.id, test: r.contest });
+                // Two providers may draw the same edge; the first keeps it.
+                for (const e of r.edges) {
+                    const key = `${e.source}\0${e.relation}\0${e.target}`;
+                    if (drawn.has(key)) continue;
+                    drawn.add(key);
+                    out.edges.push({ ...e, provider_id: provider.id });
+                }
+                // Two providers may declare the same table or template node; the first wins.
+                for (const n of r.nodes) {
+                    if (known.has(n.id)) continue;
+                    known.add(n.id);
+                    out.nodes.push(n);
+                }
+            } catch (e) {
+                out.failures?.push({ pass: `convention-providers:${provider.id}`, reason: (e as Error).message });
+            }
+        }
+        return out;
+    },
+};
+
+const defaults: GraphPass = {
+    id: 'conventions-default',
+    applies: (ctx) => ctx.files.length > 0,
+    run: (ctx) => {
+        const paths = ctx.probe.paths.length > 0 ? ctx.probe.paths : [...ctx.files, ...ctx.docs].map((f) => f.path).sort();
+        return conventionsDefault({ files: ctx.files, paths, nodes: ctx.nodes, edges: ctx.edges });
+    },
+};
+
+const docs: GraphPass = {
+    id: 'docs',
+    applies: (ctx) => ctx.docs.length > 0,
+    run: (ctx) => {
+        const allFiles = new Set([...ctx.files.map((f) => f.path), ...ctx.docs.map((d) => d.path)]);
+        const layer = docsLayer(ctx.docs, allFiles);
+        // An earlier pass may already have drawn a document as a link target.
+        const known = new Set(ctx.nodes.map((n) => n.id));
+        return { nodes: layer.nodes.filter((n) => !known.has(n.id)), edges: layer.edges };
+    },
+};
+
+const scip: GraphPass = {
+    id: 'scip',
+    applies: (ctx) => ctx.scip.length > 0,
+    run: (ctx) => {
+        const stated = scipEdges(ctx.scip, ctx.nodes);
+        return { nodes: [], edges: stated, contests: [{ test: supersededByScip(stated, ctx.nodes) }] };
+    },
+};
+
+export const PASSES: readonly GraphPass[] = [conventionProviders, defaults, docs, scip];
+
+export interface PassReport {
+    /** Edges removed by a keyed contest, per key (a provider id); only non-zero keys appear. */
+    suppressed: Record<string, number>;
+    failures: PassFailure[];
+    providers: ActiveProviderRecord[];
+}
+
+/** Run every applicable pass in order, mutating `nodes` / `edges` in place. */
+export function runPasses(
+    base: Omit<PassContext, 'nodes' | 'edges'>,
+    nodes: CodeNode[],
+    edges: CodeEdge[],
+    passes: readonly GraphPass[] = PASSES,
+): PassReport {
+    const report: PassReport = { suppressed: {}, failures: [], providers: [] };
+    for (const pass of passes) {
+        const ctx: PassContext = { ...base, nodes, edges };
+        let result: PassResult;
+        try {
+            if (!pass.applies(ctx)) continue;
+            result = pass.run(ctx);
+        } catch (e) {
+            report.failures.push({ pass: pass.id, reason: (e as Error).message });
+            continue;
+        }
+        report.failures.push(...(result.failures ?? []));
+        report.providers.push(...(result.providers ?? []));
+        for (const c of result.contests ?? []) {
+            const kept = edges.filter((e) => !c.test(e));
+            const removed = edges.length - kept.length;
+            if (c.key && removed > 0) report.suppressed[c.key] = (report.suppressed[c.key] ?? 0) + removed;
+            // Element-wise: a spread of ~200k edges overflows the call stack.
+            edges.length = 0;
+            for (const e of kept) edges.push(e);
+        }
+        for (const e of result.edges) edges.push(e);
+        for (const n of result.nodes) nodes.push(n);
+    }
+    return report;
+}

package/src/scripts/code_graph/providers/angular.ts

@@ -0,0 +1,55 @@
+/**
+ * Angular:
+ *
+ *   { path: 'x', component: XComponent }            PAGE /x --routes-to--> XComponent
+ *   { path: 'x', loadComponent: () => import('./x').then((m) => m.X) }   → X, else the module
+ *   @Component({ templateUrl: './x.html' }) class    --renders-->  the template file
+ *   constructor(private s: S) · s = inject(S)        --injects-->  S (in a decorated class)
+ *
+ * Child route paths are not joined to their parent's; `loadChildren` modules,
+ * inline `template:` strings and `styleUrls` are not followed.
+ */
+import * as path from 'node:path';
+
+import { npmRoots } from './shared/detect.js';
+import { constructorInjection, routeObjects } from './shared/js.js';
+import { type Kit, lineIndex, makeKit } from './shared/kit.js';
+import type { ConventionProvider } from './types.js';
+
+const EXTS = ['.ts'];
+
+function templateUrls(kit: Kit): number {
+    const inventory = new Set(kit.paths);
+    let count = 0;
+    for (const f of kit.filesWithExt(...EXTS)) {
+        const at = lineIndex(f.source);
+        for (const m of f.source.matchAll(/@Component\(\s*\{(?<body>[^]*?)\}\s*\)/g)) {
+            const url = /\btemplateUrl\s*:\s*(['"`])([^'"`]+)\1/.exec(m.groups?.['body'] ?? '');
+            if (!url) continue;
+            const cls = kit.nextSymbol(f.path, at(m.index as number), ['class']);
+            const target = path.posix.join(path.posix.dirname(f.path), url[2] as string);
+            if (!cls || cls.kind !== 'class' || !inventory.has(target)) continue;
+            kit.fileNode(target);
+            kit.emit(cls.id, target, 'renders', 'directive-scan');
+            count += 1;
+        }
+    }
+    return count;
+}
+
+export const angularProvider: ConventionProvider = {
+    id: 'angular',
+    detect: (probe) => npmRoots(probe, ['@angular/core']),
+    build: (input) => {
+        const kit = makeKit(input);
+        routeObjects(kit, { exts: EXTS, componentKeys: ['component', 'loadComponent'] });
+        templateUrls(kit);
+        constructorInjection(kit, {
+            exts: EXTS,
+            classDecorator: /@(?:Component|Injectable|Directive|Pipe)\(/,
+            reach: 12,
+            injectCall: /=\s*inject\(\s*([A-Za-z_$][\w$]*)\s*\)/g,
+        });
+        return kit.result();
+    },
+};

package/src/scripts/code_graph/providers/aspnetcore.ts

@@ -0,0 +1,182 @@
+/**
+ * ASP.NET Core, read by its conventions:
+ *
+ *   routing     `[HttpGet("x")]` / `[HttpPost]` / `[Route("x")]` on an action,
+ *               under a class `[Route("api/[controller]")]` → route --routes-to--> the action;
+ *               `app.MapGet("/x", Handler)` → the handler when it is a method group
+ *   EF Core     `DbSet<User> Users` in a `DbContext` → User --persists--> table:Users
+ *               (`[Table("x")]` on the entity wins)
+ *   views       `View()` / `View("Name")` in a controller action
+ *               → `Views/<Controller>/<Name or action>.cshtml`, else `Views/Shared/`
+ *   DI          a constructor parameter typed as an in-repo class or interface → injects
+ *
+ * Not followed: conventional routing tables (`MapControllerRoute`), a view named
+ * by a variable or `View(model)`, primary constructors, and a type name two
+ * in-repo declarations share — each gets no edge rather than a guess.
+ */
+import * as path from 'node:path';
+
+import type { CodeNode } from '../types.js';
+import { dotnetRoots } from './shared/detect.js';
+import { callRoutes, joinRoute, lastArgName } from './shared/extractors.js';
+import { escapeRe, type Kit, lineIndex, makeKit } from './shared/kit.js';
+import type { ConventionProvider } from './types.js';
+
+const ATTR =
+    /[[,]\s*(?<attr>Http(?:Get|Post|Put|Patch|Delete|Head|Options)|Route)(?:Attribute)?\b(?:\s*\(\s*(?:template\s*:\s*)?"(?<path>[^"]*)"[^)]*\))?/g;
+
+/** In-repo types by simple name, kept only when the name is declared once. */
+function uniqueTypes(kit: Kit): Map<string, CodeNode> {
+    const seen = new Map<string, CodeNode | null>();
+    for (const n of kit.nodeById.values()) {
+        if (!n.source_file.endsWith('.cs') || (n.kind !== 'class' && n.kind !== 'interface')) continue;
+        seen.set(n.label, seen.has(n.label) ? null : n);
+    }
+    const out = new Map<string, CodeNode>();
+    for (const [k, v] of seen) if (v) out.set(k, v);
+    return out;
+}
+
+const controllerName = (cls: CodeNode): string => cls.label.replace(/Controller$/, '');
+
+function attributeRoutes(kit: Kit): void {
+    for (const f of kit.filesWithExt('.cs')) {
+        const at = lineIndex(f.source);
+        const prefixes = new Map<string, string>();
+        const actions = new Map<string, { node: CodeNode; line: number; verbs: Array<{ verb: string; path?: string }>; routes: string[] }>();
+        for (const m of f.source.matchAll(ATTR)) {
+            const line = at(m.index as number);
+            const attr = m.groups?.['attr'] as string;
+            const tpl = m.groups?.['path'];
+            const owner = kit.enclosing(f.path, line);
+            const method = owner === f.path ? null : kit.nodeById.get(owner);
+            if (!method) {
+                const cls = kit.classAt(f.path, line);
+                if (cls && attr === 'Route' && tpl !== undefined) prefixes.set(cls.id, tpl);
+                continue;
+            }
+            const a = actions.get(method.id) ?? { node: method, line, verbs: [], routes: [] };
+            if (attr === 'Route') {
+                if (tpl !== undefined) a.routes.push(tpl);
+            } else a.verbs.push({ verb: attr.slice(4).toUpperCase(), ...(tpl !== undefined ? { path: tpl } : {}) });
+            actions.set(method.id, a);
+        }
+        for (const a of actions.values()) {
+            const cls = kit.classAt(f.path, a.node.source_location[0] as number);
+            const prefix = cls ? prefixes.get(cls.id) : undefined;
+            const pairs: Array<[string, string | undefined]> = [];
+            for (const v of a.verbs) {
+                if (v.path !== undefined) pairs.push([v.verb, v.path]);
+                else if (a.routes.length > 0) for (const r of a.routes) pairs.push([v.verb, r]);
+                else pairs.push([v.verb, undefined]);
+            }
+            if (a.verbs.length === 0) for (const r of a.routes) pairs.push(['ANY', r]);
+            for (const [verb, tpl] of pairs) {
+                const absolute = tpl !== undefined && /^~?\//.test(tpl);
+                const raw = absolute ? joinRoute(tpl.replace(/^~/, '')) : joinRoute(prefix, tpl);
+                const routePath = raw
+                    .replace(/\[controller\]/gi, cls ? controllerName(cls) : '[controller]')
+                    .replace(/\[action\]/gi, a.node.label);
+                kit.emit(kit.route(f.path, verb, routePath, a.line), a.node.id, 'routes-to', 'route-table');
+            }
+        }
+    }
+}
+
+function minimalApi(kit: Kit, types: Map<string, CodeNode>): void {
+    callRoutes(kit, {
+        exts: ['.cs'],
+        call: /\b\w+\s*\.\s*Map(?<verb>Get|Post|Put|Patch|Delete)\(\s*"(?<path>[^"]*)"\s*,(?=(?<rest>[\s\S]{0,300}))/g,
+        handler: (_k, file, rest) => {
+            const name = lastArgName(rest);
+            if (!name) return null;
+            const [head, member] = name.split('.') as [string, string | undefined];
+            if (member) {
+                const cls = types.get(head);
+                return cls ? kit.methodOf(cls.id, member) : null;
+            }
+            const local = kit.nodesInFile(file).filter((n) => n.label === head && (n.kind === 'method' || n.kind === 'function'));
+            return local.length === 1 ? (local[0] as CodeNode).id : null;
+        },
+    });
+}
+
+function entities(kit: Kit, types: Map<string, CodeNode>): void {
+    const sourceOf = new Map(kit.files.map((f) => [f.path, f.source] as const));
+    for (const f of kit.filesWithExt('.cs')) {
+        if (!/\bclass\s+\w+[^{;]*:\s*[^{;]*\bDbContext\b/.test(f.source)) continue;
+        const at = lineIndex(f.source);
+        for (const m of f.source.matchAll(/\bDbSet<\s*(?:[\w.]+\.)?(?<entity>\w+)\s*>\s+(?<prop>\w+)/g)) {
+            const entity = types.get(m.groups?.['entity'] as string);
+            if (!entity || entity.kind !== 'class') continue;
+            const lines = (sourceOf.get(entity.source_file) ?? '').split('\n');
+            const start = entity.source_location[0] as number;
+            const head = lines.slice(start - 1, start + 5).join('\n').split(/\bclass\b/)[0] ?? '';
+            const explicit = /\[\s*Table\s*\(\s*"(?<name>[^"]+)"/.exec(head)?.groups?.['name'];
+            const table = kit.table(explicit ?? (m.groups?.['prop'] as string), f.path, at(m.index as number));
+            kit.emit(entity.id, table, 'persists', 'schema-call');
+        }
+    }
+}
+
+function views(kit: Kit): void {
+    const inventory = new Set(kit.paths);
+    for (const f of kit.filesWithExt('.cs')) {
+        const at = lineIndex(f.source);
+        for (const m of f.source.matchAll(/\b(?:Partial)?View\(\s*(?:"(?<name>[^"]+)"\s*)?[,)]/g)) {
+            const line = at(m.index as number);
+            const owner = kit.enclosing(f.path, line);
+            const action = owner === f.path ? null : kit.nodeById.get(owner);
+            const cls = action ? kit.classAt(f.path, line) : null;
+            if (!action || !cls || !cls.label.endsWith('Controller')) continue;
+            const name = m.groups?.['name'] ?? action.label;
+            const candidates: string[] = [];
+            for (const root of kit.roots) {
+                if (/^~?\//.test(name)) candidates.push(path.posix.join(root, name.replace(/^~?\//, '')));
+                else {
+                    const file = name.endsWith('.cshtml') ? name : `${name}.cshtml`;
+                    candidates.push(path.posix.join(root, 'Views', controllerName(cls), file), path.posix.join(root, 'Views', 'Shared', file));
+                }
+            }
+            const target = candidates.find((c) => inventory.has(c));
+            if (!target) continue;
+            kit.fileNode(target);
+            kit.emit(action.id, target, 'renders', 'directive-scan');
+        }
+    }
+}
+
+function injection(kit: Kit, types: Map<string, CodeNode>): void {
+    const sourceOf = new Map(kit.files.map((f) => [f.path, f.source] as const));
+    for (const n of kit.nodeById.values()) {
+        if (n.kind !== 'method' || !n.source_file.endsWith('.cs')) continue;
+        const clsId = n.id.split('::').slice(0, -1).join('::');
+        const cls = kit.nodeById.get(clsId);
+        if (!cls || cls.kind !== 'class' || cls.label !== n.label) continue;
+        const lines = (sourceOf.get(n.source_file) ?? '').split('\n');
+        const start = n.source_location[0] as number;
+        const decl = lines.slice(start - 1, (n.source_location[2] as number) ?? start).join('\n');
+        const params = new RegExp(`\\b${escapeRe(n.label)}\\s*\\(([^)]*)\\)`).exec(decl)?.[1] ?? '';
+        for (const p of params.split(',')) {
+            const t = /(?:^|\s)(?:[\w.]+\.)?(?<type>[A-Za-z_]\w*)\s*(?:<[^>]*>)?\??\s+\w+\s*(?:=.*)?$/.exec(p.trim())?.groups?.['type'];
+            const target = t ? types.get(t) : undefined;
+            if (target && target.id !== cls.id) kit.emit(cls.id, target.id, 'injects', 'di-binding');
+        }
+    }
+}
+
+export const aspnetcoreProvider: ConventionProvider = {
+    id: 'aspnetcore',
+    detect: (probe) => dotnetRoots(probe, /Sdk\s*=\s*"Microsoft\.NET\.Sdk\.Web"|Include\s*=\s*"Microsoft\.AspNetCore\./),
+    build: (input) => {
+        const kit = makeKit(input);
+        const types = uniqueTypes(kit);
+        attributeRoutes(kit);
+        minimalApi(kit, types);
+        entities(kit, types);
+        views(kit);
+        injection(kit, types);
+        return kit.result();
+    },
+    roleOf: (p) => (p.endsWith('.cshtml') ? 'view' : path.posix.basename(p) === 'Program.cs' ? 'entry' : undefined),
+};