d365fo-mcp 1.17.0 → 1.17.2

package/dist/config/settings.js

@@ -87,6 +87,19 @@ export const SETTINGS = [
             'which volume that is depends on the VM image (K:, C:, J:, …).',
         placeholder: 'C:\\AOSService\\PackagesLocalDirectory',
     },
+    {
+        path: 'environment.scanDrives',
+        env: 'D365FO_SCAN_DRIVES',
+        section: 'environment',
+        tier: 'advanced',
+        type: 'string',
+        label: 'Drive letters probed for AosService',
+        description: 'Comma-separated letters the packages-root scan probes when no packagePath is configured, e.g. "C,K". ' +
+            'Empty probes C: to Z: — the letters that have ever held AosService first, the rest inside a 2 s budget. ' +
+            'Set it on a machine with a disconnected mapped network drive: one stat on such a drive stalls for the ' +
+            'SMB timeout, and the scan runs on the first tool call of a session.',
+        placeholder: 'C,K',
+    },
     {
         path: 'environment.customModels',
         env: 'CUSTOM_MODELS',

package/dist/index.js

@@ -15,6 +15,7 @@ import { createXppMcpServer } from './server/mcpServer.js';
 import { createStreamableHttpTransport } from './server/transport.js';
 import { XppSymbolIndex } from './metadata/symbolIndex.js';
 import { shouldWarmIndexes, warmIndexes, renderWarmupReport } from './metadata/indexWarmup.js';
+import { canIndexOffThread, indexMetadataOffThread } from './metadata/startupIndexing.js';
 import { XppMetadataParser } from './metadata/xmlParser.js';
 import { WorkspaceScanner } from './workspace/workspaceScanner.js';
 import { HybridSearch } from './workspace/hybridSearch.js';
@@ -300,8 +301,15 @@ async function initializeServices() {
             log.warn('No symbols found in database — run `npm run index-metadata` first');
             log.detail('or set METADATA_PATH and the server will index on startup');
             // If metadata path exists, index it
+            let metadataAccessible = false;
             try {
                 await fs.access(METADATA_PATH);
+                metadataAccessible = true;
+            }
+            catch {
+                log.warn('Metadata path not accessible — starting with empty index');
+            }
+            if (metadataAccessible) {
                 log.step(`Indexing metadata from ${METADATA_PATH}` + glyph.ellipsis);
                 serverState.statusMessage = 'Indexing metadata...';
                 const modelNamesStr = process.env.CUSTOM_MODELS || 'CustomModel';
@@ -310,11 +318,31 @@ async function initializeServices() {
                 // Single pass over all requested models — the FTS index is rebuilt once at the
                 // end of the call, so looping per model would repeat a full-table rebuild.
                 log.detail(`indexing ${modelNames.join(', ')}` + glyph.ellipsis);
-                await symbolIndex.indexMetadataDirectory(METADATA_PATH, modelNames);
-                log.ok(`Indexed ${symbolIndex.getSymbolCount().toLocaleString('en-US')} symbols from ${modelNames.length} model(s)`);
-            }
-            catch {
-                log.warn('Metadata path not accessible — starting with empty index');
+                try {
+                    if (canIndexOffThread(DB_PATH, LABELS_DB_PATH)) {
+                        // On a worker thread: the build is synchronous end to end, and inline
+                        // it blocked the event loop for its whole duration — every tool call,
+                        // get_workspace_info included, hung until it finished. dbReady is still
+                        // held until it completes, so symbol-backed tools keep answering "still
+                        // loading" rather than returning empty results; the loop stays free.
+                        const { elapsedMs } = await indexMetadataOffThread({
+                            dbPath: DB_PATH,
+                            labelsDbPath: LABELS_DB_PATH,
+                            metadataPath: METADATA_PATH,
+                            modelNames,
+                            output: process.stderr,
+                        });
+                        log.detail(`indexed in ${(elapsedMs / 1000).toFixed(1)}s on a worker thread`);
+                    }
+                    else {
+                        await symbolIndex.indexMetadataDirectory(METADATA_PATH, modelNames);
+                    }
+                    log.ok(`Indexed ${symbolIndex.getSymbolCount().toLocaleString('en-US')} symbols from ${modelNames.length} model(s)`);
+                }
+                catch (error) {
+                    log.warn(`Metadata indexing failed — starting with empty index: ${error}`);
+                    log.detail('run `npm run index-metadata` to build the database');
+                }
             }
         }
         else {

package/dist/metadata/startupIndexWorker.d.ts

@@ -0,0 +1,37 @@
+/**
+ * First-start metadata indexing, off the main thread.
+ *
+ * When the server starts with an empty symbol database and METADATA_PATH set,
+ * it indexes the requested models before it declares itself ready. That build
+ * is synchronous end to end — a recursive readdirSync per model, node:sqlite
+ * inserts, one FTS rebuild — and inline on the main thread it blocked the
+ * event loop for the whole duration: every tool call, get_workspace_info
+ * included, hung until the build finished, on exactly the machine where the
+ * user was trying the server for the first time.
+ *
+ * Here the same XppSymbolIndex.indexMetadataDirectory runs on its own
+ * connection. WAL mode lets the main thread keep serving from the same file —
+ * the startup path never takes the EXCLUSIVE lock the build scripts use, so
+ * the two connections coexist — and the main thread sees each model as its
+ * transaction commits.
+ *
+ * Spawned by indexMetadataOffThread() (startupIndexing.ts) and posts:
+ *   { type: 'done', elapsedMs, symbolCount } | { type: 'error', error }
+ *
+ * Bundled by build:scripts beside the other workers (tests/packaging/workerBundles).
+ */
+export interface StartupIndexWorkerData {
+    dbPath: string;
+    labelsDbPath: string;
+    metadataPath: string;
+    modelNames: string[];
+}
+export type StartupIndexMessage = {
+    type: 'done';
+    elapsedMs: number;
+    symbolCount: number;
+} | {
+    type: 'error';
+    error: string;
+};
+//# sourceMappingURL=startupIndexWorker.d.ts.map

package/dist/metadata/startupIndexWorker.js

@@ -0,0 +1,43 @@
+/**
+ * First-start metadata indexing, off the main thread.
+ *
+ * When the server starts with an empty symbol database and METADATA_PATH set,
+ * it indexes the requested models before it declares itself ready. That build
+ * is synchronous end to end — a recursive readdirSync per model, node:sqlite
+ * inserts, one FTS rebuild — and inline on the main thread it blocked the
+ * event loop for the whole duration: every tool call, get_workspace_info
+ * included, hung until the build finished, on exactly the machine where the
+ * user was trying the server for the first time.
+ *
+ * Here the same XppSymbolIndex.indexMetadataDirectory runs on its own
+ * connection. WAL mode lets the main thread keep serving from the same file —
+ * the startup path never takes the EXCLUSIVE lock the build scripts use, so
+ * the two connections coexist — and the main thread sees each model as its
+ * transaction commits.
+ *
+ * Spawned by indexMetadataOffThread() (startupIndexing.ts) and posts:
+ *   { type: 'done', elapsedMs, symbolCount } | { type: 'error', error }
+ *
+ * Bundled by build:scripts beside the other workers (tests/packaging/workerBundles).
+ */
+import { parentPort, workerData } from 'node:worker_threads';
+import { XppSymbolIndex } from './symbolIndex.js';
+const data = workerData;
+async function run() {
+    const started = Date.now();
+    // backgroundIndexBuilds: false — this thread IS the background; nesting a
+    // second worker per file-path index buys nothing and complicates shutdown.
+    const index = new XppSymbolIndex(data.dbPath, data.labelsDbPath, { backgroundIndexBuilds: false });
+    try {
+        await index.indexMetadataDirectory(data.metadataPath, data.modelNames);
+        const symbolCount = index.getSymbolCount();
+        parentPort.postMessage({ type: 'done', elapsedMs: Date.now() - started, symbolCount });
+    }
+    finally {
+        index.close();
+    }
+}
+run().catch(e => {
+    parentPort.postMessage({ type: 'error', error: String(e?.stack ?? e) });
+});
+//# sourceMappingURL=startupIndexWorker.js.map

package/dist/metadata/startupIndexing.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Run the first-start metadata index in a worker thread and wait for it.
+ *
+ * See startupIndexWorker.ts for why. The parent side is thin: it spawns the
+ * worker, routes its console output where the caller says (stderr in stdio
+ * mode — stdout is the MCP protocol channel there), and settles once with the
+ * worker's result. It still WAITS: the caller holds dbReady until the index is
+ * populated, so tools that need symbols keep getting the "still loading"
+ * answer instead of silently empty results — the difference is that the event
+ * loop is free meanwhile, so the tools that need no symbols answer at once.
+ */
+import type { StartupIndexWorkerData } from './startupIndexWorker.js';
+export interface StartupIndexOptions extends StartupIndexWorkerData {
+    /** Injected in tests; the real one resolves next to the compiled worker. */
+    workerUrl?: URL;
+    /** Where the worker's stdout/stderr go. Defaults to the parent's stderr. */
+    output?: NodeJS.WritableStream;
+    /**
+     * Heap cap for the worker. A worker's default old-generation limit is derived
+     * from the parent's, which is sized for serving, not for indexing.
+     */
+    maxOldGenerationSizeMb?: number;
+}
+export interface StartupIndexResult {
+    elapsedMs: number;
+    symbolCount: number;
+}
+/** In-memory databases cannot be shared with a worker — the caller indexes inline. */
+export declare function canIndexOffThread(dbPath: string, labelsDbPath: string): boolean;
+export declare function indexMetadataOffThread(opts: StartupIndexOptions): Promise<StartupIndexResult>;
+//# sourceMappingURL=startupIndexing.d.ts.map

package/dist/metadata/startupIndexing.js

@@ -0,0 +1,66 @@
+/**
+ * Run the first-start metadata index in a worker thread and wait for it.
+ *
+ * See startupIndexWorker.ts for why. The parent side is thin: it spawns the
+ * worker, routes its console output where the caller says (stderr in stdio
+ * mode — stdout is the MCP protocol channel there), and settles once with the
+ * worker's result. It still WAITS: the caller holds dbReady until the index is
+ * populated, so tools that need symbols keep getting the "still loading"
+ * answer instead of silently empty results — the difference is that the event
+ * loop is free meanwhile, so the tools that need no symbols answer at once.
+ */
+import { Worker } from 'node:worker_threads';
+/** In-memory databases cannot be shared with a worker — the caller indexes inline. */
+export function canIndexOffThread(dbPath, labelsDbPath) {
+    return dbPath !== ':memory:' && labelsDbPath !== ':memory:';
+}
+export function indexMetadataOffThread(opts) {
+    const url = opts.workerUrl ?? new URL('./startupIndexWorker.js', import.meta.url);
+    const output = opts.output ?? process.stderr;
+    const workerData = {
+        dbPath: opts.dbPath,
+        labelsDbPath: opts.labelsDbPath,
+        metadataPath: opts.metadataPath,
+        modelNames: opts.modelNames,
+    };
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            fn();
+        };
+        let worker;
+        try {
+            worker = new Worker(url, {
+                workerData,
+                // Own the streams: with the defaults a worker's stdout is piped straight
+                // into the parent's stdout, which in stdio mode is the protocol channel.
+                stdout: true,
+                stderr: true,
+                resourceLimits: { maxOldGenerationSizeMb: opts.maxOldGenerationSizeMb ?? 4096 },
+            });
+        }
+        catch (e) {
+            reject(e instanceof Error ? e : new Error(String(e)));
+            return;
+        }
+        worker.stdout.pipe(output, { end: false });
+        worker.stderr.pipe(output, { end: false });
+        worker.on('message', (msg) => {
+            if (msg.type === 'done') {
+                settle(() => resolve({ elapsedMs: msg.elapsedMs, symbolCount: msg.symbolCount }));
+                void worker.terminate();
+            }
+            else if (msg.type === 'error') {
+                settle(() => reject(new Error(msg.error)));
+                void worker.terminate();
+            }
+        });
+        worker.once('error', e => settle(() => reject(e)));
+        // A promise settles once — this covers "exited before the done message".
+        worker.once('exit', code => settle(() => reject(new Error(`startup index worker exited with code ${code}`))));
+    });
+}
+//# sourceMappingURL=startupIndexing.js.map

package/dist/scripts/build-database.js

@@ -34,6 +34,16 @@ var SETTINGS = [
     description: "AOT packages folder (PackagesLocalDirectory) used as the read-only source for indexing. Machine-wide on a traditional VM; UDE resolves it from the XPP config instead. Left empty, the server scans the machine's drives for AosService\\PackagesLocalDirectory \u2014 which volume that is depends on the VM image (K:, C:, J:, \u2026).",
     placeholder: "C:\\AOSService\\PackagesLocalDirectory"
   },
+  {
+    path: "environment.scanDrives",
+    env: "D365FO_SCAN_DRIVES",
+    section: "environment",
+    tier: "advanced",
+    type: "string",
+    label: "Drive letters probed for AosService",
+    description: 'Comma-separated letters the packages-root scan probes when no packagePath is configured, e.g. "C,K". Empty probes C: to Z: \u2014 the letters that have ever held AosService first, the rest inside a 2 s budget. Set it on a machine with a disconnected mapped network drive: one stat on such a drive stalls for the SMB timeout, and the scan runs on the first tool call of a session.',
+    placeholder: "C,K"
+  },
   {
     path: "environment.customModels",
     env: "CUSTOM_MODELS",
@@ -5394,6 +5404,15 @@ import * as fs6 from "fs";
 var FALLBACK_PACKAGES_ROOT = "C:\\AosService\\PackagesLocalDirectory";
 var PREFERRED_DRIVES = ["C", "K", "J", "I"];
 var SCANNED_DRIVES = "CDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+var DRIVE_SCAN_BUDGET_MS = 2e3;
+var SLOW_PROBE_MS = 1e3;
+var lastReport = null;
+function driveLettersToProbe(pinnedSpec) {
+  const pinned = (pinnedSpec ?? "").toUpperCase().split(/[,;\s]+/).map((s) => s.replace(/[:\\/]/g, "")).filter((l) => /^[C-Z]$/.test(l));
+  if (pinned.length > 0) return { letters: [...new Set(pinned)], pinned: true };
+  const rest = SCANNED_DRIVES.filter((l) => !PREFERRED_DRIVES.includes(l));
+  return { letters: [...PREFERRED_DRIVES, ...rest], pinned: false };
+}
 var realIo = {
   // Read through to process.platform on every access rather than snapshotting it
   // at import time — a frozen copy makes the scan ignore a platform override, so
@@ -5423,20 +5442,34 @@ function plausibility(root, io) {
   if (entries.some((e) => e.toLowerCase() === "bin")) return 2;
   return 1;
 }
-function scanPackagesRoots(io = realIo) {
+function scanPackagesRoots(io = realIo, opts = {}) {
   if (io.platform !== "win32") return [];
+  const clock = opts.clock ?? Date.now;
+  const budgetMs = opts.budgetMs ?? DRIVE_SCAN_BUDGET_MS;
+  const { letters, pinned } = driveLettersToProbe(opts.drives ?? process.env.D365FO_SCAN_DRIVES);
+  const report = { probed: [], skipped: [], slow: [], pinned };
   const hits = [];
-  for (const letter of SCANNED_DRIVES) {
-    if (!io.isDirectory(`${letter}:\\`)) continue;
-    const root = `${letter}:\\AosService\\PackagesLocalDirectory`;
-    if (!io.isDirectory(root)) continue;
+  const start = clock();
+  for (const letter of letters) {
     const preferred = PREFERRED_DRIVES.indexOf(letter);
+    if (!pinned && preferred === -1 && clock() - start > budgetMs) {
+      report.skipped.push(letter);
+      continue;
+    }
+    const t0 = clock();
+    const root = `${letter}:\\AosService\\PackagesLocalDirectory`;
+    const hit = io.isDirectory(`${letter}:\\`) && io.isDirectory(root);
+    const ms = clock() - t0;
+    report.probed.push(letter);
+    if (ms >= SLOW_PROBE_MS) report.slow.push({ letter, ms });
+    if (!hit) continue;
     hits.push({
       root,
       score: plausibility(root, io),
       rank: preferred === -1 ? PREFERRED_DRIVES.length : preferred
     });
   }
+  lastReport = report;
   return hits.sort((a, b) => b.score - a.score || a.rank - b.rank || a.root.localeCompare(b.root)).map((hit) => hit.root);
 }
 var cached = null;

package/dist/scripts/build-fts.js

@@ -34,6 +34,16 @@ var SETTINGS = [
     description: "AOT packages folder (PackagesLocalDirectory) used as the read-only source for indexing. Machine-wide on a traditional VM; UDE resolves it from the XPP config instead. Left empty, the server scans the machine's drives for AosService\\PackagesLocalDirectory \u2014 which volume that is depends on the VM image (K:, C:, J:, \u2026).",
     placeholder: "C:\\AOSService\\PackagesLocalDirectory"
   },
+  {
+    path: "environment.scanDrives",
+    env: "D365FO_SCAN_DRIVES",
+    section: "environment",
+    tier: "advanced",
+    type: "string",
+    label: "Drive letters probed for AosService",
+    description: 'Comma-separated letters the packages-root scan probes when no packagePath is configured, e.g. "C,K". Empty probes C: to Z: \u2014 the letters that have ever held AosService first, the rest inside a 2 s budget. Set it on a machine with a disconnected mapped network drive: one stat on such a drive stalls for the SMB timeout, and the scan runs on the first tool call of a session.',
+    placeholder: "C,K"
+  },
   {
     path: "environment.customModels",
     env: "CUSTOM_MODELS",
@@ -5199,6 +5209,15 @@ import * as fs4 from "fs";
 var FALLBACK_PACKAGES_ROOT = "C:\\AosService\\PackagesLocalDirectory";
 var PREFERRED_DRIVES = ["C", "K", "J", "I"];
 var SCANNED_DRIVES = "CDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+var DRIVE_SCAN_BUDGET_MS = 2e3;
+var SLOW_PROBE_MS = 1e3;
+var lastReport = null;
+function driveLettersToProbe(pinnedSpec) {
+  const pinned = (pinnedSpec ?? "").toUpperCase().split(/[,;\s]+/).map((s) => s.replace(/[:\\/]/g, "")).filter((l) => /^[C-Z]$/.test(l));
+  if (pinned.length > 0) return { letters: [...new Set(pinned)], pinned: true };
+  const rest = SCANNED_DRIVES.filter((l) => !PREFERRED_DRIVES.includes(l));
+  return { letters: [...PREFERRED_DRIVES, ...rest], pinned: false };
+}
 var realIo = {
   // Read through to process.platform on every access rather than snapshotting it
   // at import time — a frozen copy makes the scan ignore a platform override, so
@@ -5228,20 +5247,34 @@ function plausibility(root, io) {
   if (entries.some((e) => e.toLowerCase() === "bin")) return 2;
   return 1;
 }
-function scanPackagesRoots(io = realIo) {
+function scanPackagesRoots(io = realIo, opts = {}) {
   if (io.platform !== "win32") return [];
+  const clock = opts.clock ?? Date.now;
+  const budgetMs = opts.budgetMs ?? DRIVE_SCAN_BUDGET_MS;
+  const { letters, pinned } = driveLettersToProbe(opts.drives ?? process.env.D365FO_SCAN_DRIVES);
+  const report = { probed: [], skipped: [], slow: [], pinned };
   const hits = [];
-  for (const letter of SCANNED_DRIVES) {
-    if (!io.isDirectory(`${letter}:\\`)) continue;
-    const root = `${letter}:\\AosService\\PackagesLocalDirectory`;
-    if (!io.isDirectory(root)) continue;
+  const start = clock();
+  for (const letter of letters) {
     const preferred = PREFERRED_DRIVES.indexOf(letter);
+    if (!pinned && preferred === -1 && clock() - start > budgetMs) {
+      report.skipped.push(letter);
+      continue;
+    }
+    const t0 = clock();
+    const root = `${letter}:\\AosService\\PackagesLocalDirectory`;
+    const hit = io.isDirectory(`${letter}:\\`) && io.isDirectory(root);
+    const ms = clock() - t0;
+    report.probed.push(letter);
+    if (ms >= SLOW_PROBE_MS) report.slow.push({ letter, ms });
+    if (!hit) continue;
     hits.push({
       root,
       score: plausibility(root, io),
       rank: preferred === -1 ? PREFERRED_DRIVES.length : preferred
     });
   }
+  lastReport = report;
   return hits.sort((a, b) => b.score - a.score || a.rank - b.rank || a.root.localeCompare(b.root)).map((hit) => hit.root);
 }
 var cached = null;

package/dist/scripts/extract-metadata.js

@@ -34,6 +34,16 @@ var SETTINGS = [
     description: "AOT packages folder (PackagesLocalDirectory) used as the read-only source for indexing. Machine-wide on a traditional VM; UDE resolves it from the XPP config instead. Left empty, the server scans the machine's drives for AosService\\PackagesLocalDirectory \u2014 which volume that is depends on the VM image (K:, C:, J:, \u2026).",
     placeholder: "C:\\AOSService\\PackagesLocalDirectory"
   },
+  {
+    path: "environment.scanDrives",
+    env: "D365FO_SCAN_DRIVES",
+    section: "environment",
+    tier: "advanced",
+    type: "string",
+    label: "Drive letters probed for AosService",
+    description: 'Comma-separated letters the packages-root scan probes when no packagePath is configured, e.g. "C,K". Empty probes C: to Z: \u2014 the letters that have ever held AosService first, the rest inside a 2 s budget. Set it on a machine with a disconnected mapped network drive: one stat on such a drive stalls for the SMB timeout, and the scan runs on the first tool call of a session.',
+    placeholder: "C,K"
+  },
   {
     path: "environment.customModels",
     env: "CUSTOM_MODELS",
@@ -2633,6 +2643,15 @@ import * as fs6 from "fs";
 var FALLBACK_PACKAGES_ROOT = "C:\\AosService\\PackagesLocalDirectory";
 var PREFERRED_DRIVES = ["C", "K", "J", "I"];
 var SCANNED_DRIVES = "CDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+var DRIVE_SCAN_BUDGET_MS = 2e3;
+var SLOW_PROBE_MS = 1e3;
+var lastReport = null;
+function driveLettersToProbe(pinnedSpec) {
+  const pinned = (pinnedSpec ?? "").toUpperCase().split(/[,;\s]+/).map((s) => s.replace(/[:\\/]/g, "")).filter((l) => /^[C-Z]$/.test(l));
+  if (pinned.length > 0) return { letters: [...new Set(pinned)], pinned: true };
+  const rest = SCANNED_DRIVES.filter((l) => !PREFERRED_DRIVES.includes(l));
+  return { letters: [...PREFERRED_DRIVES, ...rest], pinned: false };
+}
 var realIo = {
   // Read through to process.platform on every access rather than snapshotting it
   // at import time — a frozen copy makes the scan ignore a platform override, so
@@ -2662,20 +2681,34 @@ function plausibility(root, io) {
   if (entries.some((e) => e.toLowerCase() === "bin")) return 2;
   return 1;
 }
-function scanPackagesRoots(io = realIo) {
+function scanPackagesRoots(io = realIo, opts = {}) {
   if (io.platform !== "win32") return [];
+  const clock = opts.clock ?? Date.now;
+  const budgetMs = opts.budgetMs ?? DRIVE_SCAN_BUDGET_MS;
+  const { letters, pinned } = driveLettersToProbe(opts.drives ?? process.env.D365FO_SCAN_DRIVES);
+  const report = { probed: [], skipped: [], slow: [], pinned };
   const hits = [];
-  for (const letter of SCANNED_DRIVES) {
-    if (!io.isDirectory(`${letter}:\\`)) continue;
-    const root = `${letter}:\\AosService\\PackagesLocalDirectory`;
-    if (!io.isDirectory(root)) continue;
+  const start = clock();
+  for (const letter of letters) {
     const preferred = PREFERRED_DRIVES.indexOf(letter);
+    if (!pinned && preferred === -1 && clock() - start > budgetMs) {
+      report.skipped.push(letter);
+      continue;
+    }
+    const t0 = clock();
+    const root = `${letter}:\\AosService\\PackagesLocalDirectory`;
+    const hit = io.isDirectory(`${letter}:\\`) && io.isDirectory(root);
+    const ms = clock() - t0;
+    report.probed.push(letter);
+    if (ms >= SLOW_PROBE_MS) report.slow.push({ letter, ms });
+    if (!hit) continue;
     hits.push({
       root,
       score: plausibility(root, io),
       rank: preferred === -1 ? PREFERRED_DRIVES.length : preferred
     });
   }
+  lastReport = report;
   return hits.sort((a, b) => b.score - a.score || a.rank - b.rank || a.root.localeCompare(b.root)).map((hit) => hit.root);
 }
 var cached = null;