d365fo-mcp 1.17.1 → 1.17.3

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';
@@ -103,8 +104,37 @@ console.error = (...args) => {
     const isModuleDebugMessage = /^\[[\w\- ]+\]/.test(firstArg) && !hasErrorIndicator;
     if (!isModuleDebugMessage) {
         originalConsoleError(...args);
+        return;
     }
+    logFileOnly(args);
 };
+/**
+ * Write a line the client never sees to LOG_FILE anyway.
+ *
+ * Both filters below the tee — this one and the stdio console.log redirect — exist
+ * so the MCP client's stderr pane is not a scroll of operational chatter. They were
+ * dropping the line entirely, and since the tee sits on process.stderr, a dropped
+ * line never reached the log file either. So a session that hung for five and a
+ * half minutes on its first call left a log holding a start banner and nothing
+ * else: "Loading symbols…", "Database opened in Xs" and "Database loaded in N ms"
+ * are all log.step/log.ok, all suppressed, all the answer to what it was doing.
+ * Setting DEBUG_LOGGING=true was the only way to see them, and it turns the client
+ * pane into that same scroll. The file is the right place for both.
+ */
+function logFileOnly(args) {
+    if (!_logStream)
+        return;
+    try {
+        // Timestamped, unlike the tee'd lines: these are the progress lines, and the
+        // question they answer ("which phase took the five minutes?") is unanswerable
+        // without the clock. Time only — the banner above carries the date.
+        const at = new Date().toISOString().slice(11, 23);
+        _logStream.write(`[${at}] ` + args.map(a => (typeof a === 'string' ? a : String(a))).join(' ') + '\n');
+    }
+    catch {
+        // Mirroring is best-effort; it must never take down the caller.
+    }
+}
 // ─── Global safety net ────────────────────────────────────────────────────────
 // An unhandled promise rejection terminates the Node process by default
 // (Node ≥15, --unhandled-rejections=throw). In stdio mode that kills the MCP
@@ -300,8 +330,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 +347,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 {
@@ -522,7 +579,12 @@ async function main() {
                 msg.includes('Error') || msg.includes('error') ||
                 msg.includes('Failed') || msg.includes('failed')) {
                 process.stderr.write(msg + '\n');
+                return;
             }
+            // Suppressed from the client's pane, kept in LOG_FILE — see logFileOnly.
+            // This is where every startup progress line goes: log.step/ok/detail are
+            // console.log, and console.log is this function in stdio mode.
+            logFileOnly([msg]);
         };
         console.log = stderrWrite;
         console.info = stderrWrite;

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/metadata/symbolIndex.d.ts

@@ -299,6 +299,15 @@ export declare class XppSymbolIndex {
      *
      * Returns the names of top-level objects that were removed (for cache invalidation).
      */
+    /**
+     * How many regular (non-extension) object names the prefix sample may draw.
+     *
+     * inferPrefixFromObjectNames needs MIN_SAMPLE (4) of them and decides on a 60 %
+     * coverage threshold, so a few dozen settle the question as well as a few hundred
+     * — and this is the band that costs, since a model's extensions are counted in
+     * tens while its classes and tables run to thousands.
+     */
+    private static readonly REGULAR_NAME_SAMPLE;
     /**
      * Top-level object names belonging to one model — the evidence from which a
      * model's naming prefix is inferred (see utils/modelPrefixInference.ts).
@@ -330,6 +339,15 @@ export declare class XppSymbolIndex {
      * so the same model always yields the same sample — a silent, self-reinforcing
      * failure otherwise, since this server writes names with the inferred prefix and
      * those names become evidence for the next inference.
+     *
+     * The regular band is capped well below its share of the budget
+     * (REGULAR_NAME_SAMPLE), because it is the expensive half and the cheap half
+     * carries most of the signal: extensions state the infix outright, while regular
+     * objects only have to clear MIN_SAMPLE (4) and MIN_COVERAGE (60 %) for the
+     * leading token. Reading 400 of them to settle a 4-name question was paid on the
+     * first call of every session. They cannot be dropped altogether — the underscore
+     * form ("ConSK_" vs "ConSK") appears in no extension name, so only a regular
+     * object can decide it.
      */
     getModelObjectNames(model: string, limit?: number): string[];
     removeSymbolsByFile(filePath: string): {

package/dist/metadata/symbolIndex.js

@@ -1243,6 +1243,15 @@ export class XppSymbolIndex {
      *
      * Returns the names of top-level objects that were removed (for cache invalidation).
      */
+    /**
+     * How many regular (non-extension) object names the prefix sample may draw.
+     *
+     * inferPrefixFromObjectNames needs MIN_SAMPLE (4) of them and decides on a 60 %
+     * coverage threshold, so a few dozen settle the question as well as a few hundred
+     * — and this is the band that costs, since a model's extensions are counted in
+     * tens while its classes and tables run to thousands.
+     */
+    static REGULAR_NAME_SAMPLE = 60;
     /**
      * Top-level object names belonging to one model — the evidence from which a
      * model's naming prefix is inferred (see utils/modelPrefixInference.ts).
@@ -1274,6 +1283,15 @@ export class XppSymbolIndex {
      * so the same model always yields the same sample — a silent, self-reinforcing
      * failure otherwise, since this server writes names with the inferred prefix and
      * those names become evidence for the next inference.
+     *
+     * The regular band is capped well below its share of the budget
+     * (REGULAR_NAME_SAMPLE), because it is the expensive half and the cheap half
+     * carries most of the signal: extensions state the infix outright, while regular
+     * objects only have to clear MIN_SAMPLE (4) and MIN_COVERAGE (60 %) for the
+     * leading token. Reading 400 of them to settle a 4-name question was paid on the
+     * first call of every session. They cannot be dropped altogether — the underscore
+     * form ("ConSK_" vs "ConSK") appears in no extension name, so only a regular
+     * object can decide it.
      */
     getModelObjectNames(model, limit = 400) {
         if (!model)
@@ -1285,10 +1303,21 @@ export class XppSymbolIndex {
             if (cap <= 0)
                 return [];
             const rows = db
-                .prepare(`SELECT name FROM symbols
+                .prepare(
+            // Unary + on parent_name, for the same reason as searchCustomExtensions'
+            // `+type IN (…)`: written plainly, `parent_name IS NULL` makes the planner
+            // choose idx_symbols_parent_name, whose ANALYZE stats claim ~13 rows per
+            // value. NULL is not one value — it is every top-level object of every
+            // model, 180,664 of the 1,188,748 rows on the production DB, against 274
+            // for the one model being asked about. Measured warm: 454 ms on the
+            // parent_name plan, 1 ms on the model plan; cold it is the difference
+            // between a 5-minute first get_workspace_info and an instant one.
+            // EXPLAIN QUERY PLAN must keep reporting
+            // `SEARCH symbols USING INDEX idx_symbols_model`.
+            `SELECT name FROM symbols
            WHERE model = ?
              AND type ${extensions ? 'LIKE' : 'NOT LIKE'} '%-extension'
-             ${extensions ? '' : 'AND parent_name IS NULL'}
+             ${extensions ? '' : 'AND +parent_name IS NULL'}
              AND type NOT IN ('method', 'field')
            ORDER BY type, name
            LIMIT ?`)
@@ -1300,7 +1329,7 @@ export class XppSymbolIndex {
         // regular objects before the infix evidence is ever read.
         const half = Math.max(1, Math.ceil(limit / 2));
         const extensionNames = band(true, half);
-        const regularNames = band(false, limit - extensionNames.length);
+        const regularNames = band(false, Math.min(XppSymbolIndex.REGULAR_NAME_SAMPLE, limit - extensionNames.length));
         return [...extensionNames, ...regularNames];
     }
     removeSymbolsByFile(filePath) {

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",
@@ -2261,6 +2271,15 @@ var XppSymbolIndex = class _XppSymbolIndex {
    *
    * Returns the names of top-level objects that were removed (for cache invalidation).
    */
+  /**
+   * How many regular (non-extension) object names the prefix sample may draw.
+   *
+   * inferPrefixFromObjectNames needs MIN_SAMPLE (4) of them and decides on a 60 %
+   * coverage threshold, so a few dozen settle the question as well as a few hundred
+   * — and this is the band that costs, since a model's extensions are counted in
+   * tens while its classes and tables run to thousands.
+   */
+  static REGULAR_NAME_SAMPLE = 60;
   /**
    * Top-level object names belonging to one model — the evidence from which a
    * model's naming prefix is inferred (see utils/modelPrefixInference.ts).
@@ -2292,6 +2311,15 @@ var XppSymbolIndex = class _XppSymbolIndex {
    * so the same model always yields the same sample — a silent, self-reinforcing
    * failure otherwise, since this server writes names with the inferred prefix and
    * those names become evidence for the next inference.
+   *
+   * The regular band is capped well below its share of the budget
+   * (REGULAR_NAME_SAMPLE), because it is the expensive half and the cheap half
+   * carries most of the signal: extensions state the infix outright, while regular
+   * objects only have to clear MIN_SAMPLE (4) and MIN_COVERAGE (60 %) for the
+   * leading token. Reading 400 of them to settle a 4-name question was paid on the
+   * first call of every session. They cannot be dropped altogether — the underscore
+   * form ("ConSK_" vs "ConSK") appears in no extension name, so only a regular
+   * object can decide it.
    */
   getModelObjectNames(model, limit = 400) {
     if (!model) return [];
@@ -2300,10 +2328,20 @@ var XppSymbolIndex = class _XppSymbolIndex {
     const band = (extensions, cap) => {
       if (cap <= 0) return [];
       const rows = db.prepare(
+        // Unary + on parent_name, for the same reason as searchCustomExtensions'
+        // `+type IN (…)`: written plainly, `parent_name IS NULL` makes the planner
+        // choose idx_symbols_parent_name, whose ANALYZE stats claim ~13 rows per
+        // value. NULL is not one value — it is every top-level object of every
+        // model, 180,664 of the 1,188,748 rows on the production DB, against 274
+        // for the one model being asked about. Measured warm: 454 ms on the
+        // parent_name plan, 1 ms on the model plan; cold it is the difference
+        // between a 5-minute first get_workspace_info and an instant one.
+        // EXPLAIN QUERY PLAN must keep reporting
+        // `SEARCH symbols USING INDEX idx_symbols_model`.
         `SELECT name FROM symbols
            WHERE model = ?
              AND type ${extensions ? "LIKE" : "NOT LIKE"} '%-extension'
-             ${extensions ? "" : "AND parent_name IS NULL"}
+             ${extensions ? "" : "AND +parent_name IS NULL"}
              AND type NOT IN ('method', 'field')
            ORDER BY type, name
            LIMIT ?`
@@ -2312,7 +2350,10 @@ var XppSymbolIndex = class _XppSymbolIndex {
     };
     const half = Math.max(1, Math.ceil(limit / 2));
     const extensionNames = band(true, half);
-    const regularNames = band(false, limit - extensionNames.length);
+    const regularNames = band(
+      false,
+      Math.min(_XppSymbolIndex.REGULAR_NAME_SAMPLE, limit - extensionNames.length)
+    );
     return [...extensionNames, ...regularNames];
   }
   removeSymbolsByFile(filePath) {
@@ -5394,6 +5435,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 +5473,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;