code-gauge 3.1.0 → 4.0.0

package/native/src/ncss.rs

@@ -0,0 +1,263 @@
+use std::collections::HashSet;
+use tree_sitter::Node;
+
+use crate::util::{all_children, find_children_by_field_name};
+
+pub const COMMENT_NODE_TYPES: &[&str] = &["comment", "line_comment", "block_comment"];
+
+/// Nodes never counted positionally inside NCSS containers: metadata, empty statements, Ruby
+/// heredoc bodies (tree-sitter emits them as siblings of the statement that opened the heredoc),
+/// and Ruby statement parentheses (transparent wrappers whose children count instead).
+const POSITIONAL_EXCLUSION_TYPES: &[&str] = &[
+    "attribute_item",
+    "inner_attribute_item",
+    "empty_statement",
+    "heredoc_body",
+    "parenthesized_statements",
+];
+
+/// TypeScript interface members count like Java interface members, but the same node types appear
+/// inside object-type annotations (`let x: { a: number }`), which are part of one declaration, so
+/// they only count directly under an interface body.
+const INTERFACE_MEMBER_NODE_TYPES: &[&str] = &[
+    "property_signature",
+    "method_signature",
+    "index_signature",
+    "construct_signature",
+    "call_signature",
+];
+
+/// An if-branch wrapped in one of these already counts through ncss_node_types; a bare
+/// `alternative` (Java/Go put the else branch directly in the field) needs the extra `else` count.
+const ELSE_CLAUSE_NODE_TYPES: &[&str] = &["else_clause", "elif_clause", "else", "elsif"];
+
+const IF_NODE_TYPES: &[&str] = &["if_statement", "if_expression"];
+
+/// C/C++ type specifiers only declare something when they carry a body (`struct S { ... }`);
+/// without one they are mere type references inside other declarations.
+const BODYLESS_NCSS_SPECIFIER_TYPES: &[&str] = &[
+    "struct_specifier",
+    "enum_specifier",
+    "union_specifier",
+    "class_specifier",
+];
+
+/// Counts non-commenting source statements (NCSS) in the subtree, PMD-style: one per declaration,
+/// statement, and clause (`else`, `case`/`default` label, `catch`, `finally`, try-with-resources
+/// resource); `try` itself, braces, blank lines, and comments count 0.
+pub fn count_ncss(
+    node: Node<'_>,
+    countable: &HashSet<&'static str>,
+    containers: &HashSet<&'static str>,
+) -> u64 {
+    fn visit(
+        current: Node<'_>,
+        countable: &HashSet<&'static str>,
+        containers: &HashSet<&'static str>,
+        count: &mut u64,
+    ) {
+        *count += ncss_contribution(current, countable, containers);
+        for child in all_children(current) {
+            visit(child, countable, containers, count);
+        }
+    }
+
+    let mut count = 0;
+    visit(node, countable, containers, &mut count);
+    count
+}
+
+pub fn ncss_contribution(
+    node: Node<'_>,
+    countable: &HashSet<&'static str>,
+    containers: &HashSet<&'static str>,
+) -> u64 {
+    if !node.is_named() || COMMENT_NODE_TYPES.contains(&node.kind()) || is_for_header_node(node) {
+        return 0;
+    }
+
+    let mut contribution = 0;
+    let positional = is_in_container_position(node, containers)
+        && !containers.contains(node.kind())
+        && !POSITIONAL_EXCLUSION_TYPES.contains(&node.kind());
+    if (counts_through_node_type(node, countable) || positional || counts_contextually(node))
+        && !is_declaration_wrapper(node, countable)
+    {
+        contribution += 1;
+    }
+
+    // A bare else branch (Java/Go `alternative:` without an else-clause wrapper) counts 1 like the
+    // `else` keyword does in PMD; an `else if` chain charges the nested if separately on top.
+    if IF_NODE_TYPES.contains(&node.kind()) {
+        contribution += count_bare_alternatives(node);
+    }
+
+    contribution
+}
+
+fn counts_through_node_type(node: Node<'_>, countable: &HashSet<&'static str>) -> bool {
+    if !countable.contains(node.kind()) {
+        return false;
+    }
+    if BODYLESS_NCSS_SPECIFIER_TYPES.contains(&node.kind()) {
+        return node.child_by_field_name("body").is_some();
+    }
+    // A try-with-resources `resource` counts only when it declares a variable; `try (r)` reuses an
+    // existing one and adds no statement (matching PMD).
+    if node.kind() == "resource" {
+        return node.child_by_field_name("name").is_some();
+    }
+    true
+}
+
+/// Direct container children count positionally; Ruby's `(foo; bar)` statement parentheses are
+/// transparent, so their children count when the parentheses themselves sit in a container.
+fn is_in_container_position(node: Node<'_>, containers: &HashSet<&'static str>) -> bool {
+    let mut ancestor = node.parent();
+    while let Some(current) = ancestor {
+        if current.kind() != "parenthesized_statements" {
+            return containers.contains(current.kind());
+        }
+        ancestor = current.parent();
+    }
+    false
+}
+
+/// `export const x = 1` nests a countable declaration inside `export_statement`; only the inner
+/// declaration counts, mirroring how PMD counts one statement per declared entity.
+fn is_declaration_wrapper(node: Node<'_>, countable: &HashSet<&'static str>) -> bool {
+    if node.kind() != "export_statement" {
+        return false;
+    }
+    node.child_by_field_name("declaration")
+        .is_some_and(|declaration| {
+            countable.contains(declaration.kind())
+                || declaration.kind() == "internal_module"
+                || declaration.kind() == "ambient_declaration"
+        })
+}
+
+const FOR_HEADER_FIELD_NAMES: &[&str] =
+    &["init", "initializer", "condition", "update", "increment"];
+
+/// Statement-shaped nodes in a `for` header (`for (int i = 0; i < n; i++)`) are part of the loop
+/// statement, which already counts; PMD does not count them separately. JavaScript parses the
+/// condition as an `expression_statement` and Go parses the update as an `inc_statement`, so all
+/// header fields must be excluded, not just the initializer.
+fn is_for_header_node(node: Node<'_>) -> bool {
+    let Some(parent) = node.parent() else {
+        return false;
+    };
+    // C++20 range-for initializers nest one level deeper: for_range_loop > init_statement > node.
+    if parent.kind() == "init_statement"
+        && parent
+            .parent()
+            .is_some_and(|grandparent| grandparent.kind() == "for_range_loop")
+    {
+        return true;
+    }
+    if parent.kind() != "for_statement"
+        && parent.kind() != "for_clause"
+        && parent.kind() != "for_range_loop"
+    {
+        return false;
+    }
+    FOR_HEADER_FIELD_NAMES.iter().any(|field_name| {
+        find_children_by_field_name(parent, field_name)
+            .iter()
+            .any(|child| child.id() == node.id())
+    })
+}
+
+/// Statements only countable by their position: constructs without a dedicated statement node.
+fn counts_contextually(node: Node<'_>) -> bool {
+    let parent_kind = node.parent().map(|parent| parent.kind());
+    // A Java instance initializer is a bare `block` in the class body; PMD counts it like the
+    // `static_initializer` declaration it parallels.
+    if node.kind() == "block" && parent_kind == Some("class_body") {
+        return true;
+    }
+    // TypeScript interface members (see INTERFACE_MEMBER_NODE_TYPES).
+    if INTERFACE_MEMBER_NODE_TYPES.contains(&node.kind()) && parent_kind == Some("interface_body") {
+        return true;
+    }
+    // A braceless Rust match-arm body (`1 => foo()`) has no expression_statement wrapper; count the
+    // value expression so braced and unbraced arms measure alike.
+    if parent_kind == Some("match_arm")
+        && node.kind() != "block"
+        && is_field_of_parent(node, "value")
+    {
+        return true;
+    }
+    // A TypeScript class-body method overload signature declares a member like its interface twin.
+    if node.kind() == "method_signature" && parent_kind == Some("class_body") {
+        return true;
+    }
+    // An ambient `declare namespace M { ... }` is a bare `internal_module`; the non-ambient
+    // `namespace N { ... }` is wrapped in an `expression_statement`, which already counts.
+    if node.kind() == "internal_module" && parent_kind != Some("expression_statement") {
+        return true;
+    }
+    // A Ruby endless method (`def f(x) = expr`) stores its single-statement body directly in the
+    // `body` field instead of a positional `body_statement` container.
+    if (parent_kind == Some("method") || parent_kind == Some("singleton_method"))
+        && node.kind() != "body_statement"
+        && is_field_of_parent(node, "body")
+    {
+        return true;
+    }
+    // C++ `friend class X;` declares on its own; `friend void g() { ... }` merely wraps a counted
+    // definition.
+    if node.kind() == "friend_declaration" {
+        return !crate::util::named_children(node)
+            .iter()
+            .any(|child| child.kind() == "declaration" || child.kind() == "function_definition");
+    }
+    // A Rust item-position macro invocation (`foo! {}` at module level) has no expression_statement
+    // wrapper; the semicolon form does and already counts through it.
+    if node.kind() == "macro_invocation"
+        && (parent_kind == Some("source_file") || parent_kind == Some("declaration_list"))
+    {
+        return true;
+    }
+    // Go struct fields and interface members count like other languages' member declarations, but
+    // only inside a named type declaration; inline anonymous types (`var x struct{ ... }`,
+    // `func f(h interface{ ... })`) are part of one declaration.
+    if node.kind() == "field_declaration" && parent_kind == Some("field_declaration_list") {
+        return is_go_declared_type_body(
+            node.parent().and_then(|parent| parent.parent()),
+            "struct_type",
+        );
+    }
+    if node.kind() == "method_elem" || node.kind() == "method_spec" || node.kind() == "type_elem" {
+        return is_go_declared_type_body(node.parent(), "interface_type");
+    }
+    false
+}
+
+fn is_go_declared_type_body(type_node: Option<Node<'_>>, expected_kind: &str) -> bool {
+    let Some(type_node) = type_node.filter(|type_node| type_node.kind() == expected_kind) else {
+        return false;
+    };
+    type_node
+        .parent()
+        .is_some_and(|parent| parent.kind() == "type_spec" || parent.kind() == "type_alias")
+}
+
+fn is_field_of_parent(node: Node<'_>, field_name: &str) -> bool {
+    let Some(parent) = node.parent() else {
+        return false;
+    };
+    find_children_by_field_name(parent, field_name)
+        .iter()
+        .any(|child| child.id() == node.id())
+}
+
+fn count_bare_alternatives(node: Node<'_>) -> u64 {
+    // Extras (comments) inherit the preceding sibling's field in find_children_by_field_name, so a
+    // comment between an `elif_clause` and `else_clause` must not be miscounted as a bare branch.
+    find_children_by_field_name(node, "alternative")
+        .iter()
+        .filter(|child| !child.is_extra() && !ELSE_CLAUSE_NODE_TYPES.contains(&child.kind()))
+        .count() as u64
+}

package/native/src/types.rs

@@ -0,0 +1,135 @@
+use serde::Serialize;
+
+/// Result payload of the native measurer. Mirrors CodeMetrics from src/types.ts, except that
+/// Halstead's derived values are computed on the TypeScript side: they involve transcendental
+/// functions (log/log2) whose last-bit results can differ between V8 and Rust's libm, and results
+/// must not vary with the platform's libm build.
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NativeMetrics {
+    pub language: String,
+    pub bytes: usize,
+    pub lines: LineMetrics,
+    pub functions: Vec<FunctionMetrics>,
+    pub cognitive_complexity: u64,
+    pub max_cognitive_complexity: u64,
+    pub nesting_depth: u64,
+    pub ncss_count: u64,
+    pub duplication: DuplicationMetrics,
+    pub halstead_counts: HalsteadCounts,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub syntax_tree: Option<String>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LineMetrics {
+    pub total: usize,
+    pub code: usize,
+    pub comment: usize,
+    pub blank: usize,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FunctionMetrics {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    /// The tree-sitter node type of the function node (e.g. `method_declaration`, `arrow_function`).
+    pub node_type: String,
+    pub start_line: usize,
+    pub start_column: usize,
+    pub end_line: usize,
+    pub cognitive_complexity: u64,
+    pub nesting_depth: u64,
+    pub ncss: u64,
+    pub parameter_count: usize,
+    /// Base counts of the function's whole subtree; derived floats are computed in TypeScript.
+    pub halstead_counts: HalsteadCounts,
+    pub dep_degree: u64,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DuplicateBlockOccurrence {
+    pub end_line: usize,
+    pub start_line: usize,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DuplicationMetrics {
+    pub duplicate_block_count: usize,
+    pub duplicate_block_group_count: usize,
+    pub duplicate_block_groups: Vec<Vec<DuplicateBlockOccurrence>>,
+    pub duplicate_line_count: usize,
+    /// The 1-based lines behind duplicate_line_count, sorted ascending.
+    pub duplicate_line_numbers: Vec<usize>,
+    pub duplication_ratio: f64,
+    pub max_duplicate_block_size: usize,
+}
+
+/// One file's contribution to cross-file clone detection. Mirrors CrossFileDuplicationFileData in
+/// src/duplication.ts; `code_line_numbers` is revived into a Set on the TypeScript side.
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CrossFileFileData {
+    pub candidates: Vec<CrossFileCandidate>,
+    pub tokens: Vec<CrossFileToken>,
+    pub container_statements: Vec<Vec<CrossFileTokenRange>>,
+    /// 1-based lines that are neither blank nor comment-only, sorted ascending.
+    pub code_line_numbers: Vec<usize>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CrossFileCandidate {
+    pub fingerprint: String,
+    pub token_count: usize,
+    pub start_token_index: usize,
+    pub end_token_index: usize,
+    pub start_index: usize,
+    pub end_index: usize,
+    pub start_line: usize,
+    pub end_line: usize,
+}
+
+/// A normalized token as consumed by the TypeScript project-level matcher (the Token interface in
+/// src/duplication.ts). Optional fields are omitted rather than null: the TypeScript side
+/// distinguishes absent from undefined-valued keys with `!== undefined` checks.
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CrossFileToken {
+    pub kind: &'static str,
+    pub text: String,
+    pub text_hash: i32,
+    pub text_hash2: i32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub literal_hash: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub literal_hash2: Option<i32>,
+    #[serde(skip_serializing_if = "std::ops::Not::not")]
+    pub is_name: bool,
+    pub start_row: usize,
+    pub end_row: usize,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CrossFileTokenRange {
+    pub start_token_index: usize,
+    pub end_token_index: usize,
+    pub start_index: usize,
+    pub end_index: usize,
+    pub start_line: usize,
+    pub end_line: usize,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HalsteadCounts {
+    pub distinct_operators: usize,
+    pub distinct_operands: usize,
+    pub total_operators: u64,
+    pub total_operands: u64,
+}

package/native/src/util.rs

@@ -0,0 +1,139 @@
+use tree_sitter::Node;
+
+/// The measured source. Trees are parsed from UTF-16 (matching node-tree-sitter, which parses
+/// JavaScript strings as UTF-16 — tree-sitter's error recovery can differ between encodings), so
+/// node "byte" offsets and columns are UTF-16 code units x 2; this maps them back to UTF-8 slices
+/// of the original string without allocating per node.
+pub struct Source<'a> {
+    pub code: &'a str,
+    /// UTF-16 unit -> UTF-8 byte offset. None for pure-ASCII sources, where the two coincide, so
+    /// the table's 4-bytes-per-unit cost is only paid for sources that actually need mapping.
+    utf8_offset_by_unit: Option<Vec<u32>>,
+}
+
+impl<'a> Source<'a> {
+    pub fn new(code: &'a str) -> Source<'a> {
+        if code.is_ascii() {
+            return Source {
+                code,
+                utf8_offset_by_unit: None,
+            };
+        }
+        let mut utf8_offset_by_unit = Vec::with_capacity(code.len() + 1);
+        for (offset, character) in code.char_indices() {
+            utf8_offset_by_unit.push(offset as u32);
+            // Both halves of a surrogate pair map to the character start; tree-sitter node
+            // boundaries always align to whole code points, so the halves are never split.
+            if character.len_utf16() == 2 {
+                utf8_offset_by_unit.push(offset as u32);
+            }
+        }
+        utf8_offset_by_unit.push(code.len() as u32);
+        Source {
+            code,
+            utf8_offset_by_unit: Some(utf8_offset_by_unit),
+        }
+    }
+
+    pub fn to_utf16(&self) -> Vec<u16> {
+        self.code.encode_utf16().collect()
+    }
+
+    fn utf8_offset(&self, node_byte: usize) -> usize {
+        match &self.utf8_offset_by_unit {
+            None => node_byte / 2,
+            Some(map) => map[node_byte / 2] as usize,
+        }
+    }
+}
+
+pub fn node_text<'a>(node: Node<'_>, code: &Source<'a>) -> &'a str {
+    &code.code[code.utf8_offset(node.start_byte())..code.utf8_offset(node.end_byte())]
+}
+
+pub fn named_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
+    let mut cursor = node.walk();
+    node.named_children(&mut cursor).collect()
+}
+
+pub fn all_children<'t>(node: Node<'t>) -> Vec<Node<'t>> {
+    let mut cursor = node.walk();
+    node.children(&mut cursor).collect()
+}
+
+/// Children carrying the field, with node-tree-sitter's vendored-core semantics: extra children
+/// (error-recovery nodes, comments) inherit the field of the preceding structural sibling.
+/// tree-sitter 0.22.6 instead reports no field for extras (ts_node_field_name_for_child gained an
+/// is_extra early return), which would desynchronize field-based extraction on malformed source.
+pub fn find_children_by_field_name<'t>(node: Node<'t>, field_name: &str) -> Vec<Node<'t>> {
+    let mut children = Vec::new();
+    let mut preceding_structural_field: Option<&'static str> = None;
+    for index in 0..node.child_count() {
+        if let Some(child) = node.child(index) {
+            let field = if child.is_extra() {
+                preceding_structural_field
+            } else {
+                let field = node.field_name_for_child(index as u32);
+                preceding_structural_field = field;
+                field
+            };
+            if field == Some(field_name) {
+                children.push(child);
+            }
+        }
+    }
+    children
+}
+
+/// Splits like JavaScript's `code.split(/\r\n|\n|\r/)`, with `[]` for empty input as in classifyLines.
+pub fn split_lines(code: &str) -> Vec<&str> {
+    if code.is_empty() {
+        return Vec::new();
+    }
+    let bytes = code.as_bytes();
+    let mut lines = Vec::new();
+    let mut start = 0;
+    let mut index = 0;
+    while index < bytes.len() {
+        match bytes[index] {
+            b'\r' => {
+                lines.push(&code[start..index]);
+                index += if bytes.get(index + 1) == Some(&b'\n') {
+                    2
+                } else {
+                    1
+                };
+                start = index;
+            }
+            b'\n' => {
+                lines.push(&code[start..index]);
+                index += 1;
+                start = index;
+            }
+            _ => index += 1,
+        }
+    }
+    lines.push(&code[start..]);
+    lines
+}
+
+/// JavaScript's `\s` character class (WhiteSpace + LineTerminator), which `String.prototype.trim`
+/// also uses; Rust's `char::is_whitespace` differs (it excludes U+FEFF), so this is spelled out.
+pub fn is_js_whitespace(character: char) -> bool {
+    matches!(
+        character,
+        '\t' | '\n' | '\u{000B}' | '\u{000C}' | '\r' | ' ' | '\u{00A0}' | '\u{1680}' | '\u{2000}'
+            ..='\u{200A}'
+                | '\u{2028}'
+                | '\u{2029}'
+                | '\u{202F}'
+                | '\u{205F}'
+                | '\u{3000}'
+                | '\u{FEFF}'
+    )
+}
+
+/// JavaScript ToInt32 for integer-valued numbers (all hash arithmetic stays below 2^53).
+pub fn to_int32(value: i64) -> i32 {
+    value as i32
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -31,7 +31,13 @@
   "types": "dist/index.d.ts",
   "bin": "dist/cli.js",
   "files": [
-    "dist/"
+    "dist/",
+    "native/build.rs",
+    "native/Cargo.lock",
+    "native/Cargo.toml",
+    "native/src/",
+    "scripts/buildNative.mjs",
+    "scripts/installNative.mjs"
   ],
   "scripts": {
     "benchmark": "node scripts/benchmark.mjs",
@@ -39,27 +45,18 @@
     "build-native": "node scripts/buildNative.mjs",
     "cleanup": "bun wb lint --fix --format",
     "format": "bun wb lint --format",
+    "postinstall": "node scripts/installNative.mjs",
     "lint": "bun wb lint",
     "lint-fix": "bun wb lint --fix",
-    "prepare": "lefthook install || true",
+    "prepare": "bun lefthook install || true",
     "test": "bun wb test",
-    "test/ci": "bun run build-native && CODE_GAUGE_EXPECT_NATIVE=1 vitest",
+    "test/ci": "bun run build-native && vitest",
     "typecheck": "bun wb typecheck",
     "verify": "bun wb verify",
     "verify-full": "bun wb verify --full"
   },
   "dependencies": {
-    "commander": "15.0.0",
-    "tree-sitter": "^0.21.1",
-    "tree-sitter-c": "^0.21.0",
-    "tree-sitter-cpp": "^0.22.0",
-    "tree-sitter-go": "^0.21.2",
-    "tree-sitter-java": "^0.21.0",
-    "tree-sitter-javascript": "^0.21.4",
-    "tree-sitter-python": "^0.21.0",
-    "tree-sitter-ruby": "^0.21.0",
-    "tree-sitter-rust": "^0.21.0",
-    "tree-sitter-typescript": "^0.21.2"
+    "commander": "15.0.0"
   },
   "devDependencies": {
     "@tsconfig/bun": "1.0.10",
@@ -69,12 +66,12 @@
     "@types/node": "25.9.4",
     "@willbooster/oxfmt-config": "1.2.2",
     "@willbooster/oxlint-config": "1.4.8",
-    "@willbooster/wb": "21.1.0",
-    "build-ts": "21.0.4",
+    "@willbooster/wb": "21.5.0",
+    "build-ts": "21.0.6",
     "conventional-changelog-conventionalcommits": "9.3.1",
     "lefthook": "2.1.10",
-    "oxfmt": "0.61.0",
-    "oxlint": "1.76.0",
+    "oxfmt": "0.62.0",
+    "oxlint": "1.77.0",
     "oxlint-tsgolint": "7.0.2001",
     "semantic-release": "25.0.5",
     "sort-package-json": "4.0.0",

package/scripts/buildNative.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// Builds the native Rust addon and places it at native/code-gauge.node, where the TypeScript
+// loader picks it up. Requires a Rust toolchain.
+
+import { execFileSync } from 'node:child_process';
+import { copyFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+const nativeDir = path.join(repoRoot, 'native');
+
+execFileSync('cargo', ['build', '--release'], { cwd: nativeDir, stdio: 'inherit' });
+
+const libraryNames = ['libcode_gauge_native.dylib', 'libcode_gauge_native.so', 'code_gauge_native.dll'];
+const builtLibrary = libraryNames
+  .map((name) => path.join(nativeDir, 'target', 'release', name))
+  .find((candidate) => existsSync(candidate));
+if (!builtLibrary) {
+  throw new Error('cargo build succeeded but no native library was found in native/target/release');
+}
+
+const output = path.join(nativeDir, 'code-gauge.node');
+copyFileSync(builtLibrary, output);
+console.log(`Built ${output}`);