@agentllm/codegraph-arkts 0.7.12 → 0.9.4-arkts.0

package/dist/db/sqlite-adapter.d.ts

@@ -1,8 +1,13 @@
 /**
  * SQLite Adapter
  *
- * Provides a unified interface over better-sqlite3 (native) and
- * node-sqlite3-wasm (WASM fallback) for universal cross-platform support.
+ * Thin wrapper over Node's built-in `node:sqlite` (`DatabaseSync`), exposed
+ * through a small better-sqlite3-shaped interface so the rest of the codebase
+ * is storage-agnostic.
+ *
+ * CodeGraph ships with a bundled Node runtime, so `node:sqlite` (real SQLite,
+ * with WAL + FTS5) is always available — there is no native build step and no
+ * wasm fallback. When run from source instead, it requires Node >= 22.5.
  */
 export interface SqliteStatement {
     run(...params: any[]): {
@@ -15,35 +20,24 @@ export interface SqliteStatement {
 export interface SqliteDatabase {
     prepare(sql: string): SqliteStatement;
     exec(sql: string): void;
-    pragma(str: string): any;
+    pragma(str: string, options?: {
+        simple?: boolean;
+    }): any;
     transaction<T>(fn: (...args: any[]) => T): (...args: any[]) => T;
     close(): void;
     readonly open: boolean;
 }
-export type SqliteBackend = 'native' | 'wasm';
 /**
- * One-line summary of the recovery steps shown when WASM fallback is
- * active. Single source of truth so the recipe can't drift between the
- * stderr banner and the MCP status formatter.
+ * The active SQLite backend. Only one now (`node:sqlite`); kept as a named type
+ * so `codegraph status` and the per-instance reporting have a stable shape.
  */
-export declare const WASM_FALLBACK_FIX_RECIPE: string;
+export type SqliteBackend = 'node-sqlite';
 /**
- * Multi-line banner shown to stderr when `createDatabase` falls back to
- * WASM. Replaces a one-line `console.warn` that MCP transports (which
- * take stdout for the protocol) typically swallow, leaving users on a
- * 5-10x slower backend with no signal.
+ * Create a database connection backed by `node:sqlite`.
  *
- * Exported for unit testing — pinning the recipe content prevents
- * future edits from silently stripping the recovery commands.
- */
-export declare function buildWasmFallbackBanner(nativeError?: string): string;
-/**
- * Create a database connection. Tries native better-sqlite3 first,
- * falls back to node-sqlite3-wasm. Returns the active backend
- * alongside the db so each `DatabaseConnection` can report its own
- * backend per-instance — MCP can open multiple project DBs in one
- * process (`tools.ts` getCodeGraph cache), so a process-global would
- * race / overwrite.
+ * Returns the active backend alongside the db so each `DatabaseConnection` can
+ * report it per-instance — MCP can open multiple project DBs in one process, so
+ * a process-global would race.
  */
 export declare function createDatabase(dbPath: string): {
     db: SqliteDatabase;

package/dist/db/sqlite-adapter.js

@@ -2,175 +2,74 @@
 /**
  * SQLite Adapter
  *
- * Provides a unified interface over better-sqlite3 (native) and
- * node-sqlite3-wasm (WASM fallback) for universal cross-platform support.
+ * Thin wrapper over Node's built-in `node:sqlite` (`DatabaseSync`), exposed
+ * through a small better-sqlite3-shaped interface so the rest of the codebase
+ * is storage-agnostic.
+ *
+ * CodeGraph ships with a bundled Node runtime, so `node:sqlite` (real SQLite,
+ * with WAL + FTS5) is always available — there is no native build step and no
+ * wasm fallback. When run from source instead, it requires Node >= 22.5.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WASM_FALLBACK_FIX_RECIPE = void 0;
-exports.buildWasmFallbackBanner = buildWasmFallbackBanner;
 exports.createDatabase = createDatabase;
 /**
- * One-line summary of the recovery steps shown when WASM fallback is
- * active. Single source of truth so the recipe can't drift between the
- * stderr banner and the MCP status formatter.
- */
-exports.WASM_FALLBACK_FIX_RECIPE = '`xcode-select --install` (macOS) or `apt install build-essential` (Debian/Ubuntu), ' +
-    'then `npm rebuild better-sqlite3`, or `npm install better-sqlite3 --save` to force-include it.';
-/**
- * Multi-line banner shown to stderr when `createDatabase` falls back to
- * WASM. Replaces a one-line `console.warn` that MCP transports (which
- * take stdout for the protocol) typically swallow, leaving users on a
- * 5-10x slower backend with no signal.
- *
- * Exported for unit testing — pinning the recipe content prevents
- * future edits from silently stripping the recovery commands.
- */
-function buildWasmFallbackBanner(nativeError) {
-    const sep = '─'.repeat(72);
-    const lines = [
-        sep,
-        '[CodeGraph] WASM SQLite fallback active (better-sqlite3 unavailable)',
-        sep,
-        'Indexing and sync will be 5-10x slower than the native backend.',
-        '',
-        'Fix on macOS:',
-        '  xcode-select --install        # install C build tools',
-        '  npm rebuild better-sqlite3    # rebuild native binding for current Node',
-        '',
-        'Fix on Linux:',
-        '  sudo apt install build-essential python3 make    # Debian/Ubuntu',
-        '  # or: sudo yum groupinstall "Development Tools"  # RHEL/Fedora',
-        '  npm rebuild better-sqlite3',
-        '',
-        'Or force-include as a hard dependency on any platform:',
-        '  npm install better-sqlite3 --save',
-        '',
-        'Verify after fix: `codegraph status` should show `Backend: native`.',
-    ];
-    if (nativeError) {
-        lines.push('', `Native load error: ${nativeError}`);
-    }
-    lines.push(sep);
-    return lines.join('\n');
-}
-/**
- * Translate @named parameters (better-sqlite3 style) to positional ? params
- * for node-sqlite3-wasm, which only supports positional binding.
+ * Wraps Node's built-in `node:sqlite` (`DatabaseSync`) to match the
+ * better-sqlite3 interface the rest of the code expects.
  *
- * Returns the rewritten SQL and an ordered list of parameter names.
- * If no named params are found, returns null for paramOrder (positional mode).
+ * node:sqlite is real SQLite compiled into Node, so it supports WAL, FTS5,
+ * mmap, and `@named` params natively — the only shims needed are the
+ * better-sqlite3 conveniences node:sqlite omits: a `.pragma()` helper, a
+ * `.transaction()` helper, and `open` (node:sqlite exposes `isOpen`).
  */
-function translateNamedParams(sql) {
-    const paramOrder = [];
-    const rewritten = sql.replace(/@(\w+)/g, (_match, name) => {
-        paramOrder.push(name);
-        return '?';
-    });
-    if (paramOrder.length === 0) {
-        return { sql, paramOrder: null };
-    }
-    return { sql: rewritten, paramOrder };
-}
-/**
- * Convert better-sqlite3-style params to a positional array for node-sqlite3-wasm.
- *
- * Handles three calling conventions:
- * - Named object: run({ id: '1', name: 'a' }) → positional array via paramOrder
- * - Positional args: run('a', 'b') → ['a', 'b']
- * - No args: run() → undefined
- */
-function resolveParams(params, paramOrder) {
-    if (params.length === 0)
-        return undefined;
-    // If paramOrder exists and first arg is a plain object, do named→positional translation
-    if (paramOrder && params.length === 1 && params[0] !== null && typeof params[0] === 'object' && !Array.isArray(params[0]) && !(params[0] instanceof Buffer) && !(params[0] instanceof Uint8Array)) {
-        const obj = params[0];
-        return paramOrder.map(name => obj[name]);
-    }
-    // Positional: single value or already an array
-    if (params.length === 1)
-        return params[0];
-    return params;
-}
-/**
- * Wraps node-sqlite3-wasm to match the better-sqlite3 interface.
- *
- * Key differences handled:
- * - better-sqlite3 uses @named params; node-sqlite3-wasm uses positional ? only
- * - better-sqlite3 uses variadic args: stmt.run(a, b, c)
- * - node-sqlite3-wasm uses a single array/object: stmt.run([a, b, c])
- * - node-sqlite3-wasm has `isOpen` instead of `open`
- * - node-sqlite3-wasm doesn't have a `pragma()` method
- * - node-sqlite3-wasm doesn't have a `transaction()` method
- */
-class WasmDatabaseAdapter {
+class NodeSqliteAdapter {
     _db;
-    // Track raw WASM statements so we can finalize them on close.
-    // node-sqlite3-wasm won't release its file lock if statements are left open.
-    _openStmts = new Set();
     constructor(dbPath) {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { Database } = require('node-sqlite3-wasm');
-        this._db = new Database(dbPath);
+        const { DatabaseSync } = require('node:sqlite');
+        this._db = new DatabaseSync(dbPath);
     }
     get open() {
         return this._db.isOpen;
     }
     prepare(sql) {
-        const { sql: rewrittenSql, paramOrder } = translateNamedParams(sql);
-        const stmt = this._db.prepare(rewrittenSql);
-        this._openStmts.add(stmt);
+        // node:sqlite matches better-sqlite3's calling convention (variadic
+        // positional args, or a single object for @named params), so params forward
+        // through unchanged.
+        const stmt = this._db.prepare(sql);
         return {
             run(...params) {
-                const resolved = resolveParams(params, paramOrder);
-                const result = resolved !== undefined ? stmt.run(resolved) : stmt.run();
+                const r = stmt.run(...params);
                 return {
-                    changes: result?.changes ?? 0,
-                    lastInsertRowid: result?.lastInsertRowid ?? 0,
+                    changes: Number(r?.changes ?? 0),
+                    lastInsertRowid: r?.lastInsertRowid ?? 0,
                 };
             },
             get(...params) {
-                const resolved = resolveParams(params, paramOrder);
-                return resolved !== undefined ? stmt.get(resolved) : stmt.get();
+                return stmt.get(...params);
             },
             all(...params) {
-                const resolved = resolveParams(params, paramOrder);
-                return resolved !== undefined ? stmt.all(resolved) : stmt.all();
+                return stmt.all(...params);
             },
         };
     }
     exec(sql) {
         this._db.exec(sql);
     }
-    pragma(str) {
+    pragma(str, options) {
         const trimmed = str.trim();
-        // Write pragma: "key = value"
+        // Write pragma ("key = value"): node:sqlite is real SQLite, so every pragma
+        // (WAL, mmap, synchronous, …) applies as-is.
         if (trimmed.includes('=')) {
-            const eqIdx = trimmed.indexOf('=');
-            const key = trimmed.substring(0, eqIdx).trim();
-            const value = trimmed.substring(eqIdx + 1).trim();
-            // WAL is not supported in WASM SQLite — use DELETE journal mode
-            if (key === 'journal_mode' && value.toUpperCase() === 'WAL') {
-                this._db.exec('PRAGMA journal_mode = DELETE');
-                return;
-            }
-            // mmap is not available in WASM — silently skip
-            if (key === 'mmap_size') {
-                return;
-            }
-            // synchronous = NORMAL is unsafe without WAL — use FULL
-            if (key === 'synchronous' && value.toUpperCase() === 'NORMAL') {
-                this._db.exec('PRAGMA synchronous = FULL');
-                return;
-            }
-            this._db.exec(`PRAGMA ${key} = ${value}`);
+            this._db.exec(`PRAGMA ${trimmed}`);
             return;
         }
-        // Read pragma: "key" — return the value
-        const stmt = this._db.prepare(`PRAGMA ${trimmed}`);
-        const result = stmt.get();
-        stmt.finalize();
-        return result;
+        // Read pragma. Default: the row object (e.g. { journal_mode: 'wal' }).
+        // `{ simple: true }` returns just the single column value, like better-sqlite3.
+        const row = this._db.prepare(`PRAGMA ${trimmed}`).get();
+        if (options?.simple) {
+            return row && typeof row === 'object' ? Object.values(row)[0] : row;
+        }
+        return row;
     }
     transaction(fn) {
         return (...args) => {
@@ -187,51 +86,29 @@ class WasmDatabaseAdapter {
         };
     }
     close() {
-        // Finalize all tracked statements before closing.
-        // node-sqlite3-wasm won't release its directory-based file lock
-        // if any prepared statements remain open.
-        for (const stmt of this._openStmts) {
-            try {
-                stmt.finalize();
-            }
-            catch { /* already finalized */ }
-        }
-        this._openStmts.clear();
-        this._db.close();
+        // node:sqlite's DatabaseSync.close() throws if already closed; make it
+        // idempotent to match better-sqlite3 (callers may close more than once).
+        if (this._db.isOpen)
+            this._db.close();
     }
 }
 /**
- * Create a database connection. Tries native better-sqlite3 first,
- * falls back to node-sqlite3-wasm. Returns the active backend
- * alongside the db so each `DatabaseConnection` can report its own
- * backend per-instance — MCP can open multiple project DBs in one
- * process (`tools.ts` getCodeGraph cache), so a process-global would
- * race / overwrite.
+ * Create a database connection backed by `node:sqlite`.
+ *
+ * Returns the active backend alongside the db so each `DatabaseConnection` can
+ * report it per-instance — MCP can open multiple project DBs in one process, so
+ * a process-global would race.
  */
 function createDatabase(dbPath) {
-    let nativeError;
-    let wasmError;
-    // Try native better-sqlite3 first
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const Database = require('better-sqlite3');
-        const db = new Database(dbPath);
-        return { db: db, backend: 'native' };
-    }
-    catch (error) {
-        nativeError = error instanceof Error ? error.message : String(error);
-    }
-    // Fall back to WASM
     try {
-        const db = new WasmDatabaseAdapter(dbPath);
-        console.warn(buildWasmFallbackBanner(nativeError));
-        return { db, backend: 'wasm' };
+        return { db: new NodeSqliteAdapter(dbPath), backend: 'node-sqlite' };
     }
     catch (error) {
-        wasmError = error instanceof Error ? error.message : String(error);
+        const msg = error instanceof Error ? error.message : String(error);
+        throw new Error('Failed to open SQLite via the built-in node:sqlite module.\n' +
+            'CodeGraph requires node:sqlite (Node.js 22.5+). Install the self-contained\n' +
+            'CodeGraph release (it bundles a compatible Node), or run on Node 22.5+.\n' +
+            `Underlying error: ${msg}`);
     }
-    throw new Error(`Failed to load any SQLite backend.\n` +
-        `  Native (better-sqlite3): ${nativeError}\n` +
-        `  WASM (node-sqlite3-wasm): ${wasmError}`);
 }
 //# sourceMappingURL=sqlite-adapter.js.map

package/dist/extraction/backends/arkts-arkanalyzer/adapter/vendor.js

@@ -37,9 +37,6 @@ exports.ArkAnalyzerScene = exports.ArkAnalyzerSceneConfig = void 0;
 exports.getArkAnalyzerModule = getArkAnalyzerModule;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-// Keep all vendor imports confined to this adapter subtree. Product code outside
-// src/extraction/backends/arkts-arkanalyzer/adapter must not import vendored
-// ArkAnalyzer modules directly.
 function resolveArkAnalyzerEntry() {
     const repoRoot = path.resolve(__dirname, '../../../../../');
     const candidates = [

package/dist/extraction/backends/index.d.ts

@@ -3,5 +3,5 @@ import type { ExtractionBackend, ExtractionRequest } from './types';
 export type { ExtractionBackend, ExtractionRequest } from './types';
 export declare function getExtractionBackends(): readonly ExtractionBackend[];
 export declare function getExtractionBackend(request: ExtractionRequest): ExtractionBackend;
-export declare function extractFromSource(filePath: string, source: string, language?: "arkts" | "typescript" | "javascript" | "tsx" | "jsx" | "python" | "go" | "rust" | "java" | "c" | "cpp" | "csharp" | "php" | "ruby" | "swift" | "kotlin" | "dart" | "svelte" | "vue" | "liquid" | "pascal" | "scala" | "unknown", frameworkNames?: string[]): ExtractionResult;
+export declare function extractFromSource(filePath: string, source: string, language?: "arkts" | "typescript" | "javascript" | "tsx" | "jsx" | "python" | "go" | "rust" | "java" | "c" | "cpp" | "csharp" | "php" | "ruby" | "swift" | "kotlin" | "dart" | "svelte" | "vue" | "liquid" | "pascal" | "scala" | "lua" | "luau" | "yaml" | "twig" | "unknown", frameworkNames?: string[]): ExtractionResult;
 //# sourceMappingURL=index.d.ts.map

package/dist/extraction/backends/index.js

@@ -14,7 +14,9 @@ function getExtractionBackends() {
     return EXTRACTION_BACKENDS;
 }
 function getExtractionBackend(request) {
-    if (request.filePath.toLowerCase().endsWith('/module.json5') || request.filePath.toLowerCase().endsWith('\\module.json5') || request.filePath.toLowerCase() === 'module.json5') {
+    if (request.filePath.toLowerCase().endsWith('/module.json5') ||
+        request.filePath.toLowerCase().endsWith('\\module.json5') ||
+        request.filePath.toLowerCase() === 'module.json5') {
         return backend_1.arktsArkAnalyzerBackend;
     }
     return EXTRACTION_BACKENDS.find((backend) => backend.canHandle(request)) ?? tree_sitter_backend_1.treeSitterBackend;

package/dist/extraction/grammars.d.ts

@@ -5,13 +5,25 @@
  * Grammars are loaded lazily — only languages actually present in the project
  * are compiled, keeping V8 WASM memory pressure low on large codebases.
  */
+import { Parser } from 'web-tree-sitter';
 import { Language } from '../types';
-import type { Parser as WebTreeSitterParser } from 'web-tree-sitter';
-export type GrammarLanguage = Exclude<Language, 'arkts' | 'svelte' | 'vue' | 'liquid' | 'unknown'>;
+export type GrammarLanguage = Exclude<Language, 'arkts' | 'svelte' | 'vue' | 'liquid' | 'yaml' | 'twig' | 'unknown'>;
 /**
  * File extension to Language mapping
  */
 export declare const EXTENSION_MAP: Record<string, Language>;
+/**
+ * Whether a file is one CodeGraph can parse, based purely on its extension.
+ * This is the single source of truth for "should we index this file" — derived
+ * from EXTENSION_MAP so parser support and indexing selection never drift.
+ */
+export declare function isSourceFile(filePath: string): boolean;
+/**
+ * Play Framework routes file: the extensionless `conf/routes` (and included
+ * `conf/*.routes`). No grammar — route extraction is done by the Play framework
+ * resolver, so it's processed through the no-grammar (`yaml`-style) path.
+ */
+export declare function isPlayRoutesFile(filePath: string): boolean;
 /**
  * Initialize the tree-sitter WASM runtime. Must be called before loading grammars.
  * Does NOT load any grammar WASM files — use loadGrammarsForLanguages() for that.
@@ -37,7 +49,7 @@ export declare function isGrammarsInitialized(): boolean;
  * Get a parser for the specified language.
  * Returns synchronously from pre-loaded cache.
  */
-export declare function getParser(language: Language): WebTreeSitterParser | null;
+export declare function getParser(language: Language): Parser | null;
 /**
  * Detect language from file extension
  */

package/dist/extraction/grammars.js

@@ -41,6 +41,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EXTENSION_MAP = void 0;
+exports.isSourceFile = isSourceFile;
+exports.isPlayRoutesFile = isPlayRoutesFile;
 exports.initGrammars = initGrammars;
 exports.loadGrammarsForLanguages = loadGrammarsForLanguages;
 exports.loadAllGrammars = loadAllGrammars;
@@ -55,6 +57,7 @@ exports.clearParserCache = clearParserCache;
 exports.getUnavailableGrammarErrors = getUnavailableGrammarErrors;
 exports.getLanguageDisplayName = getLanguageDisplayName;
 const path = __importStar(require("path"));
+const web_tree_sitter_1 = require("web-tree-sitter");
 /**
  * WASM filename map — maps each language to its .wasm grammar file
  * in the tree-sitter-wasms package.
@@ -78,6 +81,8 @@ const WASM_GRAMMAR_FILES = {
     dart: 'tree-sitter-dart.wasm',
     pascal: 'tree-sitter-pascal.wasm',
     scala: 'tree-sitter-scala.wasm',
+    lua: 'tree-sitter-lua.wasm',
+    luau: 'tree-sitter-luau.wasm',
 };
 /**
  * File extension to Language mapping
@@ -104,6 +109,16 @@ exports.EXTENSION_MAP = {
     '.hxx': 'cpp',
     '.cs': 'csharp',
     '.php': 'php',
+    // Drupal-specific PHP file extensions
+    '.module': 'php',
+    '.install': 'php',
+    '.theme': 'php',
+    '.inc': 'php',
+    // YAML (used for Drupal routing files; no symbol extraction, file-level tracking only)
+    '.yml': 'yaml',
+    '.yaml': 'yaml',
+    // Twig templates (file-level tracking only, no symbol extraction)
+    '.twig': 'twig',
     '.rb': 'ruby',
     '.rake': 'ruby',
     '.swift': 'swift',
@@ -121,7 +136,37 @@ exports.EXTENSION_MAP = {
     '.fmx': 'pascal',
     '.scala': 'scala',
     '.sc': 'scala',
+    '.lua': 'lua',
+    '.luau': 'luau',
 };
+function isHarmonyModuleConfigFile(filePath) {
+    return path.basename(filePath).toLowerCase() === 'module.json5';
+}
+/**
+ * Whether a file is one CodeGraph can parse, based purely on its extension.
+ * This is the single source of truth for "should we index this file" — derived
+ * from EXTENSION_MAP so parser support and indexing selection never drift.
+ */
+function isSourceFile(filePath) {
+    if (isPlayRoutesFile(filePath))
+        return true; // Play `conf/routes` is extensionless
+    if (isHarmonyModuleConfigFile(filePath))
+        return true;
+    const dot = filePath.lastIndexOf('.');
+    if (dot < 0)
+        return false;
+    return filePath.slice(dot).toLowerCase() in exports.EXTENSION_MAP;
+}
+/**
+ * Play Framework routes file: the extensionless `conf/routes` (and included
+ * `conf/*.routes`). No grammar — route extraction is done by the Play framework
+ * resolver, so it's processed through the no-grammar (`yaml`-style) path.
+ */
+function isPlayRoutesFile(filePath) {
+    return (filePath === 'conf/routes' ||
+        filePath.endsWith('/conf/routes') ||
+        filePath.endsWith('.routes'));
+}
 /**
  * Caches for loaded grammars and parsers
  */
@@ -129,9 +174,6 @@ const parserCache = new Map();
 const languageCache = new Map();
 const unavailableGrammarErrors = new Map();
 let parserInitialized = false;
-function getWebTreeSitter() {
-    return require(path.resolve(__dirname, '../../node_modules/web-tree-sitter/tree-sitter.cjs'));
-}
 /**
  * Initialize the tree-sitter WASM runtime. Must be called before loading grammars.
  * Does NOT load any grammar WASM files — use loadGrammarsForLanguages() for that.
@@ -140,8 +182,7 @@ function getWebTreeSitter() {
 async function initGrammars() {
     if (parserInitialized)
         return;
-    const { Parser } = getWebTreeSitter();
-    await Parser.init();
+    await web_tree_sitter_1.Parser.init();
     parserInitialized = true;
 }
 /**
@@ -162,12 +203,15 @@ async function loadGrammarsForLanguages(languages) {
     for (const lang of toLoad) {
         const wasmFile = WASM_GRAMMAR_FILES[lang];
         try {
-            const { Language: TreeSitterLanguage } = getWebTreeSitter();
-            // Pascal and Scala ship their own WASMs (not in tree-sitter-wasms)
-            const wasmPath = (lang === 'pascal' || lang === 'scala')
+            // Some grammars ship their own WASMs (not in tree-sitter-wasms, or the
+            // tree-sitter-wasms build is too old). Lua: tree-sitter-wasms ships an
+            // ABI-13 build that corrupts the shared WASM heap under web-tree-sitter
+            // 0.25 (drops nested calls/imports on every file after the first); we
+            // vendor the upstream ABI-15 wasm instead.
+            const wasmPath = (lang === 'pascal' || lang === 'scala' || lang === 'lua' || lang === 'luau')
                 ? path.join(__dirname, 'wasm', wasmFile)
                 : require.resolve(`tree-sitter-wasms/out/${wasmFile}`);
-            const language = await TreeSitterLanguage.load(wasmPath);
+            const language = await web_tree_sitter_1.Language.load(wasmPath);
             languageCache.set(lang, language);
         }
         catch (error) {
@@ -203,7 +247,7 @@ function getParser(language) {
     if (!lang) {
         return null;
     }
-    const parser = new (getWebTreeSitter().Parser)();
+    const parser = new web_tree_sitter_1.Parser();
     parser.setLanguage(lang);
     parserCache.set(language, parser);
     return parser;
@@ -212,6 +256,12 @@ function getParser(language) {
  * Detect language from file extension
  */
 function detectLanguage(filePath, source) {
+    // Play `conf/routes` has no grammar — route through the no-symbol path; the
+    // Play framework resolver extracts route nodes from it.
+    if (isPlayRoutesFile(filePath))
+        return 'yaml';
+    if (isHarmonyModuleConfigFile(filePath))
+        return 'arkts';
     const ext = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
     const lang = exports.EXTENSION_MAP[ext] || 'unknown';
     // .h files could be C or C++ — check source content for C++ features
@@ -242,6 +292,10 @@ function isLanguageSupported(language) {
         return true; // custom extractor (script block delegation)
     if (language === 'liquid')
         return true; // custom regex extractor
+    if (language === 'yaml')
+        return true; // file-level tracking only; Drupal routing extraction via framework resolver
+    if (language === 'twig')
+        return true; // file-level tracking only
     if (language === 'unknown')
         return false;
     return language in WASM_GRAMMAR_FILES;
@@ -254,6 +308,8 @@ function isGrammarLoaded(language) {
         return true;
     if (language === 'svelte' || language === 'vue' || language === 'liquid')
         return true;
+    if (language === 'yaml' || language === 'twig')
+        return true; // no WASM grammar needed
     return languageCache.has(language);
 }
 /**
@@ -325,6 +381,10 @@ function getLanguageDisplayName(language) {
         liquid: 'Liquid',
         pascal: 'Pascal / Delphi',
         scala: 'Scala',
+        lua: 'Lua',
+        luau: 'Luau',
+        yaml: 'YAML',
+        twig: 'Twig',
         unknown: 'Unknown',
     };
     return names[language] || language;