sweet-search 2.6.4 → 2.6.7

package/core/graph/graph-extractor.js

@@ -1394,7 +1394,11 @@ export class GraphExtractor {
 
       const groupEnd = j - 1;
       const groupContent = source.slice(start, groupEnd);
-      const isOptional = source[groupEnd + 1] === '?';
+      // A group quantified by `?` OR `*` can match zero times, so the tokens
+      // AFTER it (e.g. the real keyword) may start the line. Treating a `(?:…)*`
+      // modifier prefix as mandatory wrongly rejected lines like `class Foo`
+      // (QL/Vala/Haxe leading-modifier patterns), dropping all their entities.
+      const isOptional = source[groupEnd + 1] === '?' || source[groupEnd + 1] === '*';
       if (!isOptional) {
         const alternatives = groupContent.split('|').map((alt) => alt.trim()).filter(Boolean);
         const altTokens = [];
@@ -1409,7 +1413,14 @@ export class GraphExtractor {
       const optionalAlternatives = groupContent.split('|').map((alt) => alt.trim()).filter(Boolean);
       for (const alt of optionalAlternatives) {
         const token = this.extractLiteralPrefix(alt);
-        if (token) tokens.push(token);
+        // A nested group / non-literal alternative (e.g. `(?:(?:public|…)\s+)*`)
+        // means we cannot enumerate every literal this optional prefix could
+        // start with. Adding only the literals we *can* see would
+        // false-negative lines that begin with an un-enumerated one (Vala/Haxe
+        // `public class Foo`). Disabling the prefilter is the only
+        // correctness-preserving choice; the full regex still runs per line.
+        if (!token) return [];
+        tokens.push(token);
       }
       i = groupEnd + 2;
       while (skipLeadingWhitespace()) {}

package/core/infrastructure/constants.js

@@ -3,6 +3,8 @@
  * Extracted to prevent drift between graph-search.js and sweet-search.js
  */
 
+import { EXTENSION_MAP } from './language-patterns/maps.js';
+
 export const SYMBOL_KIND_WEIGHTS = {
   class: 1.0,
   interface: 0.95,
@@ -26,25 +28,43 @@ export const DEFINITION_TYPES = new Set([
 ]);
 
 /**
- * Canonical set of code file extensions recognized by sweet-search.
- * Used by both the indexer (sparse gram builder) and the search pipeline
- * (ripgrep type filter + code file detection). Single source of truth.
+ * Canonical set of code file extensions recognized by sweet-search's
+ * grep/pattern path — the sparse-gram literal index, native-grep extension
+ * filter, ripgrep `--type-add code` fallback, and `isRipgrepCodePath`.
+ *
+ * DERIVED from EXTENSION_MAP (the single source of truth for which extensions
+ * sweet-search indexes) so ss-grep coverage can NEVER drift behind newly-added
+ * languages. This drift previously dropped Solidity, .cts/.mts, .cljc/.cljs/.edn,
+ * .mli, .rd/.rmd, shaders, build DSLs, etc. from ss-grep even though they were
+ * discovered + embedded (so ss-search worked but ss-grep silently returned
+ * nothing). Keys are stored bare + lowercase (no leading dot) to match
+ * `path.extname(f).slice(1).toLowerCase()` at the call sites.
+ *
+ * Pure document formats (Markdown/reStructuredText/plaintext) are intentionally
+ * EXCLUDED — they go through DocumentChunker and are not part of the grep
+ * code-path (isRipgrepCodePath('README.md') must stay false, and sparse-gram
+ * candidate lists drop doc files). Config/markup/style formats (json/yaml/xml/
+ * html/css/ini/…) stay in, matching the historical set.
+ *
+ * Plus a few historically grep-able languages that have no EXTENSION_MAP entry
+ * (no chunker grammar): Ada, D, V.
  */
+const DOC_FORMAT_LANGUAGE_IDS = new Set(['markdown', 'rst', 'plaintext']);
+const LEGACY_EXTRA_CODE_EXTENSIONS = ['ada', 'd', 'v'];
 export const CODE_FILE_EXTENSIONS = new Set([
-  'js', 'ts', 'jsx', 'tsx', 'py', 'rs', 'go', 'java', 'c', 'cpp', 'h', 'hpp',
-  'cs', 'rb', 'php', 'swift', 'kt', 'scala', 'lua', 'sh', 'zig', 'hs', 'ml',
-  'ex', 'exs', 'clj', 'erl', 'r', 'jl', 'dart', 'v', 'nim', 'cr', 'd', 'f90',
-  'ada', 'pas', 'cob', 'pl', 'pm', 'sql', 'graphql', 'proto', 'yaml', 'yml',
-  'json', 'toml', 'xml', 'html', 'css', 'scss', 'sass', 'less', 'svelte',
-  'vue', 'astro', 'mdx',
+  ...Object.entries(EXTENSION_MAP)
+    .filter(([, id]) => !DOC_FORMAT_LANGUAGE_IDS.has(id))
+    .map(([ext]) => ext.replace(/^\./, '').toLowerCase()),
+  ...LEGACY_EXTRA_CODE_EXTENSIONS,
 ]);
 
 /**
  * Ripgrep type definition glob matching CODE_FILE_EXTENSIONS.
- * Used with --type-add to define a custom 'code' type for ripgrep.
+ * Used with --type-add to define a custom 'code' type for ripgrep. Derived from
+ * the same set so it stays in lockstep.
  */
 export const RIPGREP_CODE_TYPE_GLOB =
-  'code:*.{js,ts,jsx,tsx,py,rs,go,java,c,cpp,h,hpp,cs,rb,php,swift,kt,scala,lua,sh,zig,hs,ml,ex,exs,clj,erl,r,jl,dart,v,nim,cr,d,f90,ada,pas,cob,pl,pm,sql,graphql,proto,yaml,yml,json,toml,xml,html,css,scss,sass,less,svelte,vue,astro,mdx}';
+  `code:*.{${Array.from(CODE_FILE_EXTENSIONS).join(',')}}`;
 
 /**
  * Sparse gram symbol type bitmasks.

package/core/infrastructure/language-patterns/registry-tooling.js

@@ -235,6 +235,503 @@ export const TOOLING_LANGUAGES = {
       skipCallObjects: [],
     },
   },
+  // ─── Julia (graph-only spike) ────────────────────────────────────────────────
+  // No `chunker` key → getLanguageByExtension returns chunker:null → ast-chunker
+  // keeps Julia on generic windowing. The `graph` patterns alone enable
+  // regex-based entity extraction so ss-trace/code-graph works.
+  julia: {
+    indentBased: false,
+    endKeyword: null,
+    comment: { line: "#", block: ["#=", "=#"] },
+    graph: {
+      entities: {
+        function: /^\s*function\s+([A-Za-z_]\w*)/,
+        shortFunction: /^\s*([A-Za-z_]\w*)\((?:[^()]*)\)\s*(?:::[\w.<>{} ]+)?\s*=(?!=)/,
+        struct: /^\s*(?:mutable\s+)?struct\s+([A-Za-z_]\w*)/,
+        module: /^\s*module\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*(?:using|import)\s+([\w.]+)/,
+      },
+      skipCallObjects: [],
+    },
+  },
+  // ════════════════════════════════════════════════════════════════════════════
+  // GRAPH-ONLY language entries (no `chunker` key → chunking stays generic via
+  // parseGenericFile; the `graph` regexes enable ss-trace / code-graph symbol
+  // extraction). Authored 2026-06 from each language's tree-sitter tags.scm /
+  // universal-ctags conventions. Entity-type keys are free-form (the regex graph
+  // path accepts any label, like Rust's existing const/static/type).
+  // ════════════════════════════════════════════════════════════════════════════
+  clojure: {
+    indentBased: false, endKeyword: null,
+    comment: { line: ";", block: null },
+    graph: {
+      entities: {
+        function: /^\s*\(def(?:n-?|multi|method)\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        macro: /^\s*\(defmacro\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        struct: /^\s*\(def(?:record|type)\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        interface: /^\s*\(defprotocol\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        constant: /^\s*\(def\s+(?:\^(?:\{[^}]*\}|\S+)\s+)*([A-Za-z0-9*+!?<>=.\/'-]+)/,
+        module: /^\s*\(ns\s+([A-Za-z0-9*+!?<>=.\/'-]+)/,
+      },
+      relationships: { import: /^\s*\(:?(?:require|use)\s+'?\[?([A-Za-z0-9.*_-]+)/ },
+      skipCallObjects: ["let", "let*", "if", "when", "do", "fn", "map", "filter", "reduce"],
+    },
+  },
+  elisp: {
+    indentBased: false, endKeyword: null,
+    comment: { line: ";", block: null },
+    graph: {
+      entities: {
+        function: /^\s*\((?:cl-)?def(?:un|subst)\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+        macro: /^\s*\((?:cl-)?defmacro\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+        variable: /^\s*\(def(?:var|custom)\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+        constant: /^\s*\(defconst\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+        module: /^\s*\(defgroup\s+([A-Za-z0-9*+!?<>=\/_-]+)/,
+      },
+      relationships: { import: /^\s*\(require\s+'([A-Za-z0-9*+!?<>=\/_-]+)/ },
+      skipCallObjects: ["let", "let*", "if", "when", "unless", "cond", "setq", "lambda", "progn"],
+    },
+  },
+  haskell: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "--", block: ["{-", "-}"] },
+    graph: {
+      entities: {
+        function: /^\s*([a-z_][\w']*)\s*::/,
+        type: /^\s*(?:data|newtype|type)\s+([A-Z]\w*)/,
+        class: /^\s*class\s+(?:.*?=>\s*)?([A-Z]\w*)/,
+        instance: /^\s*instance\s+(?:.*?=>\s*)?([A-Z]\w*)/,
+        module: /^\s*module\s+([A-Z][\w.]*)/,
+      },
+      relationships: { import: /^\s*import\s+(?:qualified\s+)?([A-Z][\w.]*)/ },
+      skipCallObjects: ["map", "filter", "foldr", "foldl", "return", "pure", "print", "putStrLn", "fmap", "show"],
+    },
+  },
+  erlang: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "%", block: null },
+    graph: {
+      entities: {
+        module: /^\s*-module\(\s*([a-z]\w*)/,
+        function: /^\s*(?!fun\b)([a-z]\w*)\s*\((?:(?!fun\b).)*\)\s*(?:when\b.*)?->/,
+        struct: /^\s*-record\(\s*([a-z]\w*)/,
+        macro: /^\s*-define\(\s*([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*-import\(\s*([a-z]\w*)/,
+        include: /^\s*-include(?:_lib)?\(\s*"([^"]+)"/,
+        inherit: /^\s*-behaviou?r\(\s*([a-z]\w*)/,
+      },
+      skipCallObjects: ["lists", "io", "erlang", "maps", "string", "proplists", "gen_server"],
+    },
+  },
+  elm: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "--", block: ["{-", "-}"] },
+    graph: {
+      entities: {
+        function: /^\s*([a-z]\w*)\s*:/,
+        type: /^\s*type\s+alias\s+([A-Z]\w*)/,
+        enum: /^\s*type\s+([A-Z]\w*)/,
+        port: /^\s*port\s+([a-z]\w*)\s*:/,
+        module: /^\s*(?:port\s+|effect\s+)?module\s+([A-Z][\w.]*)/,
+      },
+      relationships: { import: /^\s*import\s+([A-Z][\w.]*)/ },
+      skipCallObjects: ["List", "Maybe", "Result", "Html", "String", "Debug"],
+    },
+  },
+  r: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*([A-Za-z.][\w.]*)\s*(?:<<?-|=)\s*function\b/,
+        class: /^\s*set(?:Ref)?Class\s*\(\s*["']([A-Za-z.][\w.]*)["']/,
+        method: /^\s*setMethod\s*\(\s*["']([A-Za-z.][\w.]*)["']/,
+      },
+      relationships: {
+        import: /^\s*(?:library|require)\s*\(\s*["']?([A-Za-z.][\w.]*)["']?/,
+        source: /^\s*source\s*\(\s*["']([^"']+)["']/,
+      },
+      skipCallObjects: ["c", "list", "print", "cat", "paste", "paste0", "return", "stop", "warning"],
+    },
+  },
+  perl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*sub\s+([A-Za-z_]\w*)/,
+        module: /^\s*package\s+([\w:]+)/,
+        constant: /^\s*use\s+constant\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*(?:use|require)\s+([A-Z][\w:]*)/,
+        inherit: /^\s*use\s+(?:parent|base)\s+(?:-norequire\s*,?\s*)?(?:qw[(\/{[|]\s*)?["']?([\w:]+)["']?/,
+      },
+      skipCallObjects: ["print", "say", "shift", "push", "pop", "return", "my", "scalar", "keys", "values"],
+    },
+  },
+  tcl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*proc\s+([^\s{]+)/,
+        module: /^\s*namespace\s+eval\s+([^\s{]+)/,
+      },
+      relationships: {
+        import: /^\s*package\s+require\s+([\w:]+)/,
+        source: /^\s*source\s+(\S+)/,
+      },
+      skipCallObjects: ["set", "puts", "expr", "return", "string", "list", "lappend", "incr", "if", "foreach"],
+    },
+  },
+  vim: {
+    indentBased: false, endKeyword: null,
+    comment: { line: '"', block: null },
+    graph: {
+      entities: {
+        function: /^\s*func(?:tion)?!?\s+([A-Za-z_<][\w#:.>]*)/,
+        command: /^\s*command!?\s+(?:-\S+\s+)*([A-Z]\w*)/,
+        constant: /^\s*let\s+([gsb]:[A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*(?:source|runtime)!?\s+(\S+)/ },
+      skipCallObjects: ["echo", "echom", "call", "let", "set", "execute", "normal"],
+    },
+  },
+  crystal: {
+    indentBased: false, endKeyword: "end",
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        method: /^\s*def\s+(?:self\.)?([A-Za-z_]\w*[!?=]?)/,
+        class: /^\s*(?:abstract\s+)?class\s+([A-Z]\w*)/,
+        module: /^\s*module\s+([A-Z]\w*)/,
+        struct: /^\s*(?:abstract\s+)?struct\s+([A-Z]\w*)/,
+        enum: /^\s*enum\s+([A-Z]\w*)/,
+        macro: /^\s*macro\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*require\s+"([^"]+)"/,
+        inherit: /^\s*(?:abstract\s+)?(?:class|struct)\s+[A-Z]\w*\s*<\s*([A-Z][\w:]*)/,
+        include: /^\s*(?:include|extend)\s+([A-Z][\w:]*)/,
+      },
+      skipCallObjects: ["puts", "print", "p", "pp", "raise", "self"],
+    },
+  },
+  fortran: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "!", block: null },
+    graph: {
+      entities: {
+        module: /^\s*(?:module(?!\s+(?:procedure|subroutine|function)\b)|program)\s+([a-z_]\w*)/i,
+        function: /^\s*(?!end\b)(?:[\w()*,:=.]+\s+)*?(?:subroutine|function)\s+([a-z_]\w*)/i,
+        struct: /^\s*type\b\s*(?:,[^:]*)?(?:::\s*)?(?!is\b)([a-z_]\w*)/i,
+        interface: /^\s*interface\s+([a-z_]\w*)/i,
+      },
+      relationships: { use: /^\s*use\b\s*(?:,[^:]*::\s*)?([a-z_]\w*)/i },
+      skipCallObjects: [],
+    },
+  },
+  cobol: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "*>", block: null },
+    graph: {
+      entities: {
+        module: /^\s*program-id\s*\.\s*([a-z0-9][a-z0-9-]*)/i,
+        class: /^\s*([a-z0-9][a-z0-9-]*)\s+section\s*\./i,
+        function: /^\s*(?!(?:end-[a-z]+|exit|goback|continue|stop)\b)([a-z0-9][a-z0-9-]*)\s*\.\s*$/i,
+      },
+      relationships: {
+        copyFrom: /^\s*copy\s+([a-z0-9][a-z0-9-]*)/i,
+        // CALL "subprog" → dependency edge (`call` is not a mapped relationship
+        // type; `dep` is the canonical generic-dependency key).
+        dep: /^\s*call\s+["']([a-z0-9][a-z0-9-]*)/i,
+      },
+      skipCallObjects: [],
+    },
+  },
+  assembly: {
+    indentBased: false, endKeyword: null,
+    comment: { line: ";", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^([a-zA-Z_][\w$.]*)\s*:/,
+        macro: /^\s*(?:\.macro\s+|%macro\s+|%define\s+)([a-zA-Z_][\w$.]*)/i,
+        constant: /^\s*([a-zA-Z_][\w$.]*)\s+equ\b/i,
+      },
+      relationships: {
+        import: /^\s*(?:\.extern|extern)\s+([a-zA-Z_][\w$.]*)/i,
+        include: /^\s*(?:%include|\.include)\s+["']?([^"'\s,]+)/i,
+      },
+      skipCallObjects: [],
+    },
+  },
+  pascal: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["{", "}"] },
+    graph: {
+      entities: {
+        module: /^\s*(?:unit|program|library)\s+([a-z_]\w*)/i,
+        function: /^\s*(?:procedure|function)\s+([a-z_][\w.]*)/i,
+        class: /^\s*([a-z_]\w*)\s*=\s*class\b/i,
+        struct: /^\s*([a-z_]\w*)\s*=\s*(?:packed\s+)?(?:record|object)\b/i,
+        interface: /^\s*([a-z_]\w*)\s*=\s*interface\b/i,
+        enum: /^\s*([a-z_]\w*)\s*=\s*\(\s*[a-z_]\w*(?:\s*,\s*[a-z_]\w*)*\s*\)\s*;?/i,
+      },
+      relationships: { plainImport: /^\s*uses\s+([a-z_][\w.,\s]*)/i },
+      skipCallObjects: [],
+    },
+  },
+  vala: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        module: /^\s*(?:public\s+)?namespace\s+([A-Za-z_][\w.]*)/,
+        class: /^\s*(?:(?:public|private|protected|internal|abstract|sealed|static)\s+)*class\s+([A-Za-z_]\w*)/,
+        interface: /^\s*(?:(?:public|private|protected|internal)\s+)*interface\s+([A-Za-z_]\w*)/,
+        struct: /^\s*(?:(?:public|private|protected|internal)\s+)*struct\s+([A-Za-z_]\w*)/,
+        enum: /^\s*(?:(?:public|private|protected|internal)\s+)*enum\s+([A-Za-z_]\w*)/,
+        method: /^\s*(?!return\b|if\b|else\b|while\b|for\b|foreach\b|switch\b|case\b|do\b|new\b|throw\b|yield\b)(?:(?:public|private|protected|internal|static|virtual|override|abstract|async|extern|inline|sealed|weak|unowned|owned|const|signal|delegate)\s+)*[\w.<>?\[\]*]+\s+([a-z_]\w*)\s*\(/,
+      },
+      relationships: { using: /^\s*using\s+([A-Za-z_][\w.]*)/ },
+      skipCallObjects: [],
+    },
+  },
+  haxe: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        module: /^\s*package\s+([\w.]+)/,
+        class: /^\s*(?:(?:public|private|extern|final)\s+)*class\s+([A-Za-z_]\w*)/,
+        interface: /^\s*(?:(?:public|private|extern)\s+)*interface\s+([A-Za-z_]\w*)/,
+        enum: /^\s*(?:(?:public|private|extern)\s+)*enum\s+(?!abstract\b)([A-Za-z_]\w*)/,
+        type: /^\s*(?:(?:public|private)\s+)*typedef\s+([A-Za-z_]\w*)/,
+        struct: /^\s*(?:(?:public|private|extern)\s+)*(?:enum\s+)?abstract\s+([A-Za-z_]\w*)/,
+        method: /^\s*(?:[\w@:.]+\s+)*function\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*import\s+([\w.*]+)/,
+        using: /^\s*using\s+([\w.]+)/,
+      },
+      skipCallObjects: [],
+    },
+  },
+  nix: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: ["/*", "*/"] },
+    graph: {
+      // Require BOTH a space before `=` (rejects shell `VAR=val` in build-script
+      // strings) AND a trailing `;`/`{` (real Nix attrs always terminate with
+      // `;`, or open a nested attrset with `{`) — this drops the actively-harmful
+      // false positives from spaced `key = value` config embedded in `''…''`
+      // string literals (INI/systemd/gitconfig content), at the cost of missing
+      // multi-line string attrs (`x = ''`). Conservative by design.
+      entities: { constant: /^\s*([\w'.-]+)\s+=\s*(?!=).*?[;{]\s*$/ },
+      relationships: {},
+      skipCallObjects: [],
+    },
+  },
+  glsl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*#\s*define\s+([A-Za-z_]\w*)/,
+        type: /^\s*layout\s*\([^)]*\)\s*(?:uniform|buffer)\s+([A-Za-z_]\w*)\s*\{/,
+      },
+      relationships: { import: /^\s*#\s*include\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["gl_Position", "gl_FragCoord", "gl_FragColor", "gl_FragDepth", "gl_VertexID", "gl_InstanceID"],
+    },
+  },
+  hlsl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*#\s*define\s+([A-Za-z_]\w*)/,
+        type: /^\s*(?:cbuffer|tbuffer|ConstantBuffer)\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*#\s*include\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["input", "output", "SV_Target", "SV_Position", "SV_Depth"],
+    },
+  },
+  metal: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*#\s*define\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*#\s*(?:include|import)\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["metal", "simd", "threadgroup", "device", "constant"],
+    },
+  },
+  wgsl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*fn\s+([A-Za-z_]\w*)/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*(?:@\w+\([^)]*\)\s*)*(?:const|override|var(?:<[^>]*>)?)\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {},
+      skipCallObjects: [],
+    },
+  },
+  shaderlab: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        type: /^\s*Shader\s+"([^"]+)"/,
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*(_[A-Za-z]\w*)\s*\(\s*"/,
+      },
+      relationships: { import: /^\s*#\s*include\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["UNITY_MATRIX_MVP", "_Time", "_WorldSpaceCameraPos", "unity_ObjectToWorld"],
+    },
+  },
+  cg: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        function: /^\s*(?!(?:if|for|while|switch|else|return|do|case|default)\b)(?:[A-Za-z_]\w*[\s*&]+){1,8}([A-Za-z_]\w*)\s*\(/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+        constant: /^\s*#\s*define\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*#\s*include\s+[<"]([^>"]+)[>"]/ },
+      skipCallObjects: ["UNITY_MATRIX_MVP", "_Time", "_WorldSpaceCameraPos"],
+    },
+  },
+  hcl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        resource: /^\s*resource\s+"[^"]+"\s+"([^"]+)"/,
+        data: /^\s*data\s+"[^"]+"\s+"([^"]+)"/,
+        variable: /^\s*variable\s+"([^"]+)"/,
+        module: /^\s*module\s+"([^"]+)"/,
+        output: /^\s*output\s+"([^"]+)"/,
+        provider: /^\s*provider\s+"([^"]+)"/,
+      },
+      relationships: { import: /^\s*source\s*=\s*"([^"]+)"/ },
+      skipCallObjects: [],
+    },
+  },
+  cmake: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*function\s*\(\s*([A-Za-z_]\w*)/i,
+        macro: /^\s*macro\s*\(\s*([A-Za-z_]\w*)/i,
+        constant: /^\s*set\s*\(\s*([A-Za-z_]\w*)/i,
+      },
+      relationships: { import: /^\s*(?:include|add_subdirectory|find_package)\s*\(\s*([A-Za-z_0-9./${}-]+)/i },
+      skipCallObjects: [],
+    },
+  },
+  gradle: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        task: /^\s*task\s+([A-Za-z_]\w*)/,
+        def: /^\s*def\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*import\s+([\w.]+)/ },
+      skipCallObjects: [],
+    },
+  },
+  starlark: {
+    indentBased: true, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*def\s+([A-Za-z_]\w*)/,
+        rule: /^\s*([A-Za-z_]\w*)\s*=\s*(?:rule|provider|aspect|repository_rule|tag_class|module_extension)\s*\(/,
+      },
+      relationships: { import: /^\s*load\s*\(\s*["']([^"']+)["']/ },
+      skipCallObjects: [],
+    },
+  },
+  ql: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        class: /^\s*(?:abstract\s+|final\s+|private\s+|library\s+|deprecated\s+|additional\s+|external\s+|extensible\s+)*class\s+([A-Za-z_]\w*)/,
+        function: /^\s*(?:abstract\s+|cached\s+|private\s+|final\s+|override\s+|additional\s+|deprecated\s+|library\s+|external\s+|extensible\s+|pragma\s*\[[^\]]*\]\s+|bindingset\s*\[[^\]]*\]\s+)*(?!(?:and|or|not|if|then|else|in|exists|forall|forex|count|sum|strictsum|strictcount|any|none|select|where|from|instanceof)\b)(?:[A-Za-z_][\w.]*)\s+([a-z_]\w*)\s*\(/,
+        module: /^\s*(?:private\s+|library\s+)*module\s+([A-Za-z_]\w*)/,
+        type: /^\s*newtype\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {
+        import: /^\s*(?:private\s+)?import\s+([\w.]+)/,
+        extends: /\bclass\s+\w+\s+extends\s+([\w.]+)/,
+      },
+      skipCallObjects: [],
+    },
+  },
+  systemrdl: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "//", block: ["/*", "*/"] },
+    graph: {
+      entities: {
+        addrmap: /^\s*addrmap\s+([A-Za-z_]\w*)/,
+        regfile: /^\s*regfile\s+([A-Za-z_]\w*)/,
+        reg: /^\s*reg\s+([A-Za-z_]\w*)/,
+        field: /^\s*field\s+([A-Za-z_]\w*)/,
+        mem: /^\s*mem\s+([A-Za-z_]\w*)/,
+        signal: /^\s*signal\s+([A-Za-z_]\w*)/,
+        enum: /^\s*enum\s+([A-Za-z_]\w*)/,
+        struct: /^\s*struct\s+([A-Za-z_]\w*)/,
+      },
+      relationships: {},
+      skipCallObjects: [],
+    },
+  },
+  zeek: {
+    indentBased: false, endKeyword: null,
+    comment: { line: "#", block: null },
+    graph: {
+      entities: {
+        function: /^\s*function\s+([A-Za-z_][\w:]*)/,
+        event: /^\s*event\s+([A-Za-z_][\w:]*)/,
+        hook: /^\s*hook\s+([A-Za-z_][\w:]*)/,
+        global: /^\s*global\s+(?!function\b|event\b|hook\b)([A-Za-z_]\w*)/,
+        constant: /^\s*const\s+([A-Za-z_]\w*)/,
+        type: /^\s*type\s+([A-Za-z_]\w*)/,
+        module: /^\s*module\s+([A-Za-z_]\w*)/,
+      },
+      relationships: { import: /^\s*@load\s+([\w./-]+)/ },
+      skipCallObjects: [],
+    },
+  },
+  embedded_template: {
+    indentBased: false, endKeyword: null,
+    comment: { line: null, block: ["<%#", "%>"] },
+    graph: {
+      entities: {},
+      relationships: { include: /<%[-=]?\s*include\s*\(\s*['"`]([^'"`]+)['"`]/ },
+      skipCallObjects: [],
+    },
+  },
   // ─── Solidity ────────────────────────────────────────────────────────────────
   // Real chunking is done by tree-sitter-solidity (GRAMMAR_MAP); these regex
   // patterns are the fallback used only when tree-sitter is unavailable.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sweet-search",
-  "version": "2.6.4",
+  "version": "2.6.7",
   "description": "Sweet Search - SOTA Hybrid Code Search Engine with WASM CatBoost Query Router, Semantic/Lexical/Structural Search, and Multilingual Support",
   "type": "module",
   "main": "core/search/sweet-search.js",
@@ -167,13 +167,13 @@
     "vitest": "^4.0.16"
   },
   "optionalDependencies": {
-    "@sweet-search/native-darwin-arm64": "2.6.4",
-    "@sweet-search/native-darwin-x64": "2.6.4",
-    "@sweet-search/native-linux-arm64-gnu": "2.6.4",
-    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.4",
-    "@sweet-search/native-linux-x64-gnu": "2.6.4",
-    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.4",
-    "@sweet-search/bg-priority": "2.6.4"
+    "@sweet-search/native-darwin-arm64": "2.6.7",
+    "@sweet-search/native-darwin-x64": "2.6.7",
+    "@sweet-search/native-linux-arm64-gnu": "2.6.7",
+    "@sweet-search/native-linux-arm64-gnu-cuda": "2.6.7",
+    "@sweet-search/native-linux-x64-gnu": "2.6.7",
+    "@sweet-search/native-linux-x64-gnu-cuda": "2.6.7",
+    "@sweet-search/bg-priority": "2.6.7"
   },
   "engines": {
     "node": ">=18.0.0"