code-gauge 4.3.0 → 4.4.0

package/README.md

@@ -173,9 +173,11 @@ The `duplication` section tunes how clones are detected:
   import declarations count, and statement-shaped content is counted uniformly in expression
   positions too
 - Per-function and file-level nesting depth
-- Per-function cyclomatic complexity (McCabe, own body only), matching PMD's
-  `CyclomaticComplexity` rule for Java; an API-only compatibility metric that ranking and the
-  regression gate ignore
+- Per-function cyclomatic complexity (McCabe, own body only), counted as NIST SP 500-235 defines it:
+  every decision and short-circuit operator adds one, one per case-labelled statement, plus the
+  file total over McCabe's components (every function, every initializer block, decisions outside
+  functions, and the module body of a file that runs top-level code); an API-only metric that
+  ranking and the regression gate ignore
 - Per-function parameter counts and locations (name, node type, line span)
 - Within-file duplication: copy-pasted blocks matched on normalized tokens (identifiers anonymized
   consistently, literals by kind, and literal-dense data tables excluded unless their values also

package/dist/metrics.cjs

@@ -1,2 +1,2 @@
-"use strict";const e=require("./languages.cjs"),t=require("./nativeMetrics.cjs");var n=class{registry=e.createLanguageRegistry();getSupportedLanguages(){return[...new Set([...this.registry.values()].map(e=>e.name))]}measure(e,n){let i=this.resolveLanguage(n.language),a=n.includeSyntaxTree??!1;return r(t.measureCodeNative(e,i.name,a,n.duplication),a)}collectDuplicationCandidates(e,t){return this.collectCrossFileDuplicationFileData(e,t).candidates}collectCrossFileDuplicationFileData(e,n){let r=this.resolveLanguage(n.language),i=t.collectCrossFileDataNative(e,r.name,n.duplication?.minTokens);return{candidates:i.candidates,tokens:i.tokens,containerStatements:i.containerStatements,codeLineNumbers:new Set(i.codeLineNumbers)}}collectFunctionTokenSequences(e,n){let r=this.resolveLanguage(n.language);return t.collectFunctionTokenSequencesNative(e,r.name)}resolveLanguage(e){let t=this.registry.get(e);if(!t)throw Error(`Unsupported language: ${e}`);return t}};function r(e,t){return{language:e.language,bytes:e.bytes,lines:e.lines,functions:e.functions.map(e=>({name:e.name,nodeType:e.nodeType,startLine:e.startLine,startColumn:e.startColumn,endLine:e.endLine,endColumn:e.endColumn,cyclomaticComplexity:e.cyclomaticComplexity,cognitiveComplexity:e.cognitiveComplexity,nestingDepth:e.nestingDepth,ncss:e.ncss,parameterCount:e.parameterCount,halstead:i(e.halsteadCounts),depDegree:e.depDegree})),cognitiveComplexity:e.cognitiveComplexity,maxCognitiveComplexity:e.maxCognitiveComplexity,nestingDepth:e.nestingDepth,ncssCount:e.ncssCount,duplication:e.duplication,halstead:i(e.halsteadCounts),syntaxTree:t?e.syntaxTree:void 0}}function i(e){let{distinctOperators:t,distinctOperands:n,totalOperators:r,totalOperands:i}=e,a=t+n,o=r+i,s=a===0?0:o*Math.log2(a);return{distinctOperators:t,distinctOperands:n,totalOperators:r,totalOperands:i,vocabulary:a,length:o,volume:s,effort:(n===0?0:t/2*(i/n))*s}}const a=new n;function o(e,t){return a.measure(e,t)}function s(e,t){return a.collectDuplicationCandidates(e,t)}function c(e,t){return a.collectFunctionTokenSequences(e,t)}function l(e,t){return a.collectCrossFileDuplicationFileData(e,t)}exports.TreeMeasurer=n,exports.collectCrossFileDuplicationFileData=l,exports.collectDuplicationCandidates=s,exports.collectFunctionTokenSequences=c,exports.defaultMeasurer=a,exports.measureCode=o;
+"use strict";const e=require("./languages.cjs"),t=require("./nativeMetrics.cjs");var n=class{registry=e.createLanguageRegistry();getSupportedLanguages(){return[...new Set([...this.registry.values()].map(e=>e.name))]}measure(e,n){let i=this.resolveLanguage(n.language),a=n.includeSyntaxTree??!1;return r(t.measureCodeNative(e,i.name,a,n.duplication),a)}collectDuplicationCandidates(e,t){return this.collectCrossFileDuplicationFileData(e,t).candidates}collectCrossFileDuplicationFileData(e,n){let r=this.resolveLanguage(n.language),i=t.collectCrossFileDataNative(e,r.name,n.duplication?.minTokens);return{candidates:i.candidates,tokens:i.tokens,containerStatements:i.containerStatements,codeLineNumbers:new Set(i.codeLineNumbers)}}collectFunctionTokenSequences(e,n){let r=this.resolveLanguage(n.language);return t.collectFunctionTokenSequencesNative(e,r.name)}resolveLanguage(e){let t=this.registry.get(e);if(!t)throw Error(`Unsupported language: ${e}`);return t}};function r(e,t){return{language:e.language,bytes:e.bytes,lines:e.lines,functions:e.functions.map(e=>({name:e.name,nodeType:e.nodeType,startLine:e.startLine,startColumn:e.startColumn,endLine:e.endLine,endColumn:e.endColumn,cyclomaticComplexity:e.cyclomaticComplexity,cognitiveComplexity:e.cognitiveComplexity,nestingDepth:e.nestingDepth,ncss:e.ncss,parameterCount:e.parameterCount,halstead:i(e.halsteadCounts),depDegree:e.depDegree})),cyclomaticComplexity:e.cyclomaticComplexity,cognitiveComplexity:e.cognitiveComplexity,maxCognitiveComplexity:e.maxCognitiveComplexity,nestingDepth:e.nestingDepth,ncssCount:e.ncssCount,duplication:e.duplication,halstead:i(e.halsteadCounts),syntaxTree:t?e.syntaxTree:void 0}}function i(e){let{distinctOperators:t,distinctOperands:n,totalOperators:r,totalOperands:i}=e,a=t+n,o=r+i,s=a===0?0:o*Math.log2(a);return{distinctOperators:t,distinctOperands:n,totalOperators:r,totalOperands:i,vocabulary:a,length:o,volume:s,effort:(n===0?0:t/2*(i/n))*s}}const a=new n;function o(e,t){return a.measure(e,t)}function s(e,t){return a.collectDuplicationCandidates(e,t)}function c(e,t){return a.collectFunctionTokenSequences(e,t)}function l(e,t){return a.collectCrossFileDuplicationFileData(e,t)}exports.TreeMeasurer=n,exports.collectCrossFileDuplicationFileData=l,exports.collectDuplicationCandidates=s,exports.collectFunctionTokenSequences=c,exports.defaultMeasurer=a,exports.measureCode=o;
 //# sourceMappingURL=metrics.cjs.map

package/dist/metrics.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"metrics.cjs","names":["createLanguageRegistry","measureCodeNative","collectCrossFileDataNative","collectFunctionTokenSequencesNative"],"sources":["../src/metrics.ts"],"sourcesContent":["import type { CrossFileDuplicateCandidate, CrossFileDuplicationFileData } from './duplication.js';\nimport { createLanguageRegistry } from './languages.js';\nimport {\n  collectCrossFileDataNative,\n  collectFunctionTokenSequencesNative,\n  measureCodeNative,\n  type NativeHalsteadCounts,\n  type NativeMetricsPayload,\n} from './nativeMetrics.js';\nimport type { CodeMetrics, HalsteadMetrics, LanguageDefinition, LanguageName, MeasureOptions } from './types.js';\n\n/**\n * Measures code metrics for the built-in languages. Parsing and metric passes run in the bundled\n * Rust addon (tree-sitter); this class resolves language aliases, crosses the N-API boundary, and\n * derives the Halstead float metrics from the natively measured counts.\n */\nexport class TreeMeasurer {\n  private readonly registry = createLanguageRegistry();\n\n  getSupportedLanguages(): LanguageName[] {\n    return [...new Set([...this.registry.values()].map((language) => language.name))];\n  }\n\n  measure(code: string, options: MeasureOptions): CodeMetrics {\n    const language = this.resolveLanguage(options.language);\n    const includeSyntaxTree = options.includeSyntaxTree ?? false;\n    const payload = measureCodeNative(code, language.name, includeSyntaxTree, options.duplication);\n    return assembleNativeMetrics(payload, includeSyntaxTree);\n  }\n\n  /** Collects one file's duplicate candidates for cross-file clone detection. */\n  collectDuplicationCandidates(code: string, options: MeasureOptions): CrossFileDuplicateCandidate[] {\n    return this.collectCrossFileDuplicationFileData(code, options).candidates;\n  }\n\n  /**\n   * Collects one file's duplicate candidates, normalized tokens, and statement structure for\n   * cross-file clone detection with measureCrossFileDuplication.\n   */\n  collectCrossFileDuplicationFileData(code: string, options: MeasureOptions): CrossFileDuplicationFileData {\n    const language = this.resolveLanguage(options.language);\n    const payload = collectCrossFileDataNative(code, language.name, options.duplication?.minTokens);\n    return {\n      candidates: payload.candidates,\n      tokens: payload.tokens,\n      containerStatements: payload.containerStatements,\n      // Lets cross-file line coverage count only code lines, like within-file coverage.\n      codeLineNumbers: new Set(payload.codeLineNumbers),\n    };\n  }\n\n  /**\n   * Normalized token hash sequences of every function, index-parallel to the functions array of\n   * measure(): identifiers are anonymized by first occurrence within the function, literals by\n   * kind, and keywords/operators kept verbatim, so the regression gate can re-match renamed or\n   * moved functions across two revisions by token-LCS similarity.\n   */\n  collectFunctionTokenSequences(code: string, options: MeasureOptions): Int32Array[] {\n    const language = this.resolveLanguage(options.language);\n    return collectFunctionTokenSequencesNative(code, language.name);\n  }\n\n  private resolveLanguage(name: LanguageName): LanguageDefinition {\n    const language = this.registry.get(name);\n    if (!language) {\n      throw new Error(`Unsupported language: ${name}`);\n    }\n    return language;\n  }\n}\n\n/**\n * Completes a native measurement into CodeMetrics. The object is rebuilt field by field (rather\n * than spread from the parsed JSON) so the result has a stable shape, including\n * explicitly-undefined optional keys.\n */\nfunction assembleNativeMetrics(payload: NativeMetricsPayload, includeSyntaxTree: boolean): CodeMetrics {\n  return {\n    language: payload.language,\n    bytes: payload.bytes,\n    lines: payload.lines,\n    functions: payload.functions.map((fn) => ({\n      name: fn.name,\n      nodeType: fn.nodeType,\n      startLine: fn.startLine,\n      startColumn: fn.startColumn,\n      endLine: fn.endLine,\n      endColumn: fn.endColumn,\n      cyclomaticComplexity: fn.cyclomaticComplexity,\n      cognitiveComplexity: fn.cognitiveComplexity,\n      nestingDepth: fn.nestingDepth,\n      ncss: fn.ncss,\n      parameterCount: fn.parameterCount,\n      halstead: deriveHalsteadMetrics(fn.halsteadCounts),\n      depDegree: fn.depDegree,\n    })),\n    cognitiveComplexity: payload.cognitiveComplexity,\n    maxCognitiveComplexity: payload.maxCognitiveComplexity,\n    nestingDepth: payload.nestingDepth,\n    ncssCount: payload.ncssCount,\n    duplication: payload.duplication,\n    halstead: deriveHalsteadMetrics(payload.halsteadCounts),\n    syntaxTree: includeSyntaxTree ? payload.syntaxTree : undefined,\n  };\n}\n\nfunction deriveHalsteadMetrics(counts: NativeHalsteadCounts): HalsteadMetrics {\n  const { distinctOperators, distinctOperands, totalOperators, totalOperands } = counts;\n  const vocabulary = distinctOperators + distinctOperands;\n  const length = totalOperators + totalOperands;\n  const volume = vocabulary === 0 ? 0 : length * Math.log2(vocabulary);\n  const difficulty = distinctOperands === 0 ? 0 : (distinctOperators / 2) * (totalOperands / distinctOperands);\n  const effort = difficulty * volume;\n\n  return {\n    distinctOperators,\n    distinctOperands,\n    totalOperators,\n    totalOperands,\n    vocabulary,\n    length,\n    volume,\n    effort,\n  };\n}\n\nexport const defaultMeasurer = new TreeMeasurer();\n\nexport function measureCode(code: string, options: MeasureOptions): CodeMetrics {\n  return defaultMeasurer.measure(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectDuplicationCandidates(code: string, options: MeasureOptions): CrossFileDuplicateCandidate[] {\n  return defaultMeasurer.collectDuplicationCandidates(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectFunctionTokenSequences(code: string, options: MeasureOptions): Int32Array[] {\n  return defaultMeasurer.collectFunctionTokenSequences(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectCrossFileDuplicationFileData(\n  code: string,\n  options: MeasureOptions\n): CrossFileDuplicationFileData {\n  return defaultMeasurer.collectCrossFileDuplicationFileData(code, options);\n}\n"],"mappings":"iFAgBA,IAAa,EAAb,KAA0B,CACxB,SAA4BA,EAAAA,uBAAuB,EAEnD,uBAAwC,CACtC,MAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,KAAK,SAAS,OAAO,CAAC,CAAC,CAAC,IAAK,GAAa,EAAS,IAAI,CAAC,CAAC,CAClF,CAEA,QAAQ,EAAc,EAAsC,CAC1D,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EAChD,EAAoB,EAAQ,mBAAqB,GAEvD,OAAO,EADSC,EAAAA,kBAAkB,EAAM,EAAS,KAAM,EAAmB,EAAQ,WAC/C,EAAG,CAAiB,CACzD,CAGA,6BAA6B,EAAc,EAAwD,CACjG,OAAO,KAAK,oCAAoC,EAAM,CAAO,CAAC,CAAC,UACjE,CAMA,oCAAoC,EAAc,EAAuD,CACvG,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EAChD,EAAUC,EAAAA,2BAA2B,EAAM,EAAS,KAAM,EAAQ,aAAa,SAAS,EAC9F,MAAO,CACL,WAAY,EAAQ,WACpB,OAAQ,EAAQ,OAChB,oBAAqB,EAAQ,oBAE7B,gBAAiB,IAAI,IAAI,EAAQ,eAAe,CAClD,CACF,CAQA,8BAA8B,EAAc,EAAuC,CACjF,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EACtD,OAAOC,EAAAA,oCAAoC,EAAM,EAAS,IAAI,CAChE,CAEA,gBAAwB,EAAwC,CAC9D,IAAM,EAAW,KAAK,SAAS,IAAI,CAAI,EACvC,GAAI,CAAC,EACH,MAAU,MAAM,yBAAyB,GAAM,EAEjD,OAAO,CACT,CACF,EAOA,SAAS,EAAsB,EAA+B,EAAyC,CACrG,MAAO,CACL,SAAU,EAAQ,SAClB,MAAO,EAAQ,MACf,MAAO,EAAQ,MACf,UAAW,EAAQ,UAAU,IAAK,IAAQ,CACxC,KAAM,EAAG,KACT,SAAU,EAAG,SACb,UAAW,EAAG,UACd,YAAa,EAAG,YAChB,QAAS,EAAG,QACZ,UAAW,EAAG,UACd,qBAAsB,EAAG,qBACzB,oBAAqB,EAAG,oBACxB,aAAc,EAAG,aACjB,KAAM,EAAG,KACT,eAAgB,EAAG,eACnB,SAAU,EAAsB,EAAG,cAAc,EACjD,UAAW,EAAG,SAChB,EAAE,EACF,oBAAqB,EAAQ,oBAC7B,uBAAwB,EAAQ,uBAChC,aAAc,EAAQ,aACtB,UAAW,EAAQ,UACnB,YAAa,EAAQ,YACrB,SAAU,EAAsB,EAAQ,cAAc,EACtD,WAAY,EAAoB,EAAQ,WAAa,IAAA,EACvD,CACF,CAEA,SAAS,EAAsB,EAA+C,CAC5E,GAAM,CAAE,oBAAmB,mBAAkB,iBAAgB,iBAAkB,EACzE,EAAa,EAAoB,EACjC,EAAS,EAAiB,EAC1B,EAAS,IAAe,EAAI,EAAI,EAAS,KAAK,KAAK,CAAU,EAInE,MAAO,CACL,oBACA,mBACA,iBACA,gBACA,aACA,SACA,SACA,QAXiB,IAAqB,EAAI,EAAK,EAAoB,GAAM,EAAgB,IAC/D,CAW5B,CACF,CAEA,MAAa,EAAkB,IAAI,EAEnC,SAAgB,EAAY,EAAc,EAAsC,CAC9E,OAAO,EAAgB,QAAQ,EAAM,CAAO,CAC9C,CAGA,SAAgB,EAA6B,EAAc,EAAwD,CACjH,OAAO,EAAgB,6BAA6B,EAAM,CAAO,CACnE,CAGA,SAAgB,EAA8B,EAAc,EAAuC,CACjG,OAAO,EAAgB,8BAA8B,EAAM,CAAO,CACpE,CAGA,SAAgB,EACd,EACA,EAC8B,CAC9B,OAAO,EAAgB,oCAAoC,EAAM,CAAO,CAC1E"}
+{"version":3,"file":"metrics.cjs","names":["createLanguageRegistry","measureCodeNative","collectCrossFileDataNative","collectFunctionTokenSequencesNative"],"sources":["../src/metrics.ts"],"sourcesContent":["import type { CrossFileDuplicateCandidate, CrossFileDuplicationFileData } from './duplication.js';\nimport { createLanguageRegistry } from './languages.js';\nimport {\n  collectCrossFileDataNative,\n  collectFunctionTokenSequencesNative,\n  measureCodeNative,\n  type NativeHalsteadCounts,\n  type NativeMetricsPayload,\n} from './nativeMetrics.js';\nimport type { CodeMetrics, HalsteadMetrics, LanguageDefinition, LanguageName, MeasureOptions } from './types.js';\n\n/**\n * Measures code metrics for the built-in languages. Parsing and metric passes run in the bundled\n * Rust addon (tree-sitter); this class resolves language aliases, crosses the N-API boundary, and\n * derives the Halstead float metrics from the natively measured counts.\n */\nexport class TreeMeasurer {\n  private readonly registry = createLanguageRegistry();\n\n  getSupportedLanguages(): LanguageName[] {\n    return [...new Set([...this.registry.values()].map((language) => language.name))];\n  }\n\n  measure(code: string, options: MeasureOptions): CodeMetrics {\n    const language = this.resolveLanguage(options.language);\n    const includeSyntaxTree = options.includeSyntaxTree ?? false;\n    const payload = measureCodeNative(code, language.name, includeSyntaxTree, options.duplication);\n    return assembleNativeMetrics(payload, includeSyntaxTree);\n  }\n\n  /** Collects one file's duplicate candidates for cross-file clone detection. */\n  collectDuplicationCandidates(code: string, options: MeasureOptions): CrossFileDuplicateCandidate[] {\n    return this.collectCrossFileDuplicationFileData(code, options).candidates;\n  }\n\n  /**\n   * Collects one file's duplicate candidates, normalized tokens, and statement structure for\n   * cross-file clone detection with measureCrossFileDuplication.\n   */\n  collectCrossFileDuplicationFileData(code: string, options: MeasureOptions): CrossFileDuplicationFileData {\n    const language = this.resolveLanguage(options.language);\n    const payload = collectCrossFileDataNative(code, language.name, options.duplication?.minTokens);\n    return {\n      candidates: payload.candidates,\n      tokens: payload.tokens,\n      containerStatements: payload.containerStatements,\n      // Lets cross-file line coverage count only code lines, like within-file coverage.\n      codeLineNumbers: new Set(payload.codeLineNumbers),\n    };\n  }\n\n  /**\n   * Normalized token hash sequences of every function, index-parallel to the functions array of\n   * measure(): identifiers are anonymized by first occurrence within the function, literals by\n   * kind, and keywords/operators kept verbatim, so the regression gate can re-match renamed or\n   * moved functions across two revisions by token-LCS similarity.\n   */\n  collectFunctionTokenSequences(code: string, options: MeasureOptions): Int32Array[] {\n    const language = this.resolveLanguage(options.language);\n    return collectFunctionTokenSequencesNative(code, language.name);\n  }\n\n  private resolveLanguage(name: LanguageName): LanguageDefinition {\n    const language = this.registry.get(name);\n    if (!language) {\n      throw new Error(`Unsupported language: ${name}`);\n    }\n    return language;\n  }\n}\n\n/**\n * Completes a native measurement into CodeMetrics. The object is rebuilt field by field (rather\n * than spread from the parsed JSON) so the result has a stable shape, including\n * explicitly-undefined optional keys.\n */\nfunction assembleNativeMetrics(payload: NativeMetricsPayload, includeSyntaxTree: boolean): CodeMetrics {\n  return {\n    language: payload.language,\n    bytes: payload.bytes,\n    lines: payload.lines,\n    functions: payload.functions.map((fn) => ({\n      name: fn.name,\n      nodeType: fn.nodeType,\n      startLine: fn.startLine,\n      startColumn: fn.startColumn,\n      endLine: fn.endLine,\n      endColumn: fn.endColumn,\n      cyclomaticComplexity: fn.cyclomaticComplexity,\n      cognitiveComplexity: fn.cognitiveComplexity,\n      nestingDepth: fn.nestingDepth,\n      ncss: fn.ncss,\n      parameterCount: fn.parameterCount,\n      halstead: deriveHalsteadMetrics(fn.halsteadCounts),\n      depDegree: fn.depDegree,\n    })),\n    cyclomaticComplexity: payload.cyclomaticComplexity,\n    cognitiveComplexity: payload.cognitiveComplexity,\n    maxCognitiveComplexity: payload.maxCognitiveComplexity,\n    nestingDepth: payload.nestingDepth,\n    ncssCount: payload.ncssCount,\n    duplication: payload.duplication,\n    halstead: deriveHalsteadMetrics(payload.halsteadCounts),\n    syntaxTree: includeSyntaxTree ? payload.syntaxTree : undefined,\n  };\n}\n\nfunction deriveHalsteadMetrics(counts: NativeHalsteadCounts): HalsteadMetrics {\n  const { distinctOperators, distinctOperands, totalOperators, totalOperands } = counts;\n  const vocabulary = distinctOperators + distinctOperands;\n  const length = totalOperators + totalOperands;\n  const volume = vocabulary === 0 ? 0 : length * Math.log2(vocabulary);\n  const difficulty = distinctOperands === 0 ? 0 : (distinctOperators / 2) * (totalOperands / distinctOperands);\n  const effort = difficulty * volume;\n\n  return {\n    distinctOperators,\n    distinctOperands,\n    totalOperators,\n    totalOperands,\n    vocabulary,\n    length,\n    volume,\n    effort,\n  };\n}\n\nexport const defaultMeasurer = new TreeMeasurer();\n\nexport function measureCode(code: string, options: MeasureOptions): CodeMetrics {\n  return defaultMeasurer.measure(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectDuplicationCandidates(code: string, options: MeasureOptions): CrossFileDuplicateCandidate[] {\n  return defaultMeasurer.collectDuplicationCandidates(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectFunctionTokenSequences(code: string, options: MeasureOptions): Int32Array[] {\n  return defaultMeasurer.collectFunctionTokenSequences(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectCrossFileDuplicationFileData(\n  code: string,\n  options: MeasureOptions\n): CrossFileDuplicationFileData {\n  return defaultMeasurer.collectCrossFileDuplicationFileData(code, options);\n}\n"],"mappings":"iFAgBA,IAAa,EAAb,KAA0B,CACxB,SAA4BA,EAAAA,uBAAuB,EAEnD,uBAAwC,CACtC,MAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,KAAK,SAAS,OAAO,CAAC,CAAC,CAAC,IAAK,GAAa,EAAS,IAAI,CAAC,CAAC,CAClF,CAEA,QAAQ,EAAc,EAAsC,CAC1D,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EAChD,EAAoB,EAAQ,mBAAqB,GAEvD,OAAO,EADSC,EAAAA,kBAAkB,EAAM,EAAS,KAAM,EAAmB,EAAQ,WAC/C,EAAG,CAAiB,CACzD,CAGA,6BAA6B,EAAc,EAAwD,CACjG,OAAO,KAAK,oCAAoC,EAAM,CAAO,CAAC,CAAC,UACjE,CAMA,oCAAoC,EAAc,EAAuD,CACvG,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EAChD,EAAUC,EAAAA,2BAA2B,EAAM,EAAS,KAAM,EAAQ,aAAa,SAAS,EAC9F,MAAO,CACL,WAAY,EAAQ,WACpB,OAAQ,EAAQ,OAChB,oBAAqB,EAAQ,oBAE7B,gBAAiB,IAAI,IAAI,EAAQ,eAAe,CAClD,CACF,CAQA,8BAA8B,EAAc,EAAuC,CACjF,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EACtD,OAAOC,EAAAA,oCAAoC,EAAM,EAAS,IAAI,CAChE,CAEA,gBAAwB,EAAwC,CAC9D,IAAM,EAAW,KAAK,SAAS,IAAI,CAAI,EACvC,GAAI,CAAC,EACH,MAAU,MAAM,yBAAyB,GAAM,EAEjD,OAAO,CACT,CACF,EAOA,SAAS,EAAsB,EAA+B,EAAyC,CACrG,MAAO,CACL,SAAU,EAAQ,SAClB,MAAO,EAAQ,MACf,MAAO,EAAQ,MACf,UAAW,EAAQ,UAAU,IAAK,IAAQ,CACxC,KAAM,EAAG,KACT,SAAU,EAAG,SACb,UAAW,EAAG,UACd,YAAa,EAAG,YAChB,QAAS,EAAG,QACZ,UAAW,EAAG,UACd,qBAAsB,EAAG,qBACzB,oBAAqB,EAAG,oBACxB,aAAc,EAAG,aACjB,KAAM,EAAG,KACT,eAAgB,EAAG,eACnB,SAAU,EAAsB,EAAG,cAAc,EACjD,UAAW,EAAG,SAChB,EAAE,EACF,qBAAsB,EAAQ,qBAC9B,oBAAqB,EAAQ,oBAC7B,uBAAwB,EAAQ,uBAChC,aAAc,EAAQ,aACtB,UAAW,EAAQ,UACnB,YAAa,EAAQ,YACrB,SAAU,EAAsB,EAAQ,cAAc,EACtD,WAAY,EAAoB,EAAQ,WAAa,IAAA,EACvD,CACF,CAEA,SAAS,EAAsB,EAA+C,CAC5E,GAAM,CAAE,oBAAmB,mBAAkB,iBAAgB,iBAAkB,EACzE,EAAa,EAAoB,EACjC,EAAS,EAAiB,EAC1B,EAAS,IAAe,EAAI,EAAI,EAAS,KAAK,KAAK,CAAU,EAInE,MAAO,CACL,oBACA,mBACA,iBACA,gBACA,aACA,SACA,SACA,QAXiB,IAAqB,EAAI,EAAK,EAAoB,GAAM,EAAgB,IAC/D,CAW5B,CACF,CAEA,MAAa,EAAkB,IAAI,EAEnC,SAAgB,EAAY,EAAc,EAAsC,CAC9E,OAAO,EAAgB,QAAQ,EAAM,CAAO,CAC9C,CAGA,SAAgB,EAA6B,EAAc,EAAwD,CACjH,OAAO,EAAgB,6BAA6B,EAAM,CAAO,CACnE,CAGA,SAAgB,EAA8B,EAAc,EAAuC,CACjG,OAAO,EAAgB,8BAA8B,EAAM,CAAO,CACpE,CAGA,SAAgB,EACd,EACA,EAC8B,CAC9B,OAAO,EAAgB,oCAAoC,EAAM,CAAO,CAC1E"}

package/dist/metrics.js

@@ -1,2 +1,2 @@
-import{createLanguageRegistry as e}from"./languages.js";import{collectCrossFileDataNative as t,collectFunctionTokenSequencesNative as n,measureCodeNative as r}from"./nativeMetrics.js";var i=class{registry=e();getSupportedLanguages(){return[...new Set([...this.registry.values()].map(e=>e.name))]}measure(e,t){let n=this.resolveLanguage(t.language),i=t.includeSyntaxTree??!1;return a(r(e,n.name,i,t.duplication),i)}collectDuplicationCandidates(e,t){return this.collectCrossFileDuplicationFileData(e,t).candidates}collectCrossFileDuplicationFileData(e,n){let r=this.resolveLanguage(n.language),i=t(e,r.name,n.duplication?.minTokens);return{candidates:i.candidates,tokens:i.tokens,containerStatements:i.containerStatements,codeLineNumbers:new Set(i.codeLineNumbers)}}collectFunctionTokenSequences(e,t){let r=this.resolveLanguage(t.language);return n(e,r.name)}resolveLanguage(e){let t=this.registry.get(e);if(!t)throw Error(`Unsupported language: ${e}`);return t}};function a(e,t){return{language:e.language,bytes:e.bytes,lines:e.lines,functions:e.functions.map(e=>({name:e.name,nodeType:e.nodeType,startLine:e.startLine,startColumn:e.startColumn,endLine:e.endLine,endColumn:e.endColumn,cyclomaticComplexity:e.cyclomaticComplexity,cognitiveComplexity:e.cognitiveComplexity,nestingDepth:e.nestingDepth,ncss:e.ncss,parameterCount:e.parameterCount,halstead:o(e.halsteadCounts),depDegree:e.depDegree})),cognitiveComplexity:e.cognitiveComplexity,maxCognitiveComplexity:e.maxCognitiveComplexity,nestingDepth:e.nestingDepth,ncssCount:e.ncssCount,duplication:e.duplication,halstead:o(e.halsteadCounts),syntaxTree:t?e.syntaxTree:void 0}}function o(e){let{distinctOperators:t,distinctOperands:n,totalOperators:r,totalOperands:i}=e,a=t+n,o=r+i,s=a===0?0:o*Math.log2(a);return{distinctOperators:t,distinctOperands:n,totalOperators:r,totalOperands:i,vocabulary:a,length:o,volume:s,effort:(n===0?0:t/2*(i/n))*s}}const s=new i;function c(e,t){return s.measure(e,t)}function l(e,t){return s.collectDuplicationCandidates(e,t)}function u(e,t){return s.collectFunctionTokenSequences(e,t)}function d(e,t){return s.collectCrossFileDuplicationFileData(e,t)}export{i as TreeMeasurer,d as collectCrossFileDuplicationFileData,l as collectDuplicationCandidates,u as collectFunctionTokenSequences,s as defaultMeasurer,c as measureCode};
+import{createLanguageRegistry as e}from"./languages.js";import{collectCrossFileDataNative as t,collectFunctionTokenSequencesNative as n,measureCodeNative as r}from"./nativeMetrics.js";var i=class{registry=e();getSupportedLanguages(){return[...new Set([...this.registry.values()].map(e=>e.name))]}measure(e,t){let n=this.resolveLanguage(t.language),i=t.includeSyntaxTree??!1;return a(r(e,n.name,i,t.duplication),i)}collectDuplicationCandidates(e,t){return this.collectCrossFileDuplicationFileData(e,t).candidates}collectCrossFileDuplicationFileData(e,n){let r=this.resolveLanguage(n.language),i=t(e,r.name,n.duplication?.minTokens);return{candidates:i.candidates,tokens:i.tokens,containerStatements:i.containerStatements,codeLineNumbers:new Set(i.codeLineNumbers)}}collectFunctionTokenSequences(e,t){let r=this.resolveLanguage(t.language);return n(e,r.name)}resolveLanguage(e){let t=this.registry.get(e);if(!t)throw Error(`Unsupported language: ${e}`);return t}};function a(e,t){return{language:e.language,bytes:e.bytes,lines:e.lines,functions:e.functions.map(e=>({name:e.name,nodeType:e.nodeType,startLine:e.startLine,startColumn:e.startColumn,endLine:e.endLine,endColumn:e.endColumn,cyclomaticComplexity:e.cyclomaticComplexity,cognitiveComplexity:e.cognitiveComplexity,nestingDepth:e.nestingDepth,ncss:e.ncss,parameterCount:e.parameterCount,halstead:o(e.halsteadCounts),depDegree:e.depDegree})),cyclomaticComplexity:e.cyclomaticComplexity,cognitiveComplexity:e.cognitiveComplexity,maxCognitiveComplexity:e.maxCognitiveComplexity,nestingDepth:e.nestingDepth,ncssCount:e.ncssCount,duplication:e.duplication,halstead:o(e.halsteadCounts),syntaxTree:t?e.syntaxTree:void 0}}function o(e){let{distinctOperators:t,distinctOperands:n,totalOperators:r,totalOperands:i}=e,a=t+n,o=r+i,s=a===0?0:o*Math.log2(a);return{distinctOperators:t,distinctOperands:n,totalOperators:r,totalOperands:i,vocabulary:a,length:o,volume:s,effort:(n===0?0:t/2*(i/n))*s}}const s=new i;function c(e,t){return s.measure(e,t)}function l(e,t){return s.collectDuplicationCandidates(e,t)}function u(e,t){return s.collectFunctionTokenSequences(e,t)}function d(e,t){return s.collectCrossFileDuplicationFileData(e,t)}export{i as TreeMeasurer,d as collectCrossFileDuplicationFileData,l as collectDuplicationCandidates,u as collectFunctionTokenSequences,s as defaultMeasurer,c as measureCode};
 //# sourceMappingURL=metrics.js.map

package/dist/metrics.js.map

@@ -1 +1 @@
-{"version":3,"file":"metrics.js","names":[],"sources":["../src/metrics.ts"],"sourcesContent":["import type { CrossFileDuplicateCandidate, CrossFileDuplicationFileData } from './duplication.js';\nimport { createLanguageRegistry } from './languages.js';\nimport {\n  collectCrossFileDataNative,\n  collectFunctionTokenSequencesNative,\n  measureCodeNative,\n  type NativeHalsteadCounts,\n  type NativeMetricsPayload,\n} from './nativeMetrics.js';\nimport type { CodeMetrics, HalsteadMetrics, LanguageDefinition, LanguageName, MeasureOptions } from './types.js';\n\n/**\n * Measures code metrics for the built-in languages. Parsing and metric passes run in the bundled\n * Rust addon (tree-sitter); this class resolves language aliases, crosses the N-API boundary, and\n * derives the Halstead float metrics from the natively measured counts.\n */\nexport class TreeMeasurer {\n  private readonly registry = createLanguageRegistry();\n\n  getSupportedLanguages(): LanguageName[] {\n    return [...new Set([...this.registry.values()].map((language) => language.name))];\n  }\n\n  measure(code: string, options: MeasureOptions): CodeMetrics {\n    const language = this.resolveLanguage(options.language);\n    const includeSyntaxTree = options.includeSyntaxTree ?? false;\n    const payload = measureCodeNative(code, language.name, includeSyntaxTree, options.duplication);\n    return assembleNativeMetrics(payload, includeSyntaxTree);\n  }\n\n  /** Collects one file's duplicate candidates for cross-file clone detection. */\n  collectDuplicationCandidates(code: string, options: MeasureOptions): CrossFileDuplicateCandidate[] {\n    return this.collectCrossFileDuplicationFileData(code, options).candidates;\n  }\n\n  /**\n   * Collects one file's duplicate candidates, normalized tokens, and statement structure for\n   * cross-file clone detection with measureCrossFileDuplication.\n   */\n  collectCrossFileDuplicationFileData(code: string, options: MeasureOptions): CrossFileDuplicationFileData {\n    const language = this.resolveLanguage(options.language);\n    const payload = collectCrossFileDataNative(code, language.name, options.duplication?.minTokens);\n    return {\n      candidates: payload.candidates,\n      tokens: payload.tokens,\n      containerStatements: payload.containerStatements,\n      // Lets cross-file line coverage count only code lines, like within-file coverage.\n      codeLineNumbers: new Set(payload.codeLineNumbers),\n    };\n  }\n\n  /**\n   * Normalized token hash sequences of every function, index-parallel to the functions array of\n   * measure(): identifiers are anonymized by first occurrence within the function, literals by\n   * kind, and keywords/operators kept verbatim, so the regression gate can re-match renamed or\n   * moved functions across two revisions by token-LCS similarity.\n   */\n  collectFunctionTokenSequences(code: string, options: MeasureOptions): Int32Array[] {\n    const language = this.resolveLanguage(options.language);\n    return collectFunctionTokenSequencesNative(code, language.name);\n  }\n\n  private resolveLanguage(name: LanguageName): LanguageDefinition {\n    const language = this.registry.get(name);\n    if (!language) {\n      throw new Error(`Unsupported language: ${name}`);\n    }\n    return language;\n  }\n}\n\n/**\n * Completes a native measurement into CodeMetrics. The object is rebuilt field by field (rather\n * than spread from the parsed JSON) so the result has a stable shape, including\n * explicitly-undefined optional keys.\n */\nfunction assembleNativeMetrics(payload: NativeMetricsPayload, includeSyntaxTree: boolean): CodeMetrics {\n  return {\n    language: payload.language,\n    bytes: payload.bytes,\n    lines: payload.lines,\n    functions: payload.functions.map((fn) => ({\n      name: fn.name,\n      nodeType: fn.nodeType,\n      startLine: fn.startLine,\n      startColumn: fn.startColumn,\n      endLine: fn.endLine,\n      endColumn: fn.endColumn,\n      cyclomaticComplexity: fn.cyclomaticComplexity,\n      cognitiveComplexity: fn.cognitiveComplexity,\n      nestingDepth: fn.nestingDepth,\n      ncss: fn.ncss,\n      parameterCount: fn.parameterCount,\n      halstead: deriveHalsteadMetrics(fn.halsteadCounts),\n      depDegree: fn.depDegree,\n    })),\n    cognitiveComplexity: payload.cognitiveComplexity,\n    maxCognitiveComplexity: payload.maxCognitiveComplexity,\n    nestingDepth: payload.nestingDepth,\n    ncssCount: payload.ncssCount,\n    duplication: payload.duplication,\n    halstead: deriveHalsteadMetrics(payload.halsteadCounts),\n    syntaxTree: includeSyntaxTree ? payload.syntaxTree : undefined,\n  };\n}\n\nfunction deriveHalsteadMetrics(counts: NativeHalsteadCounts): HalsteadMetrics {\n  const { distinctOperators, distinctOperands, totalOperators, totalOperands } = counts;\n  const vocabulary = distinctOperators + distinctOperands;\n  const length = totalOperators + totalOperands;\n  const volume = vocabulary === 0 ? 0 : length * Math.log2(vocabulary);\n  const difficulty = distinctOperands === 0 ? 0 : (distinctOperators / 2) * (totalOperands / distinctOperands);\n  const effort = difficulty * volume;\n\n  return {\n    distinctOperators,\n    distinctOperands,\n    totalOperators,\n    totalOperands,\n    vocabulary,\n    length,\n    volume,\n    effort,\n  };\n}\n\nexport const defaultMeasurer = new TreeMeasurer();\n\nexport function measureCode(code: string, options: MeasureOptions): CodeMetrics {\n  return defaultMeasurer.measure(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectDuplicationCandidates(code: string, options: MeasureOptions): CrossFileDuplicateCandidate[] {\n  return defaultMeasurer.collectDuplicationCandidates(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectFunctionTokenSequences(code: string, options: MeasureOptions): Int32Array[] {\n  return defaultMeasurer.collectFunctionTokenSequences(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectCrossFileDuplicationFileData(\n  code: string,\n  options: MeasureOptions\n): CrossFileDuplicationFileData {\n  return defaultMeasurer.collectCrossFileDuplicationFileData(code, options);\n}\n"],"mappings":"wLAgBA,IAAa,EAAb,KAA0B,CACxB,SAA4B,EAAuB,EAEnD,uBAAwC,CACtC,MAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,KAAK,SAAS,OAAO,CAAC,CAAC,CAAC,IAAK,GAAa,EAAS,IAAI,CAAC,CAAC,CAClF,CAEA,QAAQ,EAAc,EAAsC,CAC1D,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EAChD,EAAoB,EAAQ,mBAAqB,GAEvD,OAAO,EADS,EAAkB,EAAM,EAAS,KAAM,EAAmB,EAAQ,WAC/C,EAAG,CAAiB,CACzD,CAGA,6BAA6B,EAAc,EAAwD,CACjG,OAAO,KAAK,oCAAoC,EAAM,CAAO,CAAC,CAAC,UACjE,CAMA,oCAAoC,EAAc,EAAuD,CACvG,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EAChD,EAAU,EAA2B,EAAM,EAAS,KAAM,EAAQ,aAAa,SAAS,EAC9F,MAAO,CACL,WAAY,EAAQ,WACpB,OAAQ,EAAQ,OAChB,oBAAqB,EAAQ,oBAE7B,gBAAiB,IAAI,IAAI,EAAQ,eAAe,CAClD,CACF,CAQA,8BAA8B,EAAc,EAAuC,CACjF,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EACtD,OAAO,EAAoC,EAAM,EAAS,IAAI,CAChE,CAEA,gBAAwB,EAAwC,CAC9D,IAAM,EAAW,KAAK,SAAS,IAAI,CAAI,EACvC,GAAI,CAAC,EACH,MAAU,MAAM,yBAAyB,GAAM,EAEjD,OAAO,CACT,CACF,EAOA,SAAS,EAAsB,EAA+B,EAAyC,CACrG,MAAO,CACL,SAAU,EAAQ,SAClB,MAAO,EAAQ,MACf,MAAO,EAAQ,MACf,UAAW,EAAQ,UAAU,IAAK,IAAQ,CACxC,KAAM,EAAG,KACT,SAAU,EAAG,SACb,UAAW,EAAG,UACd,YAAa,EAAG,YAChB,QAAS,EAAG,QACZ,UAAW,EAAG,UACd,qBAAsB,EAAG,qBACzB,oBAAqB,EAAG,oBACxB,aAAc,EAAG,aACjB,KAAM,EAAG,KACT,eAAgB,EAAG,eACnB,SAAU,EAAsB,EAAG,cAAc,EACjD,UAAW,EAAG,SAChB,EAAE,EACF,oBAAqB,EAAQ,oBAC7B,uBAAwB,EAAQ,uBAChC,aAAc,EAAQ,aACtB,UAAW,EAAQ,UACnB,YAAa,EAAQ,YACrB,SAAU,EAAsB,EAAQ,cAAc,EACtD,WAAY,EAAoB,EAAQ,WAAa,IAAA,EACvD,CACF,CAEA,SAAS,EAAsB,EAA+C,CAC5E,GAAM,CAAE,oBAAmB,mBAAkB,iBAAgB,iBAAkB,EACzE,EAAa,EAAoB,EACjC,EAAS,EAAiB,EAC1B,EAAS,IAAe,EAAI,EAAI,EAAS,KAAK,KAAK,CAAU,EAInE,MAAO,CACL,oBACA,mBACA,iBACA,gBACA,aACA,SACA,SACA,QAXiB,IAAqB,EAAI,EAAK,EAAoB,GAAM,EAAgB,IAC/D,CAW5B,CACF,CAEA,MAAa,EAAkB,IAAI,EAEnC,SAAgB,EAAY,EAAc,EAAsC,CAC9E,OAAO,EAAgB,QAAQ,EAAM,CAAO,CAC9C,CAGA,SAAgB,EAA6B,EAAc,EAAwD,CACjH,OAAO,EAAgB,6BAA6B,EAAM,CAAO,CACnE,CAGA,SAAgB,EAA8B,EAAc,EAAuC,CACjG,OAAO,EAAgB,8BAA8B,EAAM,CAAO,CACpE,CAGA,SAAgB,EACd,EACA,EAC8B,CAC9B,OAAO,EAAgB,oCAAoC,EAAM,CAAO,CAC1E"}
+{"version":3,"file":"metrics.js","names":[],"sources":["../src/metrics.ts"],"sourcesContent":["import type { CrossFileDuplicateCandidate, CrossFileDuplicationFileData } from './duplication.js';\nimport { createLanguageRegistry } from './languages.js';\nimport {\n  collectCrossFileDataNative,\n  collectFunctionTokenSequencesNative,\n  measureCodeNative,\n  type NativeHalsteadCounts,\n  type NativeMetricsPayload,\n} from './nativeMetrics.js';\nimport type { CodeMetrics, HalsteadMetrics, LanguageDefinition, LanguageName, MeasureOptions } from './types.js';\n\n/**\n * Measures code metrics for the built-in languages. Parsing and metric passes run in the bundled\n * Rust addon (tree-sitter); this class resolves language aliases, crosses the N-API boundary, and\n * derives the Halstead float metrics from the natively measured counts.\n */\nexport class TreeMeasurer {\n  private readonly registry = createLanguageRegistry();\n\n  getSupportedLanguages(): LanguageName[] {\n    return [...new Set([...this.registry.values()].map((language) => language.name))];\n  }\n\n  measure(code: string, options: MeasureOptions): CodeMetrics {\n    const language = this.resolveLanguage(options.language);\n    const includeSyntaxTree = options.includeSyntaxTree ?? false;\n    const payload = measureCodeNative(code, language.name, includeSyntaxTree, options.duplication);\n    return assembleNativeMetrics(payload, includeSyntaxTree);\n  }\n\n  /** Collects one file's duplicate candidates for cross-file clone detection. */\n  collectDuplicationCandidates(code: string, options: MeasureOptions): CrossFileDuplicateCandidate[] {\n    return this.collectCrossFileDuplicationFileData(code, options).candidates;\n  }\n\n  /**\n   * Collects one file's duplicate candidates, normalized tokens, and statement structure for\n   * cross-file clone detection with measureCrossFileDuplication.\n   */\n  collectCrossFileDuplicationFileData(code: string, options: MeasureOptions): CrossFileDuplicationFileData {\n    const language = this.resolveLanguage(options.language);\n    const payload = collectCrossFileDataNative(code, language.name, options.duplication?.minTokens);\n    return {\n      candidates: payload.candidates,\n      tokens: payload.tokens,\n      containerStatements: payload.containerStatements,\n      // Lets cross-file line coverage count only code lines, like within-file coverage.\n      codeLineNumbers: new Set(payload.codeLineNumbers),\n    };\n  }\n\n  /**\n   * Normalized token hash sequences of every function, index-parallel to the functions array of\n   * measure(): identifiers are anonymized by first occurrence within the function, literals by\n   * kind, and keywords/operators kept verbatim, so the regression gate can re-match renamed or\n   * moved functions across two revisions by token-LCS similarity.\n   */\n  collectFunctionTokenSequences(code: string, options: MeasureOptions): Int32Array[] {\n    const language = this.resolveLanguage(options.language);\n    return collectFunctionTokenSequencesNative(code, language.name);\n  }\n\n  private resolveLanguage(name: LanguageName): LanguageDefinition {\n    const language = this.registry.get(name);\n    if (!language) {\n      throw new Error(`Unsupported language: ${name}`);\n    }\n    return language;\n  }\n}\n\n/**\n * Completes a native measurement into CodeMetrics. The object is rebuilt field by field (rather\n * than spread from the parsed JSON) so the result has a stable shape, including\n * explicitly-undefined optional keys.\n */\nfunction assembleNativeMetrics(payload: NativeMetricsPayload, includeSyntaxTree: boolean): CodeMetrics {\n  return {\n    language: payload.language,\n    bytes: payload.bytes,\n    lines: payload.lines,\n    functions: payload.functions.map((fn) => ({\n      name: fn.name,\n      nodeType: fn.nodeType,\n      startLine: fn.startLine,\n      startColumn: fn.startColumn,\n      endLine: fn.endLine,\n      endColumn: fn.endColumn,\n      cyclomaticComplexity: fn.cyclomaticComplexity,\n      cognitiveComplexity: fn.cognitiveComplexity,\n      nestingDepth: fn.nestingDepth,\n      ncss: fn.ncss,\n      parameterCount: fn.parameterCount,\n      halstead: deriveHalsteadMetrics(fn.halsteadCounts),\n      depDegree: fn.depDegree,\n    })),\n    cyclomaticComplexity: payload.cyclomaticComplexity,\n    cognitiveComplexity: payload.cognitiveComplexity,\n    maxCognitiveComplexity: payload.maxCognitiveComplexity,\n    nestingDepth: payload.nestingDepth,\n    ncssCount: payload.ncssCount,\n    duplication: payload.duplication,\n    halstead: deriveHalsteadMetrics(payload.halsteadCounts),\n    syntaxTree: includeSyntaxTree ? payload.syntaxTree : undefined,\n  };\n}\n\nfunction deriveHalsteadMetrics(counts: NativeHalsteadCounts): HalsteadMetrics {\n  const { distinctOperators, distinctOperands, totalOperators, totalOperands } = counts;\n  const vocabulary = distinctOperators + distinctOperands;\n  const length = totalOperators + totalOperands;\n  const volume = vocabulary === 0 ? 0 : length * Math.log2(vocabulary);\n  const difficulty = distinctOperands === 0 ? 0 : (distinctOperators / 2) * (totalOperands / distinctOperands);\n  const effort = difficulty * volume;\n\n  return {\n    distinctOperators,\n    distinctOperands,\n    totalOperators,\n    totalOperands,\n    vocabulary,\n    length,\n    volume,\n    effort,\n  };\n}\n\nexport const defaultMeasurer = new TreeMeasurer();\n\nexport function measureCode(code: string, options: MeasureOptions): CodeMetrics {\n  return defaultMeasurer.measure(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectDuplicationCandidates(code: string, options: MeasureOptions): CrossFileDuplicateCandidate[] {\n  return defaultMeasurer.collectDuplicationCandidates(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectFunctionTokenSequences(code: string, options: MeasureOptions): Int32Array[] {\n  return defaultMeasurer.collectFunctionTokenSequences(code, options);\n}\n\n/** Standalone helper mirroring measureCode for the default measurer. */\nexport function collectCrossFileDuplicationFileData(\n  code: string,\n  options: MeasureOptions\n): CrossFileDuplicationFileData {\n  return defaultMeasurer.collectCrossFileDuplicationFileData(code, options);\n}\n"],"mappings":"wLAgBA,IAAa,EAAb,KAA0B,CACxB,SAA4B,EAAuB,EAEnD,uBAAwC,CACtC,MAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,KAAK,SAAS,OAAO,CAAC,CAAC,CAAC,IAAK,GAAa,EAAS,IAAI,CAAC,CAAC,CAClF,CAEA,QAAQ,EAAc,EAAsC,CAC1D,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EAChD,EAAoB,EAAQ,mBAAqB,GAEvD,OAAO,EADS,EAAkB,EAAM,EAAS,KAAM,EAAmB,EAAQ,WAC/C,EAAG,CAAiB,CACzD,CAGA,6BAA6B,EAAc,EAAwD,CACjG,OAAO,KAAK,oCAAoC,EAAM,CAAO,CAAC,CAAC,UACjE,CAMA,oCAAoC,EAAc,EAAuD,CACvG,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EAChD,EAAU,EAA2B,EAAM,EAAS,KAAM,EAAQ,aAAa,SAAS,EAC9F,MAAO,CACL,WAAY,EAAQ,WACpB,OAAQ,EAAQ,OAChB,oBAAqB,EAAQ,oBAE7B,gBAAiB,IAAI,IAAI,EAAQ,eAAe,CAClD,CACF,CAQA,8BAA8B,EAAc,EAAuC,CACjF,IAAM,EAAW,KAAK,gBAAgB,EAAQ,QAAQ,EACtD,OAAO,EAAoC,EAAM,EAAS,IAAI,CAChE,CAEA,gBAAwB,EAAwC,CAC9D,IAAM,EAAW,KAAK,SAAS,IAAI,CAAI,EACvC,GAAI,CAAC,EACH,MAAU,MAAM,yBAAyB,GAAM,EAEjD,OAAO,CACT,CACF,EAOA,SAAS,EAAsB,EAA+B,EAAyC,CACrG,MAAO,CACL,SAAU,EAAQ,SAClB,MAAO,EAAQ,MACf,MAAO,EAAQ,MACf,UAAW,EAAQ,UAAU,IAAK,IAAQ,CACxC,KAAM,EAAG,KACT,SAAU,EAAG,SACb,UAAW,EAAG,UACd,YAAa,EAAG,YAChB,QAAS,EAAG,QACZ,UAAW,EAAG,UACd,qBAAsB,EAAG,qBACzB,oBAAqB,EAAG,oBACxB,aAAc,EAAG,aACjB,KAAM,EAAG,KACT,eAAgB,EAAG,eACnB,SAAU,EAAsB,EAAG,cAAc,EACjD,UAAW,EAAG,SAChB,EAAE,EACF,qBAAsB,EAAQ,qBAC9B,oBAAqB,EAAQ,oBAC7B,uBAAwB,EAAQ,uBAChC,aAAc,EAAQ,aACtB,UAAW,EAAQ,UACnB,YAAa,EAAQ,YACrB,SAAU,EAAsB,EAAQ,cAAc,EACtD,WAAY,EAAoB,EAAQ,WAAa,IAAA,EACvD,CACF,CAEA,SAAS,EAAsB,EAA+C,CAC5E,GAAM,CAAE,oBAAmB,mBAAkB,iBAAgB,iBAAkB,EACzE,EAAa,EAAoB,EACjC,EAAS,EAAiB,EAC1B,EAAS,IAAe,EAAI,EAAI,EAAS,KAAK,KAAK,CAAU,EAInE,MAAO,CACL,oBACA,mBACA,iBACA,gBACA,aACA,SACA,SACA,QAXiB,IAAqB,EAAI,EAAK,EAAoB,GAAM,EAAgB,IAC/D,CAW5B,CACF,CAEA,MAAa,EAAkB,IAAI,EAEnC,SAAgB,EAAY,EAAc,EAAsC,CAC9E,OAAO,EAAgB,QAAQ,EAAM,CAAO,CAC9C,CAGA,SAAgB,EAA6B,EAAc,EAAwD,CACjH,OAAO,EAAgB,6BAA6B,EAAM,CAAO,CACnE,CAGA,SAAgB,EAA8B,EAAc,EAAuC,CACjG,OAAO,EAAgB,8BAA8B,EAAM,CAAO,CACpE,CAGA,SAAgB,EACd,EACA,EAC8B,CAC9B,OAAO,EAAgB,oCAAoC,EAAM,CAAO,CAC1E"}

package/dist/nativeMetrics.cjs

@@ -1,4 +1,4 @@
 "use strict";let e=require("node:module");function t(e,t,n,r){return JSON.parse(l().measureCodeNative(i(e),t,n,a(r?.minTokens),a(r?.maxGapTokens),a(r?.minSimilarityPercent)))}function n(e,t,n){return JSON.parse(l().collectCrossFileDataNative(i(e),t,a(n)))}function r(e,t){return JSON.parse(l().collectFunctionTokenSequencesNative(i(e),t)).map(e=>Int32Array.from(e))}function i(e){return e.isWellFormed()?e:e.toWellFormed()}function a(e){return e===void 0||Number.isNaN(e)?void 0:Math.min(Math.max(Math.trunc(e),0),4294967295)}var o=class extends Error{};let s,c;function l(){if(s)return s;if(c)throw c;let t=(0,e.createRequire)(require("url").pathToFileURL(__filename).href),n=[`code-gauge-${u()}`,`../native/code-gauge.node`],r=[];for(let e of n){let n;try{n=t(e)}catch(t){r.push(`  ${e}: ${t instanceof Error?t.message.split(`
-`)[0]:String(t)}`);continue}let i=n.payloadVersion?.();if(i!==5){r.push(`  ${e}: payload version ${i??`unknown`} does not match the expected 5; rebuild the addon with \`bun run build-native\``);continue}return s=n,n}throw c=new o(`The code-gauge native addon is not available for ${u()}. Build it with \`node scripts/buildNative.mjs\` in the code-gauge package directory (requires a Rust toolchain); when installing with npm, also allow install scripts for code-gauge so its postinstall build can run.\n${r.join(`
+`)[0]:String(t)}`);continue}let i=n.payloadVersion?.();if(i!==6){r.push(`  ${e}: payload version ${i??`unknown`} does not match the expected 6; rebuild the addon with \`bun run build-native\``);continue}return s=n,n}throw c=new o(`The code-gauge native addon is not available for ${u()}. Build it with \`node scripts/buildNative.mjs\` in the code-gauge package directory (requires a Rust toolchain); when installing with npm, also allow install scripts for code-gauge so its postinstall build can run.\n${r.join(`
 `)}`),c}function u(){let e=`${process.platform}-${process.arch}`;return process.platform===`win32`?`${e}-msvc`:process.platform===`linux`?(process.report?.getReport())?.header?.glibcVersionRuntime?`${e}-gnu`:`${e}-musl`:e}exports.NativeAddonError=o,exports.collectCrossFileDataNative=n,exports.collectFunctionTokenSequencesNative=r,exports.measureCodeNative=t;
 //# sourceMappingURL=nativeMetrics.cjs.map

package/dist/nativeMetrics.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"nativeMetrics.cjs","names":["createRequire"],"sources":["../src/nativeMetrics.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport type { CrossFileDuplicateCandidate, Token, TokenRange } from './duplication.js';\nimport type { CodeMetrics, DuplicationOptions, FunctionMetrics } from './types.js';\n\n/**\n * Halstead counts measured natively; the derived float metrics (volume, effort, ...) are\n * computed in TypeScript because they involve transcendental functions (log2) whose last-bit\n * results can differ between V8 and Rust's libm, and results must not depend on the Rust side's\n * libm build.\n */\nexport interface NativeHalsteadCounts {\n  distinctOperators: number;\n  distinctOperands: number;\n  totalOperators: number;\n  totalOperands: number;\n}\n\nexport interface NativeFunctionMetricsPayload extends Omit<FunctionMetrics, 'halstead'> {\n  halsteadCounts: NativeHalsteadCounts;\n}\n\nexport interface NativeMetricsPayload extends Omit<CodeMetrics, 'halstead' | 'functions' | 'syntaxTree'> {\n  functions: NativeFunctionMetricsPayload[];\n  halsteadCounts: NativeHalsteadCounts;\n  syntaxTree?: string;\n}\n\n/** One file's cross-file clone-detection contribution as serialized by the native addon. */\nexport interface NativeCrossFileDataPayload {\n  candidates: CrossFileDuplicateCandidate[];\n  tokens: Token[];\n  containerStatements: TokenRange[][];\n  /** 1-based lines that are neither blank nor comment-only, sorted ascending. */\n  codeLineNumbers: number[];\n}\n\ninterface NativeBinding {\n  measureCodeNative(\n    code: string,\n    language: string,\n    includeSyntaxTree: boolean,\n    minTokens?: number,\n    maxGapTokens?: number,\n    minSimilarityPercent?: number\n  ): string;\n  collectCrossFileDataNative(code: string, language: string, minTokens?: number): string;\n  collectFunctionTokenSequencesNative(code: string, language: string): string;\n  payloadVersion?(): number;\n}\n\n/**\n * Must equal `payload_version` in native/src/lib.rs. A previously built addon survives a\n * `git pull` untouched, so without this handshake it would silently return payloads missing\n * newer fields instead of failing with a clear rebuild message.\n */\nconst expectedPayloadVersion = 5;\n\n/** Measures one file via the native addon, returning the raw payload for assembly in metrics.ts. */\nexport function measureCodeNative(\n  code: string,\n  language: string,\n  includeSyntaxTree: boolean,\n  duplication?: DuplicationOptions\n): NativeMetricsPayload {\n  return JSON.parse(\n    loadBinding().measureCodeNative(\n      toWellFormed(code),\n      language,\n      includeSyntaxTree,\n      clampToU32(duplication?.minTokens),\n      clampToU32(duplication?.maxGapTokens),\n      clampToU32(duplication?.minSimilarityPercent)\n    )\n  ) as NativeMetricsPayload;\n}\n\n/** Collects one file's cross-file clone-detection contribution via the native addon. */\nexport function collectCrossFileDataNative(\n  code: string,\n  language: string,\n  minTokens?: number\n): NativeCrossFileDataPayload {\n  return JSON.parse(\n    loadBinding().collectCrossFileDataNative(toWellFormed(code), language, clampToU32(minTokens))\n  ) as NativeCrossFileDataPayload;\n}\n\n/** Collects normalized token hash sequences of every function via the native addon. */\nexport function collectFunctionTokenSequencesNative(code: string, language: string): Int32Array[] {\n  const sequences = JSON.parse(\n    loadBinding().collectFunctionTokenSequencesNative(toWellFormed(code), language)\n  ) as number[][];\n  return sequences.map((sequence) => Int32Array.from(sequence));\n}\n\n/**\n * Lone surrogates cannot cross the N-API boundary losslessly, so ill-formed strings (invalid\n * UTF-16 occasionally present in real-world files) are measured with U+FFFD replacements — the\n * same code units V8's own UTF-8 conversion would substitute.\n */\nfunction toWellFormed(code: string): string {\n  return code.isWellFormed() ? code : code.toWellFormed();\n}\n\n/**\n * The duplication settings cross the boundary as u32, whose JavaScript conversion wraps modulo\n * 2^32 (2 ** 32 would become 0 and match everything). The public API accepts any safe integer, so\n * out-of-range values clamp to [0, u32::MAX] — no source can hold 2^32 tokens, so a clamped\n * threshold behaves identically to the requested one. NaN (e.g. `Number(unsetEnvVariable)`)\n * survives clamping arithmetic and would also convert to 0, so it is treated as an absent setting\n * instead.\n */\nfunction clampToU32(value: number | undefined): number | undefined {\n  return value === undefined || Number.isNaN(value)\n    ? undefined\n    : Math.min(Math.max(Math.trunc(value), 0), 0xFF_FF_FF_FF);\n}\n\n/**\n * Raised when no usable native addon can be loaded. Every measurement fails identically until the\n * addon is built, so callers measuring many files (the CLI scan) treat it as fatal for the whole\n * run instead of recording one \"skipped\" entry per file.\n */\nexport class NativeAddonError extends Error {}\n\nlet cachedBinding: NativeBinding | undefined;\nlet cachedFailure: NativeAddonError | undefined;\n\nfunction loadBinding(): NativeBinding {\n  if (cachedBinding) {\n    return cachedBinding;\n  }\n  // The failure is memoized too: resolution (including platformTriplet's diagnostic-report call\n  // on Linux) would otherwise repeat for every measured file of an already-failing run.\n  if (cachedFailure) {\n    throw cachedFailure;\n  }\n  // Resolved relative to this file, so both src/ (tests) and dist/ (build) find the addon.\n  const requireNative = createRequire(import.meta.url);\n  const specifiers = [\n    // A prebuilt platform package, when published for this platform.\n    `code-gauge-${platformTriplet()}`,\n    // A locally built addon (`bun run build-native`).\n    '../native/code-gauge.node',\n  ];\n  const failures: string[] = [];\n  for (const specifier of specifiers) {\n    let binding: NativeBinding;\n    try {\n      binding = requireNative(specifier) as NativeBinding;\n    } catch (error) {\n      failures.push(`  ${specifier}: ${error instanceof Error ? error.message.split('\\n')[0] : String(error)}`);\n      continue;\n    }\n    const version = binding.payloadVersion?.();\n    if (version !== expectedPayloadVersion) {\n      failures.push(\n        `  ${specifier}: payload version ${version ?? 'unknown'} does not match the expected ` +\n          `${expectedPayloadVersion}; rebuild the addon with \\`bun run build-native\\``\n      );\n      continue;\n    }\n    cachedBinding = binding;\n    return binding;\n  }\n  cachedFailure = new NativeAddonError(\n    `The code-gauge native addon is not available for ${platformTriplet()}. Build it with ` +\n      '`node scripts/buildNative.mjs` in the code-gauge package directory (requires a Rust ' +\n      'toolchain); when installing with npm, also allow install scripts for code-gauge so its ' +\n      `postinstall build can run.\\n${failures.join('\\n')}`\n  );\n  throw cachedFailure;\n}\n\n/**\n * The platform-package suffix in the napi-rs naming convention: Linux targets are qualified by\n * libc ABI (`linux-x64-gnu` / `linux-x64-musl`) because a glibc-linked addon cannot load on\n * Alpine/musl, and Windows by toolchain ABI (`win32-x64-msvc`), matching what napi-rs tooling\n * generates. Must match scripts/installNative.mjs and the build-native workflow's target list.\n */\nfunction platformTriplet(): string {\n  const base = `${process.platform}-${process.arch}`;\n  if (process.platform === 'win32') {\n    return `${base}-msvc`;\n  }\n  if (process.platform !== 'linux') {\n    return base;\n  }\n  // Musl builds of Node report no glibc runtime version; see napi-rs's isMusl detection.\n  const report = process.report?.getReport() as { header?: { glibcVersionRuntime?: string } } | undefined;\n  return report?.header?.glibcVersionRuntime ? `${base}-gnu` : `${base}-musl`;\n}\n"],"mappings":"0CA0DA,SAAgB,EACd,EACA,EACA,EACA,EACsB,CACtB,OAAO,KAAK,MACV,EAAY,CAAC,CAAC,kBACZ,EAAa,CAAI,EACjB,EACA,EACA,EAAW,GAAa,SAAS,EACjC,EAAW,GAAa,YAAY,EACpC,EAAW,GAAa,oBAAoB,CAC9C,CACF,CACF,CAGA,SAAgB,EACd,EACA,EACA,EAC4B,CAC5B,OAAO,KAAK,MACV,EAAY,CAAC,CAAC,2BAA2B,EAAa,CAAI,EAAG,EAAU,EAAW,CAAS,CAAC,CAC9F,CACF,CAGA,SAAgB,EAAoC,EAAc,EAAgC,CAIhG,OAHkB,KAAK,MACrB,EAAY,CAAC,CAAC,oCAAoC,EAAa,CAAI,EAAG,CAAQ,CAEjE,CAAC,CAAC,IAAK,GAAa,WAAW,KAAK,CAAQ,CAAC,CAC9D,CAOA,SAAS,EAAa,EAAsB,CAC1C,OAAO,EAAK,aAAa,EAAI,EAAO,EAAK,aAAa,CACxD,CAUA,SAAS,EAAW,EAA+C,CACjE,OAAO,IAAU,IAAA,IAAa,OAAO,MAAM,CAAK,EAC5C,IAAA,GACA,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,CAAK,EAAG,CAAC,EAAG,UAAa,CAC5D,CAOA,IAAa,EAAb,cAAsC,KAAM,CAAC,EAE7C,IAAI,EACA,EAEJ,SAAS,GAA6B,CACpC,GAAI,EACF,OAAO,EAIT,GAAI,EACF,MAAM,EAGR,IAAM,GAAA,EAAgBA,EAAAA,cAAAA,CAAAA,QAAAA,KAAAA,CAAAA,CAAAA,cAAAA,UAAAA,CAAAA,CAAAA,IAA6B,EAC7C,EAAa,CAEjB,cAAc,EAAgB,IAE9B,2BACF,EACM,EAAqB,CAAC,EAC5B,IAAK,IAAM,KAAa,EAAY,CAClC,IAAI,EACJ,GAAI,CACF,EAAU,EAAc,CAAS,CACnC,OAAS,EAAO,CACd,EAAS,KAAK,KAAK,EAAU,IAAI,aAAiB,MAAQ,EAAM,QAAQ,MAAM;CAAI,CAAC,CAAC,GAAK,OAAO,CAAK,GAAG,EACxG,QACF,CACA,IAAM,EAAU,EAAQ,iBAAiB,EACzC,GAAI,IAAY,EAAwB,CACtC,EAAS,KACP,KAAK,EAAU,oBAAoB,GAAW,UAAU,gFAE1D,EACA,QACF,CAEA,MADA,GAAgB,EACT,CACT,CAOA,KANA,GAAgB,IAAI,EAClB,oDAAoD,EAAgB,EAAE,2NAGrC,EAAS,KAAK;CAAI,GACrD,EACM,CACR,CAQA,SAAS,GAA0B,CACjC,IAAM,EAAO,GAAG,QAAQ,SAAS,GAAG,QAAQ,OAS5C,OARI,QAAQ,WAAa,QAChB,GAAG,EAAK,OAEb,QAAQ,WAAa,SAIV,QAAQ,QAAQ,UAAU,EAAA,EAC1B,QAAQ,oBAAsB,GAAG,EAAK,MAAQ,GAAG,EAAK,OAJ5D,CAKX"}
+{"version":3,"file":"nativeMetrics.cjs","names":["createRequire"],"sources":["../src/nativeMetrics.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport type { CrossFileDuplicateCandidate, Token, TokenRange } from './duplication.js';\nimport type { CodeMetrics, DuplicationOptions, FunctionMetrics } from './types.js';\n\n/**\n * Halstead counts measured natively; the derived float metrics (volume, effort, ...) are\n * computed in TypeScript because they involve transcendental functions (log2) whose last-bit\n * results can differ between V8 and Rust's libm, and results must not depend on the Rust side's\n * libm build.\n */\nexport interface NativeHalsteadCounts {\n  distinctOperators: number;\n  distinctOperands: number;\n  totalOperators: number;\n  totalOperands: number;\n}\n\nexport interface NativeFunctionMetricsPayload extends Omit<FunctionMetrics, 'halstead'> {\n  halsteadCounts: NativeHalsteadCounts;\n}\n\nexport interface NativeMetricsPayload extends Omit<CodeMetrics, 'halstead' | 'functions' | 'syntaxTree'> {\n  functions: NativeFunctionMetricsPayload[];\n  halsteadCounts: NativeHalsteadCounts;\n  syntaxTree?: string;\n}\n\n/** One file's cross-file clone-detection contribution as serialized by the native addon. */\nexport interface NativeCrossFileDataPayload {\n  candidates: CrossFileDuplicateCandidate[];\n  tokens: Token[];\n  containerStatements: TokenRange[][];\n  /** 1-based lines that are neither blank nor comment-only, sorted ascending. */\n  codeLineNumbers: number[];\n}\n\ninterface NativeBinding {\n  measureCodeNative(\n    code: string,\n    language: string,\n    includeSyntaxTree: boolean,\n    minTokens?: number,\n    maxGapTokens?: number,\n    minSimilarityPercent?: number\n  ): string;\n  collectCrossFileDataNative(code: string, language: string, minTokens?: number): string;\n  collectFunctionTokenSequencesNative(code: string, language: string): string;\n  payloadVersion?(): number;\n}\n\n/**\n * Must equal `payload_version` in native/src/lib.rs. A previously built addon survives a\n * `git pull` untouched, so without this handshake it would silently return payloads missing\n * newer fields instead of failing with a clear rebuild message.\n */\nconst expectedPayloadVersion = 6;\n\n/** Measures one file via the native addon, returning the raw payload for assembly in metrics.ts. */\nexport function measureCodeNative(\n  code: string,\n  language: string,\n  includeSyntaxTree: boolean,\n  duplication?: DuplicationOptions\n): NativeMetricsPayload {\n  return JSON.parse(\n    loadBinding().measureCodeNative(\n      toWellFormed(code),\n      language,\n      includeSyntaxTree,\n      clampToU32(duplication?.minTokens),\n      clampToU32(duplication?.maxGapTokens),\n      clampToU32(duplication?.minSimilarityPercent)\n    )\n  ) as NativeMetricsPayload;\n}\n\n/** Collects one file's cross-file clone-detection contribution via the native addon. */\nexport function collectCrossFileDataNative(\n  code: string,\n  language: string,\n  minTokens?: number\n): NativeCrossFileDataPayload {\n  return JSON.parse(\n    loadBinding().collectCrossFileDataNative(toWellFormed(code), language, clampToU32(minTokens))\n  ) as NativeCrossFileDataPayload;\n}\n\n/** Collects normalized token hash sequences of every function via the native addon. */\nexport function collectFunctionTokenSequencesNative(code: string, language: string): Int32Array[] {\n  const sequences = JSON.parse(\n    loadBinding().collectFunctionTokenSequencesNative(toWellFormed(code), language)\n  ) as number[][];\n  return sequences.map((sequence) => Int32Array.from(sequence));\n}\n\n/**\n * Lone surrogates cannot cross the N-API boundary losslessly, so ill-formed strings (invalid\n * UTF-16 occasionally present in real-world files) are measured with U+FFFD replacements — the\n * same code units V8's own UTF-8 conversion would substitute.\n */\nfunction toWellFormed(code: string): string {\n  return code.isWellFormed() ? code : code.toWellFormed();\n}\n\n/**\n * The duplication settings cross the boundary as u32, whose JavaScript conversion wraps modulo\n * 2^32 (2 ** 32 would become 0 and match everything). The public API accepts any safe integer, so\n * out-of-range values clamp to [0, u32::MAX] — no source can hold 2^32 tokens, so a clamped\n * threshold behaves identically to the requested one. NaN (e.g. `Number(unsetEnvVariable)`)\n * survives clamping arithmetic and would also convert to 0, so it is treated as an absent setting\n * instead.\n */\nfunction clampToU32(value: number | undefined): number | undefined {\n  return value === undefined || Number.isNaN(value)\n    ? undefined\n    : Math.min(Math.max(Math.trunc(value), 0), 0xFF_FF_FF_FF);\n}\n\n/**\n * Raised when no usable native addon can be loaded. Every measurement fails identically until the\n * addon is built, so callers measuring many files (the CLI scan) treat it as fatal for the whole\n * run instead of recording one \"skipped\" entry per file.\n */\nexport class NativeAddonError extends Error {}\n\nlet cachedBinding: NativeBinding | undefined;\nlet cachedFailure: NativeAddonError | undefined;\n\nfunction loadBinding(): NativeBinding {\n  if (cachedBinding) {\n    return cachedBinding;\n  }\n  // The failure is memoized too: resolution (including platformTriplet's diagnostic-report call\n  // on Linux) would otherwise repeat for every measured file of an already-failing run.\n  if (cachedFailure) {\n    throw cachedFailure;\n  }\n  // Resolved relative to this file, so both src/ (tests) and dist/ (build) find the addon.\n  const requireNative = createRequire(import.meta.url);\n  const specifiers = [\n    // A prebuilt platform package, when published for this platform.\n    `code-gauge-${platformTriplet()}`,\n    // A locally built addon (`bun run build-native`).\n    '../native/code-gauge.node',\n  ];\n  const failures: string[] = [];\n  for (const specifier of specifiers) {\n    let binding: NativeBinding;\n    try {\n      binding = requireNative(specifier) as NativeBinding;\n    } catch (error) {\n      failures.push(`  ${specifier}: ${error instanceof Error ? error.message.split('\\n')[0] : String(error)}`);\n      continue;\n    }\n    const version = binding.payloadVersion?.();\n    if (version !== expectedPayloadVersion) {\n      failures.push(\n        `  ${specifier}: payload version ${version ?? 'unknown'} does not match the expected ` +\n          `${expectedPayloadVersion}; rebuild the addon with \\`bun run build-native\\``\n      );\n      continue;\n    }\n    cachedBinding = binding;\n    return binding;\n  }\n  cachedFailure = new NativeAddonError(\n    `The code-gauge native addon is not available for ${platformTriplet()}. Build it with ` +\n      '`node scripts/buildNative.mjs` in the code-gauge package directory (requires a Rust ' +\n      'toolchain); when installing with npm, also allow install scripts for code-gauge so its ' +\n      `postinstall build can run.\\n${failures.join('\\n')}`\n  );\n  throw cachedFailure;\n}\n\n/**\n * The platform-package suffix in the napi-rs naming convention: Linux targets are qualified by\n * libc ABI (`linux-x64-gnu` / `linux-x64-musl`) because a glibc-linked addon cannot load on\n * Alpine/musl, and Windows by toolchain ABI (`win32-x64-msvc`), matching what napi-rs tooling\n * generates. Must match scripts/installNative.mjs and the build-native workflow's target list.\n */\nfunction platformTriplet(): string {\n  const base = `${process.platform}-${process.arch}`;\n  if (process.platform === 'win32') {\n    return `${base}-msvc`;\n  }\n  if (process.platform !== 'linux') {\n    return base;\n  }\n  // Musl builds of Node report no glibc runtime version; see napi-rs's isMusl detection.\n  const report = process.report?.getReport() as { header?: { glibcVersionRuntime?: string } } | undefined;\n  return report?.header?.glibcVersionRuntime ? `${base}-gnu` : `${base}-musl`;\n}\n"],"mappings":"0CA0DA,SAAgB,EACd,EACA,EACA,EACA,EACsB,CACtB,OAAO,KAAK,MACV,EAAY,CAAC,CAAC,kBACZ,EAAa,CAAI,EACjB,EACA,EACA,EAAW,GAAa,SAAS,EACjC,EAAW,GAAa,YAAY,EACpC,EAAW,GAAa,oBAAoB,CAC9C,CACF,CACF,CAGA,SAAgB,EACd,EACA,EACA,EAC4B,CAC5B,OAAO,KAAK,MACV,EAAY,CAAC,CAAC,2BAA2B,EAAa,CAAI,EAAG,EAAU,EAAW,CAAS,CAAC,CAC9F,CACF,CAGA,SAAgB,EAAoC,EAAc,EAAgC,CAIhG,OAHkB,KAAK,MACrB,EAAY,CAAC,CAAC,oCAAoC,EAAa,CAAI,EAAG,CAAQ,CAEjE,CAAC,CAAC,IAAK,GAAa,WAAW,KAAK,CAAQ,CAAC,CAC9D,CAOA,SAAS,EAAa,EAAsB,CAC1C,OAAO,EAAK,aAAa,EAAI,EAAO,EAAK,aAAa,CACxD,CAUA,SAAS,EAAW,EAA+C,CACjE,OAAO,IAAU,IAAA,IAAa,OAAO,MAAM,CAAK,EAC5C,IAAA,GACA,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,CAAK,EAAG,CAAC,EAAG,UAAa,CAC5D,CAOA,IAAa,EAAb,cAAsC,KAAM,CAAC,EAE7C,IAAI,EACA,EAEJ,SAAS,GAA6B,CACpC,GAAI,EACF,OAAO,EAIT,GAAI,EACF,MAAM,EAGR,IAAM,GAAA,EAAgBA,EAAAA,cAAAA,CAAAA,QAAAA,KAAAA,CAAAA,CAAAA,cAAAA,UAAAA,CAAAA,CAAAA,IAA6B,EAC7C,EAAa,CAEjB,cAAc,EAAgB,IAE9B,2BACF,EACM,EAAqB,CAAC,EAC5B,IAAK,IAAM,KAAa,EAAY,CAClC,IAAI,EACJ,GAAI,CACF,EAAU,EAAc,CAAS,CACnC,OAAS,EAAO,CACd,EAAS,KAAK,KAAK,EAAU,IAAI,aAAiB,MAAQ,EAAM,QAAQ,MAAM;CAAI,CAAC,CAAC,GAAK,OAAO,CAAK,GAAG,EACxG,QACF,CACA,IAAM,EAAU,EAAQ,iBAAiB,EACzC,GAAI,IAAY,EAAwB,CACtC,EAAS,KACP,KAAK,EAAU,oBAAoB,GAAW,UAAU,gFAE1D,EACA,QACF,CAEA,MADA,GAAgB,EACT,CACT,CAOA,KANA,GAAgB,IAAI,EAClB,oDAAoD,EAAgB,EAAE,2NAGrC,EAAS,KAAK;CAAI,GACrD,EACM,CACR,CAQA,SAAS,GAA0B,CACjC,IAAM,EAAO,GAAG,QAAQ,SAAS,GAAG,QAAQ,OAS5C,OARI,QAAQ,WAAa,QAChB,GAAG,EAAK,OAEb,QAAQ,WAAa,SAIV,QAAQ,QAAQ,UAAU,EAAA,EAC1B,QAAQ,oBAAsB,GAAG,EAAK,MAAQ,GAAG,EAAK,OAJ5D,CAKX"}

package/dist/nativeMetrics.js

@@ -1,4 +1,4 @@
 import{createRequire as e}from"node:module";function t(e,t,n,r){return JSON.parse(l().measureCodeNative(i(e),t,n,a(r?.minTokens),a(r?.maxGapTokens),a(r?.minSimilarityPercent)))}function n(e,t,n){return JSON.parse(l().collectCrossFileDataNative(i(e),t,a(n)))}function r(e,t){return JSON.parse(l().collectFunctionTokenSequencesNative(i(e),t)).map(e=>Int32Array.from(e))}function i(e){return e.isWellFormed()?e:e.toWellFormed()}function a(e){return e===void 0||Number.isNaN(e)?void 0:Math.min(Math.max(Math.trunc(e),0),4294967295)}var o=class extends Error{};let s,c;function l(){if(s)return s;if(c)throw c;let t=e(import.meta.url),n=[`code-gauge-${u()}`,`../native/code-gauge.node`],r=[];for(let e of n){let n;try{n=t(e)}catch(t){r.push(`  ${e}: ${t instanceof Error?t.message.split(`
-`)[0]:String(t)}`);continue}let i=n.payloadVersion?.();if(i!==5){r.push(`  ${e}: payload version ${i??`unknown`} does not match the expected 5; rebuild the addon with \`bun run build-native\``);continue}return s=n,n}throw c=new o(`The code-gauge native addon is not available for ${u()}. Build it with \`node scripts/buildNative.mjs\` in the code-gauge package directory (requires a Rust toolchain); when installing with npm, also allow install scripts for code-gauge so its postinstall build can run.\n${r.join(`
+`)[0]:String(t)}`);continue}let i=n.payloadVersion?.();if(i!==6){r.push(`  ${e}: payload version ${i??`unknown`} does not match the expected 6; rebuild the addon with \`bun run build-native\``);continue}return s=n,n}throw c=new o(`The code-gauge native addon is not available for ${u()}. Build it with \`node scripts/buildNative.mjs\` in the code-gauge package directory (requires a Rust toolchain); when installing with npm, also allow install scripts for code-gauge so its postinstall build can run.\n${r.join(`
 `)}`),c}function u(){let e=`${process.platform}-${process.arch}`;return process.platform===`win32`?`${e}-msvc`:process.platform===`linux`?(process.report?.getReport())?.header?.glibcVersionRuntime?`${e}-gnu`:`${e}-musl`:e}export{o as NativeAddonError,n as collectCrossFileDataNative,r as collectFunctionTokenSequencesNative,t as measureCodeNative};
 //# sourceMappingURL=nativeMetrics.js.map

package/dist/nativeMetrics.js.map

@@ -1 +1 @@
-{"version":3,"file":"nativeMetrics.js","names":[],"sources":["../src/nativeMetrics.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport type { CrossFileDuplicateCandidate, Token, TokenRange } from './duplication.js';\nimport type { CodeMetrics, DuplicationOptions, FunctionMetrics } from './types.js';\n\n/**\n * Halstead counts measured natively; the derived float metrics (volume, effort, ...) are\n * computed in TypeScript because they involve transcendental functions (log2) whose last-bit\n * results can differ between V8 and Rust's libm, and results must not depend on the Rust side's\n * libm build.\n */\nexport interface NativeHalsteadCounts {\n  distinctOperators: number;\n  distinctOperands: number;\n  totalOperators: number;\n  totalOperands: number;\n}\n\nexport interface NativeFunctionMetricsPayload extends Omit<FunctionMetrics, 'halstead'> {\n  halsteadCounts: NativeHalsteadCounts;\n}\n\nexport interface NativeMetricsPayload extends Omit<CodeMetrics, 'halstead' | 'functions' | 'syntaxTree'> {\n  functions: NativeFunctionMetricsPayload[];\n  halsteadCounts: NativeHalsteadCounts;\n  syntaxTree?: string;\n}\n\n/** One file's cross-file clone-detection contribution as serialized by the native addon. */\nexport interface NativeCrossFileDataPayload {\n  candidates: CrossFileDuplicateCandidate[];\n  tokens: Token[];\n  containerStatements: TokenRange[][];\n  /** 1-based lines that are neither blank nor comment-only, sorted ascending. */\n  codeLineNumbers: number[];\n}\n\ninterface NativeBinding {\n  measureCodeNative(\n    code: string,\n    language: string,\n    includeSyntaxTree: boolean,\n    minTokens?: number,\n    maxGapTokens?: number,\n    minSimilarityPercent?: number\n  ): string;\n  collectCrossFileDataNative(code: string, language: string, minTokens?: number): string;\n  collectFunctionTokenSequencesNative(code: string, language: string): string;\n  payloadVersion?(): number;\n}\n\n/**\n * Must equal `payload_version` in native/src/lib.rs. A previously built addon survives a\n * `git pull` untouched, so without this handshake it would silently return payloads missing\n * newer fields instead of failing with a clear rebuild message.\n */\nconst expectedPayloadVersion = 5;\n\n/** Measures one file via the native addon, returning the raw payload for assembly in metrics.ts. */\nexport function measureCodeNative(\n  code: string,\n  language: string,\n  includeSyntaxTree: boolean,\n  duplication?: DuplicationOptions\n): NativeMetricsPayload {\n  return JSON.parse(\n    loadBinding().measureCodeNative(\n      toWellFormed(code),\n      language,\n      includeSyntaxTree,\n      clampToU32(duplication?.minTokens),\n      clampToU32(duplication?.maxGapTokens),\n      clampToU32(duplication?.minSimilarityPercent)\n    )\n  ) as NativeMetricsPayload;\n}\n\n/** Collects one file's cross-file clone-detection contribution via the native addon. */\nexport function collectCrossFileDataNative(\n  code: string,\n  language: string,\n  minTokens?: number\n): NativeCrossFileDataPayload {\n  return JSON.parse(\n    loadBinding().collectCrossFileDataNative(toWellFormed(code), language, clampToU32(minTokens))\n  ) as NativeCrossFileDataPayload;\n}\n\n/** Collects normalized token hash sequences of every function via the native addon. */\nexport function collectFunctionTokenSequencesNative(code: string, language: string): Int32Array[] {\n  const sequences = JSON.parse(\n    loadBinding().collectFunctionTokenSequencesNative(toWellFormed(code), language)\n  ) as number[][];\n  return sequences.map((sequence) => Int32Array.from(sequence));\n}\n\n/**\n * Lone surrogates cannot cross the N-API boundary losslessly, so ill-formed strings (invalid\n * UTF-16 occasionally present in real-world files) are measured with U+FFFD replacements — the\n * same code units V8's own UTF-8 conversion would substitute.\n */\nfunction toWellFormed(code: string): string {\n  return code.isWellFormed() ? code : code.toWellFormed();\n}\n\n/**\n * The duplication settings cross the boundary as u32, whose JavaScript conversion wraps modulo\n * 2^32 (2 ** 32 would become 0 and match everything). The public API accepts any safe integer, so\n * out-of-range values clamp to [0, u32::MAX] — no source can hold 2^32 tokens, so a clamped\n * threshold behaves identically to the requested one. NaN (e.g. `Number(unsetEnvVariable)`)\n * survives clamping arithmetic and would also convert to 0, so it is treated as an absent setting\n * instead.\n */\nfunction clampToU32(value: number | undefined): number | undefined {\n  return value === undefined || Number.isNaN(value)\n    ? undefined\n    : Math.min(Math.max(Math.trunc(value), 0), 0xFF_FF_FF_FF);\n}\n\n/**\n * Raised when no usable native addon can be loaded. Every measurement fails identically until the\n * addon is built, so callers measuring many files (the CLI scan) treat it as fatal for the whole\n * run instead of recording one \"skipped\" entry per file.\n */\nexport class NativeAddonError extends Error {}\n\nlet cachedBinding: NativeBinding | undefined;\nlet cachedFailure: NativeAddonError | undefined;\n\nfunction loadBinding(): NativeBinding {\n  if (cachedBinding) {\n    return cachedBinding;\n  }\n  // The failure is memoized too: resolution (including platformTriplet's diagnostic-report call\n  // on Linux) would otherwise repeat for every measured file of an already-failing run.\n  if (cachedFailure) {\n    throw cachedFailure;\n  }\n  // Resolved relative to this file, so both src/ (tests) and dist/ (build) find the addon.\n  const requireNative = createRequire(import.meta.url);\n  const specifiers = [\n    // A prebuilt platform package, when published for this platform.\n    `code-gauge-${platformTriplet()}`,\n    // A locally built addon (`bun run build-native`).\n    '../native/code-gauge.node',\n  ];\n  const failures: string[] = [];\n  for (const specifier of specifiers) {\n    let binding: NativeBinding;\n    try {\n      binding = requireNative(specifier) as NativeBinding;\n    } catch (error) {\n      failures.push(`  ${specifier}: ${error instanceof Error ? error.message.split('\\n')[0] : String(error)}`);\n      continue;\n    }\n    const version = binding.payloadVersion?.();\n    if (version !== expectedPayloadVersion) {\n      failures.push(\n        `  ${specifier}: payload version ${version ?? 'unknown'} does not match the expected ` +\n          `${expectedPayloadVersion}; rebuild the addon with \\`bun run build-native\\``\n      );\n      continue;\n    }\n    cachedBinding = binding;\n    return binding;\n  }\n  cachedFailure = new NativeAddonError(\n    `The code-gauge native addon is not available for ${platformTriplet()}. Build it with ` +\n      '`node scripts/buildNative.mjs` in the code-gauge package directory (requires a Rust ' +\n      'toolchain); when installing with npm, also allow install scripts for code-gauge so its ' +\n      `postinstall build can run.\\n${failures.join('\\n')}`\n  );\n  throw cachedFailure;\n}\n\n/**\n * The platform-package suffix in the napi-rs naming convention: Linux targets are qualified by\n * libc ABI (`linux-x64-gnu` / `linux-x64-musl`) because a glibc-linked addon cannot load on\n * Alpine/musl, and Windows by toolchain ABI (`win32-x64-msvc`), matching what napi-rs tooling\n * generates. Must match scripts/installNative.mjs and the build-native workflow's target list.\n */\nfunction platformTriplet(): string {\n  const base = `${process.platform}-${process.arch}`;\n  if (process.platform === 'win32') {\n    return `${base}-msvc`;\n  }\n  if (process.platform !== 'linux') {\n    return base;\n  }\n  // Musl builds of Node report no glibc runtime version; see napi-rs's isMusl detection.\n  const report = process.report?.getReport() as { header?: { glibcVersionRuntime?: string } } | undefined;\n  return report?.header?.glibcVersionRuntime ? `${base}-gnu` : `${base}-musl`;\n}\n"],"mappings":"4CA0DA,SAAgB,EACd,EACA,EACA,EACA,EACsB,CACtB,OAAO,KAAK,MACV,EAAY,CAAC,CAAC,kBACZ,EAAa,CAAI,EACjB,EACA,EACA,EAAW,GAAa,SAAS,EACjC,EAAW,GAAa,YAAY,EACpC,EAAW,GAAa,oBAAoB,CAC9C,CACF,CACF,CAGA,SAAgB,EACd,EACA,EACA,EAC4B,CAC5B,OAAO,KAAK,MACV,EAAY,CAAC,CAAC,2BAA2B,EAAa,CAAI,EAAG,EAAU,EAAW,CAAS,CAAC,CAC9F,CACF,CAGA,SAAgB,EAAoC,EAAc,EAAgC,CAIhG,OAHkB,KAAK,MACrB,EAAY,CAAC,CAAC,oCAAoC,EAAa,CAAI,EAAG,CAAQ,CAEjE,CAAC,CAAC,IAAK,GAAa,WAAW,KAAK,CAAQ,CAAC,CAC9D,CAOA,SAAS,EAAa,EAAsB,CAC1C,OAAO,EAAK,aAAa,EAAI,EAAO,EAAK,aAAa,CACxD,CAUA,SAAS,EAAW,EAA+C,CACjE,OAAO,IAAU,IAAA,IAAa,OAAO,MAAM,CAAK,EAC5C,IAAA,GACA,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,CAAK,EAAG,CAAC,EAAG,UAAa,CAC5D,CAOA,IAAa,EAAb,cAAsC,KAAM,CAAC,EAE7C,IAAI,EACA,EAEJ,SAAS,GAA6B,CACpC,GAAI,EACF,OAAO,EAIT,GAAI,EACF,MAAM,EAGR,IAAM,EAAgB,EAAc,YAAY,GAAG,EAC7C,EAAa,CAEjB,cAAc,EAAgB,IAE9B,2BACF,EACM,EAAqB,CAAC,EAC5B,IAAK,IAAM,KAAa,EAAY,CAClC,IAAI,EACJ,GAAI,CACF,EAAU,EAAc,CAAS,CACnC,OAAS,EAAO,CACd,EAAS,KAAK,KAAK,EAAU,IAAI,aAAiB,MAAQ,EAAM,QAAQ,MAAM;CAAI,CAAC,CAAC,GAAK,OAAO,CAAK,GAAG,EACxG,QACF,CACA,IAAM,EAAU,EAAQ,iBAAiB,EACzC,GAAI,IAAY,EAAwB,CACtC,EAAS,KACP,KAAK,EAAU,oBAAoB,GAAW,UAAU,gFAE1D,EACA,QACF,CAEA,MADA,GAAgB,EACT,CACT,CAOA,KANA,GAAgB,IAAI,EAClB,oDAAoD,EAAgB,EAAE,2NAGrC,EAAS,KAAK;CAAI,GACrD,EACM,CACR,CAQA,SAAS,GAA0B,CACjC,IAAM,EAAO,GAAG,QAAQ,SAAS,GAAG,QAAQ,OAS5C,OARI,QAAQ,WAAa,QAChB,GAAG,EAAK,OAEb,QAAQ,WAAa,SAIV,QAAQ,QAAQ,UAAU,EAAA,EAC1B,QAAQ,oBAAsB,GAAG,EAAK,MAAQ,GAAG,EAAK,OAJ5D,CAKX"}
+{"version":3,"file":"nativeMetrics.js","names":[],"sources":["../src/nativeMetrics.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport type { CrossFileDuplicateCandidate, Token, TokenRange } from './duplication.js';\nimport type { CodeMetrics, DuplicationOptions, FunctionMetrics } from './types.js';\n\n/**\n * Halstead counts measured natively; the derived float metrics (volume, effort, ...) are\n * computed in TypeScript because they involve transcendental functions (log2) whose last-bit\n * results can differ between V8 and Rust's libm, and results must not depend on the Rust side's\n * libm build.\n */\nexport interface NativeHalsteadCounts {\n  distinctOperators: number;\n  distinctOperands: number;\n  totalOperators: number;\n  totalOperands: number;\n}\n\nexport interface NativeFunctionMetricsPayload extends Omit<FunctionMetrics, 'halstead'> {\n  halsteadCounts: NativeHalsteadCounts;\n}\n\nexport interface NativeMetricsPayload extends Omit<CodeMetrics, 'halstead' | 'functions' | 'syntaxTree'> {\n  functions: NativeFunctionMetricsPayload[];\n  halsteadCounts: NativeHalsteadCounts;\n  syntaxTree?: string;\n}\n\n/** One file's cross-file clone-detection contribution as serialized by the native addon. */\nexport interface NativeCrossFileDataPayload {\n  candidates: CrossFileDuplicateCandidate[];\n  tokens: Token[];\n  containerStatements: TokenRange[][];\n  /** 1-based lines that are neither blank nor comment-only, sorted ascending. */\n  codeLineNumbers: number[];\n}\n\ninterface NativeBinding {\n  measureCodeNative(\n    code: string,\n    language: string,\n    includeSyntaxTree: boolean,\n    minTokens?: number,\n    maxGapTokens?: number,\n    minSimilarityPercent?: number\n  ): string;\n  collectCrossFileDataNative(code: string, language: string, minTokens?: number): string;\n  collectFunctionTokenSequencesNative(code: string, language: string): string;\n  payloadVersion?(): number;\n}\n\n/**\n * Must equal `payload_version` in native/src/lib.rs. A previously built addon survives a\n * `git pull` untouched, so without this handshake it would silently return payloads missing\n * newer fields instead of failing with a clear rebuild message.\n */\nconst expectedPayloadVersion = 6;\n\n/** Measures one file via the native addon, returning the raw payload for assembly in metrics.ts. */\nexport function measureCodeNative(\n  code: string,\n  language: string,\n  includeSyntaxTree: boolean,\n  duplication?: DuplicationOptions\n): NativeMetricsPayload {\n  return JSON.parse(\n    loadBinding().measureCodeNative(\n      toWellFormed(code),\n      language,\n      includeSyntaxTree,\n      clampToU32(duplication?.minTokens),\n      clampToU32(duplication?.maxGapTokens),\n      clampToU32(duplication?.minSimilarityPercent)\n    )\n  ) as NativeMetricsPayload;\n}\n\n/** Collects one file's cross-file clone-detection contribution via the native addon. */\nexport function collectCrossFileDataNative(\n  code: string,\n  language: string,\n  minTokens?: number\n): NativeCrossFileDataPayload {\n  return JSON.parse(\n    loadBinding().collectCrossFileDataNative(toWellFormed(code), language, clampToU32(minTokens))\n  ) as NativeCrossFileDataPayload;\n}\n\n/** Collects normalized token hash sequences of every function via the native addon. */\nexport function collectFunctionTokenSequencesNative(code: string, language: string): Int32Array[] {\n  const sequences = JSON.parse(\n    loadBinding().collectFunctionTokenSequencesNative(toWellFormed(code), language)\n  ) as number[][];\n  return sequences.map((sequence) => Int32Array.from(sequence));\n}\n\n/**\n * Lone surrogates cannot cross the N-API boundary losslessly, so ill-formed strings (invalid\n * UTF-16 occasionally present in real-world files) are measured with U+FFFD replacements — the\n * same code units V8's own UTF-8 conversion would substitute.\n */\nfunction toWellFormed(code: string): string {\n  return code.isWellFormed() ? code : code.toWellFormed();\n}\n\n/**\n * The duplication settings cross the boundary as u32, whose JavaScript conversion wraps modulo\n * 2^32 (2 ** 32 would become 0 and match everything). The public API accepts any safe integer, so\n * out-of-range values clamp to [0, u32::MAX] — no source can hold 2^32 tokens, so a clamped\n * threshold behaves identically to the requested one. NaN (e.g. `Number(unsetEnvVariable)`)\n * survives clamping arithmetic and would also convert to 0, so it is treated as an absent setting\n * instead.\n */\nfunction clampToU32(value: number | undefined): number | undefined {\n  return value === undefined || Number.isNaN(value)\n    ? undefined\n    : Math.min(Math.max(Math.trunc(value), 0), 0xFF_FF_FF_FF);\n}\n\n/**\n * Raised when no usable native addon can be loaded. Every measurement fails identically until the\n * addon is built, so callers measuring many files (the CLI scan) treat it as fatal for the whole\n * run instead of recording one \"skipped\" entry per file.\n */\nexport class NativeAddonError extends Error {}\n\nlet cachedBinding: NativeBinding | undefined;\nlet cachedFailure: NativeAddonError | undefined;\n\nfunction loadBinding(): NativeBinding {\n  if (cachedBinding) {\n    return cachedBinding;\n  }\n  // The failure is memoized too: resolution (including platformTriplet's diagnostic-report call\n  // on Linux) would otherwise repeat for every measured file of an already-failing run.\n  if (cachedFailure) {\n    throw cachedFailure;\n  }\n  // Resolved relative to this file, so both src/ (tests) and dist/ (build) find the addon.\n  const requireNative = createRequire(import.meta.url);\n  const specifiers = [\n    // A prebuilt platform package, when published for this platform.\n    `code-gauge-${platformTriplet()}`,\n    // A locally built addon (`bun run build-native`).\n    '../native/code-gauge.node',\n  ];\n  const failures: string[] = [];\n  for (const specifier of specifiers) {\n    let binding: NativeBinding;\n    try {\n      binding = requireNative(specifier) as NativeBinding;\n    } catch (error) {\n      failures.push(`  ${specifier}: ${error instanceof Error ? error.message.split('\\n')[0] : String(error)}`);\n      continue;\n    }\n    const version = binding.payloadVersion?.();\n    if (version !== expectedPayloadVersion) {\n      failures.push(\n        `  ${specifier}: payload version ${version ?? 'unknown'} does not match the expected ` +\n          `${expectedPayloadVersion}; rebuild the addon with \\`bun run build-native\\``\n      );\n      continue;\n    }\n    cachedBinding = binding;\n    return binding;\n  }\n  cachedFailure = new NativeAddonError(\n    `The code-gauge native addon is not available for ${platformTriplet()}. Build it with ` +\n      '`node scripts/buildNative.mjs` in the code-gauge package directory (requires a Rust ' +\n      'toolchain); when installing with npm, also allow install scripts for code-gauge so its ' +\n      `postinstall build can run.\\n${failures.join('\\n')}`\n  );\n  throw cachedFailure;\n}\n\n/**\n * The platform-package suffix in the napi-rs naming convention: Linux targets are qualified by\n * libc ABI (`linux-x64-gnu` / `linux-x64-musl`) because a glibc-linked addon cannot load on\n * Alpine/musl, and Windows by toolchain ABI (`win32-x64-msvc`), matching what napi-rs tooling\n * generates. Must match scripts/installNative.mjs and the build-native workflow's target list.\n */\nfunction platformTriplet(): string {\n  const base = `${process.platform}-${process.arch}`;\n  if (process.platform === 'win32') {\n    return `${base}-msvc`;\n  }\n  if (process.platform !== 'linux') {\n    return base;\n  }\n  // Musl builds of Node report no glibc runtime version; see napi-rs's isMusl detection.\n  const report = process.report?.getReport() as { header?: { glibcVersionRuntime?: string } } | undefined;\n  return report?.header?.glibcVersionRuntime ? `${base}-gnu` : `${base}-musl`;\n}\n"],"mappings":"4CA0DA,SAAgB,EACd,EACA,EACA,EACA,EACsB,CACtB,OAAO,KAAK,MACV,EAAY,CAAC,CAAC,kBACZ,EAAa,CAAI,EACjB,EACA,EACA,EAAW,GAAa,SAAS,EACjC,EAAW,GAAa,YAAY,EACpC,EAAW,GAAa,oBAAoB,CAC9C,CACF,CACF,CAGA,SAAgB,EACd,EACA,EACA,EAC4B,CAC5B,OAAO,KAAK,MACV,EAAY,CAAC,CAAC,2BAA2B,EAAa,CAAI,EAAG,EAAU,EAAW,CAAS,CAAC,CAC9F,CACF,CAGA,SAAgB,EAAoC,EAAc,EAAgC,CAIhG,OAHkB,KAAK,MACrB,EAAY,CAAC,CAAC,oCAAoC,EAAa,CAAI,EAAG,CAAQ,CAEjE,CAAC,CAAC,IAAK,GAAa,WAAW,KAAK,CAAQ,CAAC,CAC9D,CAOA,SAAS,EAAa,EAAsB,CAC1C,OAAO,EAAK,aAAa,EAAI,EAAO,EAAK,aAAa,CACxD,CAUA,SAAS,EAAW,EAA+C,CACjE,OAAO,IAAU,IAAA,IAAa,OAAO,MAAM,CAAK,EAC5C,IAAA,GACA,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,CAAK,EAAG,CAAC,EAAG,UAAa,CAC5D,CAOA,IAAa,EAAb,cAAsC,KAAM,CAAC,EAE7C,IAAI,EACA,EAEJ,SAAS,GAA6B,CACpC,GAAI,EACF,OAAO,EAIT,GAAI,EACF,MAAM,EAGR,IAAM,EAAgB,EAAc,YAAY,GAAG,EAC7C,EAAa,CAEjB,cAAc,EAAgB,IAE9B,2BACF,EACM,EAAqB,CAAC,EAC5B,IAAK,IAAM,KAAa,EAAY,CAClC,IAAI,EACJ,GAAI,CACF,EAAU,EAAc,CAAS,CACnC,OAAS,EAAO,CACd,EAAS,KAAK,KAAK,EAAU,IAAI,aAAiB,MAAQ,EAAM,QAAQ,MAAM;CAAI,CAAC,CAAC,GAAK,OAAO,CAAK,GAAG,EACxG,QACF,CACA,IAAM,EAAU,EAAQ,iBAAiB,EACzC,GAAI,IAAY,EAAwB,CACtC,EAAS,KACP,KAAK,EAAU,oBAAoB,GAAW,UAAU,gFAE1D,EACA,QACF,CAEA,MADA,GAAgB,EACT,CACT,CAOA,KANA,GAAgB,IAAI,EAClB,oDAAoD,EAAgB,EAAE,2NAGrC,EAAS,KAAK;CAAI,GACrD,EACM,CACR,CAQA,SAAS,GAA0B,CACjC,IAAM,EAAO,GAAG,QAAQ,SAAS,GAAG,QAAQ,OAS5C,OARI,QAAQ,WAAa,QAChB,GAAG,EAAK,OAEb,QAAQ,WAAa,SAIV,QAAQ,QAAQ,UAAU,EAAA,EAC1B,QAAQ,oBAAsB,GAAG,EAAK,MAAQ,GAAG,EAAK,OAJ5D,CAKX"}

package/dist/types.d.ts

@@ -65,13 +65,12 @@ export interface FunctionMetrics {
     /** Exclusive end column, so functions can be tested for containment in each other. */
     endColumn: number;
     /**
-     * McCabe cyclomatic complexity of the function's own body: 1 plus one per decision point
-     * (branch, loop, non-default case label, catch, ternary, boolean operator, pattern guard). Java
-     * follows PMD's `CyclomaticComplexity` instead, which also counts `throw` but counts `&&`/`||`
-     * only inside branch, loop, ternary, and switch conditions and adds nothing for pattern labels
-     * and guards. Nested function bodies are excluded, so summing over functions counts each
-     * decision point once. Not used by ranking or the regression gate; exposed for consumers that
-     * report PMD-compatible metrics.
+     * McCabe cyclomatic complexity of the function's own body, counted from source as NIST SP 500-235
+     * §4 prescribes: 1 plus one per decision (branch, loop, catch, ternary, pattern guard), per
+     * short-circuit operator (`&&`, `||`, `and`, `or`) wherever it appears, and per case-labelled
+     * statement or match arm (stacked labels share one; default and catch-all arms add none).
+     * Full-evaluation operators and `throw` add nothing. Nested function bodies are excluded, so
+     * summing over functions counts each decision once. Not used by ranking or the regression gate.
      */
     cyclomaticComplexity: number;
     cognitiveComplexity: number;
@@ -141,6 +140,16 @@ export interface CodeMetrics {
     bytes: number;
     lines: LineMetrics;
     functions: FunctionMetrics[];
+    /**
+     * The file's cyclomatic complexity as McCabe's v = e - n + 2p over its components: the sum of
+     * every function's value, plus 1 per initializer block (Java static/instance initializers, Kotlin
+     * `init`, JavaScript/TypeScript class `static` blocks), plus the decisions outside functions,
+     * plus 1 for the module body when
+     * the file runs top-level code (always for JavaScript, TypeScript, Python, and Ruby; for C# and
+     * Kotlin when the file has top-level statements, except a Kotlin file with parse errors, whose top
+     * level the grammar cannot be trusted to have read correctly).
+     */
+    cyclomaticComplexity: number;
     cognitiveComplexity: number;
     maxCognitiveComplexity: number;
     nestingDepth: number;

package/native/src/complexity.rs

@@ -12,7 +12,6 @@ pub struct ComplexityResult {
 pub struct LanguageSets {
     pub function_nodes: HashSet<&'static str>,
     pub decision_nodes: HashSet<&'static str>,
-    pub pmd_cyclomatic: bool,
     pub nesting_nodes: HashSet<&'static str>,
     pub ncss_nodes: HashSet<&'static str>,
     pub ncss_containers: HashSet<&'static str>,
@@ -23,7 +22,6 @@ impl LanguageSets {
         LanguageSets {
             function_nodes: language.function_node_types.iter().copied().collect(),
             decision_nodes: language.decision_node_types.iter().copied().collect(),
-            pmd_cyclomatic: language.pmd_cyclomatic,
             nesting_nodes: language.nesting_node_types.iter().copied().collect(),
             ncss_nodes: language.ncss_node_types.iter().copied().collect(),
             ncss_containers: language.ncss_container_node_types.iter().copied().collect(),
@@ -138,6 +136,16 @@ struct FunctionBodyPass<'sets, 'code, 'source> {
     code: &'code Source<'source>,
     frames: Vec<FunctionBodyFrame>,
     results: HashMap<usize, FunctionBodyMetrics>,
+    /// Cyclomatic decisions inside class bodies nested in functions, which no function owns.
+    nested_class_decisions: u64,
+}
+
+/// Per-function body metrics, plus the cyclomatic decisions no function body owns.
+pub struct BodyMetrics {
+    pub by_function: HashMap<usize, FunctionBodyMetrics>,
+    /// Cyclomatic decisions outside every function body (top-level statements, field initializers,
+    /// including those of classes nested in functions).
+    pub top_level_decisions: u64,
 }
 
 /// Per-function complexity and NCSS for every function boundary, in one post-order pass so each
@@ -152,16 +160,20 @@ pub fn measure_function_body_metrics(
     root: Node<'_>,
     sets: &LanguageSets,
     code: &Source<'_>,
-) -> HashMap<usize, FunctionBodyMetrics> {
+) -> BodyMetrics {
     let mut pass = FunctionBodyPass {
         sets,
         code,
-        // frames[0] is a sentinel for top-level code; its accumulation is discarded.
+        // frames[0] is a sentinel for top-level code; only its cyclomatic decisions are kept.
         frames: vec![FunctionBodyFrame::new(0, 0)],
         results: HashMap::new(),
+        nested_class_decisions: 0,
     };
     pass.visit(root, 0, 0, false, false, false);
-    pass.results
+    BodyMetrics {
+        by_function: pass.results,
+        top_level_decisions: pass.frames[0].cyclomatic_complexity - 1 + pass.nested_class_decisions,
+    }
 }
 
 impl FunctionBodyPass<'_, '_, '_> {
@@ -201,7 +213,7 @@ impl FunctionBodyPass<'_, '_, '_> {
         // `if` keyword token), so only named nodes count as decisions.
         let is_decision = current.is_named()
             && self.sets.decision_nodes.contains(current.kind())
-            && !is_default_switch_branch(current);
+            && !is_pathless_switch_branch(current, self.code);
         let is_case_clause = current.is_named() && CASE_CLAUSE_NODE_TYPES.contains(&current.kind());
         // Ruby's `case ... else` arm is an `else` node; like every other language's default branch
         // it nests its contents inside the switch (it cannot go in the Ruby nesting set because
@@ -216,18 +228,14 @@ impl FunctionBodyPass<'_, '_, '_> {
         // surcharge (Sonar cognitive-complexity semantics).
         let is_continuation = is_decision && is_flat_chain_continuation(current);
 
-        if counts_for_own_body {
-            self.top_frame().cyclomatic_complexity += if self.sets.pmd_cyclomatic {
-                crate::cyclomatic::pmd_cyclomatic_increment(current, self.code)
-            } else {
-                // Each boolean operator and pattern guard is one more execution path; `else` adds
-                // none.
-                u64::from(
-                    is_decision
-                        || is_boolean_operator(current, self.code)
-                        || is_pattern_guard(current),
-                )
-            };
+        // Each branch, short-circuit operator, and pattern guard adds one path (McCabe; NIST SP
+        // 500-235 §4); `else` adds none.
+        if is_decision || is_boolean_operator(current, self.code) || is_pattern_guard(current) {
+            if counts_for_own_body {
+                self.top_frame().cyclomatic_complexity += 1;
+            } else if !opens_frame {
+                self.nested_class_decisions += 1;
+            }
         }
         if is_decision && !is_case_clause {
             if is_continuation {
@@ -380,7 +388,7 @@ pub fn measure_complexity(
         // `if` keyword token), so only named nodes count as decisions.
         let is_decision = current.is_named()
             && sets.decision_nodes.contains(current.kind())
-            && !is_default_switch_branch(current);
+            && !is_pathless_switch_branch(current, code);
         let is_case_clause = current.is_named() && CASE_CLAUSE_NODE_TYPES.contains(&current.kind());
         // Ruby's `case ... else` arm is an `else` node; like every other language's default branch
         // it nests its contents inside the switch (it cannot go in the Ruby nesting set because
@@ -633,13 +641,93 @@ fn is_flat_chain_continuation(node: Node<'_>) -> bool {
             .is_some_and(|alternative| alternative.id() == node.id())
 }
 
-/// Default branches of switch-like constructs add no decision.
-fn is_default_switch_branch(node: Node<'_>) -> bool {
+/// Switch branches that add no path. NIST SP 500-235 counts one path per case-labelled statement:
+/// a label-only case shares the statement of the case below it, and that statement adds a path
+/// unless one of its stacked labels is an unguarded default or catch-all (`case 3: default: g();`
+/// and `default: case 3: g();` are the default outcome) or all of them are catch-alls. Guards are
+/// charged separately, so a guarded catch-all never absorbs a case stacked with it.
+fn is_pathless_switch_branch(node: Node<'_>, code: &Source<'_>) -> bool {
+    if is_label_only_case(node) {
+        return true;
+    }
+    let mut stacked = vec![node];
+    let mut previous = node.prev_named_sibling();
+    while let Some(sibling) = previous {
+        if !crate::ncss::COMMENT_NODE_TYPES.contains(&sibling.kind()) {
+            if !is_label_only_case(sibling) {
+                break;
+            }
+            stacked.push(sibling);
+        }
+        previous = sibling.prev_named_sibling();
+    }
+    stacked
+        .iter()
+        .any(|label| is_default_switch_branch(*label, code) && !has_pattern_guard(*label))
+        || stacked
+            .iter()
+            .all(|label| is_default_switch_branch(*label, code))
+}
+
+/// A guard directly on the arm (C# `when`, Python `if`, Ruby `if`/`unless`) or inside its label or
+/// pattern (Java `when`, Rust `if`).
+fn has_pattern_guard(node: Node<'_>) -> bool {
+    crate::util::named_children(node).into_iter().any(|child| {
+        is_pattern_guard(child)
+            || crate::util::named_children(child)
+                .into_iter()
+                .any(is_pattern_guard)
+    })
+}
+
+/// A C/C++/JS/Java/C# case whose labels share the next case's statements; every grammar parses each
+/// stacked label as its own case node.
+fn is_label_only_case(node: Node<'_>) -> bool {
+    let children = non_comment_children(node);
+    match node.kind() {
+        "case_statement" => {
+            let value = node.child_by_field_name("value").map(|value| value.id());
+            children.iter().all(|child| Some(child.id()) == value)
+        }
+        "switch_case" | "switch_default" => node.child_by_field_name("body").is_none(),
+        "switch_block_statement_group" => {
+            children.iter().all(|child| child.kind() == "switch_label")
+        }
+        // A C# label is a pattern (`case 1:` parses as a constant pattern) plus an optional `when`
+        // guard; anything else, a `#if` block included, is the section's body.
+        "switch_section" => children.iter().all(|child| {
+            child.kind().ends_with("pattern")
+                || child.kind() == "discard"
+                || child.kind() == "when_clause"
+        }),
+        _ => false,
+    }
+}
+
+fn is_default_switch_branch(node: Node<'_>, code: &Source<'_>) -> bool {
     let kind = node.kind();
+    if kind == "switch_default" {
+        return true;
+    }
     if kind == "case_statement" {
         return node.child_by_field_name("value").is_none();
     }
 
+    // Java `default:` groups and `default ->` rules: a label with no expression or pattern, or a
+    // `case null, default` label, whose `default` the grammar parses as an identifier.
+    if kind == "switch_block_statement_group" || kind == "switch_rule" {
+        return non_comment_children(node)
+            .into_iter()
+            .filter(|child| child.kind() == "switch_label")
+            .any(|label| {
+                let parts = non_comment_children(label);
+                parts.is_empty()
+                    || parts.iter().any(|part| {
+                        part.kind() == "identifier" && node_text(*part, code) == "default"
+                    })
+            });
+    }
+
     // C# `default:` sections and catch-all (`_`, `var x`) labels and arms, and Kotlin `else ->`
     // entries. A guarded catch-all (`_ when cond =>`) is still a default arm: only its guard
     // branches, which is_pattern_guard charges, like Python's `case _ if cond:` and Rust's

package/native/src/functions.rs

@@ -3,15 +3,16 @@ use tree_sitter::Node;
 
 use crate::util::{all_children, find_children_by_field_name, named_children, node_text, Source};
 
-/// C++ `function_definition` also covers pure-virtual/`= default`/`= delete` members; those have no
-/// `body` and are signatures, not implementations, matching how TypeScript method signatures are
-/// excluded. Java `method_declaration` is NOT here: PMD reports abstract/interface methods as
-/// methods (NCSS 1), so bodyless Java methods stay in the function list (as do C#'s and Kotlin's).
-/// C# auto-property accessors (`{ get; set; }`) and Kotlin visibility-only accessors (`private
+/// Declarations without a body have no control flow, so they are signatures, not functions: C++
+/// pure-virtual/`= default`/`= delete` members, abstract/interface/extern methods (Java, C#,
+/// Kotlin), Go assembly-backed function declarations, and Rust trait method signatures, matching
+/// how TypeScript method signatures are excluded. C# auto-property accessors (`{ get; set; }`) and Kotlin visibility-only accessors (`private
 /// set`) hold no code, so they need a body too; a C# property or indexer is a function only in its
 /// expression-bodied form (`int X => ...`), otherwise its accessors are the functions.
 const BODY_REQUIRED_FUNCTION_TYPES: &[&str] = &[
     "function_definition",
+    "function_declaration",
+    "method_declaration",
     "constructor_declaration",
     "compact_constructor_declaration",
     "function_signature_item",
@@ -35,8 +36,9 @@ pub fn is_implemented_function(node: Node<'_>) -> bool {
             .is_some_and(|value| value.kind() == "arrow_expression_clause");
     }
 
-    // The Kotlin grammar has no fields; an implemented accessor holds a `function_body` child.
-    if node.kind() == "getter" || node.kind() == "setter" {
+    // The Kotlin grammar has no fields; an implemented function or accessor holds a
+    // `function_body` child.
+    if node.kind() == "getter" || node.kind() == "setter" || node.kind() == "function_declaration" {
         return named_children(node)
             .iter()
             .any(|child| child.kind() == "function_body");

package/native/src/languages.rs

@@ -7,9 +7,10 @@ pub struct LanguageDefinition {
     grammar_id: GrammarId,
     pub function_node_types: &'static [&'static str],
     pub decision_node_types: &'static [&'static str],
-    /// Whether cyclomatic complexity follows PMD's Java CycloVisitor (see cyclomatic.rs) instead of
-    /// the generic one-path-per-decision rule.
-    pub pmd_cyclomatic: bool,
+    /// Whether every file's top-level code runs as a module body (a component of its own in the
+    /// file's cyclomatic complexity); C# and Kotlin decide per file by the presence of top-level
+    /// statements (never for a Kotlin file with parse errors).
+    pub executes_top_level: bool,
     pub nesting_node_types: &'static [&'static str],
     pub ncss_node_types: &'static [&'static str],
     pub ncss_container_node_types: &'static [&'static str],
@@ -659,7 +660,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::JavaScript,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -670,7 +671,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::JavaScript,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -681,7 +682,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::TypeScript,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -692,7 +693,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Tsx,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: JS_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -703,7 +704,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Python,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: true,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: PYTHON_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -714,7 +715,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Go,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: GO_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: false,
         nesting_node_types: GO_NESTING_NODES,
         ncss_node_types: GO_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -725,7 +726,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Rust,
         function_node_types: COMMON_FUNCTION_NODES,
         decision_node_types: COMMON_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: false,
         nesting_node_types: COMMON_NESTING_NODES,
         ncss_node_types: RUST_NCSS_NODES,
         ncss_container_node_types: RUST_NCSS_CONTAINERS,
@@ -736,7 +737,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Java,
         function_node_types: JAVA_FUNCTION_NODES,
         decision_node_types: JAVA_DECISION_NODES,
-        pmd_cyclomatic: true,
+        executes_top_level: false,
         nesting_node_types: JAVA_DECISION_NODES,
         ncss_node_types: JAVA_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -747,7 +748,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Ruby,
         function_node_types: RUBY_FUNCTION_NODES,
         decision_node_types: RUBY_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: true,
         nesting_node_types: RUBY_DECISION_NODES,
         ncss_node_types: RUBY_NCSS_NODES,
         ncss_container_node_types: RUBY_NCSS_CONTAINERS,
@@ -758,7 +759,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::C,
         function_node_types: C_FUNCTION_NODES,
         decision_node_types: C_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: false,
         nesting_node_types: C_DECISION_NODES,
         ncss_node_types: C_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -769,7 +770,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Cpp,
         function_node_types: C_FUNCTION_NODES,
         decision_node_types: CPP_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: false,
         nesting_node_types: CPP_DECISION_NODES,
         ncss_node_types: CPP_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -780,7 +781,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::CSharp,
         function_node_types: CSHARP_FUNCTION_NODES,
         decision_node_types: CSHARP_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: false,
         nesting_node_types: CSHARP_DECISION_NODES,
         ncss_node_types: CSHARP_NCSS_NODES,
         ncss_container_node_types: &[],
@@ -791,7 +792,7 @@ pub const LANGUAGES: &[LanguageDefinition] = &[
         grammar_id: GrammarId::Kotlin,
         function_node_types: KOTLIN_FUNCTION_NODES,
         decision_node_types: KOTLIN_DECISION_NODES,
-        pmd_cyclomatic: false,
+        executes_top_level: false,
         nesting_node_types: KOTLIN_DECISION_NODES,
         ncss_node_types: KOTLIN_NCSS_NODES,
         ncss_container_node_types: KOTLIN_NCSS_CONTAINERS,

package/native/src/lib.rs

@@ -6,7 +6,6 @@ use napi_derive::napi;
 use crate::duplication::DuplicationSettings;
 
 mod complexity;
-mod cyclomatic;
 mod dep_degree;
 mod duplication;
 mod functions;
@@ -22,7 +21,7 @@ mod util;
 /// together with `expectedPayloadVersion` in src/nativeMetrics.ts.
 #[napi]
 pub fn payload_version() -> u32 {
-    5
+    6
 }
 
 /// Measures code metrics for the given source, returning the NativeMetrics payload as JSON.

package/native/src/measure.rs

@@ -38,11 +38,12 @@ pub fn measure(
         .filter(|node| !is_lambda_body_block(*node) && is_implemented_function(*node))
         .collect();
 
-    let body_metrics_by_node_id = measure_function_body_metrics(root, &sets, code);
+    let body_metrics = measure_function_body_metrics(root, &sets, code);
     let function_metrics: Vec<FunctionMetrics> = functions
         .iter()
         .map(|node| {
-            let body_metrics = body_metrics_by_node_id
+            let body_metrics = body_metrics
+                .by_function
                 .get(&node.id())
                 .expect("every collected function node opens a frame in the body-metrics pass");
             FunctionMetrics {
@@ -76,6 +77,16 @@ pub fn measure(
         language: language.name.to_string(),
         bytes: code.code.len(),
         lines,
+        // McCabe's v = e - n + 2p over the file's components: every function, every initializer
+        // block, and the module body when the file runs top-level code; decisions outside functions
+        // belong to the file.
+        cyclomatic_complexity: function_metrics
+            .iter()
+            .map(|function| function.cyclomatic_complexity)
+            .sum::<u64>()
+            + body_metrics.top_level_decisions
+            + u64::from(language.executes_top_level || has_top_level_statements(root, language))
+            + count_initializer_blocks(root),
         cognitive_complexity: global_complexity.cognitive_complexity,
         max_cognitive_complexity: function_metrics
             .iter()
@@ -95,6 +106,76 @@ pub fn measure(
     })
 }
 
+/// Initializer blocks run code of their own, so each is a component like a function: Java static
+/// and instance initializers, Kotlin `init` blocks, and JavaScript/TypeScript class `static`
+/// blocks. Their decisions already count as decisions outside functions.
+fn count_initializer_blocks(root: Node<'_>) -> u64 {
+    let initializer_types: HashSet<&'static str> = [
+        "static_initializer",
+        "anonymous_initializer",
+        "class_static_block",
+        "block",
+    ]
+    .into_iter()
+    .collect();
+    collect_nodes(root, &initializer_types)
+        .into_iter()
+        .filter(|node| {
+            // A bare block is an initializer only as a direct member of a Java class or enum body.
+            node.kind() != "block"
+                || node.parent().is_some_and(|parent| {
+                    matches!(parent.kind(), "class_body" | "enum_body_declarations")
+                })
+        })
+        .count() as u64
+}
+
+/// A C# top-level statement: a `global_statement`, or a statement inside a top-level `#if` block,
+/// which the grammar does not wrap in `global_statement`; preprocessor blocks are transparent.
+fn is_csharp_top_level_statement(node: Node<'_>) -> bool {
+    if node.kind().starts_with("preproc_") {
+        return named_children(node)
+            .into_iter()
+            .any(is_csharp_top_level_statement);
+    }
+    node.kind() == "global_statement"
+        || node.kind() == "block"
+        || node.kind().ends_with("_statement")
+}
+
+/// Whether a C# or Kotlin file runs top-level code: C# top-level statements, or a Kotlin script's
+/// statements beside its declarations.
+fn has_top_level_statements(root: Node<'_>, language: &LanguageDefinition) -> bool {
+    const KOTLIN_DECLARATIONS: &[&str] = &[
+        "package_header",
+        "import_list",
+        "class_declaration",
+        "object_declaration",
+        "function_declaration",
+        "property_declaration",
+        "type_alias",
+        "shebang_line",
+        "file_annotation",
+        "getter",
+        "setter",
+    ];
+    let children = named_children(root);
+    match language.name {
+        "csharp" => children.into_iter().any(is_csharp_top_level_statement),
+        // The grammar mis-parses some valid declarations (non-empty companion objects, `fun
+        // interface`) and leaves recovery residue at the top level, so a file with parse errors is
+        // never taken for a script.
+        "kotlin" => {
+            !root.has_error()
+                && children.iter().any(|child| {
+                    !KOTLIN_DECLARATIONS.contains(&child.kind())
+                        && !crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind())
+                })
+        }
+        _ => false,
+    }
+}
+
 /// Collects one file's cross-file clone-detection contribution; see CrossFileFileData.
 pub fn collect_cross_file_data(
     code: &str,

package/native/src/types.rs

@@ -11,6 +11,7 @@ pub struct NativeMetrics {
     pub bytes: usize,
     pub lines: LineMetrics,
     pub functions: Vec<FunctionMetrics>,
+    pub cyclomatic_complexity: u64,
     pub cognitive_complexity: u64,
     pub max_cognitive_complexity: u64,
     pub nesting_depth: u64,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -89,12 +89,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "4.3.0",
-    "code-gauge-linux-arm64-gnu": "4.3.0",
-    "code-gauge-linux-x64-musl": "4.3.0",
-    "code-gauge-linux-arm64-musl": "4.3.0",
-    "code-gauge-darwin-x64": "4.3.0",
-    "code-gauge-darwin-arm64": "4.3.0",
-    "code-gauge-win32-x64-msvc": "4.3.0"
+    "code-gauge-linux-x64-gnu": "4.4.0",
+    "code-gauge-linux-arm64-gnu": "4.4.0",
+    "code-gauge-linux-x64-musl": "4.4.0",
+    "code-gauge-linux-arm64-musl": "4.4.0",
+    "code-gauge-darwin-x64": "4.4.0",
+    "code-gauge-darwin-arm64": "4.4.0",
+    "code-gauge-win32-x64-msvc": "4.4.0"
   }
 }

package/native/src/cyclomatic.rs

@@ -1,79 +0,0 @@
-use tree_sitter::Node;
-
-use crate::util::{named_children, node_text, Source};
-
-/// Cyclomatic paths a Java node adds to its function, following PMD 7.26.0's CycloVisitor with
-/// its default options: branches and loops add 1 plus the boolean paths of their condition,
-/// `throw`/`catch`/enhanced `for` add 1, and a switch adds the boolean paths of its tested
-/// expression plus the expression alternatives of each non-default label. `&&`/`||` outside these
-/// conditions (initializers, returns, arguments) and pattern labels and guards add nothing.
-pub fn pmd_cyclomatic_increment(node: Node<'_>, code: &Source<'_>) -> u64 {
-    match node.kind() {
-        "if_statement" | "while_statement" | "do_statement" | "for_statement"
-        | "ternary_expression" => {
-            1 + node
-                .child_by_field_name("condition")
-                .map_or(0, |condition| {
-                    boolean_expression_complexity(condition, code)
-                })
-        }
-        "enhanced_for_statement" | "catch_clause" | "throw_statement" => 1,
-        "switch_expression" => node
-            .child_by_field_name("condition")
-            .map_or(0, |condition| {
-                boolean_expression_complexity(condition, code)
-            }),
-        "switch_block_statement_group" | "switch_rule" => named_children(node)
-            .into_iter()
-            .filter(|child| child.kind() == "switch_label")
-            .flat_map(named_children)
-            .filter(|child| {
-                child.kind() != "guard"
-                    && child.kind() != "pattern"
-                    && !crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind())
-            })
-            .count() as u64,
-        _ => 0,
-    }
-}
-
-/// PMD's booleanExpressionComplexity: a conditional expression costs 2 plus its parts; any other
-/// expression costs its `&&`/`||` operators. PMD has no parenthesis nodes, so they are unwrapped.
-fn boolean_expression_complexity(expression: Node<'_>, code: &Source<'_>) -> u64 {
-    let mut expression = expression;
-    while expression.kind() == "parenthesized_expression" {
-        let Some(inner) = named_children(expression)
-            .into_iter()
-            .find(|child| !crate::ncss::COMMENT_NODE_TYPES.contains(&child.kind()))
-        else {
-            return 0;
-        };
-        expression = inner;
-    }
-    if expression.kind() == "ternary_expression" {
-        return 2 + ["condition", "consequence", "alternative"]
-            .iter()
-            .filter_map(|field| expression.child_by_field_name(field))
-            .map(|part| boolean_expression_complexity(part, code))
-            .sum::<u64>();
-    }
-    count_conditional_operators(expression, code)
-}
-
-/// `&&`/`||` binaries in the subtree, not descending into lambdas or class bodies, which PMD treats
-/// as find boundaries.
-fn count_conditional_operators(node: Node<'_>, code: &Source<'_>) -> u64 {
-    if node.kind() == "lambda_expression" || node.kind() == "class_body" {
-        return 0;
-    }
-    let own = u64::from(
-        node.kind() == "binary_expression"
-            && node
-                .child_by_field_name("operator")
-                .is_some_and(|operator| matches!(node_text(operator, code), "&&" | "||")),
-    );
-    own + named_children(node)
-        .into_iter()
-        .map(|child| count_conditional_operators(child, code))
-        .sum::<u64>()
-}