arceus-s 1.6.4

package/dist/core/ingestion/languages/python/scope-resolver.js

@@ -0,0 +1,53 @@
+/**
+ * Python `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed
+ * by the generic `runScopeResolution` orchestrator.
+ *
+ * The provider is a thin wiring object — Python's specific bits
+ * (super recognizer, LEGB merge precedence, Python's relative-import
+ * resolver, the simplified MRO walk) plug into `runScopeResolution`.
+ *
+ * Migration reference: when bringing up the next language
+ * (TypeScript / Java / Kotlin / Ruby), copy this file's structure —
+ * implement the 6 required `ScopeResolver` fields, optionally toggle
+ * the 2 booleans, and register in `scope-resolution/pipeline/registry.ts`.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { pythonProvider } from '../python.js';
+import { pythonArityCompatibility, pythonMergeBindings, resolvePythonImportTarget, } from './index.js';
+const pythonScopeResolver = {
+    language: SupportedLanguages.Python,
+    languageProvider: pythonProvider,
+    importEdgeReason: 'python-scope: import',
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
+        // Copy the orchestrator's `ReadonlySet` into a `Set` because the
+        // legacy Python resolver chain (`resolvePythonImportInternal` →
+        // `resolveAbsoluteFromFiles` / `hasRepoCandidate`) is typed to
+        // receive a mutable `Set<string>`. The copy is O(N) but called
+        // once per import — trivial compared to the parser work.
+        const ws = { fromFile, allFilePaths: new Set(allFilePaths) };
+        // `WorkspaceIndex` is an opaque `unknown` placeholder in the
+        // shared contract, so `ws` passes structurally without a cast.
+        return resolvePythonImportTarget({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
+    },
+    // Python LEGB precedence: local > import/namespace/reexport > wildcard.
+    // The per-scope id is unused by pythonMergeBindings (tier ordering
+    // is computed purely from BindingRef.origin), so we don't need to
+    // synthesize a Scope.
+    mergeBindings: (existing, incoming) => [...pythonMergeBindings([...existing, ...incoming])],
+    // Adapter: pythonArityCompatibility predates RegistryProviders and
+    // uses (def, callsite). ScopeResolver contract is (callsite, def).
+    // Wrapper kept to honor both contracts without altering the legacy
+    // shape that LanguageProvider.arityCompatibility consumes.
+    arityCompatibility: (callsite, def) => pythonArityCompatibility(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    isSuperReceiver: (text) => /^super\s*\(/.test(text),
+    // Python is dynamically typed — field-fallback heuristic on, return-
+    // type propagation across imports on. Both default to true; listed
+    // explicitly here for documentation.
+    fieldFallbackOnMethodLookup: true,
+    propagatesReturnTypesAcrossImports: true,
+};
+export { pythonScopeResolver };

package/dist/core/ingestion/languages/python/simple-hooks.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Trivial / no-op-ish hooks for the Python provider. Kept together
+ * because each is a few lines and they share a common theme: they exist
+ * to make the provider's choice explicit (rather than relying on
+ * "absence == default") so reviewers don't have to re-derive the
+ * analysis.
+ */
+import type { CaptureMatch, NodeLabel, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+import type { SyntaxNode } from 'tree-sitter';
+export declare function pythonFunctionDefinitionLabel(functionNode: SyntaxNode, defaultLabel: NodeLabel): NodeLabel;
+/** Python has no block scope, so the central extractor's "innermost
+ *  enclosing scope" default is already correct: `for x in …` creates
+ *  `x` in the enclosing function/module scope (because we never emit a
+ *  `@scope.block` for the for-loop body), comprehension variables stay
+ *  in their expression context, etc. Returns `null` to delegate. */
+export declare function pythonBindingScopeFor(_decl: CaptureMatch, _innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/** Function-local `from x import Y` should attach the binding to the
+ *  function scope, not the module. Class-body imports (rare but legal —
+ *  `class A: import x` makes `x` a class attribute) attach to the class.
+ *  Module-level imports delegate to the central default. */
+export declare function pythonImportOwningScope(_imp: ParsedImport, innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/** Look up `self` or `cls` in the function scope's type bindings.
+ *  Returns `null` for free functions (no `self`/`cls`) and for
+ *  non-Function scopes. */
+export declare function pythonReceiverBinding(functionScope: Scope): TypeRef | null;

package/dist/core/ingestion/languages/python/simple-hooks.js

@@ -0,0 +1,43 @@
+/**
+ * Trivial / no-op-ish hooks for the Python provider. Kept together
+ * because each is a few lines and they share a common theme: they exist
+ * to make the provider's choice explicit (rather than relying on
+ * "absence == default") so reviewers don't have to re-derive the
+ * analysis.
+ */
+import { findAncestorBeforeBoundary, FUNCTION_NODE_TYPES } from '../../utils/ast-helpers.js';
+const PYTHON_METHOD_CONTAINER_TYPES = new Set(['class_definition']);
+export function pythonFunctionDefinitionLabel(functionNode, defaultLabel) {
+    if (defaultLabel !== 'Function')
+        return defaultLabel;
+    const ancestor = findAncestorBeforeBoundary(functionNode, PYTHON_METHOD_CONTAINER_TYPES, FUNCTION_NODE_TYPES);
+    return ancestor === null ? 'Function' : 'Method';
+}
+// ─── bindingScopeFor ──────────────────────────────────────────────────────
+/** Python has no block scope, so the central extractor's "innermost
+ *  enclosing scope" default is already correct: `for x in …` creates
+ *  `x` in the enclosing function/module scope (because we never emit a
+ *  `@scope.block` for the for-loop body), comprehension variables stay
+ *  in their expression context, etc. Returns `null` to delegate. */
+export function pythonBindingScopeFor(_decl, _innermost, _tree) {
+    return null;
+}
+// ─── importOwningScope ────────────────────────────────────────────────────
+/** Function-local `from x import Y` should attach the binding to the
+ *  function scope, not the module. Class-body imports (rare but legal —
+ *  `class A: import x` makes `x` a class attribute) attach to the class.
+ *  Module-level imports delegate to the central default. */
+export function pythonImportOwningScope(_imp, innermost, _tree) {
+    if (innermost.kind === 'Function' || innermost.kind === 'Class')
+        return innermost.id;
+    return null;
+}
+// ─── receiverBinding ──────────────────────────────────────────────────────
+/** Look up `self` or `cls` in the function scope's type bindings.
+ *  Returns `null` for free functions (no `self`/`cls`) and for
+ *  non-Function scopes. */
+export function pythonReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('self') ?? functionScope.typeBindings.get('cls') ?? null;
+}

package/dist/core/ingestion/languages/python.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Python Language Provider
+ *
+ * Assembles all Python-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Python traits:
+ *   - importSemantics: 'namespace' (Python uses namespace imports, not wildcard)
+ *   - mroStrategy: 'c3' (Python C3 linearization for multiple inheritance)
+ *   - namedBindingExtractor: present (from X import Y)
+ */
+export declare const pythonProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/python.js

@@ -0,0 +1,133 @@
+/**
+ * Python Language Provider
+ *
+ * Assembles all Python-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Python traits:
+ *   - importSemantics: 'namespace' (Python uses namespace imports, not wildcard)
+ *   - mroStrategy: 'c3' (Python C3 linearization for multiple inheritance)
+ *   - namedBindingExtractor: present (from X import Y)
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { pythonClassConfig } from '../class-extractors/configs/python.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as pythonConfig } from '../type-extractors/python.js';
+import { pythonExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { pythonImportConfig } from '../import-resolvers/configs/python.js';
+import { extractPythonNamedBindings } from '../named-bindings/python.js';
+import { PYTHON_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { pythonConfig as pythonFieldConfig } from '../field-extractors/configs/python.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { pythonMethodConfig } from '../method-extractors/configs/python.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { pythonVariableConfig } from '../variable-extractors/configs/python.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { pythonCallConfig } from '../call-extractors/configs/python.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { emitPythonScopeCaptures, pythonFunctionDefinitionLabel, interpretPythonImport, interpretPythonTypeBinding, pythonArityCompatibility, pythonBindingScopeFor, pythonImportOwningScope, pythonMergeBindings, pythonReceiverBinding, resolvePythonImportTarget, } from './python/index.js';
+const BUILT_INS = new Set([
+    'print',
+    'len',
+    'range',
+    'str',
+    'int',
+    'float',
+    'list',
+    'dict',
+    'set',
+    'tuple',
+    'append',
+    'extend',
+    'update',
+    'type',
+    'isinstance',
+    'issubclass',
+    'getattr',
+    'setattr',
+    'hasattr',
+    'enumerate',
+    'zip',
+    'sorted',
+    'reversed',
+    'min',
+    'max',
+    'sum',
+    'abs',
+]);
+function pythonDescriptionExtractor(nodeLabel, _nodeName, captureMap) {
+    if (nodeLabel !== 'Function' && nodeLabel !== 'Method')
+        return undefined;
+    const functionNode = captureMap['definition.function'] ?? captureMap['definition.method'];
+    if (functionNode === undefined)
+        return undefined;
+    return extractPythonDocstring(functionNode);
+}
+function extractPythonDocstring(functionNode) {
+    const body = functionNode.childForFieldName('body');
+    const firstStatement = body?.namedChild(0);
+    if (firstStatement?.type !== 'expression_statement')
+        return undefined;
+    const literal = firstStatement.namedChild(0);
+    if (literal?.type !== 'string')
+        return undefined;
+    return normalizePythonStringLiteral(literal.text);
+}
+function normalizePythonStringLiteral(text) {
+    const match = text.match(/^[rRuUbBfF]*("""|'''|"|')([\s\S]*)\1$/);
+    const raw = match?.[2]?.trim();
+    if (!raw)
+        return undefined;
+    return raw.replace(/\s+/g, ' ');
+}
+export const pythonProvider = defineLanguage({
+    id: SupportedLanguages.Python,
+    extensions: ['.py'],
+    entryPointPatterns: [/^app$/, /^(get|post|put|delete|patch)_/i, /^api_/, /^view_/],
+    astFrameworkPatterns: [
+        {
+            framework: 'fastapi',
+            entryPointMultiplier: 3.0,
+            reason: 'fastapi-decorator',
+            patterns: ['@app.get', '@app.post', '@app.put', '@app.delete', '@router.get'],
+        },
+        {
+            framework: 'flask',
+            entryPointMultiplier: 2.8,
+            reason: 'flask-decorator',
+            patterns: ['@app.route', '@blueprint.route'],
+        },
+    ],
+    treeSitterQueries: PYTHON_QUERIES,
+    typeConfig: pythonConfig,
+    exportChecker: pythonExportChecker,
+    importResolver: createImportResolver(pythonImportConfig),
+    namedBindingExtractor: extractPythonNamedBindings,
+    importSemantics: 'namespace',
+    mroStrategy: 'c3',
+    callExtractor: createCallExtractor(pythonCallConfig),
+    fieldExtractor: createFieldExtractor(pythonFieldConfig),
+    methodExtractor: createMethodExtractor(pythonMethodConfig),
+    variableExtractor: createVariableExtractor(pythonVariableConfig),
+    classExtractor: createClassExtractor(pythonClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Python),
+    descriptionExtractor: pythonDescriptionExtractor,
+    builtInNames: BUILT_INS,
+    labelOverride: pythonFunctionDefinitionLabel,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    // Python is the first migration. See ./python/index.ts for the
+    // full per-hook rationale and the canonical capture vocabulary in
+    // ./python/query.ts (PYTHON_SCOPE_QUERY constant).
+    emitScopeCaptures: emitPythonScopeCaptures,
+    interpretImport: interpretPythonImport,
+    interpretTypeBinding: interpretPythonTypeBinding,
+    bindingScopeFor: pythonBindingScopeFor,
+    importOwningScope: pythonImportOwningScope,
+    mergeBindings: (_scope, bindings) => pythonMergeBindings(bindings),
+    receiverBinding: pythonReceiverBinding,
+    arityCompatibility: pythonArityCompatibility,
+    resolveImportTarget: resolvePythonImportTarget,
+});

package/dist/core/ingestion/languages/ruby.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Ruby language provider.
+ *
+ * Ruby uses wildcard import semantics (require/require_relative bring
+ * everything into scope). Ruby has SPECIAL call routing via routeRubyCall
+ * to handle require, include/extend (heritage), and attr_accessor/
+ * attr_reader/attr_writer (property definitions) as call expressions.
+ */
+export declare const rubyProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/ruby.js

@@ -0,0 +1,235 @@
+/**
+ * Ruby language provider.
+ *
+ * Ruby uses wildcard import semantics (require/require_relative bring
+ * everything into scope). Ruby has SPECIAL call routing via routeRubyCall
+ * to handle require, include/extend (heritage), and attr_accessor/
+ * attr_reader/attr_writer (property definitions) as call expressions.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { rubyClassConfig } from '../class-extractors/configs/ruby.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as rubyConfig } from '../type-extractors/ruby.js';
+import { routeRubyCall } from '../call-routing.js';
+import { rubyExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { rubyImportConfig } from '../import-resolvers/configs/ruby.js';
+import { RUBY_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { rubyConfig as rubyFieldConfig } from '../field-extractors/configs/ruby.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { rubyMethodConfig } from '../method-extractors/configs/ruby.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { rubyVariableConfig } from '../variable-extractors/configs/ruby.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { rubyCallConfig } from '../call-extractors/configs/ruby.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { rubyHeritageConfig } from '../heritage-extractors/configs/ruby.js';
+import { maybeRewriteRubyBareCallToSelf } from '../utils/ruby-self-call.js';
+import { findEnclosingClassInfo } from '../utils/ast-helpers.js';
+/**
+ * Ruby label override. Applied to:
+ *   - `definition.module` captures in the structure phase — remaps to `Trait`
+ *     so Ruby modules are registered in the class-like type registry and are
+ *     therefore resolvable by `lookupClassByName` during mixin heritage
+ *     resolution (`include`/`extend`/`prepend`).
+ *   - `definition.function` captures — Ruby has no bare "function" construct
+ *     (top-level `def` is a method on `main`); return the default so generic
+ *     logic continues to apply.
+ *
+ * Returning `null` means "skip this definition"; we never do that here.
+ */
+const rubyLabelOverride = (_node, defaultLabel) => {
+    if (defaultLabel === 'Module')
+        return 'Trait';
+    return defaultLabel;
+};
+/** Ruby method/singleton_method: extract name from 'name' field, label as Method. */
+const rubyExtractFunctionName = (node) => {
+    if (node.type !== 'method' && node.type !== 'singleton_method')
+        return null;
+    let nameNode = node.childForFieldName?.('name');
+    if (!nameNode) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'identifier') {
+                nameNode = c;
+                break;
+            }
+        }
+    }
+    return { funcName: nameNode?.text ?? null, label: 'Method' };
+};
+const BUILT_INS = new Set([
+    'puts',
+    'p',
+    'pp',
+    'raise',
+    'fail',
+    'require',
+    'require_relative',
+    'load',
+    'autoload',
+    'include',
+    'extend',
+    'prepend',
+    'attr_accessor',
+    'attr_reader',
+    'attr_writer',
+    'public',
+    'private',
+    'protected',
+    'module_function',
+    'lambda',
+    'proc',
+    'block_given?',
+    'nil?',
+    'is_a?',
+    'kind_of?',
+    'instance_of?',
+    'respond_to?',
+    'freeze',
+    'frozen?',
+    'dup',
+    'tap',
+    'yield_self',
+    'each',
+    'select',
+    'reject',
+    'detect',
+    'collect',
+    'inject',
+    'flat_map',
+    'each_with_object',
+    'each_with_index',
+    'any?',
+    'all?',
+    'none?',
+    'count',
+    'first',
+    'last',
+    'sort_by',
+    'min_by',
+    'max_by',
+    'group_by',
+    'partition',
+    'compact',
+    'flatten',
+    'uniq',
+]);
+/**
+ * Remaps `class << self` (singleton_class) to its enclosing class/module for
+ * receiver inference. A `singleton_class` node is not itself a type — walking
+ * up to the real owner lets `inferImplicitReceiver` set `hint='singleton'`.
+ * Returns null for orphaned singleton_class (no enclosing class/module found).
+ * All other container types are returned as-is.
+ */
+const rubyResolveEnclosingOwner = (node) => {
+    if (node.type === 'singleton_class') {
+        let ancestor = node.parent;
+        while (ancestor) {
+            if (ancestor.type === 'class' || ancestor.type === 'module') {
+                return ancestor;
+            }
+            ancestor = ancestor.parent;
+        }
+        return null; // no enclosing class/module — skip
+    }
+    return node; // use as-is for all other container types
+};
+export const rubyProvider = defineLanguage({
+    id: SupportedLanguages.Ruby,
+    extensions: ['.rb', '.rake', '.gemspec'],
+    entryPointPatterns: [/^call$/, /^perform$/, /^execute$/],
+    astFrameworkPatterns: [
+        {
+            framework: 'rails',
+            entryPointMultiplier: 3.0,
+            reason: 'rails-pattern',
+            patterns: [
+                'ApplicationController',
+                'ApplicationRecord',
+                'ActiveRecord::Base',
+                'before_action',
+                'after_action',
+                'has_many',
+                'belongs_to',
+                'has_one',
+                'validates',
+            ],
+        },
+        {
+            framework: 'sinatra',
+            entryPointMultiplier: 2.8,
+            reason: 'sinatra-pattern',
+            patterns: ['Sinatra::Base', 'Sinatra::Application'],
+        },
+    ],
+    treeSitterQueries: RUBY_QUERIES,
+    typeConfig: rubyConfig,
+    exportChecker: rubyExportChecker,
+    importResolver: createImportResolver(rubyImportConfig),
+    callRouter: routeRubyCall,
+    importSemantics: 'wildcard-leaf',
+    callExtractor: createCallExtractor(rubyCallConfig),
+    resolveEnclosingOwner: rubyResolveEnclosingOwner,
+    fieldExtractor: createFieldExtractor(rubyFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...rubyMethodConfig,
+        extractFunctionName: rubyExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(rubyVariableConfig),
+    classExtractor: createClassExtractor(rubyClassConfig),
+    heritageExtractor: createHeritageExtractor(rubyHeritageConfig),
+    labelOverride: rubyLabelOverride,
+    // Ruby MRO is kind-aware: prepend providers beat the class's own method,
+    // which in turn beats include providers. See `lookupMethodByOwnerWithMRO`
+    // in `model/resolve.ts` for the walk order.
+    mroStrategy: 'ruby-mixin',
+    // ── DAG hooks ────────────────────────────────────────────────────
+    //
+    // DAG stage 3: rewrite bare calls (e.g. `serialize` in Account#call_serialize)
+    // as `self.serialize` so they route through owner-scoped MRO instead of
+    // global free-call lookup. `dispatchKind` goes into `hint` for stage 4.
+    inferImplicitReceiver: ({ calledName, callForm, receiverName, receiverTypeName, callNode, filePath, }) => {
+        // Only fire when no receiver has been resolved already.
+        if (receiverName || receiverTypeName)
+            return null;
+        const enclosing = findEnclosingClassInfo(callNode, filePath, rubyResolveEnclosingOwner);
+        const rewrite = maybeRewriteRubyBareCallToSelf(calledName, callForm, callNode, enclosing?.className ?? null, { isBuiltInName: (n) => BUILT_INS.has(n), mroStrategy: 'ruby-mixin' });
+        if (!rewrite)
+            return null;
+        return {
+            callForm: rewrite.callForm,
+            receiverName: rewrite.receiverName,
+            receiverTypeName: rewrite.receiverTypeName,
+            receiverSource: 'implicit-self',
+            hint: rewrite.dispatchKind, // 'instance' | 'singleton'
+        };
+    },
+    // DAG stage 4: two Ruby dispatch overrides —
+    //   implicit-self: MRO walk first, fallback to free-arity-narrowed on miss.
+    //   class-as-receiver: singleton ancestry (extend providers only); miss null-routes.
+    selectDispatch: ({ receiverSource, hint }) => {
+        if (receiverSource === 'implicit-self') {
+            // hint='instance' → instance ancestry (prepend→direct→include, see mro-strategy.ts § 'ruby-mixin')
+            // hint='singleton' → singleton ancestry (extend providers only; miss null-routes)
+            const ancestryView = hint === 'singleton' ? 'singleton' : 'instance';
+            return {
+                primary: 'owner-scoped',
+                fallback: 'free-arity-narrowed',
+                ancestryView,
+            };
+        }
+        if (receiverSource === 'class-as-receiver') {
+            // Class constant receiver (e.g. Account.log): singleton ancestry only; miss null-routes.
+            return {
+                primary: 'owner-scoped',
+                ancestryView: 'singleton',
+            };
+        }
+        return null;
+    },
+    builtInNames: BUILT_INS,
+});

package/dist/core/ingestion/languages/rust.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Rust Language Provider
+ *
+ * Assembles all Rust-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Rust traits:
+ *   - importSemantics: 'named' (Rust has use X::{a, b})
+ *   - mroStrategy: 'qualified-syntax' (Rust uses trait qualification, not MRO)
+ *   - namedBindingExtractor: present (use X::{a, b} extracts named bindings)
+ */
+export declare const rustProvider: import("../language-provider.js").LanguageProvider;