gitnexus 1.6.4-rc.19 → 1.6.4-rc.20

package/dist/core/ingestion/call-processor.d.ts

@@ -130,9 +130,9 @@ export declare const resolveMemberCall: (ownerType: string, methodName: string,
  * resolution via `ctx.resolve()`.
  *
  * Used for `foo()`, `doStuff()` — unqualified calls with no receiver.
- * Also handles Swift/Kotlin implicit constructors (`User()` without `new`)
- * by delegating to {@link resolveStaticCall} when the tiered pool contains
- * class-like targets.
+ * Also handles implicit constructors (`User()` without `new`) by delegating
+ * to {@link resolveStaticCall} when the tiered pool contains class-like
+ * targets.
  *
  * {@link resolveCallTarget} delegates here for `callForm === 'free'`.
  *

package/dist/core/ingestion/call-processor.js

@@ -3,7 +3,7 @@ import { CLASS_TYPES, CALL_TARGET_TYPES, lookupMethodByOwnerWithMRO } from './mo
  * DAG stage 4 fallback: used when `selectDispatch` is absent or returns null.
  * Preserves pre-DAG dispatch semantics:
  *   - 'constructor'         → constructor branch
- *   - 'free'                → free branch (admits Swift/Kotlin class-target fast path)
+ *   - 'free'                → free branch (admits class-target fast path)
  *   - 'member' or undefined → owner-scoped branch
  *
  * `undefined` callForm MUST route through owner-scoped (not free) so bare
@@ -1275,41 +1275,19 @@ const disambiguateByOverloadOrArgTypes = (pool, overloadHints, preComputedArgTyp
         return matchCandidatesByArgTypes(pool, preComputedArgTypes);
     return null;
 };
-/**
- * Collapse Swift-extension duplicate Class/Struct candidates to the primary
- * definition, preferring the shortest file path.
- *
- * Swift extensions (`extension User { ... }` in a separate file) create
- * multiple `Class` nodes sharing the same symbol name — one for the primary
- * declaration and one per extension file. When overload disambiguation and
- * receiver narrowing both fail to converge on a single candidate, this
- * heuristic picks the primary definition based on the assumption that it
- * lives at the shortest file path (e.g. `User.swift` over `UserExtensions.swift`).
- *
- * Intentionally narrower than {@link INSTANTIABLE_CLASS_TYPES}: only `Class`
- * and `Struct` are considered, not `Record`. Swift extensions only produce
- * `Class` duplicates in practice, and C#/Kotlin records do not exhibit the
- * same multi-file-definition pattern, so widening this set risks accidental
- * dedup of legitimately distinct record types.
- *
- * Returns a `ResolveResult` when the heuristic fires, `null` when the
- * candidate pool does not match the shape (mixed types, non-Class/Struct
- * kinds, or `length <= 1`). Callers should fall through to their own null
- * return when this helper returns `null`.
- *
- * Used by `resolveFreeCall`. Having a single source of truth prevents
- * duplication if the heuristic is ever tuned.
- */
-const dedupSwiftExtensionCandidates = (candidates, tier) => {
-    if (candidates.length <= 1)
-        return null;
-    const allSameType = candidates.every((c) => c.type === candidates[0].type);
-    if (!allSameType)
-        return null;
-    if (candidates[0].type !== 'Class' && candidates[0].type !== 'Struct')
+const orderProviderSameNameTypeCandidates = (candidates, typeName, filePath) => {
+    const language = getLanguageFromFilename(filePath);
+    if (language == null)
         return null;
-    const sorted = [...candidates].sort((a, b) => a.filePath.length - b.filePath.length);
-    return toResolveResult(sorted[0], tier);
+    return (getProvider(language).orderSameNameTypeCandidates?.({
+        typeName,
+        callSiteFilePath: filePath,
+        candidates,
+    }) ?? null);
+};
+const resolveProviderPrimaryTypeCandidate = (candidates, tier, typeName, filePath) => {
+    const ordered = orderProviderSameNameTypeCandidates(candidates, typeName, filePath);
+    return ordered && ordered.length > 0 ? toResolveResult(ordered[0], tier) : null;
 };
 /**
  * Thin dispatcher that routes a call to the appropriate specialized resolver.
@@ -1742,6 +1720,25 @@ ancestryView) => {
             break;
         }
     }
+    if (!firstDef && !ambiguous) {
+        const orderedTypeCandidates = orderProviderSameNameTypeCandidates(ctx.model.types.lookupClassByName(receiverTypeName), receiverTypeName, filePath);
+        if (orderedTypeCandidates) {
+            for (const candidate of orderedTypeCandidates) {
+                const def = canWalkMRO
+                    ? lookupMethodByOwnerWithMRO(candidate.nodeId, methodName, heritageMap, ctx.model, mroStrategy, argCount)
+                    : ctx.model.methods.lookupMethodByOwner(candidate.nodeId, methodName, argCount);
+                if (!def)
+                    continue;
+                if (!firstDef) {
+                    firstDef = def;
+                }
+                else if (def.nodeId !== firstDef.nodeId) {
+                    ambiguous = true;
+                    break;
+                }
+            }
+        }
+    }
     if (!firstDef || ambiguous)
         return undefined;
     return { def: firstDef, tier: typeResolved.tier };
@@ -1791,9 +1788,9 @@ export const resolveMemberCall = (ownerType, methodName, currentFile, ctx, herit
  * resolution via `ctx.resolve()`.
  *
  * Used for `foo()`, `doStuff()` — unqualified calls with no receiver.
- * Also handles Swift/Kotlin implicit constructors (`User()` without `new`)
- * by delegating to {@link resolveStaticCall} when the tiered pool contains
- * class-like targets.
+ * Also handles implicit constructors (`User()` without `new`) by delegating
+ * to {@link resolveStaticCall} when the tiered pool contains class-like
+ * targets.
  *
  * {@link resolveCallTarget} delegates here for `callForm === 'free'`.
  *
@@ -1816,33 +1813,30 @@ export const resolveFreeCall = (calledName, filePath, ctx, argCount, tieredOverr
     if (!tiered)
         return null;
     let filteredCandidates = filterCallableCandidates(tiered.candidates, argCount, 'free');
-    // Class-target fast path: Swift/Kotlin `User()` — free-form call targeting a
-    // class. Delegates to resolveStaticCall for O(1) class + constructor lookup.
+    // Class-target fast path: free-form call targeting a class. Delegates to
+    // resolveStaticCall for O(1) class + constructor lookup.
     // The `.some()` trigger must stay aligned with `INSTANTIABLE_CLASS_TYPES` —
     // any type admitted here that is not in that set will cause resolveStaticCall
     // to return null, wasting two lookup passes per call. `Enum` is deliberately
-    // excluded; `Record` is included so C# records and Kotlin data classes reach
-    // the fast path.
+    // excluded; `Record` is included so record-like class targets reach the fast
+    // path.
     // Align with INSTANTIABLE_CLASS_TYPES by reusing the set directly rather
     // than enumerating literal strings. This converts an invariant that was
     // previously enforced by a comment ("keep this list aligned with
     // INSTANTIABLE_CLASS_TYPES") into one enforced structurally — any future
-    // extension of the set (e.g. Kotlin `object`) propagates here automatically.
-    // The `dedupSwiftExtensionCandidates` helper used in the tail of this
-    // function deliberately uses a narrower literal `'Class' | 'Struct'` check
-    // — Swift extensions only produce Class duplicates in practice, so Record
-    // is excluded there by design. Do not collapse that helper into
-    // INSTANTIABLE_CLASS_TYPES.
+    // extension of the set propagates here automatically.
+    // Language providers can still choose a primary same-name type candidate in
+    // the tail of this function when their grammars index one logical type
+    // multiple times.
     const hasClassTarget = filteredCandidates.length === 0 &&
         tiered.candidates.some((c) => INSTANTIABLE_CLASS_TYPES.has(c.type));
     if (hasClassTarget) {
         const staticResult = resolveStaticCall(calledName, filePath, ctx, argCount, tiered);
         if (staticResult)
             return staticResult;
-        // Retry with constructor form: Swift/Kotlin constructor calls look like
-        // free function calls (no `new` keyword). If resolveStaticCall didn't
-        // match, re-filter with constructor form so CONSTRUCTOR_TARGET_TYPES
-        // applies.
+        // Retry with constructor form for languages whose constructor calls look
+        // like free function calls. If resolveStaticCall didn't match, re-filter
+        // with constructor form so CONSTRUCTOR_TARGET_TYPES applies.
         //
         // The retry fires for every null return from `resolveStaticCall`, which
         // can happen for three distinct reasons — all three are handled below:
@@ -1856,9 +1850,8 @@ export const resolveFreeCall = (calledName, filePath, ctx, argCount, tieredOverr
         //   (b) Homonym ambiguity — two or more instantiable class candidates
         //       share the name (e.g. `User` in two files, same tier). The
         //       retry repopulates `filteredCandidates` with both Classes and
-        //       they flow into `dedupSwiftExtensionCandidates` below, which
-        //       either picks the shortest-path primary or null-routes.
-        //       Covered by the R7 Swift-extension dedup test.
+        //       they flow into the provider same-name candidate hook below, which
+        //       can pick a primary definition or null-route.
         //
         //   (c) `resolveStaticCall` step 4 bailed because the tiered pool
         //       contains ownerless `Constructor` nodes (some extractors emit
@@ -1882,11 +1875,9 @@ export const resolveFreeCall = (calledName, filePath, ctx, argCount, tieredOverr
             return toResolveResult(disambiguated, tiered.tier);
     }
     if (filteredCandidates.length !== 1) {
-        // See `dedupSwiftExtensionCandidates` — shared helper, single source of
-        // truth for the Swift-extension same-name collision heuristic.
-        const deduped = dedupSwiftExtensionCandidates(filteredCandidates, tiered.tier);
-        if (deduped)
-            return deduped;
+        const primary = resolveProviderPrimaryTypeCandidate(filteredCandidates, tiered.tier, calledName, filePath);
+        if (primary)
+            return primary;
         return null;
     }
     return toResolveResult(filteredCandidates[0], tiered.tier);
@@ -2034,9 +2025,11 @@ export const resolveStaticCall = (className, currentFile, ctx, argCount, tieredO
     //     Interface / Trait / Impl). Null-route via the fall-through `return
     //     null` — this is the dominant Codex-fix case.
     //   length === 1 → a single instantiable candidate remains, return it.
-    //   length  >  1 → two or more instantiable classes share the name (e.g.
-    //     homonym classes across files with no import narrowing). Fall through
-    //     to `return null` so the caller null-routes rather than guess.
+    //   length  >  1 → let the call-site provider choose a primary when it can
+    //     prove the candidates are one logical type; otherwise null-route.
+    const primary = resolveProviderPrimaryTypeCandidate(instantiableCandidates, typeResolved.tier, className, currentFile);
+    if (primary)
+        return primary;
     if (instantiableCandidates.length === 1) {
         return toResolveResult(instantiableCandidates[0], typeResolved.tier);
     }

package/dist/core/ingestion/language-provider.d.ts

@@ -382,6 +382,14 @@ interface LanguageProviderConfig {
      * else treats as `'free'`).
      */
     readonly classifyCallForm?: (captures: CaptureMatch, enclosingScope: Scope) => 'free' | 'member' | 'constructor' | 'index';
+    /** Order same-name type candidates when a language can index multiple
+     * definitions for one logical type. Return null to keep shared ambiguity
+     * handling. */
+    readonly orderSameNameTypeCandidates?: (params: {
+        readonly typeName: string;
+        readonly callSiteFilePath: string;
+        readonly candidates: readonly SymbolDefinition[];
+    }) => readonly SymbolDefinition[] | null;
     /**
      * Is this callable definition compatible with the given call-site arity?
      * Language-specific rules: Python `*args`/`**kwargs`/defaults, JS default

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

@@ -112,6 +112,19 @@ const swiftExtractFunctionName = (node) => {
         return { funcName: 'deinit', label: 'Constructor' };
     return null; // fall through to generic
 };
+const orderSwiftSameNameTypeCandidates = ({ callSiteFilePath, candidates, }) => {
+    if (!callSiteFilePath.endsWith('.swift'))
+        return null;
+    if (candidates.length <= 1)
+        return null;
+    if (!candidates.every((c) => c.type === candidates[0].type))
+        return null;
+    if (candidates[0].type !== 'Class' && candidates[0].type !== 'Struct')
+        return null;
+    if (!candidates.every((c) => c.filePath.endsWith('.swift')))
+        return null;
+    return [...candidates].sort((a, b) => a.filePath.length - b.filePath.length || a.filePath.localeCompare(b.filePath));
+};
 const BUILT_INS = new Set([
     'print',
     'debugPrint',
@@ -240,5 +253,6 @@ export const swiftProvider = defineLanguage({
     classExtractor: createClassExtractor(swiftClassConfig),
     heritageExtractor: createHeritageExtractor(SupportedLanguages.Swift),
     implicitImportWirer: wireSwiftImplicitImports,
+    orderSameNameTypeCandidates: orderSwiftSameNameTypeCandidates,
     builtInNames: BUILT_INS,
 });

package/dist/core/ingestion/method-extractors/configs/swift.js

@@ -1,5 +1,5 @@
 // gitnexus/src/core/ingestion/method-extractors/configs/swift.ts
-// Verified against tree-sitter-swift 0.6.0
+// Verified against tree-sitter-swift 0.7.x
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { findVisibility, hasKeyword, hasModifier } from '../../field-extractors/configs/helpers.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
@@ -97,7 +97,7 @@ function extractSwiftReturnType(node) {
  */
 function extractSwiftParameters(node) {
     const params = [];
-    // In tree-sitter-swift 0.6.0, parameters are direct children of function_declaration.
+    // In tree-sitter-swift, parameters are direct children of function_declaration.
     // Default value tokens ('=', literal) are siblings of the parameter node at the
     // function_declaration level, not children of the parameter node.
     for (let i = 0; i < node.childCount; i++) {
@@ -242,8 +242,7 @@ function extractSwiftAnnotations(node) {
 // ---------------------------------------------------------------------------
 export const swiftMethodConfig = {
     language: SupportedLanguages.Swift,
-    // tree-sitter-swift 0.6.0 may use class_declaration for classes, structs, enums, extensions,
-    // and actors — but this cannot be verified until the grammar installs on Node 22+.
+    // Keep this conservative until Swift type-shape coverage is expanded.
     // TODO: Verify struct_declaration, enum_declaration, extension_declaration, actor_declaration
     // node types once tree-sitter-swift loads on Node 22, and add them here if they are distinct.
     // protocol_declaration is a separate, confirmed node type.

package/dist/core/ingestion/parsing-processor.js

@@ -412,10 +412,12 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                     }
                 }
             }
-            // Append #<paramCount> to Method/Constructor IDs to disambiguate overloads.
-            // Functions are not suffixed — they don't overload by name in the same scope.
+            // Append #<paramCount> to owned callable IDs to disambiguate overloads.
+            // Top-level Function IDs stay stable; functions inside an owner may overload.
             // When same-arity collisions exist, append ~type1,type2 for further disambiguation.
-            const needsAritySuffix = nodeLabel === 'Method' || nodeLabel === 'Constructor';
+            const needsAritySuffix = nodeLabel === 'Method' ||
+                nodeLabel === 'Constructor' ||
+                (nodeLabel === 'Function' && enclosingClassId !== null);
             let arityTag = needsAritySuffix && arityForId !== undefined ? `#${arityForId}` : '';
             if (arityTag && seqDefMethods && seqDefMethodInfo && seqClassNodeId !== undefined) {
                 // Use cached method map + collision groups (built once per class, not per method)

package/dist/core/ingestion/type-extractors/swift.js

@@ -21,6 +21,9 @@ function unwrapSwiftExpression(node) {
     }
     return node;
 }
+function swiftNavigationSuffixName(node) {
+    return node?.type === 'navigation_suffix' ? node.lastNamedChild?.text : node?.text;
+}
 /** Swift: let x: Foo = ... */
 const extractDeclaration = (node, env) => {
     // Swift property_declaration has pattern and type_annotation
@@ -99,8 +102,8 @@ const extractInitializer = (node, env, classNames) => {
     // Explicit init: User.init(name: "alice") — navigation_expression with .init suffix
     if (callee.type === 'navigation_expression') {
         const receiver = callee.firstNamedChild;
-        const suffix = callee.lastNamedChild;
-        if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') {
+        if (receiver?.type === 'simple_identifier' &&
+            swiftNavigationSuffixName(callee.lastNamedChild) === 'init') {
             const calleeName = receiver.text;
             if (calleeName && classNames.has(calleeName)) {
                 env.set(varName, calleeName);
@@ -114,7 +117,7 @@ const scanConstructorBinding = (node) => {
         return undefined;
     if (hasTypeAnnotation(node))
         return undefined;
-    const pattern = node.childForFieldName('pattern');
+    const pattern = node.childForFieldName('pattern') ?? findChild(node, 'pattern');
     if (!pattern)
         return undefined;
     const varName = pattern.text;
@@ -147,7 +150,7 @@ const scanConstructorBinding = (node) => {
     if (callee.type === 'navigation_expression') {
         const receiver = callee.firstNamedChild;
         const suffix = callee.lastNamedChild;
-        if (receiver?.type === 'simple_identifier' && suffix?.text === 'init') {
+        if (receiver?.type === 'simple_identifier' && swiftNavigationSuffixName(suffix) === 'init') {
             return { varName, calleeName: receiver.text };
         }
         // General qualified call: service.getUser() → extract method name.

package/dist/core/ingestion/workers/parse-worker.js

@@ -1615,10 +1615,12 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     }
                 }
             }
-            // Append #<paramCount> to Method/Constructor IDs to disambiguate overloads.
-            // Functions are not suffixed — they don't overload by name in the same scope.
+            // Append #<paramCount> to owned callable IDs to disambiguate overloads.
+            // Top-level Function IDs stay stable; functions inside an owner may overload.
             // When same-arity collisions exist, append ~type1,type2 for further disambiguation.
-            const needsAritySuffix = nodeLabel === 'Method' || nodeLabel === 'Constructor';
+            const needsAritySuffix = nodeLabel === 'Method' ||
+                nodeLabel === 'Constructor' ||
+                (nodeLabel === 'Function' && enclosingClassId !== null);
             let arityTag = needsAritySuffix && arityForId !== undefined ? `#${arityForId}` : '';
             if (arityTag && defMethodMap && defMethodInfo) {
                 const groups = buildCollisionGroups(defMethodMap);

package/hooks/claude/gitnexus-hook.cjs

@@ -31,11 +31,21 @@ function readInput() {
  * Find the .gitnexus directory by walking up from startDir.
  * Returns the path to .gitnexus/ or null if not found.
  */
+function isGlobalRegistryDir(candidate) {
+  if (fs.existsSync(path.join(candidate, 'meta.json'))) return false;
+  return (
+    fs.existsSync(path.join(candidate, 'registry.json')) ||
+    fs.existsSync(path.join(candidate, 'repos'))
+  );
+}
+
 function findGitNexusDir(startDir) {
   let dir = startDir || process.cwd();
   for (let i = 0; i < 5; i++) {
     const candidate = path.join(dir, '.gitnexus');
-    if (fs.existsSync(candidate)) return candidate;
+    if (fs.existsSync(candidate)) {
+      if (!isGlobalRegistryDir(candidate)) return candidate;
+    }
     const parent = path.dirname(dir);
     if (parent === dir) break;
     dir = parent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.19",
+  "version": "1.6.4-rc.20",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -47,7 +47,7 @@
     "test:integration": "vitest run test/integration",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "postinstall": "node scripts/patch-tree-sitter-swift.cjs && node scripts/build-tree-sitter-dart.cjs && node scripts/build-tree-sitter-proto.cjs",
+    "postinstall": "node scripts/build-tree-sitter-dart.cjs && node scripts/build-tree-sitter-proto.cjs",
     "prepare": "node scripts/build.js",
     "prepack": "node scripts/build.js"
   },
@@ -91,7 +91,7 @@
     "tree-sitter-dart": "file:./vendor/tree-sitter-dart",
     "tree-sitter-kotlin": "^0.3.8",
     "tree-sitter-proto": "file:./vendor/tree-sitter-proto",
-    "tree-sitter-swift": "^0.6.0"
+    "tree-sitter-swift": "file:./vendor/tree-sitter-swift"
   },
   "devDependencies": {
     "@types/cli-progress": "^3.11.6",

package/scripts/build-tree-sitter-proto.cjs

@@ -26,7 +26,7 @@
  *   `node_modules/tree-sitter-proto/build/Release/tree_sitter_proto_binding.node`
  *   — under npm-managed territory, safe on upgrade.
  *
- *   Mirrors scripts/patch-tree-sitter-swift.cjs. Best-effort: if any
+ *   Mirrors the tree-sitter-dart build helper. Best-effort: if any
  *   precondition fails (optional dep absent, no toolchain, --ignore-scripts),
  *   warn and exit 0 so gitnexus install still succeeds.
  */

package/vendor/tree-sitter-swift/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 alex-pinkus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/tree-sitter-swift/README.md

@@ -0,0 +1,139 @@
+## GitNexus vendor notice
+
+This directory is a GitNexus-managed vendored copy of the official
+`tree-sitter-swift@0.7.1` npm runtime package, including its official native
+prebuilds. GitNexus keeps the top-level `tree-sitter` dependency pinned to
+`^0.21.1` until the broader parser runtime upgrade is handled separately.
+
+When updating this vendor package, replace it from an official
+`tree-sitter-swift` npm release, keep the native `prebuilds/` artifacts, update
+the `_vendoredBy` provenance fields in `package.json`, and verify the packed
+GitNexus tarball can load `tree-sitter-swift`.
+
+![Parse rate badge](https://byob.yarr.is/alex-pinkus/tree-sitter-swift/parse_rate)
+[![Crates.io badge](https://byob.yarr.is/alex-pinkus/tree-sitter-swift/crates_io_version)](https://crates.io/crates/tree-sitter-swift)
+[![NPM badge](https://byob.yarr.is/alex-pinkus/tree-sitter-swift/npm_version)](https://www.npmjs.com/package/tree-sitter-swift)
+[![Build](https://github.com/alex-pinkus/tree-sitter-swift/actions/workflows/top-repos.yml/badge.svg)](https://github.com/alex-pinkus/tree-sitter-swift/actions/workflows/top-repos.yml)
+
+# tree-sitter-swift
+
+This contains a [`tree-sitter`](https://tree-sitter.github.io/tree-sitter) grammar for the Swift programming language.
+
+## Getting started
+
+To use this parser to parse Swift code, you'll want to depend on either the Rust crate or the NPM package.
+
+### Rust
+
+To use the Rust crate, you'll add this to your `Cargo.toml`:
+
+```
+tree-sitter = "0.23.0"
+tree-sitter-swift = "=0.7.0"
+```
+
+Then you can use a `tree-sitter` parser with the language declared here:
+
+```
+let mut parser = tree_sitter::Parser::new();
+parser.set_language(tree_sitter_swift::language())?;
+
+// ...
+
+let tree = parser.parse(&my_source_code, None)
+    .ok_or_else(|| /* error handling code */)?;
+```
+
+### Javascript
+
+To use this from NPM, you'll add similar dependencies to `package.json`:
+
+```
+"dependencies: {
+  "tree-sitter-swift": "0.7.0",
+  "tree-sitter": "^0.22.1"
+}
+```
+
+Your usage of the parser will look like:
+
+```
+const Parser = require("tree-sitter");
+const Swift = require("tree-sitter-swift");
+
+const parser = new Parser();
+parser.setLanguage(Swift);
+
+// ...
+
+const tree = parser.parse(mySourceCode);
+```
+
+### Editing the grammar
+
+With this package checked out, a common workflow for editing the grammar will look something like:
+
+1. Make a change to `grammar.ts`.
+2. Run `npm install && npm test` to see whether the change has had impact on existing parsing behavior. The default
+   `npm test` target requires `valgrind` to be installed; if you do not have it installed, and do not wish to, you can
+   substitute `tree-sitter test` directly.
+3. Run `tree-sitter parse` on some real Swift codebase and see whether (or where) it fails.
+4. Use any failures to create new corpus test cases.
+
+## Contributions
+
+All contributions to this repository are welcome.
+
+If said contribution is to check generated files (e.g., `parser.c`) into the repository, be aware that your contribution will not be accepted. Make sure to read the [FAQ entry](https://github.com/alex-pinkus/tree-sitter-swift?tab=readme-ov-file#where-is-your-parserc) and the [prior](https://github.com/alex-pinkus/tree-sitter-swift/issues/362) [discussions](https://github.com/alex-pinkus/tree-sitter-swift/pull/315) and [compromises](https://github.com/alex-pinkus/tree-sitter-swift/issues/149) that have occurred already on this topic.
+
+## Using tree-sitter-swift in Web Assembly
+
+To use tree-sitter-swift as a language for the web bindings version tree-sitter, which will likely be a more modern version than the published node
+module. [see](https://github.com/tree-sitter/tree-sitter/blob/master/lib/binding_web/README.md). Follow the instructions below
+
+1. Install the node modules `npm install web-tree-sitter tree-sitter-swift`
+2. Run the tree-sitter cli to create the wasm bundle
+   ```sh
+   $ npx tree-sitter build-asm ./node_modules/tree-sitter
+   ```
+3. Boot tree-sitter wasm like this.
+
+```js
+const Parser = require('web-tree-sitter');
+async function run() {
+  //needs to happen first
+  await Parser.init();
+  //wait for the load of swift
+  const Swift = await Parser.Language.load('./tree-sitter-swift.wasm');
+
+  const parser = new Parser();
+  parser.setLanguage(Swift);
+
+  //Parse your swift code here.
+  const tree = parser.parse('print("Hello, World!")');
+}
+//if you want to run this
+run().then(console.log, console.error);
+```
+
+## Frequently asked questions
+
+### Where is your `parser.c`?
+
+This repository currently omits most of the code that is autogenerated during a build. This means, for instance, that
+`grammar.json` and `parser.c` are both only available following a build. It also significantly reduces noise during
+diffs.
+
+The side benefit of not checking in `parser.c` is that you can guarantee backwards compatibility. Parsers generated by
+the tree-sitter CLI aren't always backwards compatible. If you need a parser, generate it yourself using the CLI; all
+the information to do so is available in this package. By doing that, you'll also know for sure that your parser version
+and your library version are compatible.
+
+If you need a `parser.c`, and you don't care about the tree-sitter version, but you don't have a local setup that would
+allow you to obtain the parser, you can just download one from a recent workflow run in this package. To do so:
+
+- Go to the [GitHub actions page](https://github.com/alex-pinkus/tree-sitter-swift/actions) for this
+  repository.
+- Click on the "Publish `grammar.json` and `parser.c`" action for the appropriate commit.
+- Go down to `Artifacts` and click on `generated-parser-src`. All the relevant parser files will be available in your
+  download.

package/vendor/tree-sitter-swift/bindings/node/index.d.ts

@@ -0,0 +1,28 @@
+type BaseNode = {
+  type: string;
+  named: boolean;
+};
+
+type ChildNode = {
+  multiple: boolean;
+  required: boolean;
+  types: BaseNode[];
+};
+
+type NodeInfo =
+  | (BaseNode & {
+      subtypes: BaseNode[];
+    })
+  | (BaseNode & {
+      fields: { [name: string]: ChildNode };
+      children: ChildNode[];
+    });
+
+type Language = {
+  name: string;
+  language: unknown;
+  nodeTypeInfo: NodeInfo[];
+};
+
+declare const language: Language;
+export = language;

package/vendor/tree-sitter-swift/bindings/node/index.js

@@ -0,0 +1,7 @@
+const root = require("path").join(__dirname, "..", "..");
+
+module.exports = require("node-gyp-build")(root);
+
+try {
+  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+} catch (_) {}

package/vendor/tree-sitter-swift/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "tree-sitter-swift",
+  "version": "0.7.1",
+  "description": "A tree-sitter grammar for the Swift programming language",
+  "main": "bindings/node/index.js",
+  "types": "bindings/node/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alex-pinkus/tree-sitter-swift.git"
+  },
+  "_vendoredBy": "gitnexus - minimal runtime package copied from official tree-sitter-swift@0.7.1 (gitHead 88bfd19a89be9d0481b14566fb6160cccea2fe0a). Keeps upstream prebuilds while allowing GitNexus to stay on tree-sitter@0.21.1 until #858 is resolved.",
+  "scripts": {
+    "install": "node-gyp-build"
+  },
+  "dependencies": {
+    "node-addon-api": "^8.0.0",
+    "node-gyp-build": "^4.8.0"
+  },
+  "peerDependencies": {
+    "tree-sitter": "^0.21.1 || ^0.22.1"
+  },
+  "peerDependenciesMeta": {
+    "tree-sitter": {
+      "optional": true
+    }
+  }
+}