sigmap 8.32.1 → 8.34.0

package/llms-full.txt

@@ -11,13 +11,13 @@ ranking keeps the relevant context in scope (cutting tokens ~97% as a side
 effect), with no LLM calls, embeddings, or vector database. Works with Claude,
 Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 8.32.1 | Benchmark: sigmap-v8.32-main (2026-09-12)
+# Version: 8.34.0 | Benchmark: sigmap-v8.34-main (2026-09-13)
 # Source: auto-generated from package.json, version.json, benchmarks/latest.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 
 ---
 
-## Core metrics (benchmark: sigmap-v8.32-main, 2026-09-12)
+## Core metrics (benchmark: sigmap-v8.34-main, 2026-09-13)
 
 | Metric | Without SigMap | With SigMap |
 |--------|----------------|-------------|
@@ -25,7 +25,7 @@ Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 | Token reduction | — | 96.8% average |
 | Task-success proxy (modeled) | — | 62.9% |
 | Prompts per task | 2.84 | 1.58 (44.4% fewer) |
-| Supported languages | — | 32 |
+| Supported languages | — | 33 |
 | MCP tools | — | 21 |
 | npm runtime dependencies | — | 0 |
 
@@ -370,9 +370,9 @@ impact = {"depth":3,"includeSigs":true}
 
 ---
 
-## Supported languages (32 extractors)
+## Supported languages (33 extractors)
 
-cpp, csharp, css, dart, dockerfile, gdscript, go, graphql, html, java, javascript, kotlin, markdown, php, properties, protobuf, python, r, ruby, rust, scala, shell, sql, svelte, swift, terraform, toml, typescript, typescript_react, vue_sfc, xml, yaml
+cpp, csharp, css, dart, dockerfile, gdscript, go, graphql, html, java, javascript, kotlin, lua, markdown, php, properties, protobuf, python, r, ruby, rust, scala, shell, sql, svelte, swift, terraform, toml, typescript, typescript_react, vue_sfc, xml, yaml
 
 ---
 

package/llms.txt

@@ -11,7 +11,7 @@ ranking keeps the relevant context in scope (cutting tokens ~97% as a side
 effect), with no LLM calls, embeddings, or vector database. Works with Claude,
 Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 8.32.1 | Benchmark: sigmap-v8.32-main (2026-09-12)
+# Version: 8.34.0 | Benchmark: sigmap-v8.34-main (2026-09-13)
 # Source: auto-generated from package.json, version.json, benchmarks/latest.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 
@@ -23,13 +23,13 @@ Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 - No blast-radius awareness before editing a hub file — `--impact` shows every file a change touches.
 - Pasted stack traces, CI logs, and JSON bloat the prompt — `squeeze` minimizes them and enriches the top frame from the symbol index.
 
-## Core metrics (benchmark: sigmap-v8.32-main, 2026-09-12)
+## Core metrics (benchmark: sigmap-v8.34-main, 2026-09-13)
 
 - hit@5 retrieval: 78.9% vs 44.0% single-shot grep baseline (1.73× lift)
 - Token reduction: 96.8% average across benchmark repos
 - Task-success proxy: 62.9% (modeled from retrieval tiers, not measured LLM sessions)
 - Prompts per task: 1.58 vs 2.84 baseline (44.4% fewer, modeled)
-- Languages: 32 supported · MCP tools: 21
+- Languages: 33 supported · MCP tools: 21
 - Dependencies: zero npm runtime dependencies · fully offline
 
 ## Quick start

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "8.32.1",
+  "version": "8.34.0",
   "description": "The deterministic, verifiable grounding layer for AI code work — a zero-dependency signature-and-evidence map that grounds Claude, Cursor, Copilot, Aider, Windsurf, local LLMs & MCP agents against your real code (repo + installed libraries) so they stop hallucinating files, imports & APIs. Runs offline via npx; byte-stable output; ~97% token reduction as proof.",
   "main": "packages/core/index.js",
   "exports": {

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "8.32.1",
+  "version": "8.34.0",
   "description": "SigMap CLI wrapper — thin adapter for programmatic CLI invocation",
   "main": "index.js",
   "keywords": [

package/packages/core/index.js

@@ -29,6 +29,7 @@ const EXT_MAP = {
   '.swift': 'swift',
   '.dart': 'dart',
   '.scala': 'scala',   '.sc': 'scala',
+  '.lua': 'lua',
   '.gd': 'gdscript',
   '.r': 'r',           '.R': 'r',
   '.vue': 'vue',

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "8.32.1",
+  "version": "8.34.0",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/config/loader.js

@@ -81,7 +81,7 @@ const SUPPORTED_CODE_EXTS = new Set([
   '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
   '.py', '.pyw', '.java', '.kt', '.kts', '.go', '.rs', '.cs',
   '.cpp', '.c', '.h', '.hpp', '.cc', '.rb', '.rake', '.php',
-  '.swift', '.dart', '.scala', '.sc', '.vue', '.svelte',
+  '.swift', '.dart', '.scala', '.sc', '.lua', '.vue', '.svelte',
   '.html', '.htm', '.css', '.scss', '.sass', '.less',
   '.yml', '.yaml', '.sh', '.bash', '.zsh', '.fish',
   '.sql', '.graphql', '.gql', '.tf', '.tfvars', '.proto',

package/src/config/tune.js

@@ -38,7 +38,7 @@ const TOKENS_PER_FILE = 25;
 const SOURCE_EXTS = new Set([
   '.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.py', '.rb', '.go', '.rs',
   '.java', '.kt', '.cs', '.cpp', '.c', '.h', '.hpp', '.swift', '.dart',
-  '.scala', '.php', '.gd', '.r', '.R',
+  '.scala', '.php', '.lua', '.gd', '.r', '.R',
 ]);
 
 /** Raw user config file content, or null when absent/unparsable. */

package/src/discovery/language-detector.js

@@ -19,6 +19,7 @@ const EXT_TO_LANG = {
   '.java': 'java', '.kt': 'kotlin', '.cs': 'csharp', '.cpp': 'cpp',
   '.c': 'cpp', '.h': 'cpp', '.hpp': 'cpp', '.swift': 'swift',
   '.dart': 'dart', '.scala': 'scala', '.php': 'php',
+  '.lua': 'lua',
   '.gd': 'gdscript',
   '.r': 'r', '.R': 'r',
 };

package/src/discovery/source-root-registry.js

@@ -156,12 +156,21 @@ const REGISTRY = {
       akka:  { detectionFiles: [], detectionDeps: ['akka'], srcDirs: ['src/main/scala','src'] },
       play:  { detectionFiles: [], detectionDeps: ['play'], srcDirs: ['app','conf'] },
       spark: { detectionFiles: [], detectionDeps: ['spark'],srcDirs: ['src/main/scala'] },
-      zio:   { detectionFiles: [], detectionDeps: ['zio'],  srcDirs: ['src/main/scala'] },
+      zio:   { detectionFiles: [], detectionDeps: ['zio'], srcDirs: ['src/main/scala'] },
     },
     srcDirs:  ['src/main/scala','src'],
     penalties: ['target'],
   },
 
+  lua: {
+    manifestFiles: ['.luarc.json', 'selene.toml', 'stylua.toml'],
+    frameworks: {
+      luarocks: { detectionFiles: ['*.rockspec'], srcDirs: ['src','lua','lib'] },
+    },
+    srcDirs:  ['src','lua','lib'],
+    penalties: ['.luarocks','luarocks_modules'],
+  },
+
   r: {
     manifestFiles: ['DESCRIPTION','renv.lock'],
     frameworks: {

package/src/discovery/source-root-scorer.js

@@ -7,7 +7,7 @@ const { git } = require('../util/git');
 const CODE_EXTS = new Set([
   '.js','.mjs','.cjs','.ts','.tsx','.jsx',
   '.py','.rb','.go','.rs','.java','.kt',
-  '.cs','.cpp','.c','.h','.swift','.dart','.scala','.php',
+  '.cs','.cpp','.c','.h','.swift','.dart','.scala','.php','.lua',
 ]);
 
 const AUTO_SKIP = new Set([

package/src/eval/analyzer.js

@@ -14,47 +14,13 @@ const fs   = require('fs');
 const path = require('path');
 
 // Extension → extractor name (mirrors EXT_MAP in gen-context.js)
-const EXT_MAP = {
-  '.ts': 'typescript', '.tsx': 'typescript',
-  '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
-  '.py': 'python',     '.pyw': 'python',
-  '.java': 'java',
-  '.kt': 'kotlin',     '.kts': 'kotlin',
-  '.go': 'go',
-  '.rs': 'rust',
-  '.cs': 'csharp',
-  '.cpp': 'cpp', '.c': 'cpp', '.h': 'cpp', '.hpp': 'cpp', '.cc': 'cpp',
-  '.rb': 'ruby',       '.rake': 'ruby',
-  '.php': 'php',
-  '.swift': 'swift',
-  '.dart': 'dart',
-  '.scala': 'scala',   '.sc': 'scala',
-  '.gd': 'gdscript',
-  '.r': 'r',           '.R': 'r',
-  '.svelte': 'svelte',
-  '.html': 'html',     '.htm': 'html',
-  '.css': 'css',       '.scss': 'css', '.sass': 'css', '.less': 'css',
-  '.yml': 'yaml',      '.yaml': 'yaml',
-  '.sh': 'shell',      '.bash': 'shell', '.zsh': 'shell', '.fish': 'shell',
-  '.toml': 'toml',
-  '.properties': 'properties',
-  '.xml': 'xml',
-  '.md': 'markdown',
-  // Phase C specialized extractors
-  '.tsx': 'typescript_react',
-  '.vue': 'vue_sfc',
-};
-
-function isDockerfile(name) {
-  return name === 'Dockerfile' || name.startsWith('Dockerfile.');
-}
+// Extractor resolution goes through the dispatcher — the single source of
+// truth (#591). This file previously kept its own copy, which had drifted to
+// a dead duplicate `.vue` key.
+const { langFor } = require('../extractors/dispatch');
 
 function getExtractorName(filePath) {
-  const base = path.basename(filePath);
-  const ext  = path.extname(base).toLowerCase();
-  if (EXT_MAP[ext]) return EXT_MAP[ext];
-  if (isDockerfile(base)) return 'dockerfile';
-  return null;
+  return langFor(filePath);
 }
 
 /** Rough token estimate: chars / 4 */

package/src/extractors/deps.js

@@ -89,6 +89,28 @@ function extractRDeps(src) {
   return [...deps].slice(0, 5);
 }
 
+/**
+ * Extract Lua require() module dependencies.
+ * Captures `require "mod"` and `require("mod")`, returning compact module
+ * names as they appear in source.
+ * @param {string} src
+ * @returns {string[]}
+ */
+function extractLuaDeps(src) {
+  const deps = new Set();
+  const stripped = stripLuaComments(src || '');
+  for (const m of stripped.matchAll(/\brequire\s*(?:\(\s*)?["']([A-Za-z0-9_.\/-]+)["']\s*\)?/g)) {
+    if (m[1]) deps.add(m[1]);
+  }
+  return [...deps].slice(0, 5);
+}
+
+function stripLuaComments(src) {
+  return String(src || '')
+    .replace(/--\[\[[\s\S]*?\]\]/g, '')
+    .replace(/--.*$/gm, '');
+}
+
 /**
  * Build reverse dependency map from forward map.
  * @param {Map<string, string[]>} forwardMap
@@ -107,4 +129,4 @@ function buildReverseDepMap(forwardMap) {
   return reverse;
 }
 
-module.exports = { extractPythonDeps, extractTSDeps, extractRDeps, buildReverseDepMap };
+module.exports = { extractPythonDeps, extractTSDeps, extractRDeps, extractLuaDeps, buildReverseDepMap };

package/src/extractors/dispatch.js

@@ -28,6 +28,7 @@ const EXTRACTORS = {
   swift: require('./swift'),
   dart: require('./dart'),
   scala: require('./scala'),
+  lua: require('./lua'),
   gdscript: require('./gdscript'),
   r: require('./r'),
   vue_sfc: require('./vue_sfc'),
@@ -48,6 +49,21 @@ const EXTRACTORS = {
   generic: require('./generic'),
 };
 
+/**
+ * Extension → extractor module name. **The single source of truth for
+ * extractor resolution** (#591).
+ *
+ * Anything that decides *which extractor module to load* must go through
+ * `langFor` rather than declaring its own copy. Three copies existed and two
+ * had drifted: `src/eval/analyzer.js` carried a dead duplicate `.vue` key, and
+ * the `--diagnose-extractors` map pointed at `vue.js` after that module was
+ * deleted — which is how an unreachable extractor survived unnoticed (#582).
+ *
+ * Not every extension map in the codebase belongs here. `language-detector.js`
+ * maps `.tsx → typescript` for language *statistics*, and `dashboard.js` keeps
+ * short display *labels*. Both are correct for their purpose and deliberately
+ * differ from resolution — folding them in would miscount languages.
+ */
 const EXT_MAP = {
   '.ts': 'typescript', '.tsx': 'typescript_react',
   '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
@@ -63,6 +79,7 @@ const EXT_MAP = {
   '.swift': 'swift',
   '.dart': 'dart',
   '.scala': 'scala', '.sc': 'scala',
+  '.lua': 'lua',
   '.gd': 'gdscript',
   '.r': 'r', '.R': 'r',
   '.vue': 'vue_sfc',
@@ -108,4 +125,4 @@ function extractFile(filePathOrName, src) {
   }
 }
 
-module.exports = { extractFile, langFor };
+module.exports = { extractFile, langFor, EXT_MAP };

package/src/extractors/lua.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const { capWithNotice } = require('../util/truncate');
+
+// Ceiling discloses what it drops rather than truncating silently (#583).
+// Collection runs to completion so the marker reports the true overflow —
+// stopping early made r.js report "+1 more" where 50 were hidden (#584).
+const PER_FILE_LIMIT = 30;
+
+/**
+ * Extract signatures from Lua source code.
+ *
+ * Recognised constructs:
+ *   - Global functions: `function name(args)`
+ *   - Module-table functions: `function M.name(args)` / `function M:name(args)`
+ *   - Local functions: `local function name(args)`
+ *   - Assigned functions: `name = function(args)` / `M.name = function(args)`
+ *   - Module imports: `local mod = require("mod")` as compact hints
+ *   - LDoc-style doc comments (`---`) as first-sentence hints
+ *
+ * The extractor is regex-only and zero-dependency, matching SigMap's Tier-3
+ * language extractor style.
+ *
+ * @param {string} src - Raw file content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+  const hints = collectDocHints(src);
+  const stripped = stripLuaComments(src);
+  const seen = new Set();
+
+  // local foo = require('bar.baz') — useful module-surface hint, capped low.
+  for (const m of stripped.matchAll(/^\s*(?:local\s+)?([A-Za-z_]\w*)\s*=\s*require\s*\(\s*['"]([A-Za-z0-9_.\/-]+)['"]\s*\)/gm)) {
+    pushUnique(sigs, seen, `require ${m[2]} as ${m[1]}`);
+  }
+
+  // local function name(args)
+  for (const m of stripped.matchAll(/^\s*local\s+function\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/gm)) {
+    if (m[1].startsWith('_')) continue;
+    pushUnique(sigs, seen, `local function ${m[1]}(${normalizeParams(m[2])})${applyHint(hints, m[1])}`);
+  }
+
+  // function name(args), function M.name(args), function M:name(args)
+  for (const m of stripped.matchAll(/^\s*function\s+([A-Za-z_]\w*(?:(?:\.|:)[A-Za-z_]\w*)*)\s*\(([^)]*)\)/gm)) {
+    const name = m[1];
+    if (name.startsWith('_')) continue;
+    pushUnique(sigs, seen, `function ${name}(${normalizeParams(m[2])})${applyHint(hints, name)}`);
+  }
+
+  // name = function(args), M.name = function(args), M:name = function(args)
+  for (const m of stripped.matchAll(/^\s*(?:local\s+)?([A-Za-z_]\w*(?:(?:\.|:)[A-Za-z_]\w*)*)\s*=\s*function\s*\(([^)]*)\)/gm)) {
+    const name = m[1];
+    if (name.startsWith('_')) continue;
+    pushUnique(sigs, seen, `${name} = function(${normalizeParams(m[2])})${applyHint(hints, name)}`);
+  }
+
+  return capWithNotice(sigs, PER_FILE_LIMIT, 'signatures');
+}
+
+function pushUnique(out, seen, sig) {
+  if (!sig || seen.has(sig)) return;
+  seen.add(sig);
+  out.push(sig);
+}
+
+function normalizeParams(params) {
+  return String(params || '')
+    .replace(/--.*$/gm, '')
+    .split(',')
+    .map((p) => p.trim().replace(/\s+/g, ' '))
+    .filter(Boolean)
+    .join(', ');
+}
+
+function applyHint(hints, name) {
+  const h = hints.get(name);
+  return h ? `  # ${h}` : '';
+}
+
+/**
+ * Attach each contiguous `---` doc block to the next function-like declaration
+ * by its extracted symbol name.
+ */
+function collectDocHints(src) {
+  const hints = new Map();
+  const lines = src.split('\n');
+  let block = [];
+  for (const line of lines) {
+    const doc = line.match(/^\s*---\s?(.*)$/);
+    if (doc) {
+      block.push(doc[1]);
+    } else if (block.length > 0) {
+      const decl = line.match(/^\s*local\s+function\s+([A-Za-z_]\w*)\s*\(/)
+                || line.match(/^\s*function\s+([A-Za-z_]\w*(?:(?:\.|:)[A-Za-z_]\w*)*)\s*\(/)
+                || line.match(/^\s*(?:local\s+)?([A-Za-z_]\w*(?:(?:\.|:)[A-Za-z_]\w*)*)\s*=\s*function\s*\(/);
+      if (decl) {
+        const hint = firstDocSentence(block);
+        if (hint) hints.set(decl[1], hint);
+      }
+      block = [];
+    }
+  }
+  return hints;
+}
+
+function firstDocSentence(block) {
+  for (const raw of block) {
+    const line = String(raw || '').trim();
+    if (!line || line.startsWith('@')) continue;
+    return line.replace(/\s+/g, ' ').slice(0, 60).replace(/[.,;:!?]+$/, '').trim();
+  }
+  return '';
+}
+
+/** Strip Lua line and long comments while preserving strings enough for regex scans. */
+function stripLuaComments(src) {
+  const out = src.split('');
+  const blank = (a, b) => { for (let i = a; i < b; i++) if (out[i] !== '\n') out[i] = ' '; };
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      i++;
+      while (i < src.length) {
+        if (src[i] === '\\') { i += 2; continue; }
+        if (src[i] === quote) { i++; break; }
+        if (src[i] === '\n') break;
+        i++;
+      }
+      continue;
+    }
+    if (src.startsWith('--[[', i)) {
+      const end = src.indexOf(']]', i + 4);
+      blank(i, end === -1 ? src.length : end + 2);
+      i = end === -1 ? src.length : end + 2;
+      continue;
+    }
+    if (src.startsWith('--', i)) {
+      const end = src.indexOf('\n', i + 2);
+      blank(i, end === -1 ? src.length : end);
+      i = end === -1 ? src.length : end;
+      continue;
+    }
+    i++;
+  }
+  return out.join('');
+}
+
+module.exports = { extract };

package/src/graph/call-graph.js

@@ -26,6 +26,8 @@ const PY_EXTS = new Set(['.py', '.pyw']);
 const JAVA_EXTS = new Set(['.java']);
 const GO_EXTS = new Set(['.go']);
 const RS_EXTS = new Set(['.rs']);
+const KT_EXTS = new Set(['.kt', '.kts']);
+const SCALA_EXTS = new Set(['.scala', '.sc']);
 
 // Tokens that look like `name(` calls or definition headers but are language
 // keywords, not user symbols — never treated as a call or a definition.
@@ -349,6 +351,81 @@ function rustDefs(masked) {
 
 // Pick the masker whose comment/string syntax matches the language.
 // Java and Go share JS syntax (Go raw strings mask like template literals).
+/**
+ * Body range for a JVM-family member that may use either a brace body or an
+ * expression body (`fun f() = expr` / `def f = expr`), which Java has not.
+ * An expression body runs to the end of its line — enough to capture the calls
+ * it makes, which is all the graph needs.
+ * @returns {{bodyStart:number, bodyEnd:number}|null} null when neither form follows
+ */
+function jvmBodyRange(masked, from) {
+  let k = from;
+  while (k < masked.length && masked[k] !== '{' && masked[k] !== '=' && masked[k] !== '\n' && masked[k] !== ';') k++;
+  if (masked[k] === '{') return { bodyStart: k, bodyEnd: matchDelim(masked, k, '{', '}') };
+  if (masked[k] === '=') {
+    // `= {` is still a brace body, just written with an assignment.
+    let j = k + 1;
+    while (j < masked.length && /\s/.test(masked[j])) j++;
+    if (masked[j] === '{') return { bodyStart: j, bodyEnd: matchDelim(masked, j, '{', '}') };
+    const eol = masked.indexOf('\n', k);
+    return { bodyStart: k, bodyEnd: eol === -1 ? masked.length : eol };
+  }
+  return null; // abstract member or interface declaration
+}
+
+/**
+ * Kotlin `fun` definitions, including extension functions (`fun Foo.bar()`,
+ * recorded as `bar`) and expression bodies.
+ */
+function ktDefs(masked) {
+  const defs = [];
+  const seen = new Set();
+  const re = /(?:^|\n)[ \t]*((?:(?:public|private|protected|internal|open|override|abstract|final|suspend|inline|operator|infix|tailrec|external|expect|actual|inner|companion)\s+)*)fun\s+(?:<[^>\n]{0,80}>\s*)?(?:[A-Za-z_][\w.<>]*\.)?([A-Za-z_][\w]*)\s*\(/g;
+  let m;
+  while ((m = re.exec(masked)) !== null) {
+    const name = m[2];
+    if (NON_CALL.has(name)) continue;
+    const paren = masked.indexOf('(', m.index + m[0].length - 1);
+    const close = matchDelim(masked, paren, '(', ')');
+    if (close < 0) continue;
+    const range = jvmBodyRange(masked, close + 1);
+    const line = lineAt(masked, m.index + 1);
+    const key = name + ':' + (range ? range.bodyStart : line);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    // An abstract/interface member owns no body: it can receive edges but
+    // never produces them, the same treatment javaDefs gives declarations.
+    defs.push(range ? { name, line, ...range } : { name, line, bodyStart: close, bodyEnd: close });
+  }
+  return defs;
+}
+
+/**
+ * Scala `def` definitions. Handles parameterless members (`def foo: Int = 1`),
+ * type parameters, and expression bodies.
+ */
+function scalaDefs(masked) {
+  const defs = [];
+  const seen = new Set();
+  const re = /(?:^|\n)[ \t]*((?:(?:private|protected|override|implicit|final|lazy|sealed|abstract|inline)(?:\s*\[[^\]\n]{0,60}\])?\s+)*)def\s+([A-Za-z_][\w]*)\s*(?=[\[\(:=])/g;
+  let m;
+  while ((m = re.exec(masked)) !== null) {
+    const name = m[2];
+    if (NON_CALL.has(name)) continue;
+    // Step past an optional type-parameter list, then an optional value list.
+    let k = m.index + m[0].length;
+    if (masked[k] === '[') { const e = matchDelim(masked, k, '[', ']'); if (e < 0) continue; k = e + 1; }
+    while (masked[k] === '(') { const e = matchDelim(masked, k, '(', ')'); if (e < 0) break; k = e + 1; }
+    const range = jvmBodyRange(masked, k);
+    const line = lineAt(masked, m.index + 1);
+    const key = name + ':' + (range ? range.bodyStart : line);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    defs.push(range ? { name, line, ...range } : { name, line, bodyStart: k, bodyEnd: k });
+  }
+  return defs;
+}
+
 function maskFor(filePath, src) {
   const ext = path.extname(filePath).toLowerCase();
   if (PY_EXTS.has(ext)) return maskPy(src);
@@ -363,6 +440,8 @@ function extractDefs(filePath, src) {
   if (JAVA_EXTS.has(ext)) return javaDefs(maskJs(src));
   if (GO_EXTS.has(ext)) return goDefs(maskJs(src));
   if (RS_EXTS.has(ext)) return rustDefs(maskRust(src));
+  if (KT_EXTS.has(ext)) return ktDefs(maskJs(src));
+  if (SCALA_EXTS.has(ext)) return scalaDefs(maskJs(src));
   return null; // unsupported language
 }
 
@@ -452,7 +531,8 @@ function _walk(dir, excludeSet, out, depth, maxDepth) {
     if (e.isDirectory()) _walk(full, excludeSet, out, depth + 1, maxDepth);
     else if (e.isFile()) {
       const ext = path.extname(e.name).toLowerCase();
-      if (JS_EXTS.has(ext) || PY_EXTS.has(ext) || JAVA_EXTS.has(ext) || GO_EXTS.has(ext) || RS_EXTS.has(ext)) out.push(full);
+      if (JS_EXTS.has(ext) || PY_EXTS.has(ext) || JAVA_EXTS.has(ext) || GO_EXTS.has(ext)
+        || RS_EXTS.has(ext) || KT_EXTS.has(ext) || SCALA_EXTS.has(ext)) out.push(full);
     }
   }
 }

package/src/map/route-table.js

@@ -20,6 +20,45 @@ function shouldSkipFile(rel) {
   return /(^|\/)(gen-context|gen-project-map)\.js$/.test(normalized);
 }
 
+/**
+ * Byte offsets and prefixes of every `@Controller(...)` in a file.
+ * A file may declare several controllers, so each route is attributed to the
+ * nearest one above it rather than to a single file-wide prefix.
+ * @param {string} content
+ * @returns {Array<{index:number, prefix:string}>} ascending by index
+ */
+function nestControllerPrefixes(content) {
+  const out = [];
+  const re = /@Controller\s*\(\s*(?:['"`]([^'"`]*)['"`])?/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    out.push({ index: m.index, prefix: m[1] || '' });
+  }
+  return out;
+}
+
+/** Prefix of the nearest `@Controller` above `index`, or '' when there is none. */
+function prefixBefore(controllers, index) {
+  let prefix = '';
+  for (const c of controllers) {
+    if (c.index > index) break;
+    prefix = c.prefix;
+  }
+  return prefix;
+}
+
+/**
+ * Join a controller prefix and a method path into one route path.
+ * Either side may be empty, absent, or carry its own slashes.
+ * @returns {string} always slash-prefixed; never a trailing slash except '/'
+ */
+function joinRoute(prefix, methodPath) {
+  const parts = [prefix, methodPath]
+    .map((p) => String(p || '').trim().replace(/^\/+|\/+$/g, ''))
+    .filter(Boolean);
+  return parts.length ? '/' + parts.join('/') : '/';
+}
+
 /**
  * Structured route rows across the supported frameworks — the data behind
  * `analyze`, exposed for retrieval surface-enrichment (#488).
@@ -48,16 +87,14 @@ function collectRoutes(files, cwd) {
         routes.push({ method: m[1].toUpperCase(), path: m[2], file: rel });
       }
 
-      // NestJS decorators: @Get('/path') @Post('/path')
-      const re2 = /@(Get|Post|Put|Patch|Delete|Head|Options|All)\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
+      // NestJS: @Get(':id') / @Post() — composed with the enclosing
+      // @Controller('prefix'). Without the prefix the emitted path matches
+      // nothing real, which defeats the point of route pseudo-signatures (#585).
+      const controllers = nestControllerPrefixes(content);
+      const re2 = /@(Get|Post|Put|Patch|Delete|Head|Options|All)\s*\(\s*(?:['"`]([^'"`]*)['"`])?\s*\)/g;
       while ((m = re2.exec(content)) !== null) {
-        routes.push({ method: m[1].toUpperCase(), path: m[2], file: rel });
-      }
-
-      // NestJS: @Get() with no path
-      const re3 = /@(Get|Post|Put|Patch|Delete)\s*\(\s*\)/g;
-      while ((m = re3.exec(content)) !== null) {
-        routes.push({ method: m[1].toUpperCase(), path: '/', file: rel });
+        const prefix = prefixBefore(controllers, m.index);
+        routes.push({ method: m[1].toUpperCase(), path: joinRoute(prefix, m[2]), file: rel });
       }
     }
 

package/src/mcp/server.js

@@ -18,7 +18,7 @@ const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, exp
 
 const SERVER_INFO = {
   name: 'sigmap',
-  version: '8.32.1',
+  version: '8.34.0',
   description: 'SigMap MCP server — code signatures on demand',
 };