gitnexus 1.6.10-rc.55 → 1.6.10-rc.57

package/dist/core/analysis-features.d.ts

@@ -0,0 +1,21 @@
+/** A durable statement that one analysis capability was produced by this build. */
+export interface AnalysisFeatureDescriptor {
+    readonly id: string;
+    readonly version: number;
+    readonly appliesTo: (filePaths: readonly string[]) => boolean;
+}
+export type AnalysisFeatureVersions = Readonly<Record<string, number>>;
+/**
+ * The Class table shape is global even when a repository contains no JVM code.
+ * Existing v8 indexes predate the frameworkAnnotations column and therefore
+ * need one full rebuild before any incremental Class write can be safe.
+ */
+export declare const CLASS_FRAMEWORK_ANNOTATIONS_FEATURE: AnalysisFeatureDescriptor;
+/** Resolve the exact feature set this build promises for the supplied files. */
+export declare function resolveAnalysisFeatureVersions(descriptors: readonly AnalysisFeatureDescriptor[], filePaths: readonly string[]): Record<string, number>;
+/**
+ * Compare an untrusted metadata value with the exact capabilities produced by
+ * this build. Extra keys also mismatch: a rollback must rebuild instead of
+ * certifying graph semantics emitted only by a newer binary.
+ */
+export declare function findAnalysisFeatureMismatches(actual: unknown, expected: AnalysisFeatureVersions): readonly string[];

package/dist/core/analysis-features.js

@@ -0,0 +1,59 @@
+/**
+ * The Class table shape is global even when a repository contains no JVM code.
+ * Existing v8 indexes predate the frameworkAnnotations column and therefore
+ * need one full rebuild before any incremental Class write can be safe.
+ */
+export const CLASS_FRAMEWORK_ANNOTATIONS_FEATURE = {
+    id: 'graph.class-framework-annotations',
+    version: 1,
+    appliesTo: () => true,
+};
+/** Resolve the exact feature set this build promises for the supplied files. */
+export function resolveAnalysisFeatureVersions(descriptors, filePaths) {
+    const resolved = new Map();
+    const seenIds = new Set();
+    for (const descriptor of descriptors) {
+        if (descriptor.id.trim().length === 0) {
+            throw new Error('Analysis feature descriptor id must not be empty');
+        }
+        if (!Number.isSafeInteger(descriptor.version) || descriptor.version < 1) {
+            throw new Error(`Analysis feature "${descriptor.id}" has invalid version ${descriptor.version}`);
+        }
+        if (seenIds.has(descriptor.id)) {
+            throw new Error(`Duplicate analysis feature descriptor: ${descriptor.id}`);
+        }
+        seenIds.add(descriptor.id);
+        if (!descriptor.appliesTo(filePaths))
+            continue;
+        resolved.set(descriptor.id, descriptor.version);
+    }
+    return Object.fromEntries([...resolved].sort(([left], [right]) => left.localeCompare(right)));
+}
+/**
+ * Compare an untrusted metadata value with the exact capabilities produced by
+ * this build. Extra keys also mismatch: a rollback must rebuild instead of
+ * certifying graph semantics emitted only by a newer binary.
+ */
+export function findAnalysisFeatureMismatches(actual, expected) {
+    const expectedKeys = Object.keys(expected);
+    if (actual === undefined)
+        return expectedKeys.map((id) => `missing:${id}`);
+    if (actual === null || typeof actual !== 'object' || Array.isArray(actual)) {
+        return ['invalid:analysisFeatures'];
+    }
+    const stamped = actual;
+    const mismatches = [];
+    for (const id of expectedKeys) {
+        const value = stamped[id];
+        if (value === undefined)
+            mismatches.push(`missing:${id}`);
+        else if (value !== expected[id])
+            mismatches.push(`version:${id}`);
+    }
+    for (const id of Object.keys(stamped)) {
+        if (!Object.prototype.hasOwnProperty.call(expected, id)) {
+            mismatches.push(`unexpected:${id}`);
+        }
+    }
+    return mismatches.sort();
+}

package/dist/core/ingestion/frameworks/spring/analysis-features.d.ts

@@ -0,0 +1,3 @@
+import type { AnalysisFeatureDescriptor } from '../../../analysis-features.js';
+/** Durable completeness contract for Java/Kotlin Spring Bean evidence. */
+export declare const SPRING_BEAN_INVENTORY_FEATURE: AnalysisFeatureDescriptor;

package/dist/core/ingestion/frameworks/spring/analysis-features.js

@@ -0,0 +1,7 @@
+import { isSpringBeanCandidateSourceFile } from './bean-catalog.js';
+/** Durable completeness contract for Java/Kotlin Spring Bean evidence. */
+export const SPRING_BEAN_INVENTORY_FEATURE = {
+    id: 'spring.bean-inventory',
+    version: 1,
+    appliesTo: (filePaths) => filePaths.some(isSpringBeanCandidateSourceFile),
+};

package/dist/core/ingestion/frameworks/spring/bean-candidates.d.ts

@@ -0,0 +1,24 @@
+import type { Capture, ParsedFile, ScopeId } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+export interface ClassAnnotationFact {
+    readonly classScopeId: ScopeId;
+    readonly annotationNames: readonly string[];
+}
+export interface ClassAnnotationFactStore {
+    clear(): void;
+    set(filePath: string, facts: readonly ClassAnnotationFact[]): void;
+    get(filePath: string): readonly ClassAnnotationFact[];
+}
+/** Per-language store for capture facts that cross the worker boundary. */
+export declare function createClassAnnotationFactStore(): ClassAnnotationFactStore;
+/** Record one annotation from the language's existing scope-query traversal. */
+export declare function recordClassAnnotationCapture(facts: Map<ScopeId, Set<string>>, filePath: string, classCapture: Pick<Capture, 'range'>, annotationName: string): void;
+export declare function materializeClassAnnotationFacts(facts: ReadonlyMap<ScopeId, ReadonlySet<string>>): readonly ClassAnnotationFact[];
+export interface SpringBeanCandidateAdapter {
+    getClassAnnotationFacts(filePath: string): readonly ClassAnnotationFact[];
+    isPackageVisibilityIncomplete(filePath: string): boolean;
+}
+/** Build a language hook that enriches Class nodes after scope resolution. */
+export declare function createSpringBeanCandidateAttacher(adapter: SpringBeanCandidateAdapter): (graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes) => void;

package/dist/core/ingestion/frameworks/spring/bean-candidates.js

@@ -0,0 +1,178 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { isClassLike, lookupBindingsAt } from '../../scope-resolution/scope/walkers.js';
+import { SPRING_BEAN_STEREOTYPES } from './bean-catalog.js';
+/** Per-language store for capture facts that cross the worker boundary. */
+export function createClassAnnotationFactStore() {
+    const factsByFile = new Map();
+    return {
+        clear: () => factsByFile.clear(),
+        set: (filePath, facts) => {
+            if (facts.length === 0)
+                factsByFile.delete(filePath);
+            else
+                factsByFile.set(filePath, facts);
+        },
+        get: (filePath) => factsByFile.get(filePath) ?? [],
+    };
+}
+/** Record one annotation from the language's existing scope-query traversal. */
+export function recordClassAnnotationCapture(facts, filePath, classCapture, annotationName) {
+    const classScopeId = makeScopeId({ filePath, range: classCapture.range, kind: 'Class' });
+    const names = facts.get(classScopeId) ?? new Set();
+    names.add(annotationName.trim());
+    facts.set(classScopeId, names);
+}
+export function materializeClassAnnotationFacts(facts) {
+    return [...facts].map(([classScopeId, annotationNames]) => ({
+        classScopeId,
+        annotationNames: [...annotationNames],
+    }));
+}
+function simpleNameOf(def) {
+    const qualifiedName = def.qualifiedName;
+    if (qualifiedName === undefined)
+        return undefined;
+    const separator = qualifiedName.lastIndexOf('.');
+    return separator === -1 ? qualifiedName : qualifiedName.slice(separator + 1);
+}
+function buildOwnedTypeNamesByOwner(indexes) {
+    const namesByOwner = new Map();
+    for (const def of indexes.defs.byId.values()) {
+        if (def.ownerId === undefined)
+            continue;
+        if (!isClassLike(def.type) && def.type !== 'Annotation')
+            continue;
+        const simpleName = simpleNameOf(def);
+        if (simpleName === undefined)
+            continue;
+        const names = namesByOwner.get(def.ownerId) ?? new Set();
+        names.add(simpleName);
+        namesByOwner.set(def.ownerId, names);
+    }
+    return namesByOwner;
+}
+function hasLexicalTypeDeclaration(startScope, simpleName, indexes) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        const locals = scope.bindings.get(simpleName);
+        if (locals?.some(({ def }) => isClassLike(def.type) || def.type === 'Annotation'))
+            return true;
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function explicitImportTargets(parsed, simpleName) {
+    const targets = new Set();
+    for (const entry of parsed.parsedImports) {
+        if (entry.kind !== 'named' && entry.kind !== 'alias')
+            continue;
+        if (entry.localName !== simpleName)
+            continue;
+        targets.add(entry.targetRaw);
+    }
+    return targets;
+}
+function hasInheritedTypeDeclaration(startScope, simpleName, indexes, ownedTypeNamesByOwner) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        if (scope.kind === 'Class') {
+            const classDef = scope.ownedDefs.find((def) => isClassLike(def.type));
+            if (classDef !== undefined) {
+                for (const ancestorId of indexes.methodDispatch.mroFor(classDef.nodeId)) {
+                    if (ownedTypeNamesByOwner.get(ancestorId)?.has(simpleName) === true)
+                        return true;
+                }
+            }
+        }
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function hasVisibleTypeBinding(startScope, simpleName, indexes) {
+    let scopeId = startScope;
+    const visited = new Set();
+    while (scopeId !== null && !visited.has(scopeId)) {
+        visited.add(scopeId);
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope === undefined)
+            return false;
+        const visible = lookupBindingsAt(scopeId, simpleName, indexes);
+        if (visible.some(({ def }) => isClassLike(def.type) || def.type === 'Annotation'))
+            return true;
+        scopeId = scope.parent;
+    }
+    return false;
+}
+function wildcardImportTarget(parsed, simpleName) {
+    const wildcardPackages = new Set(parsed.parsedImports
+        .filter((entry) => entry.kind === 'wildcard')
+        .map((entry) => entry.targetRaw.replace(/\.\*$/, '')));
+    if (wildcardPackages.size !== 1)
+        return undefined;
+    const [packageName] = wildcardPackages;
+    const target = `${packageName}.${simpleName}`;
+    return SPRING_BEAN_STEREOTYPES.has(target) ? target : undefined;
+}
+function resolveSpringAnnotation(rawName, parsed, enclosingScope, indexes, ownedTypeNamesByOwner, isPackageVisibilityIncomplete) {
+    if (rawName.includes('.')) {
+        return SPRING_BEAN_STEREOTYPES.has(rawName) ? rawName : undefined;
+    }
+    if (hasLexicalTypeDeclaration(enclosingScope, rawName, indexes))
+        return undefined;
+    if (hasInheritedTypeDeclaration(enclosingScope, rawName, indexes, ownedTypeNamesByOwner)) {
+        return undefined;
+    }
+    const explicitImports = explicitImportTargets(parsed, rawName);
+    if (explicitImports.size > 0) {
+        if (explicitImports.size !== 1)
+            return undefined;
+        const [imported] = explicitImports;
+        return SPRING_BEAN_STEREOTYPES.has(imported) ? imported : undefined;
+    }
+    const wildcardTarget = wildcardImportTarget(parsed, rawName);
+    if (wildcardTarget === undefined || isPackageVisibilityIncomplete)
+        return undefined;
+    return hasVisibleTypeBinding(enclosingScope, rawName, indexes) ? undefined : wildcardTarget;
+}
+/** Build a language hook that enriches Class nodes after scope resolution. */
+export function createSpringBeanCandidateAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        const ownedTypeNamesByOwner = buildOwnedTypeNamesByOwner(indexes);
+        for (const parsed of parsedFiles) {
+            for (const fact of adapter.getClassAnnotationFacts(parsed.filePath)) {
+                const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+                if (classScope === undefined || classScope.kind !== 'Class')
+                    continue;
+                const classDef = classScope.ownedDefs.find((def) => def.type === 'Class');
+                if (classDef === undefined)
+                    continue;
+                const graphId = resolveDefGraphId(parsed.filePath, classDef, nodeLookup);
+                if (graphId === undefined)
+                    continue;
+                const classNode = graph.getNode(graphId);
+                if (classNode === undefined || classNode.label !== 'Class')
+                    continue;
+                const recognized = new Set();
+                for (const rawName of fact.annotationNames) {
+                    const annotation = resolveSpringAnnotation(rawName, parsed, classScope.parent, indexes, ownedTypeNamesByOwner, adapter.isPackageVisibilityIncomplete(parsed.filePath));
+                    if (annotation !== undefined)
+                        recognized.add(annotation);
+                }
+                if (recognized.size === 1) {
+                    classNode.properties.frameworkAnnotations = [...recognized];
+                }
+            }
+        }
+    };
+}

package/dist/core/ingestion/frameworks/spring/bean-catalog.d.ts

@@ -0,0 +1,12 @@
+export interface SpringBeanMetadata {
+    framework: 'spring';
+    role: string;
+    annotation: string;
+}
+export interface SpringBeanStereotype {
+    role: string;
+}
+export declare const SPRING_BEAN_STEREOTYPES: Map<string, SpringBeanStereotype>;
+export declare function deriveSpringBeanMetadata(frameworkAnnotations: readonly string[]): SpringBeanMetadata | undefined;
+/** Whether a source change can alter Spring Bean candidate metadata. */
+export declare function isSpringBeanCandidateSourceFile(filePath: string): boolean;

package/dist/core/ingestion/frameworks/spring/bean-catalog.js

@@ -0,0 +1,26 @@
+export const SPRING_BEAN_STEREOTYPES = new Map([
+    ['org.springframework.stereotype.Component', { role: 'component' }],
+    ['org.springframework.stereotype.Service', { role: 'service' }],
+    ['org.springframework.stereotype.Repository', { role: 'repository' }],
+    ['org.springframework.stereotype.Controller', { role: 'controller' }],
+    ['org.springframework.web.bind.annotation.RestController', { role: 'rest-controller' }],
+    ['org.springframework.context.annotation.Configuration', { role: 'configuration' }],
+]);
+export function deriveSpringBeanMetadata(frameworkAnnotations) {
+    const recognized = [
+        ...new Set(frameworkAnnotations.filter((annotation) => SPRING_BEAN_STEREOTYPES.has(annotation))),
+    ];
+    if (recognized.length !== 1)
+        return undefined;
+    const annotation = recognized[0];
+    const stereotype = SPRING_BEAN_STEREOTYPES.get(annotation);
+    if (!stereotype)
+        return undefined;
+    return { framework: 'spring', role: stereotype.role, annotation };
+}
+const SPRING_BEAN_SOURCE_EXTENSIONS = ['.java', '.kt', '.kts'];
+/** Whether a source change can alter Spring Bean candidate metadata. */
+export function isSpringBeanCandidateSourceFile(filePath) {
+    const normalized = filePath.toLowerCase();
+    return SPRING_BEAN_SOURCE_EXTENSIONS.some((extension) => normalized.endsWith(extension));
+}

package/dist/core/ingestion/languages/java/capture-side-channel.d.ts

@@ -0,0 +1,18 @@
+import type { ParsedFile } from '../../../../_shared/index.js';
+import { type ClassAnnotationFact } from '../../frameworks/spring/bean-candidates.js';
+import { type JvmPackageFact } from '../jvm/package-facts.js';
+export type JavaClassAnnotationFact = ClassAnnotationFact;
+export interface JavaCaptureSideChannel {
+    readonly kind: 'java';
+    readonly packageFact: JvmPackageFact;
+    readonly classAnnotations: readonly JavaClassAnnotationFact[];
+}
+/** Clear facts retained by a prior workspace pass in a long-lived process. */
+export declare function clearJavaClassAnnotationFacts(): void;
+/** Store the annotation syntax collected by Java's existing scope-query traversal. */
+export declare function setJavaClassAnnotationFacts(filePath: string, facts: readonly JavaClassAnnotationFact[]): void;
+/** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
+export declare function collectJavaCaptureSideChannel(filePath: string): JavaCaptureSideChannel | undefined;
+export declare function getJavaClassAnnotationFacts(filePath: string): readonly JavaClassAnnotationFact[];
+/** Restore worker-collected facts before Java's post-resolution hook runs. */
+export declare function applyJavaCaptureSideChannel(parsed: ParsedFile): void;

package/dist/core/ingestion/languages/java/capture-side-channel.js

@@ -0,0 +1,42 @@
+import { createClassAnnotationFactStore, } from '../../frameworks/spring/bean-candidates.js';
+import { isJvmPackageFact, UNKNOWN_JVM_PACKAGE_FACT, } from '../jvm/package-facts.js';
+import { getJavaPackageFact, setJavaPackageFact } from './package-facts.js';
+const classAnnotations = createClassAnnotationFactStore();
+/** Clear facts retained by a prior workspace pass in a long-lived process. */
+export function clearJavaClassAnnotationFacts() {
+    classAnnotations.clear();
+}
+/** Store the annotation syntax collected by Java's existing scope-query traversal. */
+export function setJavaClassAnnotationFacts(filePath, facts) {
+    classAnnotations.set(filePath, facts);
+}
+/** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
+export function collectJavaCaptureSideChannel(filePath) {
+    const facts = classAnnotations.get(filePath);
+    const packageFact = getJavaPackageFact(filePath);
+    if (facts.length === 0 && packageFact === undefined)
+        return undefined;
+    return {
+        kind: 'java',
+        packageFact: packageFact ?? UNKNOWN_JVM_PACKAGE_FACT,
+        classAnnotations: facts,
+    };
+}
+export function getJavaClassAnnotationFacts(filePath) {
+    return classAnnotations.get(filePath);
+}
+/** Restore worker-collected facts before Java's post-resolution hook runs. */
+export function applyJavaCaptureSideChannel(parsed) {
+    const data = parsed.captureSideChannel;
+    if (data === undefined ||
+        data === null ||
+        typeof data !== 'object' ||
+        data.kind !== 'java' ||
+        !Array.isArray(data.classAnnotations)) {
+        setJavaClassAnnotationFacts(parsed.filePath, []);
+        setJavaPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
+        return;
+    }
+    setJavaClassAnnotationFacts(parsed.filePath, data.classAnnotations);
+    setJavaPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
+}

package/dist/core/ingestion/languages/java/captures.d.ts

@@ -11,7 +11,8 @@
  *   3. **Arity metadata** on method/constructor declarations.
  *   4. **Reference arity** on call sites.
  *
- * Pure given the input source text. No I/O, no globals consulted.
+ * The returned captures are deterministic. Class-annotation facts are also
+ * recorded for the worker side-channel consumed after scope resolution.
  */
-import type { CaptureMatch } from '../../../../_shared/index.js';
-export declare function emitJavaScopeCaptures(sourceText: string, _filePath: string, cachedTree?: unknown): readonly CaptureMatch[];
+import { type CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitJavaScopeCaptures(sourceText: string, filePath: string, cachedTree?: unknown): readonly CaptureMatch[];

package/dist/core/ingestion/languages/java/captures.js

@@ -1,18 +1,4 @@
-/**
- * `emitScopeCaptures` for Java.
- *
- * Drives the Java scope query against tree-sitter-java and groups raw
- * matches into `CaptureMatch[]` for the central extractor. Layers:
- *
- *   1. **Decomposed import declarations** — each `import_declaration`
- *      is re-emitted with `@import.kind/source/name` markers.
- *   2. **Receiver binding synthesis** — `this`/`super` type-bindings
- *      on instance methods.
- *   3. **Arity metadata** on method/constructor declarations.
- *   4. **Reference arity** on call sites.
- *
- * Pure given the input source text. No I/O, no globals consulted.
- */
+import { materializeClassAnnotationFacts, recordClassAnnotationCapture, } from '../../frameworks/spring/bean-candidates.js';
 import { nodeIfType, nodeToCapture, synthesizeJavaAnonymousClassName, syntheticCapture, } from '../../utils/ast-helpers.js';
 import { splitImportDeclaration } from './import-decomposer.js';
 import { computeJavaArityMetadata } from './arity-metadata.js';
@@ -21,6 +7,8 @@ import { getJavaParser, getJavaScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { setJavaClassAnnotationFacts } from './capture-side-channel.js';
+import { captureJavaPackageFact } from './package-facts.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.constructor'];
@@ -58,7 +46,7 @@ function shouldEmitReadMember(memberNode) {
             return true;
     }
 }
-export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
+export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
         tree = parseSourceSafe(getJavaParser(), sourceText, undefined, {
@@ -69,8 +57,10 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
     else {
         recordCacheHit();
     }
+    captureJavaPackageFact(filePath, tree.rootNode);
     const rawMatches = getJavaScopeQuery().matches(tree.rootNode);
     const out = [];
+    const classAnnotations = new Map();
     for (const m of rawMatches) {
         const grouped = {};
         // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
@@ -89,6 +79,12 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
+        const annotatedClass = grouped['@class-annotation.class'];
+        const annotationName = grouped['@class-annotation.name'];
+        if (annotatedClass !== undefined && annotationName !== undefined) {
+            recordClassAnnotationCapture(classAnnotations, filePath, annotatedClass, annotationName.text);
+            continue;
+        }
         // Decompose each `import_declaration`. `@import.statement` is captured
         // directly on the `import_declaration` node.
         if (grouped['@import.statement'] !== undefined) {
@@ -180,6 +176,7 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         out.push(grouped);
     }
+    setJavaClassAnnotationFacts(filePath, materializeClassAnnotationFacts(classAnnotations));
     return [
         ...resolveVarTypeBindings(out),
         ...synthesizeJavaInheritanceReferences(tree.rootNode),

package/dist/core/ingestion/languages/java/package-facts.d.ts

@@ -0,0 +1,5 @@
+import { type JvmPackageFact, type JvmPackageSyntaxNode } from '../jvm/package-facts.js';
+export declare const clearJavaPackageFacts: () => void;
+export declare const captureJavaPackageFact: (filePath: string, root: JvmPackageSyntaxNode) => void;
+export declare const setJavaPackageFact: (filePath: string, fact: JvmPackageFact) => void;
+export declare const getJavaPackageFact: (filePath: string) => JvmPackageFact | undefined;

package/dist/core/ingestion/languages/java/package-facts.js

@@ -0,0 +1,9 @@
+import { createJvmPackageFactStore, } from '../jvm/package-facts.js';
+const javaPackageFacts = createJvmPackageFactStore({
+    packageNodeType: 'package_declaration',
+    packageNameNodeTypes: ['scoped_identifier', 'identifier'],
+});
+export const clearJavaPackageFacts = () => javaPackageFacts.clear();
+export const captureJavaPackageFact = (filePath, root) => javaPackageFacts.capture(filePath, root);
+export const setJavaPackageFact = (filePath, fact) => javaPackageFacts.set(filePath, fact);
+export const getJavaPackageFact = (filePath) => javaPackageFacts.get(filePath);

package/dist/core/ingestion/languages/java/package-siblings.d.ts

@@ -1,17 +1,4 @@
-/**
- * Java package-scope implicit visibility.
- *
- * Classes in the same Java package see each other without explicit
- * `import` statements.  This hook groups files by `package` declaration,
- * then injects cross-file class defs into each file's module-scope
- * `bindingAugmentations` and mirrors type-bindings across same-package
- * files — the Java equivalent of C#'s `populateNamespaceSiblings`.
- */
-import type { ParsedFile } from '../../../../_shared/index.js';
-import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
-export declare function populateJavaPackageSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, ctx: {
+export declare const populateJavaPackageSiblings: (parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes, ctx: {
     readonly fileContents: ReadonlyMap<string, string>;
-    readonly treeCache?: {
-        get(filePath: string): unknown;
-    };
-}): void;
+}) => void;
+export declare const isJavaPackageSiblingVisibilityIncomplete: (filePath: string) => boolean;