arceus-s 1.6.4

package/dist/core/ingestion/emit-references.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Phase 5 of the RFC #909 ingestion lifecycle: drain `ReferenceIndex`
+ * into the knowledge graph as labeled edges with `confidence` and
+ * `evidence` properties (Ring 2 PKG #925).
+ *
+ * The resolution phase (future PR) writes `Reference` records into
+ * `model.scopes.referenceSites`-derived `ReferenceIndex`; this module
+ * materializes those records as `GraphRelationship`s via
+ * `graph.addRelationship`. Every emitted edge carries:
+ *
+ *   - `type`: one of `'CALLS' | 'ACCESSES' | 'INHERITS' | 'USES'`
+ *     (mapped from `Reference.kind` — `'read'` and `'write'` both route
+ *     to `ACCESSES`; `'type-reference'` and `'import-use'` route to
+ *     `USES`; `'call'` stays `CALLS`; `'inherits'` stays `INHERITS`).
+ *   - `confidence`: the pre-computed confidence from the Reference record.
+ *   - `reason`: human-readable summary (`"scope-resolution: call | confidence 0.75"`).
+ *   - `evidence`: the full `ResolutionEvidence[]` trace — additive graph
+ *     property (see `GraphRelationship.evidence` in arceus-shared),
+ *     so queries that don't know about it are unaffected.
+ *   - `step`: carries the reference's access-kind discriminant when
+ *     available (`1` for read, `2` for write) so `ACCESSES` edges retain
+ *     the read/write distinction without forcing a new edge type.
+ *
+ * ## Optional scope-tree flush
+ *
+ * When `INGESTION_EMIT_SCOPES=1` is set, this module also emits:
+ *
+ *   - `Scope` nodes for every `Scope` in the tree
+ *   - `CONTAINS` edges from parent scope to child scope
+ *   - `DEFINES` edges from scope to its `ownedDefs` members
+ *   - `IMPORTS` edges from scope to `targetModuleScope` of each finalized
+ *     `ImportEdge` that carries one
+ *
+ * Off by default — existing queries that don't know about `Scope` nodes
+ * continue to work, and the storage cost is opt-in.
+ *
+ * ## Source-of-truth: the caller def for a reference
+ *
+ * A `Reference` says "some code inside `fromScope` references `toDef`".
+ * The graph wants `(callerNodeId, calleeNodeId)`. We resolve the caller
+ * by walking up the scope tree from `fromScope` until we find a scope
+ * whose `ownedDefs` contains a Function-like def. If no such ancestor
+ * exists, the edge is attributed to the first def owned by the innermost
+ * ancestor scope, and if THAT produces nothing either the edge is
+ * skipped (with a count returned in `EmitStats.skippedNoCaller`).
+ */
+import type { ReferenceIndex } from '../../_shared/index.js';
+import type { KnowledgeGraph } from '../graph/types.js';
+import type { ScopeResolutionIndexes } from './model/scope-resolution-indexes.js';
+export interface EmitStats {
+    readonly edgesEmitted: number;
+    /** References dropped because no caller def could be resolved. */
+    readonly skippedNoCaller: number;
+    /** References dropped because `toDef` was not found in the DefIndex. */
+    readonly skippedMissingTarget: number;
+    /** Scope nodes emitted — `0` unless `INGESTION_EMIT_SCOPES=1`. */
+    readonly scopeNodesEmitted: number;
+    /** Scope-tree structural edges emitted — `0` unless `INGESTION_EMIT_SCOPES=1`. */
+    readonly scopeEdgesEmitted: number;
+}
+export interface EmitReferencesInput {
+    readonly graph: KnowledgeGraph;
+    readonly scopes: ScopeResolutionIndexes;
+    readonly referenceIndex: ReferenceIndex;
+    /** Human-consumable label for the `reason` prefix. Defaults to `'scope-resolution'`. */
+    readonly sourceLabel?: string;
+}
+/**
+ * Drain `referenceIndex.bySourceScope` into graph edges.
+ *
+ * The scope-tree flush is controlled separately by
+ * `INGESTION_EMIT_SCOPES` — callers can run `emitReferencesToGraph`
+ * without scope-node emission or layer the two calls as needed.
+ */
+export declare function emitReferencesToGraph(input: EmitReferencesInput): EmitStats;
+/**
+ * Emit `Scope` nodes + `CONTAINS`/`DEFINES`/`IMPORTS` edges representing
+ * the lexical scope tree itself. Skipped unless `INGESTION_EMIT_SCOPES=1`
+ * at the public entry point; exported here for tests that want to
+ * exercise the path directly.
+ */
+export declare function emitScopeGraph(input: {
+    readonly graph: KnowledgeGraph;
+    readonly scopes: ScopeResolutionIndexes;
+}): {
+    readonly scopeNodesEmitted: number;
+    readonly scopeEdgesEmitted: number;
+};

package/dist/core/ingestion/emit-references.js

@@ -0,0 +1,229 @@
+/**
+ * Phase 5 of the RFC #909 ingestion lifecycle: drain `ReferenceIndex`
+ * into the knowledge graph as labeled edges with `confidence` and
+ * `evidence` properties (Ring 2 PKG #925).
+ *
+ * The resolution phase (future PR) writes `Reference` records into
+ * `model.scopes.referenceSites`-derived `ReferenceIndex`; this module
+ * materializes those records as `GraphRelationship`s via
+ * `graph.addRelationship`. Every emitted edge carries:
+ *
+ *   - `type`: one of `'CALLS' | 'ACCESSES' | 'INHERITS' | 'USES'`
+ *     (mapped from `Reference.kind` — `'read'` and `'write'` both route
+ *     to `ACCESSES`; `'type-reference'` and `'import-use'` route to
+ *     `USES`; `'call'` stays `CALLS`; `'inherits'` stays `INHERITS`).
+ *   - `confidence`: the pre-computed confidence from the Reference record.
+ *   - `reason`: human-readable summary (`"scope-resolution: call | confidence 0.75"`).
+ *   - `evidence`: the full `ResolutionEvidence[]` trace — additive graph
+ *     property (see `GraphRelationship.evidence` in arceus-shared),
+ *     so queries that don't know about it are unaffected.
+ *   - `step`: carries the reference's access-kind discriminant when
+ *     available (`1` for read, `2` for write) so `ACCESSES` edges retain
+ *     the read/write distinction without forcing a new edge type.
+ *
+ * ## Optional scope-tree flush
+ *
+ * When `INGESTION_EMIT_SCOPES=1` is set, this module also emits:
+ *
+ *   - `Scope` nodes for every `Scope` in the tree
+ *   - `CONTAINS` edges from parent scope to child scope
+ *   - `DEFINES` edges from scope to its `ownedDefs` members
+ *   - `IMPORTS` edges from scope to `targetModuleScope` of each finalized
+ *     `ImportEdge` that carries one
+ *
+ * Off by default — existing queries that don't know about `Scope` nodes
+ * continue to work, and the storage cost is opt-in.
+ *
+ * ## Source-of-truth: the caller def for a reference
+ *
+ * A `Reference` says "some code inside `fromScope` references `toDef`".
+ * The graph wants `(callerNodeId, calleeNodeId)`. We resolve the caller
+ * by walking up the scope tree from `fromScope` until we find a scope
+ * whose `ownedDefs` contains a Function-like def. If no such ancestor
+ * exists, the edge is attributed to the first def owned by the innermost
+ * ancestor scope, and if THAT produces nothing either the edge is
+ * skipped (with a count returned in `EmitStats.skippedNoCaller`).
+ */
+/**
+ * Drain `referenceIndex.bySourceScope` into graph edges.
+ *
+ * The scope-tree flush is controlled separately by
+ * `INGESTION_EMIT_SCOPES` — callers can run `emitReferencesToGraph`
+ * without scope-node emission or layer the two calls as needed.
+ */
+export function emitReferencesToGraph(input) {
+    const { graph, scopes, referenceIndex } = input;
+    const sourceLabel = input.sourceLabel ?? 'scope-resolution';
+    let edgesEmitted = 0;
+    let skippedNoCaller = 0;
+    let skippedMissingTarget = 0;
+    for (const [fromScope, refs] of referenceIndex.bySourceScope) {
+        for (const ref of refs) {
+            const targetDef = scopes.defs.get(ref.toDef);
+            if (targetDef === undefined) {
+                skippedMissingTarget++;
+                continue;
+            }
+            const callerId = resolveCallerNodeId(fromScope, scopes);
+            if (callerId === undefined) {
+                skippedNoCaller++;
+                continue;
+            }
+            graph.addRelationship(buildRelationship(ref, callerId, targetDef, sourceLabel));
+            edgesEmitted++;
+        }
+    }
+    const scopeStats = isScopeEmissionEnabled()
+        ? emitScopeGraph({ graph, scopes })
+        : { scopeNodesEmitted: 0, scopeEdgesEmitted: 0 };
+    return { edgesEmitted, skippedNoCaller, skippedMissingTarget, ...scopeStats };
+}
+/**
+ * Emit `Scope` nodes + `CONTAINS`/`DEFINES`/`IMPORTS` edges representing
+ * the lexical scope tree itself. Skipped unless `INGESTION_EMIT_SCOPES=1`
+ * at the public entry point; exported here for tests that want to
+ * exercise the path directly.
+ */
+export function emitScopeGraph(input) {
+    const { graph, scopes } = input;
+    let scopeNodesEmitted = 0;
+    let scopeEdgesEmitted = 0;
+    for (const scope of scopes.scopeTree.byId.values()) {
+        graph.addNode({
+            id: scope.id,
+            label: 'CodeElement', // the generic bucket for non-symbol graph nodes
+            properties: {
+                name: scope.kind,
+                filePath: scope.filePath,
+                startLine: scope.range.startLine,
+                endLine: scope.range.endLine,
+                description: `Scope: ${scope.kind}`,
+            },
+        });
+        scopeNodesEmitted++;
+        if (scope.parent !== null) {
+            graph.addRelationship({
+                id: `rel:contains:${scope.parent}->${scope.id}`,
+                sourceId: scope.parent,
+                targetId: scope.id,
+                type: 'CONTAINS',
+                confidence: 1,
+                reason: 'scope-tree parent/child',
+            });
+            scopeEdgesEmitted++;
+        }
+        for (const def of scope.ownedDefs) {
+            graph.addRelationship({
+                id: `rel:defines:${scope.id}->${def.nodeId}`,
+                sourceId: scope.id,
+                targetId: def.nodeId,
+                type: 'DEFINES',
+                confidence: 1,
+                reason: 'scope.ownedDefs',
+            });
+            scopeEdgesEmitted++;
+        }
+    }
+    for (const [scopeId, edges] of scopes.imports) {
+        for (const edge of edges) {
+            if (edge.targetModuleScope === undefined)
+                continue;
+            graph.addRelationship({
+                id: `rel:imports:${scopeId}->${edge.targetModuleScope}:${edge.localName}`,
+                sourceId: scopeId,
+                targetId: edge.targetModuleScope,
+                type: 'IMPORTS',
+                confidence: edge.linkStatus === 'unresolved' ? 0.5 : 1,
+                reason: `import ${edge.kind} ${edge.localName}`,
+            });
+            scopeEdgesEmitted++;
+        }
+    }
+    return { scopeNodesEmitted, scopeEdgesEmitted };
+}
+// ─── Internal ───────────────────────────────────────────────────────────────
+/** Accepted truthy values for `INGESTION_EMIT_SCOPES`. */
+const TRUTHY = new Set(['true', '1', 'yes']);
+function isScopeEmissionEnabled() {
+    const raw = process.env['INGESTION_EMIT_SCOPES'];
+    if (raw === undefined)
+        return false;
+    return TRUTHY.has(raw.trim().toLowerCase());
+}
+/**
+ * Walk up from `startScope` looking for the first ancestor scope whose
+ * `ownedDefs` contains a Function-like def (Function / Method /
+ * Constructor). Fall back to the innermost ancestor's first `ownedDef`
+ * if none is found; return `undefined` if all ancestors have no defs.
+ */
+function resolveCallerNodeId(startScope, scopes) {
+    const tree = scopes.scopeTree;
+    let current = startScope;
+    const visited = new Set();
+    let firstOwnedFallback;
+    while (current !== null) {
+        if (visited.has(current))
+            break;
+        visited.add(current);
+        const scope = tree.getScope(current);
+        if (scope === undefined)
+            break;
+        // Prefer a Function-like owner.
+        const fnDef = scope.ownedDefs.find((d) => isFunctionLike(d.type));
+        if (fnDef !== undefined)
+            return fnDef.nodeId;
+        // Stash the first owned def we see as a conservative fallback.
+        if (firstOwnedFallback === undefined && scope.ownedDefs.length > 0) {
+            firstOwnedFallback = scope.ownedDefs[0].nodeId;
+        }
+        current = scope.parent;
+    }
+    return firstOwnedFallback;
+}
+function isFunctionLike(type) {
+    return type === 'Function' || type === 'Method' || type === 'Constructor';
+}
+function buildRelationship(ref, callerId, targetDef, sourceLabel) {
+    const type = mapKindToType(ref.kind);
+    const reason = `${sourceLabel}: ${ref.kind} | confidence ${ref.confidence.toFixed(3)}`;
+    // `step` encodes read/write discriminator for ACCESSES edges (1=read, 2=write).
+    // Other kinds omit `step`.
+    const step = ref.kind === 'read' ? 1 : ref.kind === 'write' ? 2 : undefined;
+    return {
+        id: `rel:${type}:${callerId}->${targetDef.nodeId}:${ref.atRange.startLine}:${ref.atRange.startCol}`,
+        sourceId: callerId,
+        targetId: targetDef.nodeId,
+        type,
+        confidence: ref.confidence,
+        reason,
+        evidence: ref.evidence.map(serializeEvidence),
+        ...(step !== undefined ? { step } : {}),
+    };
+}
+/**
+ * Map a `Reference.kind` to an existing `RelationshipType`. Read/write
+ * both fold into `ACCESSES`; `type-reference` + `import-use` both fold
+ * into `USES`. This keeps the graph schema additive — no new
+ * RelationshipType values are introduced by this module.
+ */
+function mapKindToType(kind) {
+    switch (kind) {
+        case 'call':
+            return 'CALLS';
+        case 'read':
+        case 'write':
+            return 'ACCESSES';
+        case 'inherits':
+            return 'INHERITS';
+        case 'type-reference':
+        case 'import-use':
+            return 'USES';
+    }
+}
+function serializeEvidence(e) {
+    return {
+        kind: e.kind,
+        weight: e.weight,
+        ...(e.note !== undefined ? { note: e.note } : {}),
+    };
+}

package/dist/core/ingestion/entry-point-scoring.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Entry Point Scoring
+ *
+ * Calculates entry point scores for process detection based on:
+ * 1. Call ratio (existing algorithm - callees / (callers + 1))
+ * 2. Export status (exported functions get higher priority)
+ * 3. Name patterns (functions matching entry point patterns like handle*, on*, *Controller)
+ * 4. Framework detection (path-based detection for Next.js, Express, Django, etc.)
+ *
+ * This module is language-agnostic - language-specific patterns are defined per language.
+ */
+import { SupportedLanguages } from '../../_shared/index.js';
+export interface EntryPointScoreResult {
+    score: number;
+    reasons: string[];
+}
+/**
+ * Calculate an entry point score for a function/method
+ *
+ * Higher scores indicate better entry point candidates.
+ * Score = baseScore × exportMultiplier × nameMultiplier
+ *
+ * @param name - Function/method name
+ * @param language - Programming language
+ * @param isExported - Whether the function is exported/public
+ * @param callerCount - Number of functions that call this function
+ * @param calleeCount - Number of functions this function calls
+ * @returns Score and array of reasons explaining the score
+ */
+export declare function calculateEntryPointScore(name: string, language: SupportedLanguages, isExported: boolean, callerCount: number, calleeCount: number, filePath?: string): EntryPointScoreResult;
+/**
+ * Check if a file path is a test file (should be excluded from entry points)
+ * Covers common test file patterns across all supported languages
+ */
+export declare function isTestFile(filePath: string): boolean;
+/**
+ * Check if a file path is likely a utility/helper file
+ * These might still have entry points but should be lower priority
+ */
+export declare function isUtilityFile(filePath: string): boolean;

package/dist/core/ingestion/entry-point-scoring.js

@@ -0,0 +1,196 @@
+/**
+ * Entry Point Scoring
+ *
+ * Calculates entry point scores for process detection based on:
+ * 1. Call ratio (existing algorithm - callees / (callers + 1))
+ * 2. Export status (exported functions get higher priority)
+ * 3. Name patterns (functions matching entry point patterns like handle*, on*, *Controller)
+ * 4. Framework detection (path-based detection for Next.js, Express, Django, etc.)
+ *
+ * This module is language-agnostic - language-specific patterns are defined per language.
+ */
+import { detectFrameworkFromPath } from './framework-detection.js';
+import { providers } from './languages/index.js';
+// ============================================================================
+// NAME PATTERNS
+// ============================================================================
+/**
+ * Universal entry point naming patterns shared across all languages.
+ * Per-language patterns live on each LanguageProvider.entryPointPatterns.
+ */
+const UNIVERSAL_ENTRY_POINT_PATTERNS = [
+    /^(main|init|bootstrap|start|run|setup|configure)$/i,
+    /^handle[A-Z]/, // handleLogin, handleSubmit
+    /^on[A-Z]/, // onClick, onSubmit
+    /Handler$/, // RequestHandler
+    /Controller$/, // UserController
+    /^process[A-Z]/, // processPayment
+    /^execute[A-Z]/, // executeQuery
+    /^perform[A-Z]/, // performAction
+    /^dispatch[A-Z]/, // dispatchEvent
+    /^trigger[A-Z]/, // triggerAction
+    /^fire[A-Z]/, // fireEvent
+    /^emit[A-Z]/, // emitEvent
+];
+/** Pre-computed merged patterns (universal + language-specific) from providers. */
+const MERGED_ENTRY_POINT_PATTERNS = Object.fromEntries(Object.entries(providers).map(([lang, provider]) => [
+    lang,
+    [...UNIVERSAL_ENTRY_POINT_PATTERNS, ...(provider.entryPointPatterns ?? [])],
+]));
+// ============================================================================
+// UTILITY PATTERNS - Functions that should be penalized
+// ============================================================================
+/**
+ * Patterns that indicate utility/helper functions (NOT entry points)
+ * These get penalized in scoring
+ */
+const UTILITY_PATTERNS = [
+    /^(get|set|is|has|can|should|will|did)[A-Z]/, // Accessors/predicates
+    /^_/, // Private by convention
+    /^(format|parse|validate|convert|transform)/i, // Transformation utilities
+    /^(log|debug|error|warn|info)$/i, // Logging
+    /^(to|from)[A-Z]/, // Conversions
+    /^(encode|decode)/i, // Encoding utilities
+    /^(serialize|deserialize)/i, // Serialization
+    /^(clone|copy|deep)/i, // Cloning utilities
+    /^(merge|extend|assign)/i, // Object utilities
+    /^(filter|map|reduce|sort|find)/i, // Collection utilities (standalone)
+    /Helper$/,
+    /Util$/,
+    /Utils$/,
+    /^utils?$/i,
+    /^helpers?$/i,
+];
+// ============================================================================
+// MAIN SCORING FUNCTION
+// ============================================================================
+/**
+ * Calculate an entry point score for a function/method
+ *
+ * Higher scores indicate better entry point candidates.
+ * Score = baseScore × exportMultiplier × nameMultiplier
+ *
+ * @param name - Function/method name
+ * @param language - Programming language
+ * @param isExported - Whether the function is exported/public
+ * @param callerCount - Number of functions that call this function
+ * @param calleeCount - Number of functions this function calls
+ * @returns Score and array of reasons explaining the score
+ */
+export function calculateEntryPointScore(name, language, isExported, callerCount, calleeCount, filePath = '') {
+    const reasons = [];
+    // Must have outgoing calls to be an entry point (we need to trace forward)
+    if (calleeCount === 0) {
+        return { score: 0, reasons: ['no-outgoing-calls'] };
+    }
+    // Base score: call ratio (existing algorithm)
+    // High ratio = calls many, called by few = likely entry point
+    const baseScore = calleeCount / (callerCount + 1);
+    reasons.push(`base:${baseScore.toFixed(2)}`);
+    // Export bonus: exported/public functions are more likely entry points
+    const exportMultiplier = isExported ? 2.0 : 1.0;
+    if (isExported) {
+        reasons.push('exported');
+    }
+    // Name pattern scoring
+    let nameMultiplier = 1.0;
+    // Check negative patterns first (utilities get penalized)
+    if (UTILITY_PATTERNS.some((p) => p.test(name))) {
+        nameMultiplier = 0.3; // Significant penalty
+        reasons.push('utility-pattern');
+    }
+    else {
+        // Check positive patterns
+        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language];
+        if (allPatterns?.some((p) => p.test(name))) {
+            nameMultiplier = 1.5; // Bonus for matching entry point pattern
+            reasons.push('entry-pattern');
+        }
+    }
+    // Framework detection bonus (Phase 2)
+    let frameworkMultiplier = 1.0;
+    if (filePath) {
+        const frameworkHint = detectFrameworkFromPath(filePath);
+        if (frameworkHint) {
+            frameworkMultiplier = frameworkHint.entryPointMultiplier;
+            reasons.push(`framework:${frameworkHint.reason}`);
+        }
+    }
+    // Calculate final score
+    const finalScore = baseScore * exportMultiplier * nameMultiplier * frameworkMultiplier;
+    return {
+        score: finalScore,
+        reasons,
+    };
+}
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Check if a file path is a test file (should be excluded from entry points)
+ * Covers common test file patterns across all supported languages
+ */
+export function isTestFile(filePath) {
+    const p = filePath.toLowerCase().replace(/\\/g, '/');
+    return (
+    // JavaScript/TypeScript test patterns
+    p.includes('.test.') ||
+        p.includes('.spec.') ||
+        p.includes('__tests__/') ||
+        p.includes('__mocks__/') ||
+        // Generic test folders
+        p.includes('/test/') ||
+        p.includes('/tests/') ||
+        p.includes('/testing/') ||
+        // Python test patterns
+        p.endsWith('_test.py') ||
+        p.includes('/test_') ||
+        // Go test patterns
+        p.endsWith('_test.go') ||
+        // Java test patterns
+        p.includes('/src/test/') ||
+        // Rust test patterns (inline tests are different, but test files)
+        p.includes('/tests/') ||
+        // Swift/iOS test patterns
+        p.endsWith('tests.swift') ||
+        p.endsWith('test.swift') ||
+        p.includes('uitests/') ||
+        // C# test patterns
+        p.endsWith('tests.cs') ||
+        p.endsWith('test.cs') ||
+        p.includes('.tests/') ||
+        p.includes('.test/') ||
+        p.includes('.integrationtests/') ||
+        p.includes('.unittests/') ||
+        p.includes('/testproject/') ||
+        // PHP/Laravel test patterns
+        p.endsWith('test.php') ||
+        p.endsWith('spec.php') ||
+        p.includes('/tests/feature/') ||
+        p.includes('/tests/unit/') ||
+        // Ruby test patterns
+        p.endsWith('_spec.rb') ||
+        p.endsWith('_test.rb') ||
+        p.includes('/spec/') ||
+        p.includes('/test/fixtures/'));
+}
+/**
+ * Check if a file path is likely a utility/helper file
+ * These might still have entry points but should be lower priority
+ */
+export function isUtilityFile(filePath) {
+    const p = filePath.toLowerCase().replace(/\\/g, '/');
+    return (p.includes('/utils/') ||
+        p.includes('/util/') ||
+        p.includes('/helpers/') ||
+        p.includes('/helper/') ||
+        p.includes('/common/') ||
+        p.includes('/shared/') ||
+        p.includes('/lib/') ||
+        p.endsWith('/utils.ts') ||
+        p.endsWith('/utils.js') ||
+        p.endsWith('/helpers.ts') ||
+        p.endsWith('/helpers.js') ||
+        p.endsWith('_utils.py') ||
+        p.endsWith('_helpers.py'));
+}

package/dist/core/ingestion/export-detection.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Export Detection
+ *
+ * Determines whether a symbol (function, class, etc.) is exported/public
+ * in its language. This is a pure function — safe for use in worker threads.
+ *
+ * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ */
+import { type SyntaxNode } from './utils/ast-helpers.js';
+/** Handler type: given a node and symbol name, return true if the symbol is exported/public. */
+export type ExportChecker = (node: SyntaxNode, name: string) => boolean;
+/** JS/TS: walk ancestors looking for export_statement or export_specifier. */
+export declare const tsExportChecker: ExportChecker;
+/** Python: public if no leading underscore (convention). */
+export declare const pythonExportChecker: ExportChecker;
+/** Java: check for 'public' modifier — modifiers are siblings of the name node, not parents. */
+export declare const javaExportChecker: ExportChecker;
+/**
+ * C#: modifier nodes are SIBLINGS of the name node inside the declaration.
+ * Walk up to the declaration node, then scan its direct children.
+ */
+export declare const csharpExportChecker: ExportChecker;
+/** Go: uppercase first letter = exported. */
+export declare const goExportChecker: ExportChecker;
+/**
+ * Rust: visibility_modifier is a SIBLING of the name node within the declaration node
+ * (function_item, struct_item, etc.), not a parent. Walk up to the declaration node,
+ * then scan its direct children.
+ */
+export declare const rustExportChecker: ExportChecker;
+/**
+ * Kotlin: default visibility is public (unlike Java).
+ * visibility_modifier is inside modifiers, a sibling of the name node within the declaration.
+ */
+export declare const kotlinExportChecker: ExportChecker;
+/**
+ * C/C++: functions without 'static' storage class have external linkage by default,
+ * making them globally accessible (equivalent to exported). Only functions explicitly
+ * marked 'static' are file-scoped (not exported). C++ anonymous namespaces
+ * (namespace { ... }) also give internal linkage.
+ */
+export declare const cCppExportChecker: ExportChecker;
+/** PHP: check for visibility modifier or top-level scope. */
+export declare const phpExportChecker: ExportChecker;
+/**
+ * Swift: treat symbols as exported unless explicitly marked private/fileprivate.
+ *
+ * Swift's default access level is `internal`, which means visible to all files
+ * in the same module/target. Since Arceus indexes at the target level,
+ * `internal` symbols should be treated as exported (cross-file visible).
+ * Only `private` and `fileprivate` symbols are truly file-scoped.
+ */
+export declare const swiftExportChecker: ExportChecker;
+/** Ruby: all top-level definitions are public (no export syntax). */
+export declare const rubyExportChecker: ExportChecker;
+/** Dart: public if no leading underscore (convention, same as Python). */
+export declare const dartExportChecker: ExportChecker;