context-slice 1.8.2

package/dist/src/languages/go/resolve.js

@@ -0,0 +1,313 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+/** Go's package boundary is per-directory, never by matching package-clause name strings. */
+function directoryOf(filePath) {
+    const dir = dirname(filePath);
+    return dir === "." ? "" : dir;
+}
+function readModulePath(goModDir) {
+    try {
+        const text = readFileSync(join(goModDir, "go.mod"), "utf8");
+        return text.match(/^module\s+(\S+)/m)?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The directories a go.work file lists under `use`, supporting both the block form
+ * ("use (\n\t./a\n\t./b\n)") and repeated single-line directives ("use ./a\nuse ./b"). */
+function parseGoWorkUseDirs(text) {
+    const dirs = [];
+    const block = text.match(/use\s*\(([^)]*)\)/s);
+    if (block) {
+        for (const line of block[1].split("\n")) {
+            const dir = line.trim().split(/\s+/)[0];
+            if (dir)
+                dirs.push(dir);
+        }
+    }
+    for (const m of text.matchAll(/^use\s+(\.\S+)/gm))
+        dirs.push(m[1]);
+    return dirs;
+}
+function normalizeWorkspaceDir(relDir) {
+    return relDir.replace(/^\.\//, "").replace(/\/$/, "").replace(/^\.$/, "");
+}
+/** Every module this project can resolve imports into: the modules a go.work file lists under
+ * `use` (a multi-module workspace), or else the single module at this project's own go.mod (the
+ * common case). No go.work and no go.mod means no imports resolve to project code — the correct
+ * safe fallback, not a special case. */
+function discoverModules(root) {
+    let workText;
+    try {
+        workText = readFileSync(join(root, "go.work"), "utf8");
+    }
+    catch {
+        workText = undefined;
+    }
+    if (workText !== undefined) {
+        const modules = [];
+        for (const relDir of parseGoWorkUseDirs(workText)) {
+            const dir = normalizeWorkspaceDir(relDir);
+            const path = readModulePath(join(root, dir));
+            if (path)
+                modules.push({ path, dir });
+        }
+        return modules;
+    }
+    const rootPath = readModulePath(root);
+    return rootPath ? [{ path: rootPath, dir: "" }] : [];
+}
+/** A method's own receiver variable name, e.g. "u" in "func (u *User) Name(...)" — read directly
+ * off the symbol's own .source text rather than re-deriving it from parse.ts, since Phase 1
+ * already formats every method's signature/source starting with its receiver clause. */
+function receiverVarNameOf(method) {
+    return method.source.match(/^func\s*\(\s*(\w+)\s+/)?.[1];
+}
+/** Narrow, regex-based binding-type inference over a function body — mirrors
+ * src/languages/python/resolve.ts's bindingClass exactly: single unambiguous assignment only,
+ * any reassignment or multiple bindings drop the evidence rather than guessing. Captures an
+ * optional package-qualified form ("pkg.Type") alongside the bare form ("Type"). */
+function bindingTypeInBody(body, receiver) {
+    const literalOrVar = new RegExp(`(?<![\\w.])${receiver}\\s*:?=\\s*(?:&)?(?:([A-Za-z_]\\w*)\\.)?([A-Za-z_]\\w*)\\s*\\{` +
+        `|var\\s+${receiver}\\s+\\*?(?:([A-Za-z_]\\w*)\\.)?([A-Za-z_]\\w*)\\b`, "g");
+    const matches = [...body.matchAll(literalOrVar)];
+    const reassignments = [...body.matchAll(new RegExp(`(?<![\\w.:])${receiver}\\s*=[^=]`, "g"))].length;
+    if (matches.length === 1 && reassignments === 0) {
+        const [, literalPkg, literalType, varPkg, varType] = matches[0];
+        if (literalType)
+            return { pkg: literalPkg, type: literalType };
+        if (varType)
+            return { pkg: varPkg, type: varType };
+    }
+    if (matches.length === 0 && reassignments === 0) {
+        const ctor = body.match(new RegExp(`(?<![\\w.])${receiver}\\s*:=\\s*(?:([A-Za-z_]\\w*)\\.)?(New[A-Za-z_]\\w*)\\s*\\(`));
+        if (ctor)
+            return { pkg: ctor[1], ctorName: ctor[2] };
+    }
+    return undefined;
+}
+/** A struct's own embedded field TYPES (not all fields) — same-directory lookup only, cycle-safe. */
+function embeddedTypesOf(struct, byDirectory, visited) {
+    const dir = directoryOf(struct.filePath);
+    const siblings = byDirectory.get(dir) ?? [];
+    const types = [];
+    for (const f of siblings) {
+        if (f.kind !== "field" || f.parentId !== struct.id || !f.metadata?.embedded)
+            continue;
+        const embeddedType = siblings.find((s) => s.kind === "class" && s.name === f.name);
+        if (embeddedType && !visited.has(embeddedType.id)) {
+            visited.add(embeddedType.id);
+            types.push(embeddedType);
+        }
+    }
+    return types;
+}
+/** BFS one promotion-depth level at a time; a match at a shallower depth shadows deeper ones;
+ * multiple matches at the SAME depth are ambiguous (Go itself rejects this at compile time). */
+function findPromotedMethod(struct, methodName, byDirectory) {
+    const visited = new Set([struct.id]);
+    let frontier = embeddedTypesOf(struct, byDirectory, visited);
+    while (frontier.length) {
+        const matches = frontier
+            .map((t) => (byDirectory.get(directoryOf(t.filePath)) ?? []).find((s) => s.kind === "method" && s.name === methodName && s.supertypes?.includes(t.name)))
+            .filter((m) => Boolean(m));
+        if (matches.length === 1)
+            return matches[0];
+        if (matches.length > 1)
+            return "ambiguous";
+        const next = [];
+        for (const t of frontier)
+            next.push(...embeddedTypesOf(t, byDirectory, visited));
+        frontier = next;
+    }
+    return undefined;
+}
+/** Every method reachable from a struct, name -> its own normalized signature: its direct methods,
+ * plus every method reachable via embedding at any depth (a shallower method shadows a deeper
+ * same-named one, mirroring findPromotedMethod's own depth-shadowing — unlike call resolution's
+ * mere "is this name reachable at all", interface satisfaction needs the signature that would
+ * actually be promoted, so a same-name-different-signature method at a deeper level must not win). */
+function methodSetOf(struct, byDirectory) {
+    const methods = new Map();
+    const collectDirect = (type) => {
+        for (const s of byDirectory.get(directoryOf(type.filePath)) ?? [])
+            if (s.kind === "method" && s.supertypes?.includes(type.name) && !methods.has(s.name))
+                methods.set(s.name, s.metadata?.methodSignature ?? "");
+    };
+    collectDirect(struct);
+    const visited = new Set([struct.id]);
+    let frontier = embeddedTypesOf(struct, byDirectory, visited);
+    while (frontier.length) {
+        const next = [];
+        for (const t of frontier) {
+            collectDirect(t);
+            next.push(...embeddedTypesOf(t, byDirectory, visited));
+        }
+        frontier = next;
+    }
+    return methods;
+}
+function resolveInterfaceSatisfaction(symbols, byDirectory) {
+    // Go's interface satisfaction is structural and project-wide, not package-scoped: a struct in
+    // package "impl" can satisfy an interface declared in package "contract" with no import between
+    // them. Interfaces and structs are therefore collected across every directory, not grouped by one.
+    const interfaces = symbols.filter((s) => s.kind === "interface" && s.metadata?.interfaceMethods);
+    const structs = symbols.filter((s) => s.kind === "class");
+    for (const struct of structs) {
+        const methods = methodSetOf(struct, byDirectory);
+        // Recomputed from scratch every pass, not appended to: struct.supertypes is owned entirely
+        // by this resolver (parse.ts never sets it on struct symbols), and ProjectIndex.rebuild()
+        // reuses persisted symbols across incremental rebuilds, so appending would duplicate entries
+        // on every rebuild and never drop a stale one.
+        const satisfied = [];
+        for (const iface of interfaces) {
+            const required = iface.metadata.interfaceMethods;
+            const signatures = iface.metadata.interfaceMethodSignatures ?? {};
+            // Exact-signature match: a method of the same name but a different parameter/result
+            // shape does not satisfy the interface, matching Go's own compile-time rule.
+            if (required.length > 0 && required.every((name) => methods.get(name) === signatures[name])) {
+                satisfied.push(iface.name);
+            }
+        }
+        struct.supertypes = satisfied;
+    }
+}
+function settle(call, target, kind, evidence) {
+    call.resolvedTargetId = target.id;
+    call.resolutionKind = kind;
+    call.confidence = "exact";
+    call.evidence = [...call.evidence, evidence];
+}
+export function resolveGoCalls(context) {
+    const symbolsById = new Map(context.symbols.map((s) => [s.id, s]));
+    const byDirectory = new Map();
+    for (const symbol of context.symbols) {
+        const dir = directoryOf(symbol.filePath);
+        const list = byDirectory.get(dir) ?? [];
+        list.push(symbol);
+        byDirectory.set(dir, list);
+    }
+    const modules = discoverModules(context.root);
+    const importsByFile = new Map();
+    for (const record of context.imports) {
+        const list = importsByFile.get(record.filePath) ?? [];
+        list.push(record);
+        importsByFile.set(record.filePath, list);
+    }
+    const resolveDirectCall = (call, caller) => {
+        const candidates = (byDirectory.get(directoryOf(caller.filePath)) ?? []).filter((s) => s.kind === "function" && s.name === call.calleeName);
+        if (candidates.length === 1)
+            settle(call, candidates[0], "same-file", "same-package direct call");
+    };
+    // Go modules convention: a module path at major version >=2 ends in "/vN" (go.dev/ref/mod#major-version-suffixes),
+    // but the package's own declared name is unaffected, e.g. "github.com/go-chi/chi/v5" is still used as "chi.Foo(...)".
+    // Strip that suffix before taking the last path segment for the unaliased case. Known limitation: a package whose
+    // real (unversioned) last segment happens to look like "vN" itself is not handled — rare enough not to special-case.
+    const importLocalName = (record) => record.localName ?? record.module.replace(/\/v\d+$/, "").split("/").pop();
+    // Shared by resolveQualifiedCall (pkg.Func()) and resolveMethodCall (x.Method() where x's type
+    // is pkg.Type): maps an import alias, as used in the caller's file, to that package's directory
+    // within THIS module. undefined means the alias is unresolvable or names an external package.
+    const resolveImportDirectory = (alias, callerFilePath) => {
+        const record = (importsByFile.get(callerFilePath) ?? []).find((r) => importLocalName(r) === alias);
+        if (!record)
+            return undefined;
+        for (const mod of modules) {
+            if (record.module === mod.path || record.module.startsWith(mod.path + "/")) {
+                const withinModule = record.module.slice(mod.path.length).replace(/^\//, "");
+                return [mod.dir, withinModule].filter(Boolean).join("/");
+            }
+        }
+        return undefined;
+    };
+    const resolveQualifiedCall = (call, caller) => {
+        if (!call.receiverText || !/^[A-Z]/.test(call.calleeName))
+            return false; // unexported: never a package-qualified target
+        const record = (importsByFile.get(caller.filePath) ?? []).find((r) => importLocalName(r) === call.receiverText);
+        if (!record)
+            return false;
+        const relative = resolveImportDirectory(call.receiverText, caller.filePath);
+        if (relative === undefined) {
+            call.externalPackage = record.module;
+            return false;
+        }
+        const candidates = (byDirectory.get(relative) ?? []).filter((s) => s.kind === "function" && s.name === call.calleeName && s.modifiers.includes("exported"));
+        if (candidates.length === 1) {
+            settle(call, candidates[0], "imported", "package-qualified import call");
+            return true;
+        }
+        return false;
+    };
+    const resolveMethodCall = (call, caller) => {
+        if (!call.receiverText)
+            return;
+        let typeName;
+        let pkgAlias;
+        if (caller.kind === "method" && caller.supertypes?.[0] && receiverVarNameOf(caller) === call.receiverText) {
+            typeName = caller.supertypes[0];
+        }
+        else {
+            const bound = bindingTypeInBody(caller.body ?? caller.source, call.receiverText);
+            pkgAlias = bound?.pkg;
+            if (bound && "type" in bound) {
+                typeName = bound.type;
+            }
+            else if (bound && "ctorName" in bound) {
+                // The real constructed type is whatever the constructor itself declares as its return
+                // type, not a name guessed from the constructor's own name (e.g. "NewFoo" returning *Bar).
+                const ctorDir = pkgAlias ? resolveImportDirectory(pkgAlias, caller.filePath) : directoryOf(caller.filePath);
+                const ctorFn = ctorDir === undefined
+                    ? undefined
+                    : (byDirectory.get(ctorDir) ?? []).find((s) => s.kind === "function" &&
+                        s.name === bound.ctorName &&
+                        (!pkgAlias || s.modifiers.includes("exported")));
+                typeName = ctorFn?.metadata?.returnType;
+            }
+        }
+        if (!typeName)
+            return;
+        let dir;
+        if (pkgAlias) {
+            if (!/^[A-Z]/.test(call.calleeName))
+                return; // unexported: never callable from another package
+            const resolved = resolveImportDirectory(pkgAlias, caller.filePath);
+            if (resolved === undefined)
+                return; // external or unresolvable package alias
+            dir = resolved;
+        }
+        else {
+            dir = directoryOf(caller.filePath);
+        }
+        // A cross-package match must itself be exported; a same-package match needs no such check,
+        // since it's reached the same way an unexported method is legitimately called in Go.
+        const requireExported = Boolean(pkgAlias);
+        const directMethod = (byDirectory.get(dir) ?? []).find((s) => s.kind === "method" &&
+            s.name === call.calleeName &&
+            s.supertypes?.includes(typeName) &&
+            (!requireExported || s.modifiers.includes("exported")));
+        if (directMethod) {
+            settle(call, directMethod, "same-type", "receiver-type method call");
+            return;
+        }
+        const struct = (byDirectory.get(dir) ?? []).find((s) => s.kind === "class" && s.name === typeName);
+        if (!struct)
+            return;
+        const promoted = findPromotedMethod(struct, call.calleeName, byDirectory);
+        if (promoted && promoted !== "ambiguous" && (!requireExported || promoted.modifiers.includes("exported"))) {
+            settle(call, promoted, "same-type", "struct embedding method promotion");
+        }
+    };
+    for (const call of context.calls) {
+        const caller = symbolsById.get(call.callerId);
+        if (!caller)
+            continue;
+        if (!call.receiverText) {
+            resolveDirectCall(call, caller);
+            continue;
+        }
+        if (resolveQualifiedCall(call, caller))
+            continue;
+        resolveMethodCall(call, caller);
+    }
+    resolveInterfaceSatisfaction(context.symbols, byDirectory);
+}

package/dist/src/languages/java/enterprise/dependency-injection.js

@@ -0,0 +1,175 @@
+import { registerEnterpriseExtractor, registerEnterpriseResolver } from "./registry.js";
+// Two-phase design: the per-file extractor only records injection points (type name,
+// optional @Qualifier) as provisional "unresolved" relations; bean identity (§13) needs
+// every project class/interface, so resolveDependencyRelations runs as a post-pass once
+// all files are parsed (see registry.ts resolveEnterpriseRelations).
+const QUALIFIER_RE = /@Qualifier\s*\(\s*(?:value\s*=\s*)?"([^"]*)"\s*\)/;
+const STEREOTYPES = new Set(["Component", "Service", "Repository", "Controller", "RestController", "Configuration"]);
+const INJECT_ANNOTATIONS = new Set(["Autowired", "Inject", "Resource"]);
+/** Strips a leading "@" and any dotted package prefix, e.g. "@org.springframework...Autowired" -> "Autowired". */
+function bareName(annotation) {
+    return annotation.slice(annotation.lastIndexOf(".") + 1).replace("@", "");
+}
+/** Text between the first top-level "(" and its matching ")", string-aware. */
+function firstParenGroup(text) {
+    let inString = false;
+    let depth = 0;
+    let start = -1;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '"' && text[i - 1] !== "\\")
+            inString = !inString;
+        if (inString)
+            continue;
+        if (ch === "(" && depth++ === 0)
+            start = i + 1;
+        else if (ch === ")" && --depth === 0)
+            return text.slice(start, i);
+    }
+    return undefined;
+}
+/** Splits on commas outside (), <>, and strings. */
+function splitTopLevel(text) {
+    const parts = [];
+    let inString = false;
+    let depth = 0;
+    let last = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '"' && text[i - 1] !== "\\")
+            inString = !inString;
+        if (inString)
+            continue;
+        if (ch === "(" || ch === "<")
+            depth++;
+        else if (ch === ")" || ch === ">")
+            depth--;
+        else if (ch === "," && depth === 0) {
+            parts.push(text.slice(last, i));
+            last = i + 1;
+        }
+    }
+    parts.push(text.slice(last));
+    return parts.map((p) => p.trim()).filter(Boolean);
+}
+/** "@Qualifier("x") final a.b.Repo repo" -> { type: "Repo", name: "repo", qualifier: "x" }. */
+function parseDeclaration(text) {
+    const qualifier = text.match(QUALIFIER_RE)?.[1];
+    const bare = text
+        .replace(/@[\w.]+(?:\s*\([^)]*\))?/g, " ")
+        .replace(/\b(?:final|private|protected|public|static|transient|volatile)\b/g, " ")
+        .trim();
+    // ponytail: generic wrappers (List<Repo>, Optional<Repo>) resolve by the outer type, which
+    // is never a project class, so they produce no relation; unwrap if collection DI matters.
+    const match = bare.match(/^((?:[\w$]+\.)*([\w$]+))\s*(?:<.*>)?\s*(?:\[\s*\])*\s+([\w$]+)$/s);
+    if (!match)
+        return undefined;
+    return { type: match[2], name: match[3], qualifier };
+}
+function relation(source, filePath, decl, evidence) {
+    return {
+        kind: "INJECTS_DEPENDENCY",
+        family: "dependency-injection",
+        sourceSymbolId: source.id,
+        targetLabel: decl.type,
+        confidence: "unresolved", // provisional until resolveDependencyRelations runs
+        evidence: decl.qualifier !== undefined ? [evidence, `@Qualifier("${decl.qualifier}")`] : [evidence],
+        range: source.range,
+        filePath,
+    };
+}
+function extractDependencyInjection(symbols, filePath, _source) {
+    const own = symbols.filter((s) => s.filePath === filePath);
+    const relations = [];
+    // Constructor injection first (§12 preference ordering). Gated: only a Spring-managed class
+    // (stereotype) or an explicitly @Autowired/@Inject constructor counts, so value objects like
+    // Order(Customer c) never become false "exact" edges (§57).
+    const seen = new Set();
+    for (const ctor of own.filter((s) => s.kind === "constructor")) {
+        // parseJava can emit an annotated constructor twice (same range/source, "#2" id); keep one.
+        const key = `${ctor.range.startLine}:${ctor.range.startColumn}:${ctor.source}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const cls = own.find((s) => s.id === ctor.parentId);
+        const stereotyped = cls?.annotations.some((a) => STEREOTYPES.has(bareName(a)));
+        const annotated = ctor.annotations.some((a) => bareName(a) === "Autowired" || bareName(a) === "Inject");
+        if (!stereotyped && !annotated)
+            continue;
+        const params = firstParenGroup(ctor.source);
+        if (!params)
+            continue;
+        for (const param of splitTopLevel(params)) {
+            const decl = parseDeclaration(param);
+            if (decl)
+                relations.push(relation(ctor, filePath, decl, `constructor parameter ${decl.type} ${decl.name}`));
+        }
+    }
+    // Field injection, using field symbols directly (Phase 0 AST rewrite) instead of a
+    // regex scan over class-member text.
+    for (const field of own.filter((s) => s.kind === "field")) {
+        const annotation = field.annotations.find((a) => INJECT_ANNOTATIONS.has(bareName(a)));
+        if (!annotation)
+            continue;
+        const cls = own.find((s) => s.id === field.parentId);
+        if (!cls)
+            continue;
+        const decl = parseDeclaration(`${field.metadata?.declaredType ?? ""} ${field.name}`);
+        if (!decl)
+            continue;
+        const hasQualifier = field.annotations.some((a) => bareName(a) === "Qualifier");
+        decl.qualifier ??= hasQualifier ? field.source.match(QUALIFIER_RE)?.[1] : undefined;
+        relations.push(relation(cls, filePath, decl, `@${bareName(annotation)} field ${decl.type} ${field.name}`));
+    }
+    // Explicit setter injection, using method symbols directly.
+    for (const method of own.filter((s) => s.kind === "method")) {
+        const annotation = method.annotations.find((a) => INJECT_ANNOTATIONS.has(bareName(a)));
+        if (!annotation)
+            continue;
+        // method.source includes any leading annotations (tree-sitter's method_declaration node
+        // starts at the modifiers); strip them first so a parenthesized annotation argument (e.g.
+        // @Autowired(required = false)) isn't mistaken by firstParenGroup for the method's own params.
+        const bodyText = method.source.replace(/^(?:\s*@[\w.]+(?:\s*\([^)]*\))?\s*)*/, "");
+        const params = firstParenGroup(bodyText);
+        if (params === undefined)
+            continue;
+        const hasQualifier = method.annotations.some((a) => bareName(a) === "Qualifier");
+        const qualifier = hasQualifier ? method.source.match(QUALIFIER_RE)?.[1] : undefined;
+        for (const param of splitTopLevel(params)) {
+            const p = parseDeclaration(param);
+            if (!p)
+                continue;
+            p.qualifier ??= qualifier;
+            relations.push(relation(method, filePath, p, `${annotation} setter ${method.name}(${p.type})`));
+        }
+    }
+    return relations;
+}
+/**
+ * Bean identity (§13): exactly one project class/interface with the simple name -> exact;
+ * several -> unresolved (never a guessed winner); zero -> not a bean. A @Qualifier value is
+ * kept as evidence only: candidates all share the simple name, so it can't break a tie.
+ */
+export function resolveBeanType(typeName, projectTypes) {
+    const candidates = projectTypes.filter((s) => s.name === typeName);
+    if (candidates.length === 0)
+        return undefined;
+    if (candidates.length === 1)
+        return { confidence: "exact", targetSymbolId: candidates[0].id };
+    return { confidence: "unresolved" };
+}
+/** Post-pass: fills in bean identity for DI relations; drops ones naming no project type. */
+export function resolveDependencyRelations(relations, allSymbols) {
+    const projectTypes = allSymbols.filter((s) => s.kind === "class" || s.kind === "interface");
+    return relations.flatMap((r) => {
+        if (r.kind !== "INJECTS_DEPENDENCY" || r.family !== "dependency-injection")
+            return [r];
+        const resolved = resolveBeanType(r.targetLabel ?? "", projectTypes);
+        if (!resolved)
+            return [];
+        const { targetSymbolId: _stale, ...rest } = r;
+        return [{ ...rest, ...resolved }];
+    });
+}
+registerEnterpriseExtractor(extractDependencyInjection);
+registerEnterpriseResolver(resolveDependencyRelations);

package/dist/src/languages/java/enterprise/jpa-entity.js

@@ -0,0 +1,89 @@
+import { registerEnterpriseExtractor, registerEnterpriseResolver } from "./registry.js";
+// Two-phase, like dependency-injection.ts: the per-file extractor emits provisional
+// "unresolved" ENTITY_RELATIONs whose targetLabel carries the raw target simple name
+// (the side-channel the resolver reads); resolveEntityRelations then applies the
+// unique-simple-name rule once every project symbol is known.
+const RELATION_ANNOTATIONS = new Set(["OneToOne", "OneToMany", "ManyToOne", "ManyToMany"]);
+const COLLECTION_RE = /\b(?:List|Set|Collection)<\s*([\w.]+)\s*>/;
+/** Strips a leading "@" and any dotted package prefix, e.g. "@javax.persistence.ManyToOne" -> "ManyToOne". */
+function bareName(annotation) {
+    return annotation.slice(annotation.lastIndexOf(".") + 1).replace("@", "");
+}
+/**
+ * Matches ONE specific, already-AST-confirmed relationship annotation's own argument text
+ * (mappedBy/fetch/cascade). Detection of WHICH relationship annotation (if any) is present
+ * happens via SymbolRecord.annotations, never via this regex -- this only ever runs to
+ * extract an argument list for a name already known to be real. The optional
+ * `(?:[\w.]+\.)?` prefix tolerates a fully-qualified annotation name the same way
+ * bareName() already tolerates one for detection.
+ */
+function relationArgsRegex(name) {
+    return new RegExp(`@(?:[\\w.]+\\.)?${name}\\b(?:\\s*\\(([^)]*)\\))?`);
+}
+/** Same qualified-name-tolerant pattern as relationArgsRegex, for the fixed @JoinColumn name. */
+function joinColumnArgsRegex() {
+    return /@(?:[\w.]+\.)?JoinColumn\s*\(([^)]*)\)/;
+}
+/** Explicit mappedBy/fetch/cascade only (§26-27): anything absent stays absent. */
+function explicitAttributes(args) {
+    const found = [];
+    const mappedBy = args.match(/\bmappedBy\s*=\s*("[^"]*")/)?.[1];
+    if (mappedBy)
+        found.push(`mappedBy = ${mappedBy}`);
+    const fetch = args.match(/\bfetch\s*=\s*([\w.]+)/)?.[1];
+    if (fetch)
+        found.push(`fetch = ${fetch}`);
+    const cascade = args.match(/\bcascade\s*=\s*(\{[^}]*\}|[\w.]+)/)?.[1];
+    if (cascade)
+        found.push(`cascade = ${cascade}`);
+    return found;
+}
+function extractEntityRelations(symbols, filePath, _source) {
+    const relations = [];
+    const entities = symbols.filter((s) => s.filePath === filePath && s.kind === "class" && s.annotations.includes("@Entity"));
+    for (const entity of entities) {
+        const fields = symbols.filter((s) => s.kind === "field" && s.parentId === entity.id);
+        for (const field of fields) {
+            const relationName = field.annotations.map(bareName).find((name) => RELATION_ANNOTATIONS.has(name));
+            if (!relationName)
+                continue;
+            const relationMatch = field.source.match(relationArgsRegex(relationName));
+            const typeText = field.metadata?.declaredType ?? "";
+            const rawTarget = typeText.match(COLLECTION_RE)?.[1] ?? typeText.replace(/<.*>/s, "").trim();
+            const hasJoinColumn = field.annotations.some((a) => bareName(a) === "JoinColumn");
+            const joinColumn = hasJoinColumn ? field.source.match(joinColumnArgsRegex())?.[1] : undefined;
+            relations.push({
+                kind: "ENTITY_RELATION",
+                family: "spring-data-jpa",
+                sourceSymbolId: entity.id,
+                targetLabel: rawTarget.slice(rawTarget.lastIndexOf(".") + 1),
+                confidence: "unresolved", // provisional until resolveEntityRelations runs
+                evidence: [
+                    `@${relationName} on field ${field.name}`,
+                    ...explicitAttributes(relationMatch?.[1] ?? ""),
+                    ...(joinColumn !== undefined ? [`@JoinColumn(${joinColumn.trim()})`] : []),
+                ],
+                range: entity.range,
+                filePath,
+            });
+        }
+    }
+    return relations;
+}
+/** Same rule as DI bean identity: 1 match exact, 0 dropped, 2+ unresolved (never guessed). */
+function resolveEntityRelations(relations, allSymbols) {
+    const projectTypes = allSymbols.filter((s) => s.kind === "class" || s.kind === "interface");
+    return relations.flatMap((r) => {
+        if (r.kind !== "ENTITY_RELATION" || r.family !== "spring-data-jpa")
+            return [r];
+        const candidates = projectTypes.filter((s) => s.name === r.targetLabel);
+        if (candidates.length === 0)
+            return [];
+        const { targetSymbolId: _stale, ...rest } = r;
+        if (candidates.length > 1)
+            return [{ ...rest, confidence: "unresolved" }];
+        return [{ ...rest, confidence: "exact", targetSymbolId: candidates[0].id }];
+    });
+}
+registerEnterpriseExtractor(extractEntityRelations);
+registerEnterpriseResolver(resolveEntityRelations);

package/dist/src/languages/java/enterprise/registry.js

@@ -0,0 +1,22 @@
+let extractors = [];
+let resolvers = [];
+/** Called once per family module at import time, mirroring registerLanguage in languages/adapter.ts. */
+export function registerEnterpriseExtractor(extractor) {
+    extractors.push(extractor);
+}
+/** Runs every registered family extractor over one file's symbols and unions the results. */
+export function extractEnterpriseRelations(symbols, filePath, source) {
+    return extractors.flatMap((extractor) => extractor(symbols, filePath, source));
+}
+export function registerEnterpriseResolver(resolver) {
+    resolvers.push(resolver);
+}
+/** Runs every registered resolver in turn over the complete relation and symbol sets. */
+export function resolveEnterpriseRelations(relations, allSymbols) {
+    return resolvers.reduce((acc, resolver) => resolver(acc, allSymbols), relations);
+}
+/** Test-only: clears registrations between test files so registry state doesn't leak. */
+export function __resetEnterpriseExtractorsForTests() {
+    extractors = [];
+    resolvers = [];
+}