d365fo-mcp 1.16.0 → 1.16.2

package/dist/metadata/symbolIndex.d.ts

@@ -36,6 +36,35 @@ export interface ExtensionMetadataRecord {
     eventSubscriptions?: string[];
     model: string;
 }
+/**
+ * Construction-time switches for the deferred file_path index builds.
+ *
+ * The defaults describe the long-running server: build in the background, treat
+ * anything over 200 MB as big enough to be worth a thread. A one-shot CLI wants
+ * the opposite of both — see scripts/build-database.ts.
+ */
+export interface XppSymbolIndexOptions {
+    /**
+     * Dispatch large index builds to a worker thread (default true).
+     *
+     * Set false in one-shot scripts. A worker writes through a SECOND connection to
+     * the same file, which cannot coexist with `locking_mode = EXCLUSIVE` on the
+     * writer — the build script takes that lock and the worker (or the writer,
+     * depending on who gets there first) fails with SQLITE_BUSY. Blocking the event
+     * loop, the reason the worker exists at all, costs a CLI nothing.
+     */
+    backgroundIndexBuilds?: boolean;
+    /**
+     * Skip the file_path index builds during construction; the caller runs
+     * ensureFilePathIndexes() itself once its bulk load is done (default false).
+     *
+     * Building them up front makes a bulk load maintain two extra B-trees per row,
+     * and on a full rebuild the work is thrown away by clear() anyway.
+     */
+    deferFilePathIndexes?: boolean;
+    /** Byte size at which a DB is "large" enough to hand its index build to a worker. */
+    largeDbThresholdBytes?: number;
+}
 export declare class XppSymbolIndex {
     db: Database;
     labelsDb: Database;
@@ -54,12 +83,16 @@ export declare class XppSymbolIndex {
     private suggestionNamesCache;
     private symbolsByTermCache;
     private perConnStmtCache;
+    private backgroundIndexBuilds;
+    private deferFilePathIndexes;
+    private largeDbThresholdBytes;
+    private pendingIndexWorkers;
     /**
      * Directory holding the metadata databases. Sibling marker files (the blob-download
      * note, the last-build record) live here so they travel with the index they describe.
      */
     get dataDir(): string;
-    constructor(dbPath: string, labelsDbPath?: string);
+    constructor(dbPath: string, labelsDbPath?: string, options?: XppSymbolIndexOptions);
     /**
      * Returns the next read-only connection from the pool (round-robin).
      * Falls back to the main writer connection when the pool is empty
@@ -69,11 +102,20 @@ export declare class XppSymbolIndex {
      * to benefit from read-pool parallelism and per-connection stmt caching.
      */
     getReadDb(): Database;
+    /** True while a background file_path index build is still running. */
+    hasPendingIndexBuilds(): boolean;
     /**
      * Close and drain all read-pool connections.
      * Must be called before setting locking_mode = EXCLUSIVE on the writer
      * connection (e.g. in build scripts) — SQLite cannot grant EXCLUSIVE while
      * any other connection (even read-only, even in-process) holds a shared lock.
+     *
+     * The read pool is NOT the only other connection this class opens: an index
+     * build dispatched to a worker holds a writer connection to the same file, and
+     * this method cannot drain it (worker shutdown is asynchronous; this is not).
+     * Callers that take an EXCLUSIVE lock must construct with
+     * `backgroundIndexBuilds: false` so no such worker ever exists — the warning
+     * below is the tripwire for the ones that forget.
      */
     closeReadPool(): void;
     /**
@@ -150,11 +192,19 @@ export declare class XppSymbolIndex {
      * build is instant and runs here; on a large existing DB it is handed to a
      * worker thread, and until it finishes those deletes simply stay as slow as
      * they are today.
+     *
+     * Public because build scripts defer it (see XppSymbolIndexOptions) and run it
+     * themselves after their bulk load, with the worker dispatch turned off.
      */
-    private ensureFilePathIndexes;
+    ensureFilePathIndexes(): void;
     /**
      * Build one index on a separate thread so the main event loop keeps serving.
-     * WAL mode allows the worker's write to proceed alongside main-thread readers.
+     *
+     * The worker opens its OWN write connection to the same file, so this is only
+     * legal while the database stays in WAL mode and no one takes an EXCLUSIVE lock
+     * on it for the duration — both guaranteed by the caller (ensureFilePathIndexes
+     * checks the journal mode, and build scripts opt out of workers entirely).
+     *
      * Best-effort: a failure leaves the index absent, which is exactly the state
      * the server ran in before, so it is logged and never thrown.
      */

package/dist/metadata/symbolIndex.js

@@ -77,6 +77,15 @@ export class XppSymbolIndex {
     // Per-connection prepared-statement cache.  Prepared statements are bound to
     // their originating connection and cannot be shared across connections.
     perConnStmtCache = new WeakMap();
+    // See XppSymbolIndexOptions. Held as fields so ensureFilePathIndexes() reads the
+    // same answer whether it runs from the constructor or from a build script later.
+    backgroundIndexBuilds;
+    deferFilePathIndexes;
+    largeDbThresholdBytes;
+    // Index-build workers still running. closeReadPool() cannot drain these (it only
+    // owns the read pool), so track them to warn about the EXCLUSIVE-lock race and to
+    // tear them down in close().
+    pendingIndexWorkers = new Set();
     /**
      * Directory holding the metadata databases. Sibling marker files (the blob-download
      * note, the last-build record) live here so they travel with the index they describe.
@@ -84,8 +93,11 @@ export class XppSymbolIndex {
     get dataDir() {
         return path.dirname(this.dbPath);
     }
-    constructor(dbPath, labelsDbPath) {
+    constructor(dbPath, labelsDbPath, options = {}) {
         this.dbPath = dbPath;
+        this.backgroundIndexBuilds = options.backgroundIndexBuilds !== false;
+        this.deferFilePathIndexes = options.deferFilePathIndexes === true;
+        this.largeDbThresholdBytes = options.largeDbThresholdBytes ?? 200 * 1024 * 1024;
         // Ensure database directory exists
         const dbDir = path.dirname(dbPath);
         if (!fs.existsSync(dbDir)) {
@@ -167,13 +179,29 @@ export class XppSymbolIndex {
             return this.db;
         return this.readPool[this.readPoolRR++ % this.readPool.length];
     }
+    /** True while a background file_path index build is still running. */
+    hasPendingIndexBuilds() {
+        return this.pendingIndexWorkers.size > 0;
+    }
     /**
      * Close and drain all read-pool connections.
      * Must be called before setting locking_mode = EXCLUSIVE on the writer
      * connection (e.g. in build scripts) — SQLite cannot grant EXCLUSIVE while
      * any other connection (even read-only, even in-process) holds a shared lock.
+     *
+     * The read pool is NOT the only other connection this class opens: an index
+     * build dispatched to a worker holds a writer connection to the same file, and
+     * this method cannot drain it (worker shutdown is asynchronous; this is not).
+     * Callers that take an EXCLUSIVE lock must construct with
+     * `backgroundIndexBuilds: false` so no such worker ever exists — the warning
+     * below is the tripwire for the ones that forget.
      */
     closeReadPool() {
+        if (this.pendingIndexWorkers.size > 0) {
+            console.error(`[SymbolIndex] closeReadPool() with ${this.pendingIndexWorkers.size} background index ` +
+                `build(s) still running — these hold their own write connections and will contend ` +
+                `with locking_mode = EXCLUSIVE. Construct with { backgroundIndexBuilds: false }.`);
+        }
         for (const conn of this.readPool) {
             try {
                 conn.close();
@@ -709,7 +737,9 @@ export class XppSymbolIndex {
       CREATE INDEX IF NOT EXISTS idx_md_define ON macro_defines(define_name);
       CREATE INDEX IF NOT EXISTS idx_md_model ON macro_defines(model);
     `);
-        this.ensureFilePathIndexes();
+        if (!this.deferFilePathIndexes) {
+            this.ensureFilePathIndexes();
+        }
     }
     /**
      * The `labels` indexes that exist purely to accelerate reads, keyed by name so
@@ -810,6 +840,9 @@ export class XppSymbolIndex {
      * build is instant and runs here; on a large existing DB it is handed to a
      * worker thread, and until it finishes those deletes simply stay as slow as
      * they are today.
+     *
+     * Public because build scripts defer it (see XppSymbolIndexOptions) and run it
+     * themselves after their bulk load, with the worker dispatch turned off.
      */
     ensureFilePathIndexes() {
         const missing = (db, indexName) => !db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = ?`).get(indexName);
@@ -819,7 +852,7 @@ export class XppSymbolIndex {
             if (dbFile === ':memory:')
                 return false;
             try {
-                return fs.statSync(dbFile).size > 200 * 1024 * 1024;
+                return fs.statSync(dbFile).size > this.largeDbThresholdBytes;
             }
             catch {
                 return false;
@@ -861,7 +894,12 @@ export class XppSymbolIndex {
         // .label.txt (813 on a default build), so building them is instant and needs
         // neither the deferral nor the worker dispatch the per-label table needed.
         for (const item of work) {
-            if (isLarge(item.dbFile)) {
+            // A worker writes through its own connection, which only works while the
+            // database is in WAL mode and nothing holds an EXCLUSIVE lock. Build scripts
+            // switch to journal_mode = MEMORY and take that lock, so the journal mode is
+            // checked here rather than assumed — off WAL the only safe build is inline.
+            const inWal = item.db.pragma('journal_mode', { simple: true }) === 'wal';
+            if (isLarge(item.dbFile) && this.backgroundIndexBuilds && inWal) {
                 this.buildIndexInWorker(item.dbFile, item.sql, item.name);
             }
             else {
@@ -871,7 +909,12 @@ export class XppSymbolIndex {
     }
     /**
      * Build one index on a separate thread so the main event loop keeps serving.
-     * WAL mode allows the worker's write to proceed alongside main-thread readers.
+     *
+     * The worker opens its OWN write connection to the same file, so this is only
+     * legal while the database stays in WAL mode and no one takes an EXCLUSIVE lock
+     * on it for the duration — both guaranteed by the caller (ensureFilePathIndexes
+     * checks the journal mode, and build scripts opt out of workers entirely).
+     *
      * Best-effort: a failure leaves the index absent, which is exactly the state
      * the server ran in before, so it is logged and never thrown.
      */
@@ -880,6 +923,7 @@ export class XppSymbolIndex {
             const worker = new Worker(new URL('./buildIndexWorker.js', import.meta.url), {
                 workerData: { dbPath, sql, indexName },
             });
+            this.pendingIndexWorkers.add(worker);
             // unref() so a pending index build never keeps the process alive on exit.
             worker.unref();
             worker.once('message', (msg) => {
@@ -889,9 +933,14 @@ export class XppSymbolIndex {
                 else {
                     console.error(`[SymbolIndex] Background build of ${indexName} failed: ${msg.error}`);
                 }
+                this.pendingIndexWorkers.delete(worker);
                 void worker.terminate();
             });
-            worker.once('error', e => console.error(`[SymbolIndex] ${indexName} worker error: ${e}`));
+            worker.once('error', e => {
+                this.pendingIndexWorkers.delete(worker);
+                console.error(`[SymbolIndex] ${indexName} worker error: ${e}`);
+            });
+            worker.once('exit', () => this.pendingIndexWorkers.delete(worker));
         }
         catch (e) {
             console.error(`[SymbolIndex] Could not start ${indexName} worker: ${e}`);
@@ -3836,6 +3885,14 @@ export class XppSymbolIndex {
             console.error(`[SymbolIndex] Final labels FTS flush failed: ${e}`);
             this._labelsFtsTimer = null;
         }
+        // Background index builds hold their own write connection to the same file;
+        // leaving one running past close() writes into a database the owner considers
+        // shut. terminate() is async and best-effort — we do not await it, we only stop
+        // the build from outliving us.
+        for (const worker of this.pendingIndexWorkers) {
+            void worker.terminate();
+        }
+        this.pendingIndexWorkers.clear();
         // Drain read pools first — writer close will fail on WAL if readers hold a lock.
         this.closeReadPool();
         this.stmtCache.clear();

package/dist/scripts/build-database.js

@@ -1208,6 +1208,15 @@ var XppSymbolIndex = class _XppSymbolIndex {
   // Per-connection prepared-statement cache.  Prepared statements are bound to
   // their originating connection and cannot be shared across connections.
   perConnStmtCache = /* @__PURE__ */ new WeakMap();
+  // See XppSymbolIndexOptions. Held as fields so ensureFilePathIndexes() reads the
+  // same answer whether it runs from the constructor or from a build script later.
+  backgroundIndexBuilds;
+  deferFilePathIndexes;
+  largeDbThresholdBytes;
+  // Index-build workers still running. closeReadPool() cannot drain these (it only
+  // owns the read pool), so track them to warn about the EXCLUSIVE-lock race and to
+  // tear them down in close().
+  pendingIndexWorkers = /* @__PURE__ */ new Set();
   /**
    * Directory holding the metadata databases. Sibling marker files (the blob-download
    * note, the last-build record) live here so they travel with the index they describe.
@@ -1215,8 +1224,11 @@ var XppSymbolIndex = class _XppSymbolIndex {
   get dataDir() {
     return path.dirname(this.dbPath);
   }
-  constructor(dbPath, labelsDbPath) {
+  constructor(dbPath, labelsDbPath, options = {}) {
     this.dbPath = dbPath;
+    this.backgroundIndexBuilds = options.backgroundIndexBuilds !== false;
+    this.deferFilePathIndexes = options.deferFilePathIndexes === true;
+    this.largeDbThresholdBytes = options.largeDbThresholdBytes ?? 200 * 1024 * 1024;
     const dbDir = path.dirname(dbPath);
     if (!fs2.existsSync(dbDir)) {
       fs2.mkdirSync(dbDir, { recursive: true });
@@ -1281,13 +1293,29 @@ var XppSymbolIndex = class _XppSymbolIndex {
     if (this.readPool.length === 0) return this.db;
     return this.readPool[this.readPoolRR++ % this.readPool.length];
   }
+  /** True while a background file_path index build is still running. */
+  hasPendingIndexBuilds() {
+    return this.pendingIndexWorkers.size > 0;
+  }
   /**
    * Close and drain all read-pool connections.
    * Must be called before setting locking_mode = EXCLUSIVE on the writer
    * connection (e.g. in build scripts) — SQLite cannot grant EXCLUSIVE while
    * any other connection (even read-only, even in-process) holds a shared lock.
+   *
+   * The read pool is NOT the only other connection this class opens: an index
+   * build dispatched to a worker holds a writer connection to the same file, and
+   * this method cannot drain it (worker shutdown is asynchronous; this is not).
+   * Callers that take an EXCLUSIVE lock must construct with
+   * `backgroundIndexBuilds: false` so no such worker ever exists — the warning
+   * below is the tripwire for the ones that forget.
    */
   closeReadPool() {
+    if (this.pendingIndexWorkers.size > 0) {
+      console.error(
+        `[SymbolIndex] closeReadPool() with ${this.pendingIndexWorkers.size} background index build(s) still running \u2014 these hold their own write connections and will contend with locking_mode = EXCLUSIVE. Construct with { backgroundIndexBuilds: false }.`
+      );
+    }
     for (const conn of this.readPool) {
       try {
         conn.close();
@@ -1766,7 +1794,9 @@ var XppSymbolIndex = class _XppSymbolIndex {
       CREATE INDEX IF NOT EXISTS idx_md_define ON macro_defines(define_name);
       CREATE INDEX IF NOT EXISTS idx_md_model ON macro_defines(model);
     `);
-    this.ensureFilePathIndexes();
+    if (!this.deferFilePathIndexes) {
+      this.ensureFilePathIndexes();
+    }
   }
   /**
    * The `labels` indexes that exist purely to accelerate reads, keyed by name so
@@ -1860,13 +1890,16 @@ var XppSymbolIndex = class _XppSymbolIndex {
    * build is instant and runs here; on a large existing DB it is handed to a
    * worker thread, and until it finishes those deletes simply stay as slow as
    * they are today.
+   *
+   * Public because build scripts defer it (see XppSymbolIndexOptions) and run it
+   * themselves after their bulk load, with the worker dispatch turned off.
    */
   ensureFilePathIndexes() {
     const missing = (db, indexName) => !db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = ?`).get(indexName);
     const isLarge = (dbFile) => {
       if (dbFile === ":memory:") return false;
       try {
-        return fs2.statSync(dbFile).size > 200 * 1024 * 1024;
+        return fs2.statSync(dbFile).size > this.largeDbThresholdBytes;
       } catch {
         return false;
       }
@@ -1898,7 +1931,8 @@ var XppSymbolIndex = class _XppSymbolIndex {
       });
     }
     for (const item of work) {
-      if (isLarge(item.dbFile)) {
+      const inWal = item.db.pragma("journal_mode", { simple: true }) === "wal";
+      if (isLarge(item.dbFile) && this.backgroundIndexBuilds && inWal) {
         this.buildIndexInWorker(item.dbFile, item.sql, item.name);
       } else {
         item.db.exec(item.sql);
@@ -1907,7 +1941,12 @@ var XppSymbolIndex = class _XppSymbolIndex {
   }
   /**
    * Build one index on a separate thread so the main event loop keeps serving.
-   * WAL mode allows the worker's write to proceed alongside main-thread readers.
+   *
+   * The worker opens its OWN write connection to the same file, so this is only
+   * legal while the database stays in WAL mode and no one takes an EXCLUSIVE lock
+   * on it for the duration — both guaranteed by the caller (ensureFilePathIndexes
+   * checks the journal mode, and build scripts opt out of workers entirely).
+   *
    * Best-effort: a failure leaves the index absent, which is exactly the state
    * the server ran in before, so it is logged and never thrown.
    */
@@ -1916,6 +1955,7 @@ var XppSymbolIndex = class _XppSymbolIndex {
       const worker = new Worker(new URL("./buildIndexWorker.js", import.meta.url), {
         workerData: { dbPath, sql, indexName }
       });
+      this.pendingIndexWorkers.add(worker);
       worker.unref();
       worker.once("message", (msg) => {
         if (msg.ok) {
@@ -1923,9 +1963,14 @@ var XppSymbolIndex = class _XppSymbolIndex {
         } else {
           console.error(`[SymbolIndex] Background build of ${indexName} failed: ${msg.error}`);
         }
+        this.pendingIndexWorkers.delete(worker);
         void worker.terminate();
       });
-      worker.once("error", (e) => console.error(`[SymbolIndex] ${indexName} worker error: ${e}`));
+      worker.once("error", (e) => {
+        this.pendingIndexWorkers.delete(worker);
+        console.error(`[SymbolIndex] ${indexName} worker error: ${e}`);
+      });
+      worker.once("exit", () => this.pendingIndexWorkers.delete(worker));
     } catch (e) {
       console.error(`[SymbolIndex] Could not start ${indexName} worker: ${e}`);
     }
@@ -4601,6 +4646,10 @@ Point the installation at a drive with room (a full index needs several GB): re-
       console.error(`[SymbolIndex] Final labels FTS flush failed: ${e}`);
       this._labelsFtsTimer = null;
     }
+    for (const worker of this.pendingIndexWorkers) {
+      void worker.terminate();
+    }
+    this.pendingIndexWorkers.clear();
     this.closeReadPool();
     this.stmtCache.clear();
     try {
@@ -7140,7 +7189,10 @@ async function buildDatabase() {
   console.log(kv("Labels DB", shortPath(OUTPUT_LABELS_DB)));
   console.log(kv("VACUUM", EXTRACT_MODE === "all" || FORCE_VACUUM ? c.green("enabled") : c.dim("disabled (incremental build)")));
   console.log("");
-  const symbolIndex = new XppSymbolIndex(OUTPUT_DB, OUTPUT_LABELS_DB);
+  const symbolIndex = new XppSymbolIndex(OUTPUT_DB, OUTPUT_LABELS_DB, {
+    backgroundIndexBuilds: false,
+    deferFilePathIndexes: true
+  });
   const extractManifestCustomModels = readExtractedCustomModels(INPUT_PATH);
   if (extractManifestCustomModels !== void 0) {
     symbolIndex.setNonMicrosoftModels(extractManifestCustomModels);
@@ -7345,6 +7397,11 @@ async function buildDatabase() {
     console.log("");
     log.info("Skipping label indexing (INCLUDE_LABELS=false)");
   }
+  console.log("");
+  log.step("Building file_path indexes...");
+  const filePathIdxStart = Date.now();
+  symbolIndex.ensureFilePathIndexes();
+  log.ok(`file_path indexes built in ${((Date.now() - filePathIdxStart) / 1e3).toFixed(2)}s`);
   if (SKIP_FTS) {
     console.log("");
     log.info("Skipping WAL conversion (database will be finalized by build-fts step)");

package/dist/scripts/build-fts.js

@@ -1147,6 +1147,15 @@ var XppSymbolIndex = class _XppSymbolIndex {
   // Per-connection prepared-statement cache.  Prepared statements are bound to
   // their originating connection and cannot be shared across connections.
   perConnStmtCache = /* @__PURE__ */ new WeakMap();
+  // See XppSymbolIndexOptions. Held as fields so ensureFilePathIndexes() reads the
+  // same answer whether it runs from the constructor or from a build script later.
+  backgroundIndexBuilds;
+  deferFilePathIndexes;
+  largeDbThresholdBytes;
+  // Index-build workers still running. closeReadPool() cannot drain these (it only
+  // owns the read pool), so track them to warn about the EXCLUSIVE-lock race and to
+  // tear them down in close().
+  pendingIndexWorkers = /* @__PURE__ */ new Set();
   /**
    * Directory holding the metadata databases. Sibling marker files (the blob-download
    * note, the last-build record) live here so they travel with the index they describe.
@@ -1154,8 +1163,11 @@ var XppSymbolIndex = class _XppSymbolIndex {
   get dataDir() {
     return path.dirname(this.dbPath);
   }
-  constructor(dbPath, labelsDbPath) {
+  constructor(dbPath, labelsDbPath, options = {}) {
     this.dbPath = dbPath;
+    this.backgroundIndexBuilds = options.backgroundIndexBuilds !== false;
+    this.deferFilePathIndexes = options.deferFilePathIndexes === true;
+    this.largeDbThresholdBytes = options.largeDbThresholdBytes ?? 200 * 1024 * 1024;
     const dbDir = path.dirname(dbPath);
     if (!fs2.existsSync(dbDir)) {
       fs2.mkdirSync(dbDir, { recursive: true });
@@ -1220,13 +1232,29 @@ var XppSymbolIndex = class _XppSymbolIndex {
     if (this.readPool.length === 0) return this.db;
     return this.readPool[this.readPoolRR++ % this.readPool.length];
   }
+  /** True while a background file_path index build is still running. */
+  hasPendingIndexBuilds() {
+    return this.pendingIndexWorkers.size > 0;
+  }
   /**
    * Close and drain all read-pool connections.
    * Must be called before setting locking_mode = EXCLUSIVE on the writer
    * connection (e.g. in build scripts) — SQLite cannot grant EXCLUSIVE while
    * any other connection (even read-only, even in-process) holds a shared lock.
+   *
+   * The read pool is NOT the only other connection this class opens: an index
+   * build dispatched to a worker holds a writer connection to the same file, and
+   * this method cannot drain it (worker shutdown is asynchronous; this is not).
+   * Callers that take an EXCLUSIVE lock must construct with
+   * `backgroundIndexBuilds: false` so no such worker ever exists — the warning
+   * below is the tripwire for the ones that forget.
    */
   closeReadPool() {
+    if (this.pendingIndexWorkers.size > 0) {
+      console.error(
+        `[SymbolIndex] closeReadPool() with ${this.pendingIndexWorkers.size} background index build(s) still running \u2014 these hold their own write connections and will contend with locking_mode = EXCLUSIVE. Construct with { backgroundIndexBuilds: false }.`
+      );
+    }
     for (const conn of this.readPool) {
       try {
         conn.close();
@@ -1705,7 +1733,9 @@ var XppSymbolIndex = class _XppSymbolIndex {
       CREATE INDEX IF NOT EXISTS idx_md_define ON macro_defines(define_name);
       CREATE INDEX IF NOT EXISTS idx_md_model ON macro_defines(model);
     `);
-    this.ensureFilePathIndexes();
+    if (!this.deferFilePathIndexes) {
+      this.ensureFilePathIndexes();
+    }
   }
   /**
    * The `labels` indexes that exist purely to accelerate reads, keyed by name so
@@ -1799,13 +1829,16 @@ var XppSymbolIndex = class _XppSymbolIndex {
    * build is instant and runs here; on a large existing DB it is handed to a
    * worker thread, and until it finishes those deletes simply stay as slow as
    * they are today.
+   *
+   * Public because build scripts defer it (see XppSymbolIndexOptions) and run it
+   * themselves after their bulk load, with the worker dispatch turned off.
    */
   ensureFilePathIndexes() {
     const missing = (db, indexName) => !db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = ?`).get(indexName);
     const isLarge = (dbFile) => {
       if (dbFile === ":memory:") return false;
       try {
-        return fs2.statSync(dbFile).size > 200 * 1024 * 1024;
+        return fs2.statSync(dbFile).size > this.largeDbThresholdBytes;
       } catch {
         return false;
       }
@@ -1837,7 +1870,8 @@ var XppSymbolIndex = class _XppSymbolIndex {
       });
     }
     for (const item of work) {
-      if (isLarge(item.dbFile)) {
+      const inWal = item.db.pragma("journal_mode", { simple: true }) === "wal";
+      if (isLarge(item.dbFile) && this.backgroundIndexBuilds && inWal) {
         this.buildIndexInWorker(item.dbFile, item.sql, item.name);
       } else {
         item.db.exec(item.sql);
@@ -1846,7 +1880,12 @@ var XppSymbolIndex = class _XppSymbolIndex {
   }
   /**
    * Build one index on a separate thread so the main event loop keeps serving.
-   * WAL mode allows the worker's write to proceed alongside main-thread readers.
+   *
+   * The worker opens its OWN write connection to the same file, so this is only
+   * legal while the database stays in WAL mode and no one takes an EXCLUSIVE lock
+   * on it for the duration — both guaranteed by the caller (ensureFilePathIndexes
+   * checks the journal mode, and build scripts opt out of workers entirely).
+   *
    * Best-effort: a failure leaves the index absent, which is exactly the state
    * the server ran in before, so it is logged and never thrown.
    */
@@ -1855,6 +1894,7 @@ var XppSymbolIndex = class _XppSymbolIndex {
       const worker = new Worker(new URL("./buildIndexWorker.js", import.meta.url), {
         workerData: { dbPath, sql, indexName }
       });
+      this.pendingIndexWorkers.add(worker);
       worker.unref();
       worker.once("message", (msg) => {
         if (msg.ok) {
@@ -1862,9 +1902,14 @@ var XppSymbolIndex = class _XppSymbolIndex {
         } else {
           console.error(`[SymbolIndex] Background build of ${indexName} failed: ${msg.error}`);
         }
+        this.pendingIndexWorkers.delete(worker);
         void worker.terminate();
       });
-      worker.once("error", (e) => console.error(`[SymbolIndex] ${indexName} worker error: ${e}`));
+      worker.once("error", (e) => {
+        this.pendingIndexWorkers.delete(worker);
+        console.error(`[SymbolIndex] ${indexName} worker error: ${e}`);
+      });
+      worker.once("exit", () => this.pendingIndexWorkers.delete(worker));
     } catch (e) {
       console.error(`[SymbolIndex] Could not start ${indexName} worker: ${e}`);
     }
@@ -4540,6 +4585,10 @@ Point the installation at a drive with room (a full index needs several GB): re-
       console.error(`[SymbolIndex] Final labels FTS flush failed: ${e}`);
       this._labelsFtsTimer = null;
     }
+    for (const worker of this.pendingIndexWorkers) {
+      void worker.terminate();
+    }
+    this.pendingIndexWorkers.clear();
     this.closeReadPool();
     this.stmtCache.clear();
     try {
@@ -5228,7 +5277,10 @@ async function buildFts() {
     console.error('   Run "npm run build-database" (with SKIP_FTS=true) first.');
     process.exit(1);
   }
-  const symbolIndex = new XppSymbolIndex(OUTPUT_DB, OUTPUT_LABELS_DB);
+  const symbolIndex = new XppSymbolIndex(OUTPUT_DB, OUTPUT_LABELS_DB, {
+    backgroundIndexBuilds: false,
+    deferFilePathIndexes: true
+  });
   symbolIndex.closeReadPool();
   symbolIndex.db.pragma("journal_mode = MEMORY");
   symbolIndex.db.pragma("synchronous = OFF");
@@ -5289,6 +5341,10 @@ async function buildFts() {
   } else {
     console.log("\n\u23ED\uFE0F  Skipping label indexing (INCLUDE_LABELS=false)");
   }
+  console.log("\n\u{1F511} Building file_path indexes...");
+  const filePathIdxStart = Date.now();
+  symbolIndex.ensureFilePathIndexes();
+  console.log(`   \u2705 Done in ${((Date.now() - filePathIdxStart) / 1e3).toFixed(2)}s`);
   console.log("\n\u{1F504} Converting databases to WAL mode for production...");
   symbolIndex.db.pragma("locking_mode = NORMAL");
   symbolIndex.db.pragma("journal_mode = WAL");

package/dist/tools/sdlc/sysTestRunner.js

@@ -1,5 +1,5 @@
 import { execFile } from 'child_process';
-import { parseSysTestXml } from '../../eval/oracle/systest.js';
+import { parseSysTestXml } from './sysTestXml.js';
 import util from 'util';
 import path from 'path';
 import os from 'os';

package/dist/tools/sdlc/sysTestXml.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Reader for the `/xml:` result document SysTestConsole writes.
+ *
+ * This lives beside the runner rather than in `src/eval/` because it is loaded
+ * at runtime by `sysTestRunner.ts`, and `src/eval/**` is a dev-only tree that
+ * package.json's `files` list keeps out of the published tarball
+ * (`"!dist/eval/**"`). A shipped module importing across that boundary makes
+ * the installed server fail to start with ERR_MODULE_NOT_FOUND. The eval
+ * oracle re-exports this from `src/eval/oracle/systest.ts`; the dependency
+ * runs eval → tools, never the other way.
+ */
+/** One test method's outcome, read from the runner's XML result document. */
+export interface SysTestCaseOutcome {
+    name: string;
+    passed: boolean;
+    message?: string;
+}
+/**
+ * Per-method outcomes from the `/xml:` document SysTestConsole writes.
+ *
+ * The shape is the platform's own: SysTestListenerXML builds
+ * `<test-results><results><test-case name="…" success="true|false">` and adds a
+ * `<failure><message>…</message></failure>` child for a failing one (the element
+ * names are #define'd at the top of that class). Reading it beats the regex over
+ * combined stdout that the runner used to classify with: a class named
+ * …ErrorHandlingTest made "error" appear in the output of a passing run, and a
+ * green run was reported as failed.
+ *
+ * Returns [] when the text is not such a document, so callers can fall back.
+ */
+export declare function parseSysTestXml(xml: string | null | undefined): SysTestCaseOutcome[];
+//# sourceMappingURL=sysTestXml.d.ts.map

package/dist/tools/sdlc/sysTestXml.js

@@ -0,0 +1,54 @@
+/**
+ * Reader for the `/xml:` result document SysTestConsole writes.
+ *
+ * This lives beside the runner rather than in `src/eval/` because it is loaded
+ * at runtime by `sysTestRunner.ts`, and `src/eval/**` is a dev-only tree that
+ * package.json's `files` list keeps out of the published tarball
+ * (`"!dist/eval/**"`). A shipped module importing across that boundary makes
+ * the installed server fail to start with ERR_MODULE_NOT_FOUND. The eval
+ * oracle re-exports this from `src/eval/oracle/systest.ts`; the dependency
+ * runs eval → tools, never the other way.
+ */
+/**
+ * Per-method outcomes from the `/xml:` document SysTestConsole writes.
+ *
+ * The shape is the platform's own: SysTestListenerXML builds
+ * `<test-results><results><test-case name="…" success="true|false">` and adds a
+ * `<failure><message>…</message></failure>` child for a failing one (the element
+ * names are #define'd at the top of that class). Reading it beats the regex over
+ * combined stdout that the runner used to classify with: a class named
+ * …ErrorHandlingTest made "error" appear in the output of a passing run, and a
+ * green run was reported as failed.
+ *
+ * Returns [] when the text is not such a document, so callers can fall back.
+ */
+export function parseSysTestXml(xml) {
+    if (!xml || !/<test-case\b/i.test(xml))
+        return [];
+    const outcomes = [];
+    // The SELF-CLOSING form has to be tried first. With the paired form leading, its
+    // `[^>]*` happily consumed the `/` of `<test-case … />` and the lazy body then ran
+    // on to the NEXT `</test-case>`, swallowing two results into one.
+    const caseRe = /<test-case\b([^>]*?)\/>|<test-case\b([^>]*)>([\s\S]*?)<\/test-case>/gi;
+    let m;
+    while ((m = caseRe.exec(xml)) !== null) {
+        const attrs = m[1] ?? m[2] ?? '';
+        const body = m[3] ?? '';
+        const name = /\bname\s*=\s*"([^"]*)"/i.exec(attrs)?.[1] ?? '';
+        const successAttr = /\bsuccess\s*=\s*"([^"]*)"/i.exec(attrs)?.[1];
+        const failure = /<failure\b[^>]*>([\s\S]*?)<\/failure>/i.exec(body)?.[1];
+        const message = failure
+            ? (/<message\b[^>]*>([\s\S]*?)<\/message>/i.exec(failure)?.[1] ?? failure)
+                .replace(/<[^>]+>/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim()
+            : undefined;
+        // `success` is authoritative when present; a <failure> child decides otherwise.
+        const passed = successAttr !== undefined
+            ? /^(true|1)$/i.test(successAttr)
+            : failure === undefined;
+        outcomes.push(message ? { name, passed, message } : { name, passed });
+    }
+    return outcomes;
+}
+//# sourceMappingURL=sysTestXml.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "d365fo-mcp",
-  "version": "1.16.0",
+  "version": "1.16.2",
   "description": "MCP Server for X++ Code Completion in D365 Finance & Operations",
   "type": "module",
   "main": "dist/index.js",