gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/frameworks/spring/dynamic-lookups.d.ts

@@ -0,0 +1,22 @@
+import type { ParsedFile, Range, ScopeId } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { DiInjectionMatch } from '../../di-extractors/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+export interface SpringDynamicLookupFact {
+    readonly ownerScopeId: ScopeId;
+    readonly ownerRange: Range;
+    readonly receiverName: string;
+    readonly methodName: string;
+    readonly targetTypeName: string;
+}
+export declare function springDynamicLookupCardinality(receiverName: string, methodName: string): DiInjectionMatch['cardinality'] | null;
+export interface SpringDynamicLookupMetadataAdapter {
+    getFacts(filePath: string): readonly SpringDynamicLookupFact[];
+}
+/**
+ * Attach AST-captured programmatic Spring lookups to the framework-neutral DI
+ * resolver. Java/Kotlin own syntax capture; this shared JVM/Spring seam owns
+ * import-aware type binding and metadata attachment.
+ */
+export declare function createSpringDynamicLookupMetadataAttacher(adapter: SpringDynamicLookupMetadataAdapter): (graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes) => void;

package/dist/core/ingestion/frameworks/spring/dynamic-lookups.js

@@ -0,0 +1,124 @@
+import { SPRING_DI_INJECTION_SITES_PROPERTY } from '../../di-extractors/spring.js';
+import { resolveCallerGraphId, resolveDefGraphId, } from '../../scope-resolution/graph-bridge/ids.js';
+import { isClassLike, lookupBindingsAt } from '../../scope-resolution/scope/walkers.js';
+const COLLECTION_LOOKUP_METHODS = new Set(['getBeans', 'getBeansOfType']);
+const SINGLE_LOOKUP_METHODS = new Set(['getBean']);
+/**
+ * Distinctive utility names plus conventional Spring context variable names.
+ * Generic locals remain recall-oriented because repositories often omit the
+ * third-party context type from the index; AST call/class-literal gates and
+ * import-aware target resolution prevent the raw-text false-positive class.
+ */
+const KNOWN_RECEIVERS = new Set([
+    'SpringContextUtil',
+    'SpringContextHolder',
+    'SpringBeanUtil',
+    'ApplicationContextProvider',
+    'BeanFactoryProvider',
+    'ApplicationContext',
+    'BeanFactory',
+    'ListableBeanFactory',
+    'applicationContext',
+    'context',
+    'ctx',
+    'appContext',
+    'beanFactory',
+]);
+export function springDynamicLookupCardinality(receiverName, methodName) {
+    const receiverSimpleName = receiverName.slice(receiverName.lastIndexOf('.') + 1);
+    if (!KNOWN_RECEIVERS.has(receiverSimpleName))
+        return null;
+    if (COLLECTION_LOOKUP_METHODS.has(methodName))
+        return 'collection';
+    if (SINGLE_LOOKUP_METHODS.has(methodName))
+        return 'single';
+    return null;
+}
+function visibleTypeDefinitions(fact, indexes) {
+    const simpleName = fact.targetTypeName.slice(fact.targetTypeName.lastIndexOf('.') + 1);
+    let scopeId = fact.ownerScopeId;
+    while (scopeId !== null) {
+        const visible = lookupBindingsAt(scopeId, simpleName, indexes)
+            .map(({ def }) => def)
+            .filter((def) => isClassLike(def.type))
+            .filter((def) => !fact.targetTypeName.includes('.') || def.qualifiedName === fact.targetTypeName);
+        if (visible.length > 0) {
+            const unique = new Map(visible.map((def) => [def.nodeId, def]));
+            return [...unique.values()];
+        }
+        scopeId = indexes.scopeTree.getScope(scopeId)?.parent ?? null;
+    }
+    return [];
+}
+function resolveTargetTypeName(graph, fact, callerLanguage, nodeLookup, indexes) {
+    const graphIds = new Set();
+    for (const definition of visibleTypeDefinitions(fact, indexes)) {
+        const graphId = resolveDefGraphId(definition.filePath, definition, nodeLookup);
+        if (graphId === undefined)
+            continue;
+        const node = graph.getNode(graphId);
+        if ((node?.label === 'Class' ||
+            node?.label === 'Interface' ||
+            node?.label === 'Record' ||
+            node?.label === 'Enum') &&
+            node.properties.language === callerLanguage) {
+            graphIds.add(graphId);
+        }
+    }
+    if (graphIds.size !== 1)
+        return undefined;
+    const targetId = graphIds.values().next().value;
+    if (targetId === undefined)
+        return undefined;
+    const target = graph.getNode(targetId);
+    if (target === undefined)
+        return undefined;
+    const qualifiedName = target.properties.qualifiedName;
+    return typeof qualifiedName === 'string' ? qualifiedName : target.properties.name;
+}
+/**
+ * Attach AST-captured programmatic Spring lookups to the framework-neutral DI
+ * resolver. Java/Kotlin own syntax capture; this shared JVM/Spring seam owns
+ * import-aware type binding and metadata attachment.
+ */
+export function createSpringDynamicLookupMetadataAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        for (const parsed of parsedFiles) {
+            for (const fact of adapter.getFacts(parsed.filePath)) {
+                const cardinality = springDynamicLookupCardinality(fact.receiverName, fact.methodName);
+                if (cardinality === null)
+                    continue;
+                const callerId = resolveCallerGraphId(fact.ownerScopeId, indexes, nodeLookup, {
+                    startLine: fact.ownerRange.startLine,
+                    startCol: fact.ownerRange.startCol,
+                });
+                if (callerId === undefined)
+                    continue;
+                const caller = graph.getNode(callerId);
+                if (caller === undefined ||
+                    (caller.label !== 'Function' &&
+                        caller.label !== 'Method' &&
+                        caller.label !== 'Constructor')) {
+                    continue;
+                }
+                const targetTypeName = resolveTargetTypeName(graph, fact, caller.properties.language, nodeLookup, indexes);
+                if (targetTypeName === undefined)
+                    continue;
+                const match = {
+                    targetTypeName,
+                    cardinality,
+                    edgeSource: 'site',
+                    reason: `Spring dynamic lookup: ${fact.receiverName}.${fact.methodName}(${fact.targetTypeName})`,
+                };
+                // Singular lookups intentionally use the shared DI selection policy:
+                // a unique/@Primary candidate wins; unresolved multiplicity is an
+                // explicit 0.5-confidence fan-out rather than a guessed runtime winner.
+                const existing = caller.properties[SPRING_DI_INJECTION_SITES_PROPERTY];
+                caller.properties[SPRING_DI_INJECTION_SITES_PROPERTY] = [
+                    ...(Array.isArray(existing) ? existing : []),
+                    match,
+                ];
+            }
+        }
+    };
+}

package/dist/core/ingestion/frameworks/spring/message-producers.d.ts

@@ -0,0 +1,78 @@
+import type { Range, ScopeId } from '../../../../_shared/index.js';
+import type { SpringArgumentFact } from './argument-facts.js';
+/**
+ * Outbound side of Spring messaging: the template calls that publish to a
+ * broker destination, mirroring the inbound `@KafkaListener` / `@RabbitListener`
+ * family already recognized in `non-http-handlers.ts`.
+ *
+ * Recognition is purely syntactic and happens while the language's own scope
+ * query already has the call node in hand. The receiver's declared type is NOT
+ * consulted: at capture time the field may be inherited, injected from another
+ * file, or typed through an import that is not finalized yet. Matching on the
+ * receiver's simple name instead keeps the capture cheap and resolver-free; a
+ * later phase that owns type information can refine or discard a fact.
+ */
+export type SpringMessageProducerTemplate = 'kafka' | 'rabbit' | 'jms' | 'stream-bridge';
+/**
+ * Cheap pre-filter usable before any receiver text is materialized. Both
+ * languages visit every member call, so the common case must cost one set
+ * lookup on the method name.
+ */
+export declare function isSpringMessageProducerMethod(methodName: string): boolean;
+/**
+ * Classify a `receiver.method(...)` call as a messaging producer, or `null`.
+ *
+ * `receiverName` is the receiver expression as written; only its last
+ * dot-separated segment participates, so `this.kafkaTemplate` and
+ * `outer.inner.kafkaTemplate` match while `templates.get("k")` does not.
+ *
+ * The PLAIN_IDENTIFIER gate runs BEFORE the fold and is load-bearing, because
+ * the last-dot split is textual: in `config.get("a.kafkaTemplate")` it yields
+ * `kafkaTemplate")`, which folds to something a name match would accept. Only
+ * an identifier survives the gate, which is also what rejects `templates["k"]`,
+ * `getTemplate()`, and a receiver whose dot is separated by a comment.
+ *
+ * The folded segment then matches case-insensitively when it CONTAINS the
+ * template type name, so every convention a template bean is really declared
+ * with is recognized — decorated by prefix (`orderKafkaTemplate`), by suffix
+ * (`kafkaTemplateDlq`, `kafkaTemplateV2`, `rabbitTemplate1`), or written as a
+ * constant (`KAFKA_TEMPLATE`, `STREAM_BRIDGE`). A suffix-only rule accepted
+ * one of those and silently dropped the rest, which are exactly the publishes
+ * this capture exists to find. A receiver named only `template` still does not
+ * match: without type information that would attribute any `send` in the
+ * repository to Kafka.
+ *
+ * The bare type name (`KafkaTemplate.send(...)`) contains itself and so is
+ * accepted. That is left as it is: the match is by NAME, a name equal to the
+ * type is the strongest evidence the rule has, and a later phase that owns type
+ * information can discard a static-looking receiver.
+ *
+ * A substring rule also lets ONE receiver satisfy TWO signatures, which a
+ * suffix rule could not: `KafkaTemplate` and `StreamBridge` both publish
+ * through `send`, and `RabbitTemplate` and `JmsTemplate` both through
+ * `convertAndSend`, so `streamBridgeKafkaTemplate.send(...)` matches two
+ * templates at once. Such a receiver yields NO fact. Nothing here can break the
+ * tie honestly: the receiver's TYPE is deliberately not resolved, and the name
+ * is not ranked evidence — neither the longest match, nor the last one, nor the
+ * order of this list says whether that bean is a KafkaTemplate fronted by a
+ * stream binding or a StreamBridge named after the broker behind it. Returning
+ * the first match published an arbitrary choice as a definite broker
+ * attribution, the one outcome a consumer cannot tell from a fact. Silence
+ * costs a rare publish and stays recoverable by a phase that owns types.
+ */
+export declare function springMessageProducerTemplateOf(receiverName: string, methodName: string): SpringMessageProducerTemplate | null;
+export interface SpringMessageProducerFact {
+    /** Callable that performs the publish; the enclosing method or function. */
+    readonly ownerScopeId: ScopeId;
+    readonly ownerRange: Range;
+    readonly template: SpringMessageProducerTemplate;
+    /** Receiver expression as written, for example `this.orderKafkaTemplate`. */
+    readonly receiverName: string;
+    readonly methodName: string;
+    /**
+     * Call arguments in source order, or absent when the call site has no
+     * argument list at all (a Kotlin trailing-lambda call). An empty array means
+     * an empty argument list was written — a different fact from no list.
+     */
+    readonly args?: readonly SpringArgumentFact[];
+}

package/dist/core/ingestion/frameworks/spring/message-producers.js

@@ -0,0 +1,90 @@
+const PRODUCER_SIGNATURES = [
+    { template: 'kafka', typeName: 'KafkaTemplate', methodName: 'send' },
+    { template: 'rabbit', typeName: 'RabbitTemplate', methodName: 'convertAndSend' },
+    { template: 'jms', typeName: 'JmsTemplate', methodName: 'convertAndSend' },
+    { template: 'stream-bridge', typeName: 'StreamBridge', methodName: 'send' },
+];
+const PRODUCER_METHOD_NAMES = new Set(PRODUCER_SIGNATURES.map((signature) => signature.methodName));
+/** A receiver we can attribute; `templates["k"]` or `getTemplate()` cannot be. */
+const PLAIN_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+ * Fold a receiver's simple name to the form the type-name match runs against.
+ *
+ * `_` and `$` are word separators in the spellings this has to accept, not part
+ * of the words: `KAFKA_TEMPLATE` and `kafka_template` are the same bean name as
+ * `kafkaTemplate`, written to the constant and snake conventions. Digits stay,
+ * because they are part of a name (`kafkaTemplate2`), never a separator.
+ */
+function foldReceiverName(receiverSimpleName) {
+    return receiverSimpleName.replace(/[_$]/g, '').toLowerCase();
+}
+/**
+ * Cheap pre-filter usable before any receiver text is materialized. Both
+ * languages visit every member call, so the common case must cost one set
+ * lookup on the method name.
+ */
+export function isSpringMessageProducerMethod(methodName) {
+    return PRODUCER_METHOD_NAMES.has(methodName);
+}
+/**
+ * Classify a `receiver.method(...)` call as a messaging producer, or `null`.
+ *
+ * `receiverName` is the receiver expression as written; only its last
+ * dot-separated segment participates, so `this.kafkaTemplate` and
+ * `outer.inner.kafkaTemplate` match while `templates.get("k")` does not.
+ *
+ * The PLAIN_IDENTIFIER gate runs BEFORE the fold and is load-bearing, because
+ * the last-dot split is textual: in `config.get("a.kafkaTemplate")` it yields
+ * `kafkaTemplate")`, which folds to something a name match would accept. Only
+ * an identifier survives the gate, which is also what rejects `templates["k"]`,
+ * `getTemplate()`, and a receiver whose dot is separated by a comment.
+ *
+ * The folded segment then matches case-insensitively when it CONTAINS the
+ * template type name, so every convention a template bean is really declared
+ * with is recognized — decorated by prefix (`orderKafkaTemplate`), by suffix
+ * (`kafkaTemplateDlq`, `kafkaTemplateV2`, `rabbitTemplate1`), or written as a
+ * constant (`KAFKA_TEMPLATE`, `STREAM_BRIDGE`). A suffix-only rule accepted
+ * one of those and silently dropped the rest, which are exactly the publishes
+ * this capture exists to find. A receiver named only `template` still does not
+ * match: without type information that would attribute any `send` in the
+ * repository to Kafka.
+ *
+ * The bare type name (`KafkaTemplate.send(...)`) contains itself and so is
+ * accepted. That is left as it is: the match is by NAME, a name equal to the
+ * type is the strongest evidence the rule has, and a later phase that owns type
+ * information can discard a static-looking receiver.
+ *
+ * A substring rule also lets ONE receiver satisfy TWO signatures, which a
+ * suffix rule could not: `KafkaTemplate` and `StreamBridge` both publish
+ * through `send`, and `RabbitTemplate` and `JmsTemplate` both through
+ * `convertAndSend`, so `streamBridgeKafkaTemplate.send(...)` matches two
+ * templates at once. Such a receiver yields NO fact. Nothing here can break the
+ * tie honestly: the receiver's TYPE is deliberately not resolved, and the name
+ * is not ranked evidence — neither the longest match, nor the last one, nor the
+ * order of this list says whether that bean is a KafkaTemplate fronted by a
+ * stream binding or a StreamBridge named after the broker behind it. Returning
+ * the first match published an arbitrary choice as a definite broker
+ * attribution, the one outcome a consumer cannot tell from a fact. Silence
+ * costs a rare publish and stays recoverable by a phase that owns types.
+ */
+export function springMessageProducerTemplateOf(receiverName, methodName) {
+    if (!isSpringMessageProducerMethod(methodName))
+        return null;
+    const receiverSimpleName = receiverName.slice(receiverName.lastIndexOf('.') + 1).trim();
+    if (!PLAIN_IDENTIFIER.test(receiverSimpleName))
+        return null;
+    const folded = foldReceiverName(receiverSimpleName);
+    let matched = null;
+    for (const signature of PRODUCER_SIGNATURES) {
+        if (signature.methodName !== methodName)
+            continue;
+        if (!folded.includes(signature.typeName.toLowerCase()))
+            continue;
+        // A second match makes the receiver ambiguous; see above for why it is not
+        // resolved by preferring one of them.
+        if (matched !== null)
+            return null;
+        matched = signature.template;
+    }
+    return matched;
+}

package/dist/core/ingestion/frameworks/spring/non-http-handlers.d.ts

@@ -2,12 +2,41 @@ import type { ParsedFile, Range, 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';
+import type { SpringArgumentFact } from './argument-facts.js';
 export declare const SPRING_NON_HTTP_HANDLER_ENTRY_POINT_MULTIPLIER = 3;
 export type SpringNonHttpHandlerKind = 'scheduled' | 'event' | 'message' | 'xxl-job';
 export interface SpringNonHttpHandlerAnnotationFact {
     readonly name: string;
     /** Kotlin use-site targets describe generated/property elements, not the callable. */
     readonly useSiteTarget?: string;
+    /**
+     * Annotation arguments in source order. An empty array always means an empty
+     * list was written (`@Scheduled()`), which is a different fact from absence —
+     * but absence has TWO causes, and only one of them is a statement about the
+     * source. Either the annotation was written without an argument list
+     * (`@Scheduled`), or arguments were never read for this callable.
+     *
+     * They are read only for a callable that carries a handler annotation. Java
+     * produces facts for no other callable, so there absence does mean "no list
+     * was written". Kotlin also produces a fact for a merely annotated function —
+     * it captures those without a name prefilter so an import alias cannot hide a
+     * handler — and on those facts arguments are absent however the annotation
+     * was written.
+     *
+     * The values keep their source spelling, with one deliberate exception:
+     * `normalizeSpringFactText` trims them and collapses whitespace around the
+     * dots of a multi-line expression, so `Destinations.ORDERS` and the same
+     * reference wrapped across lines produce equal facts. Without that, source
+     * formatting — including the enclosing block's indentation, which is not a
+     * property of the expression at all — would leak into the data and make two
+     * spellings of one destination compare unequal downstream.
+     *
+     * Nothing else is touched. `@KafkaListener(topics = ...)` and
+     * `@RabbitListener(queues = ...)` name the destination differently, and a
+     * destination may be a literal, a constant reference, or a `${...}`
+     * placeholder; resolving any of those belongs to a later phase.
+     */
+    readonly args?: readonly SpringArgumentFact[];
 }
 export interface SpringNonHttpHandlerFact<Annotation extends SpringNonHttpHandlerAnnotationFact = SpringNonHttpHandlerAnnotationFact> {
     readonly ownerScopeId: ScopeId;

package/dist/core/ingestion/frameworks/spring/vendor-prefixes.d.ts

@@ -0,0 +1,7 @@
+/** Return the configured vendor prefixes as a canonical, duplicate-free set. */
+export declare function springVendorPrefixes(): ReadonlySet<string>;
+/**
+ * Stable metadata value for the route semantics controlled by the prefix list.
+ * Sorting makes equivalent lists independent of declaration order.
+ */
+export declare function springVendorPrefixesKey(): string;

package/dist/core/ingestion/frameworks/spring/vendor-prefixes.js

@@ -0,0 +1,22 @@
+const DEFAULT_SPRING_VENDOR_PREFIXES = 'Win';
+let cachedRawValue;
+let cachedPrefixes;
+/** Return the configured vendor prefixes as a canonical, duplicate-free set. */
+export function springVendorPrefixes() {
+    const rawValue = process.env.GITNEXUS_SPRING_VENDOR_PREFIXES ?? DEFAULT_SPRING_VENDOR_PREFIXES;
+    if (cachedPrefixes && cachedRawValue === rawValue)
+        return cachedPrefixes;
+    cachedRawValue = rawValue;
+    cachedPrefixes = new Set(rawValue
+        .split(',')
+        .map((prefix) => prefix.trim())
+        .filter(Boolean));
+    return cachedPrefixes;
+}
+/**
+ * Stable metadata value for the route semantics controlled by the prefix list.
+ * Sorting makes equivalent lists independent of declaration order.
+ */
+export function springVendorPrefixesKey() {
+    return JSON.stringify([...springVendorPrefixes()].sort());
+}

package/dist/core/ingestion/import-resolvers/configs/zig.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Zig import resolution.
+ *
+ * Local-file imports (`@import("./foo.zig")`, `@import("foo.zig")`) resolve
+ * relative to the importer. Bare names (`@import("bar")`) resolve through
+ * build.zig.zon `.path` deps when a parsed ZigBuildZonConfig is available
+ * (see language-config.ts `loadZigBuildConfig`). Everything unresolvable —
+ * `std`, `builtin`, `root`, `.url`-based deps — returns an empty result so
+ * it doesn't produce ghost import edges.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+export declare const zigImportStrategy: ImportResolverStrategy;
+export declare const zigImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/zig.js

@@ -0,0 +1,26 @@
+/**
+ * Zig import resolution.
+ *
+ * Local-file imports (`@import("./foo.zig")`, `@import("foo.zig")`) resolve
+ * relative to the importer. Bare names (`@import("bar")`) resolve through
+ * build.zig.zon `.path` deps when a parsed ZigBuildZonConfig is available
+ * (see language-config.ts `loadZigBuildConfig`). Everything unresolvable —
+ * `std`, `builtin`, `root`, `.url`-based deps — returns an empty result so
+ * it doesn't produce ghost import edges.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { resolveZigImportInternal } from '../zig.js';
+const stripQuotes = (s) => s.replace(/^['"]|['"]$/g, '');
+export const zigImportStrategy = (rawImportPath, filePath, ctx) => {
+    // tree-sitter-zig captures the string with surrounding quotes.
+    const stripped = stripQuotes(rawImportPath);
+    const resolved = resolveZigImportInternal(filePath, stripped, ctx.allFilePaths, ctx.configs.zigBuildZon ?? null);
+    // Unresolvable (stdlib / builtin / .url dep / missing file): stop the
+    // chain with an empty result rather than falling through to suffix
+    // matching, which could ghost-match an unrelated same-named file.
+    return { kind: 'files', files: resolved ? [resolved] : [] };
+};
+export const zigImportConfig = {
+    language: SupportedLanguages.Zig,
+    strategies: [zigImportStrategy],
+};

package/dist/core/ingestion/import-resolvers/zig.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Zig module import resolution — internal helpers.
+ *
+ * Zig imports take three shapes:
+ *   const std = @import("std");                  → stdlib, unresolvable
+ *   const builtin = @import("builtin");          → compiler builtin, unresolvable
+ *   const root = @import("root");                → user's main module, unresolvable here
+ *   const foo = @import("./foo.zig");            → relative path
+ *   const foo = @import("foo.zig");              → also relative (Zig treats unprefixed
+ *                                                  paths with a `.zig` extension as
+ *                                                  filesystem-relative to the importer)
+ *   const lp = @import("lightpanda");            → the repo's OWN module, declared by
+ *                                                  its root build.zig (`b.addModule`)
+ *   const bar = @import("bar");                  → package dep declared in build.zig.zon
+ *
+ * Bare-name resolution is handled when a parsed ZigBuildZonConfig is
+ * supplied (see `loadZigBuildConfig`). The import table of the build module
+ * the importer belongs to comes first (`buildModules` — per-module
+ * `addImport` aliases, see `zigModulesContaining`), then the root
+ * build.zig's named modules flattened repo-wide (`rootModules`, name → root
+ * file — a repo with no build.zig.zon still resolves them). `.url`-based deps unpack into a build cache outside
+ * the repo and so are returned as null; `.path`-based deps are resolved
+ * through the root the dep's own build.zig declares, then the conventional
+ * `<dep_root>/src/root.zig`, `<dep_root>/src/<name>.zig`,
+ * `<dep_root>/src/main.zig` layouts.
+ */
+import { type ZigBuildZonConfig } from '../language-config.js';
+/** Resolve a Zig @import argument to a file path in the repository.
+ *  Returns null when the import is a stdlib / builtin / root reference,
+ *  an unresolvable build.zig.zon package dep, or genuinely unresolvable.
+ *
+ *  `buildZon` (optional) supplies the parsed `.dependencies` map from
+ *  build.zig.zon. */
+export declare function resolveZigImportInternal(currentFile: string, importPath: string, allFiles: ReadonlySet<string>, buildZon?: ZigBuildZonConfig | null): string | null;