@event4u/agent-config 17.2.0 → 17.3.0

package/src/scripts/code_graph/providers/shared/detect.ts

@@ -0,0 +1,78 @@
+/**
+ * Detection by manifest, per package root. Every helper returns the sorted
+ * roots (`''` for the repository root) whose manifest declares one of the
+ * named packages — never a guess from file suffixes.
+ */
+import * as path from 'node:path';
+
+import type { ProjectProbe } from '../types.js';
+
+function rootOf(p: string): string {
+    const d = path.posix.dirname(p);
+    return d === '.' ? '' : d;
+}
+
+function rootsWhere(probe: ProjectProbe, basename: RegExp, declares: (text: string) => boolean): string[] {
+    const roots = new Set<string>();
+    for (const [p, text] of probe.manifests) if (basename.test(path.posix.basename(p)) && declares(text)) roots.add(rootOf(p));
+    return [...roots].sort();
+}
+
+function jsonDeps(text: string, keys: readonly string[]): string[] {
+    try {
+        const j = JSON.parse(text) as Record<string, Record<string, string> | undefined>;
+        return keys.flatMap((k) => Object.keys(j[k] ?? {}));
+    } catch {
+        return [];
+    }
+}
+
+const matches = (names: readonly (string | RegExp)[], dep: string): boolean =>
+    names.some((n) => (typeof n === 'string' ? n === dep : n.test(dep)));
+
+/** `package.json` dependencies, devDependencies or peerDependencies. */
+export function npmRoots(probe: ProjectProbe, names: readonly (string | RegExp)[]): string[] {
+    return rootsWhere(probe, /^package\.json$/, (t) =>
+        jsonDeps(t, ['dependencies', 'devDependencies', 'peerDependencies']).some((d) => matches(names, d)),
+    );
+}
+
+/** `composer.json` require or require-dev. */
+export function composerRoots(probe: ProjectProbe, names: readonly (string | RegExp)[]): string[] {
+    return rootsWhere(probe, /^composer\.json$/, (t) => jsonDeps(t, ['require', 'require-dev']).some((d) => matches(names, d)));
+}
+
+/** `pyproject.toml` or a `requirements*.txt` naming the distribution. */
+export function pythonRoots(probe: ProjectProbe, names: readonly string[]): string[] {
+    const re = new RegExp(`(^|["'\\s\\[,])(${names.map((n) => n.replace(/[-_.]/g, '[-_.]')).join('|')})(?=[\\s"'<>=~!;\\[,]|$)`, 'im');
+    return rootsWhere(probe, /^(pyproject\.toml|requirements[\w.-]*\.txt)$/, (t) => re.test(t));
+}
+
+/** A Maven `pom.xml` or Gradle build file naming the artifact. */
+export function jvmRoots(probe: ProjectProbe, artifact: RegExp): string[] {
+    return rootsWhere(probe, /^(pom\.xml|build\.gradle(\.kts)?)$/, (t) => artifact.test(t));
+}
+
+/** A `go.mod` requiring the module. */
+export function goRoots(probe: ProjectProbe, modules: readonly string[]): string[] {
+    return rootsWhere(probe, /^go\.mod$/, (t) => modules.some((m) => t.includes(m)));
+}
+
+/** A `*.csproj` referencing the SDK or package. */
+export function dotnetRoots(probe: ProjectProbe, marker: RegExp): string[] {
+    return rootsWhere(probe, /\.csproj$/, (t) => marker.test(t));
+}
+
+/** A `Gemfile` declaring the gem. */
+export function gemRoots(probe: ProjectProbe, gem: string): string[] {
+    return rootsWhere(probe, /^Gemfile$/, (t) => new RegExp(`^\\s*gem\\s+['"]${gem}['"]`, 'm').test(t));
+}
+
+/** Marker files present in the probe, by basename, as roots. */
+export function markerRoots(probe: ProjectProbe, basename: string): string[] {
+    return [...new Set([...probe.markers].filter((p) => path.posix.basename(p) === basename).map(rootOf))].sort();
+}
+
+export function union(...lists: string[][]): string[] {
+    return [...new Set(lists.flat())].sort();
+}

package/src/scripts/code_graph/providers/shared/extractors.ts

@@ -0,0 +1,249 @@
+/**
+ * The five shared mechanisms most providers are a parameter table for
+ * (road-to-graph-providers-for-every-stack 4.1):
+ *
+ *   annotationRoutes   @Get('/x') · @app.get("/x") · #[Route('/x')] · [HttpGet("x")]  route → the method below it
+ *   callRoutes         app.get('/x', h) · path('x/', views.h) · r.GET("/x", h)          route → the handler named
+ *   fsRoutes           a page module whose path is its route                         route → the module
+ *   tableMapping       @Table(name = "t") · __tablename__ · $table · conventions      model → table, migration → table
+ *   templateRoots      render('a/b.html') · render_template('x.html') · View("Name")  code → the template file
+ *
+ * Every edge is emitted only when its target exists; what a rule cannot settle
+ * (a closure, a name built at runtime) gets no edge rather than a guess.
+ */
+import * as path from 'node:path';
+
+import type { SourceFile } from '../../build.js';
+import type { CodeNode } from '../../types.js';
+import { type Kit, lineIndex } from './kit.js';
+
+export function joinRoute(...parts: Array<string | undefined>): string {
+    const joined = parts
+        .filter((p): p is string => typeof p === 'string' && p.length > 0)
+        .map((p) => p.replace(/^\/+|\/+$/g, ''))
+        .filter(Boolean)
+        .join('/');
+    return `/${joined}`;
+}
+
+export interface AnnotationRouteSpec {
+    exts: readonly string[];
+    /** A route decorator; named groups `verb` (optional) and `path` (optional). */
+    route: RegExp;
+    /** HTTP verb when the decorator carries it in its name; `ANY` otherwise. */
+    verb?: (m: RegExpMatchArray) => string;
+    /** A class-level prefix decorator just above the class; named group `path`. */
+    prefix?: RegExp;
+    /** How far above a class its prefix decorator may sit, in lines. */
+    prefixReach?: number;
+}
+
+export function annotationRoutes(kit: Kit, spec: AnnotationRouteSpec): number {
+    let count = 0;
+    for (const f of kit.filesWithExt(...spec.exts)) {
+        const at = lineIndex(f.source);
+        const prefixes = spec.prefix
+            ? [...f.source.matchAll(spec.prefix)].map((m) => ({ line: at(m.index as number), path: m.groups?.['path'] ?? '' }))
+            : [];
+        for (const m of f.source.matchAll(spec.route)) {
+            const index = m.index as number;
+            // A decorator inside a line comment is prose, not a route. A docblock
+            // line (` * @Route`) is not skipped: annotation-routed frameworks read it.
+            const lineStart = f.source.lastIndexOf('\n', index - 1) + 1;
+            if (/\/\/|^\s*#(?!\[)/.test(f.source.slice(lineStart, index))) continue;
+            const line = at(index);
+            const handler = kit.nextSymbol(f.path, line, ['method', 'function']);
+            const cls = handler ? kit.classAt(f.path, handler.source_location[0] as number) : null;
+            const reach = spec.prefixReach ?? 6;
+            const clsLine = cls ? (cls.source_location[0] as number) : -1;
+            const prefix = cls ? prefixes.filter((p) => p.line <= clsLine && p.line >= clsLine - reach).pop()?.path : undefined;
+            const verb = (spec.verb ? spec.verb(m) : (m.groups?.['verb'] ?? 'ANY')).toUpperCase();
+            const id = kit.route(f.path, verb, joinRoute(prefix, m.groups?.['path']), line);
+            if (handler) kit.emit(id, handler.id, 'routes-to', 'route-table');
+            count += 1;
+        }
+    }
+    return count;
+}
+
+export interface CallRouteSpec {
+    exts: readonly string[];
+    /**
+     * A route registration; named groups `verb` (optional), `path`, `rest` (the
+     * text after the path). Capture `rest` inside a lookahead —
+     * `(?=(?<rest>[\s\S]{0,300}))` — or it swallows the next registration.
+     */
+    call: RegExp;
+    verb?: (m: RegExpMatchArray) => string;
+    /** Resolve the handler from `rest`; the default reads the last argument as a name or `obj.member`. */
+    handler?: (kit: Kit, file: string, rest: string) => string | null;
+}
+
+/** The last argument of a call's remaining text, if it is a plain name or `obj.member`. */
+export function lastArgName(rest: string): string | null {
+    let depth = 0;
+    let end = rest.length;
+    for (let i = 0; i < rest.length; i++) {
+        const c = rest[i];
+        if (c === '(' || c === '[' || c === '{') depth += 1;
+        else if (c === ')' || c === ']' || c === '}') {
+            if (depth === 0) {
+                end = i;
+                break;
+            }
+            depth -= 1;
+        }
+    }
+    const args = rest.slice(0, end).split(',').map((a) => a.trim()).filter(Boolean);
+    const last = args[args.length - 1];
+    return last && /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?$/.test(last) ? last : null;
+}
+
+export function defaultHandler(kit: Kit, file: string, rest: string): string | null {
+    const name = lastArgName(rest);
+    if (!name) return null;
+    const [head, member] = name.split('.') as [string, string | undefined];
+    const resolved = kit.resolveName(file, head);
+    if (!member) return resolved;
+    if (resolved) return kit.methodOf(resolved, member) ?? kit.resolveName(path.posix.join(path.posix.dirname(file), head), member);
+    return null;
+}
+
+export function callRoutes(kit: Kit, spec: CallRouteSpec): number {
+    let count = 0;
+    for (const f of kit.filesWithExt(...spec.exts)) {
+        const at = lineIndex(f.source);
+        for (const m of f.source.matchAll(spec.call)) {
+            const line = at(m.index as number);
+            const verb = (spec.verb ? spec.verb(m) : (m.groups?.['verb'] ?? 'ANY')).toUpperCase();
+            const id = kit.route(f.path, verb, joinRoute(m.groups?.['path']), line);
+            const target = (spec.handler ?? defaultHandler)(kit, f.path, m.groups?.['rest'] ?? '');
+            if (target) kit.emit(id, target, 'routes-to', 'route-table');
+            count += 1;
+        }
+    }
+    return count;
+}
+
+export interface FsRouteSpec {
+    /** The route of a path, or null when it is no page module. */
+    route: (p: string) => { verb: string; path: string } | null;
+}
+
+export function fsRoutes(kit: Kit, spec: FsRouteSpec): number {
+    let count = 0;
+    for (const p of kit.paths) {
+        const r = spec.route(p);
+        if (!r) continue;
+        kit.fileNode(p);
+        const id = kit.route(p, r.verb, r.path, 1);
+        kit.emit(id, p, 'routes-to', 'route-table');
+        count += 1;
+    }
+    return count;
+}
+
+export interface TableMappingSpec {
+    exts: readonly string[];
+    /** Marks the class it precedes or opens as mapped to a table. */
+    entity: RegExp;
+    /** The explicit table name, searched in the entity's declaration region; named group `name`. */
+    tableName?: RegExp;
+    /** The table a mapped class gets when nothing names one. */
+    convention?: (className: string) => string;
+    /** A migration or schema statement creating a table; named group `name`. */
+    migration?: { files: (p: string) => boolean; create: RegExp };
+}
+
+export function snakePlural(name: string): string {
+    const snake = name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+    if (/[^aeiou]y$/.test(snake)) return `${snake.slice(0, -1)}ies`;
+    if (/(s|x|z|ch|sh)$/.test(snake)) return `${snake}es`;
+    return `${snake}s`;
+}
+
+export function tableMapping(kit: Kit, spec: TableMappingSpec): number {
+    let count = 0;
+    if (spec.migration) {
+        for (const f of kit.files.filter((x) => spec.migration?.files(x.path))) {
+            const at = lineIndex(f.source);
+            for (const m of f.source.matchAll(spec.migration.create)) {
+                const name = m.groups?.['name'];
+                if (!name) continue;
+                kit.emit(f.path, kit.table(name, f.path, at(m.index as number)), 'migrates', 'schema-call');
+            }
+        }
+    }
+    for (const f of kit.filesWithExt(...spec.exts)) {
+        const at = lineIndex(f.source);
+        const lines = f.source.split('\n');
+        for (const m of f.source.matchAll(spec.entity)) {
+            const line = at(m.index as number);
+            const cls = kit.classAt(f.path, line) ?? kit.nextSymbol(f.path, line, ['class']);
+            if (!cls || cls.kind !== 'class') continue;
+            const start = cls.source_location[0] as number;
+            const end = (cls.source_location[2] ?? start) as number;
+            // Up to four lines of decorators above the class — but never past the
+            // end of the class before it, whose own table name would be read.
+            let floor = 0;
+            for (const n of kit.nodesInFile(f.path)) {
+                if (n.kind !== 'class' || n.id === cls.id) continue;
+                const nEnd = (n.source_location[2] ?? n.source_location[0]) as number;
+                if (nEnd < start && nEnd > floor) floor = nEnd;
+            }
+            const region = lines.slice(Math.max(floor, Math.min(line, start) - 1 - 4), end).join('\n');
+            const explicit = spec.tableName ? spec.tableName.exec(region)?.groups?.['name'] : undefined;
+            const name = explicit ?? spec.convention?.(cls.label);
+            if (!name) continue;
+            kit.emit(cls.id, kit.table(name, f.path, start), 'persists', 'schema-call');
+            count += 1;
+        }
+    }
+    return count;
+}
+
+export interface TemplateRootSpec {
+    exts: readonly string[];
+    /** A render call; named group `name` is the template as written. */
+    call: RegExp;
+    /** Directories templates live under, repo- or package-root-relative. */
+    roots: readonly string[];
+    /** Extensions tried when the name carries none. */
+    extensions: readonly string[];
+    /** Rewrite a name before lookup (`a.b` → `a/b`). */
+    normalize?: (name: string) => string;
+    /** Further template directories for one file, repo-relative (a folder its own source declares). */
+    rootsFor?: (file: SourceFile) => readonly string[];
+}
+
+export function templateRoots(kit: Kit, spec: TemplateRootSpec): number {
+    const inventory = new Set(kit.paths);
+    let count = 0;
+    for (const f of kit.filesWithExt(...spec.exts)) {
+        const at = lineIndex(f.source);
+        for (const m of f.source.matchAll(spec.call)) {
+            const raw = m.groups?.['name'];
+            if (!raw) continue;
+            const name = spec.normalize ? spec.normalize(raw) : raw;
+            const hasExt = /\.[A-Za-z0-9]+$/.test(path.posix.basename(name));
+            const hits = new Set<string>();
+            const dirs = [...kit.roots.flatMap((r) => spec.roots.map((t) => path.posix.join(r, t))), ...(spec.rootsFor?.(f) ?? [])];
+            for (const root of new Set(dirs)) {
+                for (const c of hasExt ? [path.posix.join(root, name)] : spec.extensions.map((x) => path.posix.join(root, `${name}${x}`))) {
+                    if (inventory.has(c)) hits.add(c);
+                }
+            }
+            if (hits.size !== 1) continue;
+            const target = [...hits][0] as string;
+            kit.fileNode(target);
+            kit.emit(kit.enclosing(f.path, at(m.index as number)), target, 'renders', 'directive-scan');
+            count += 1;
+        }
+    }
+    return count;
+}
+
+/** The class a node belongs to, for a method id `<file>#<Class>::<m>`. */
+export function classOf(n: CodeNode): string {
+    return n.id.split('::')[0] as string;
+}

package/src/scripts/code_graph/providers/shared/js.ts

@@ -0,0 +1,252 @@
+/**
+ * Mechanics the JavaScript providers share and the five extractors do not
+ * carry: resolving a module specifier and a default import, reading a route
+ * object literal, constructor injection, and the verb functions a route module
+ * exports.
+ *
+ * Same contract as the extractors: an edge only when its target exists; a
+ * specifier that is not relative, or a value built at runtime, gets no edge.
+ */
+import * as path from 'node:path';
+
+import type { CodeNode } from '../../types.js';
+import { joinRoute } from './extractors.js';
+import { type Kit, lineIndex } from './kit.js';
+
+const MODULE_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.vue', '.svelte'];
+
+/** A kit that sees only the code files `keep` accepts (one ORM among several sharing a decorator name). */
+export function scopeKit(kit: Kit, keep: (source: string) => boolean): Kit {
+    const files = kit.files.filter((f) => keep(f.source));
+    return { ...kit, files, filesWithExt: (...exts) => files.filter((f) => exts.some((x) => f.path.endsWith(x))) };
+}
+
+/** The project file a relative specifier written in `file` names; null for a package or alias specifier. */
+export function resolveModule(kit: Kit, file: string, spec: string): string | null {
+    if (!spec.startsWith('./') && !spec.startsWith('../')) return null;
+    const base = path.posix.join(path.posix.dirname(file), spec);
+    if (base.startsWith('..')) return null;
+    const known = (p: string): boolean => kit.fileIds.has(p) || kit.nodeById.has(p) || kit.hasPath(p);
+    if (/\.[A-Za-z0-9]+$/.test(path.posix.basename(base)) && known(base)) return base;
+    for (const c of [...MODULE_EXTS.map((x) => `${base}${x}`), ...MODULE_EXTS.map((x) => `${base}/index${x}`)]) if (known(c)) return c;
+    return null;
+}
+
+function symbolIn(kit: Kit, file: string, name: string): string | null {
+    for (const n of kit.nodesInFile(file)) if (n.label === name && n.kind !== 'method' && n.kind !== 'file') return n.id;
+    return null;
+}
+
+/** A module target: the named symbol inside it when it declares one, else the module file. */
+export function moduleTarget(kit: Kit, file: string, spec: string, member?: string): string | null {
+    const mod = resolveModule(kit, file, spec);
+    if (!mod) return null;
+    const sym = member ? symbolIn(kit, mod, member) : null;
+    if (sym) return sym;
+    kit.fileNode(mod);
+    return mod;
+}
+
+/**
+ * A component name as written in `file`: a same-file or named-import symbol
+ * (`kit.resolveName`), else a default import — the symbol of that name in the
+ * imported module, or the module file itself.
+ */
+export function resolveComponent(kit: Kit, file: string, name: string): string | null {
+    const named = kit.resolveName(file, name);
+    if (named) return named;
+    const src = kit.files.find((f) => f.path === file)?.source ?? '';
+    const esc = name.replace(/\$/g, '\\$');
+    const m = new RegExp(`\\bimport\\s+${esc}\\s*(?:,\\s*\\{[^}]*\\})?\\s+from\\s+(['"])([^'"]+)\\1`).exec(src);
+    return m ? moduleTarget(kit, file, m[2] as string, name) : null;
+}
+
+/**
+ * The object literal around `index`: its bounds, and its own top-level text with
+ * every nested `{}` and `[]` blanked (parentheses kept, so `() => import('./x')`
+ * stays readable). Null when `index` sits inside parentheses or a bracket first.
+ */
+export function objectAt(src: string, index: number): { start: number; end: number; flat: string } | null {
+    let depth = 0;
+    let start = -1;
+    for (let i = index - 1; i >= 0; i--) {
+        const c = src[i];
+        if (c === ')' || c === ']' || c === '}') depth += 1;
+        else if (c === '(' || c === '[' || c === '{') {
+            if (depth === 0) {
+                if (c !== '{') return null;
+                start = i;
+                break;
+            }
+            depth -= 1;
+        }
+    }
+    if (start < 0) return null;
+    const out: string[] = [];
+    const stack: string[] = [];
+    for (let i = start + 1; i < src.length; i++) {
+        const c = src[i] as string;
+        const nested = (): boolean => stack.some((s) => s !== '(');
+        if (c === '{' || c === '[' || c === '(') {
+            const blank = nested() || c !== '(';
+            stack.push(c);
+            out.push(blank ? ' ' : c);
+        } else if (c === '}' || c === ']' || c === ')') {
+            if (stack.length === 0) return { start, end: i, flat: out.join('') };
+            stack.pop();
+            out.push(nested() || c !== ')' ? ' ' : c);
+        } else out.push(nested() ? ' ' : c);
+    }
+    return null;
+}
+
+/** The text of `key: <value>` in a flat object, up to the next top-level comma. */
+export function valueOf(flat: string, key: string): string | null {
+    const m = new RegExp(`(?:^|[\\s,])${key}\\s*:`).exec(flat);
+    if (!m) return null;
+    let depth = 0;
+    const from = m.index + m[0].length;
+    for (let i = from; i < flat.length; i++) {
+        const c = flat[i];
+        if (c === '(') depth += 1;
+        else if (c === ')') depth -= 1;
+        else if (c === ',' && depth === 0) return flat.slice(from, i).trim();
+    }
+    return flat.slice(from).trim();
+}
+
+/** What a component value names: a dynamic import (with an optional `.then(m => m.X)`), a JSX element, or a name. */
+export function componentTarget(kit: Kit, file: string, value: string): string | null {
+    const imp = /\bimport\(\s*(['"`])([^'"`]+)\1\s*\)(?:\s*\.then\(\s*\(?\s*(\w+)\s*\)?\s*=>\s*\3\.(\w+)\s*\))?/.exec(value);
+    if (imp) return moduleTarget(kit, file, imp[2] as string, imp[4]);
+    const jsx = /^<\s*([A-Z][\w$]*)/.exec(value);
+    if (jsx) return resolveComponent(kit, file, jsx[1] as string);
+    if (/^[A-Za-z_$][\w$]*$/.test(value)) return resolveComponent(kit, file, value);
+    return null;
+}
+
+export interface RouteObjectSpec {
+    exts: readonly string[];
+    /** Keys whose value is the component a route renders; a `path` object with none of them is no route. */
+    componentKeys: readonly string[];
+}
+
+/** `{ path: '/x', component: X }` route objects → a PAGE route --routes-to--> the component or lazily imported module. */
+export function routeObjects(kit: Kit, spec: RouteObjectSpec): number {
+    let count = 0;
+    for (const f of kit.filesWithExt(...spec.exts)) {
+        const at = lineIndex(f.source);
+        for (const m of f.source.matchAll(/(?:^|[\s,{])path\s*:\s*(['"`])(?<path>[^'"`$]*)\1/g)) {
+            const obj = objectAt(f.source, m.index as number);
+            if (!obj) continue;
+            const values = spec.componentKeys.map((k) => valueOf(obj.flat, k)).filter((v): v is string => v !== null);
+            if (values.length === 0) continue;
+            const id = kit.route(f.path, 'PAGE', joinRoute(m.groups?.['path']), at(m.index as number));
+            for (const v of values) {
+                const target = componentTarget(kit, f.path, v);
+                if (target) kit.emit(id, target, 'routes-to', 'route-table');
+            }
+            count += 1;
+        }
+    }
+    return count;
+}
+
+function symbolsOf(kit: Kit, file: string, kind: CodeNode['kind']): CodeNode[] {
+    return kit.nodesInFile(file).filter((n) => n.kind === kind);
+}
+
+/** The parameter list of the first `constructor(` in `text`, balanced. */
+function constructorParams(text: string): string[] {
+    const m = /\bconstructor\s*\(/.exec(text);
+    if (!m) return [];
+    let depth = 0;
+    const from = m.index + m[0].length;
+    const parts: string[] = [];
+    let cur = '';
+    for (let i = from; i < text.length; i++) {
+        const c = text[i] as string;
+        if (c === '(' || c === '<' || c === '[' || c === '{') depth += 1;
+        else if (c === ')' || c === '>' || c === ']' || c === '}') {
+            if (depth === 0) break;
+            depth -= 1;
+        }
+        if (c === ',' && depth === 0) {
+            parts.push(cur);
+            cur = '';
+        } else cur += c;
+    }
+    if (cur.trim()) parts.push(cur);
+    return parts;
+}
+
+export interface InjectionSpec {
+    exts: readonly string[];
+    /** A class decorator marking the class as container-managed, searched just above the class. */
+    classDecorator: RegExp;
+    /** How far above the class its decorator may sit, in lines. */
+    reach?: number;
+    /** A field initializer naming the dependency (`inject(X)`); group 1 is the type. */
+    injectCall?: RegExp;
+}
+
+/** `constructor(private readonly s: UsersService)` in a decorated class → class --injects--> UsersService. */
+export function constructorInjection(kit: Kit, spec: InjectionSpec): number {
+    let count = 0;
+    for (const f of kit.filesWithExt(...spec.exts)) {
+        const lines = f.source.split('\n');
+        for (const cls of symbolsOf(kit, f.path, 'class')) {
+            const start = cls.source_location[0] as number;
+            const end = (cls.source_location[2] ?? start) as number;
+            const above = lines.slice(Math.max(0, start - 1 - (spec.reach ?? 6)), start).join('\n');
+            if (!spec.classDecorator.test(above)) continue;
+            const body = lines.slice(start - 1, end).join('\n');
+            const types: string[] = [];
+            for (const p of constructorParams(body)) {
+                const t = /^\s*(?:@\w+\([^)]*\)\s*)*(?:(?:public|private|protected|readonly)\s+)*[A-Za-z_$][\w$]*\??\s*:\s*([A-Za-z_$][\w$]*)/.exec(p);
+                if (t) types.push(t[1] as string);
+            }
+            if (spec.injectCall) for (const m of body.matchAll(spec.injectCall)) types.push(m[1] as string);
+            for (const t of types) {
+                const target = kit.resolveName(f.path, t);
+                if (!target || target === cls.id || kit.nodeById.get(target)?.kind !== 'class') continue;
+                kit.emit(cls.id, target, 'injects', 'di-binding');
+                count += 1;
+            }
+        }
+    }
+    return count;
+}
+
+export const HTTP_VERBS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'] as const;
+
+/** `export async function GET()` · `export const POST = …` in a route module → one route per verb → that function. */
+export function exportedVerbRoutes(kit: Kit, file: string, routePath: string): number {
+    const src = kit.files.find((f) => f.path === file)?.source;
+    if (src === undefined) return 0;
+    const at = lineIndex(src);
+    let count = 0;
+    const re = new RegExp(`\\bexport\\s+(?:async\\s+function|function|const|let)\\s+(${HTTP_VERBS.join('|')})\\b`, 'g');
+    for (const m of src.matchAll(re)) {
+        const verb = m[1] as string;
+        const id = kit.route(file, verb, routePath, at(m.index as number));
+        const target = kit.resolveName(file, verb);
+        if (target) kit.emit(id, target, 'routes-to', 'route-table');
+        count += 1;
+    }
+    return count;
+}
+
+/** `p` relative to the deepest of `roots` it lies under, with that root; null when under none. */
+export function underRoot(roots: readonly string[], p: string): { root: string; rel: string } | null {
+    for (const root of [...roots].sort((a, b) => b.length - a.length)) {
+        if (root === '') return { root, rel: p };
+        if (p.startsWith(`${root}/`)) return { root, rel: p.slice(root.length + 1) };
+    }
+    return null;
+}
+
+/** Route segments as the default pass writes them: groups, slots and `index` dropped. */
+export function cleanRoute(parts: readonly string[]): string {
+    return `/${parts.filter((s) => !/^\(.*\)$/.test(s) && !s.startsWith('@') && s !== 'index').join('/')}`.replace(/\/$/, '') || '/';
+}