@j0hanz/filesystem-mcp 1.1.2 → 1.2.0

package/dist/lib/constants.js

@@ -1,4 +1,11 @@
 import { availableParallelism } from 'node:os';
+const TRUE_ENV_VALUES = new Set(['1', 'true', 'yes', 'y', 'on']);
+const FALSE_ENV_VALUES = new Set(['0', 'false', 'no', 'n', 'off']);
+const KIB = 1024;
+const MIB = 1024 * KIB;
+function logInvalidEnvValue(envVar, value, expected, defaultValue) {
+    console.error(`[WARNING] Invalid ${envVar} value: ${value} (must be ${expected}). Using default: ${String(defaultValue)}`);
+}
 // Helper for parsing environment variables (only used for configurable values)
 function parseEnvInt(envVar, defaultValue, min, max) {
     const value = process.env[envVar];
@@ -6,7 +13,7 @@ function parseEnvInt(envVar, defaultValue, min, max) {
         return defaultValue;
     const parsed = parseInt(value, 10);
     if (Number.isNaN(parsed) || parsed < min || parsed > max) {
-        console.error(`[WARNING] Invalid ${envVar} value: ${value} (must be ${String(min)}-${String(max)}). Using default: ${String(defaultValue)}`);
+        logInvalidEnvValue(envVar, value, `${String(min)}-${String(max)}`, defaultValue);
         return defaultValue;
     }
     return parsed;
@@ -16,25 +23,29 @@ function parseEnvBool(envVar, defaultValue) {
     if (value === undefined)
         return defaultValue;
     const normalized = value.trim().toLowerCase();
-    if (['1', 'true', 'yes', 'y', 'on'].includes(normalized))
+    if (TRUE_ENV_VALUES.has(normalized))
         return true;
-    if (['0', 'false', 'no', 'n', 'off'].includes(normalized))
+    if (FALSE_ENV_VALUES.has(normalized))
         return false;
-    console.error(`[WARNING] Invalid ${envVar} value: ${value} (must be true/false). Using default: ${String(defaultValue)}`);
+    logInvalidEnvValue(envVar, value, 'true/false', defaultValue);
     return defaultValue;
 }
 function parseEnvList(envVar) {
     const value = process.env[envVar];
     if (!value)
         return [];
-    return value
-        .split(/[,\n]/u)
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0);
+    const entries = [];
+    for (const token of value.split(/[,\n]/u)) {
+        const trimmed = token.trim();
+        if (trimmed.length > 0) {
+            entries.push(trimmed);
+        }
+    }
+    return entries;
 }
 // Auto-tuned parallelism based on CPU cores (no env override)
-const BYTES_PER_PARALLEL_TASK = 64 * 1024 * 1024;
-const BYTES_PER_SEARCH_WORKER = 128 * 1024 * 1024;
+const BYTES_PER_PARALLEL_TASK = 64 * MIB;
+const BYTES_PER_SEARCH_WORKER = 128 * MIB;
 function getAvailableMemory() {
     if (typeof process.availableMemory !== 'function')
         return undefined;
@@ -61,9 +72,9 @@ function getDefaultSearchWorkers() {
 // Hardcoded optimal values (no env override needed)
 export const PARALLEL_CONCURRENCY = getOptimalParallelism();
 // Configurable via environment variables
-export const MAX_SEARCHABLE_FILE_SIZE = parseEnvInt('MAX_SEARCH_SIZE', 1024 * 1024, 100 * 1024, 10 * 1024 * 1024);
-export const MAX_TEXT_FILE_SIZE = parseEnvInt('MAX_FILE_SIZE', 10 * 1024 * 1024, 1024 * 1024, 100 * 1024 * 1024);
-export const DEFAULT_READ_MANY_MAX_TOTAL_SIZE = parseEnvInt('MAX_READ_MANY_TOTAL_SIZE', 512 * 1024, 10 * 1024, 100 * 1024 * 1024);
+export const MAX_SEARCHABLE_FILE_SIZE = parseEnvInt('MAX_SEARCH_SIZE', MIB, 100 * KIB, 10 * MIB);
+export const MAX_TEXT_FILE_SIZE = parseEnvInt('MAX_FILE_SIZE', 10 * MIB, MIB, 100 * MIB);
+export const DEFAULT_READ_MANY_MAX_TOTAL_SIZE = parseEnvInt('MAX_READ_MANY_TOTAL_SIZE', 512 * KIB, 10 * KIB, 100 * MIB);
 export const DEFAULT_SEARCH_TIMEOUT_MS = parseEnvInt('DEFAULT_SEARCH_TIMEOUT', 5000, 100, 60000);
 const ALLOW_SENSITIVE_FILES = parseEnvBool('FS_CONTEXT_ALLOW_SENSITIVE', false);
 const ENV_DENYLIST = parseEnvList('FS_CONTEXT_DENYLIST');
@@ -73,7 +84,7 @@ const ENV_ALLOWLIST = parseEnvList('FS_CONTEXT_ALLOWLIST');
  * Default: CPU cores (capped at 8 for optimal I/O performance).
  * Configurable via FS_CONTEXT_SEARCH_WORKERS env var.
  */
-export const SEARCH_WORKERS = parseEnvInt('FS_CONTEXT_SEARCH_WORKERS', getDefaultSearchWorkers(), 0, 16);
+export const SEARCH_WORKERS = parseEnvInt('FS_CONTEXT_SEARCH_WORKERS', getDefaultSearchWorkers(), 1, 16);
 // Hardcoded defaults
 export const DEFAULT_MAX_DEPTH = 10;
 export const DEFAULT_LIST_MAX_ENTRIES = 10000;

package/dist/lib/errors.js

@@ -27,6 +27,9 @@ function getNodeErrno(error) {
         return undefined;
     return errno;
 }
+function messageIncludesAny(message, patterns) {
+    return patterns.some((pattern) => message.includes(pattern));
+}
 const ERRNO_CODE_BY_VALUE = new Map();
 const SYSTEM_ERROR_MAP = getSystemErrorMap();
 for (const [name, value] of Object.entries(osConstants.errno)) {
@@ -187,23 +190,25 @@ const ERROR_SUGGESTIONS = {
     [ErrorCode.E_SYMLINK_NOT_ALLOWED]: 'Symbolic links that escape allowed directories are not permitted for security reasons.',
     [ErrorCode.E_UNKNOWN]: 'An unexpected error occurred. Check the error message for details.',
 };
+const NOT_FOUND_PATTERNS = ['enoent', 'no such file or directory'];
+const PERMISSION_DENIED_PATTERNS = [
+    'permission denied',
+    'not permitted',
+];
 function getDirectErrorCode(error) {
     if (error instanceof McpError) {
         return error.code;
     }
     const code = getNodeErrorCodeLabel(error);
-    if (code) {
-        return getNodeErrorCode(code);
-    }
-    return undefined;
+    return code ? getNodeErrorCode(code) : undefined;
 }
 function classifyMessageError(error) {
     const message = isNativeError(error) ? error.message : String(error);
     const lower = message.toLowerCase();
-    if (lower.includes('enoent') || lower.includes('no such file or directory')) {
+    if (messageIncludesAny(lower, NOT_FOUND_PATTERNS)) {
         return ErrorCode.E_NOT_FOUND;
     }
-    if (lower.includes('permission denied') || lower.includes('not permitted')) {
+    if (messageIncludesAny(lower, PERMISSION_DENIED_PATTERNS)) {
         return ErrorCode.E_PERMISSION_DENIED;
     }
     if (lower.includes('not a directory')) {

package/dist/lib/file-operations/common.d.ts

@@ -0,0 +1,4 @@
+export declare function needsStatsForSort(sortBy: string): boolean;
+export declare function withOptionalStoppedReason<T extends object, R extends string>(summary: T, stoppedReason: R | undefined): T | (T & {
+    stoppedReason: R;
+});

package/dist/lib/file-operations/common.js

@@ -0,0 +1,9 @@
+export function needsStatsForSort(sortBy) {
+    return sortBy === 'size' || sortBy === 'modified';
+}
+export function withOptionalStoppedReason(summary, stoppedReason) {
+    if (stoppedReason === undefined) {
+        return summary;
+    }
+    return { ...summary, stoppedReason };
+}

package/dist/lib/file-operations/file-info.js

@@ -15,6 +15,7 @@ const PERM_STRINGS = [
     'rw-',
     'rwx',
 ];
+const UNKNOWN_PATH = '(unknown)';
 function getPermissions(mode) {
     const ownerIndex = (mode >> 6) & 0b111;
     const groupIndex = (mode >> 3) & 0b111;
@@ -74,14 +75,21 @@ function buildEmptyResult() {
     };
 }
 async function processFileInfo(filePath, options) {
-    const info = await getFileInfo(filePath, {
-        includeMimeType: options.includeMimeType,
-        signal: options.signal,
-    });
+    const info = await getFileInfo(filePath, options);
     return { path: filePath, info };
 }
+function buildIndexedPathTasks(paths) {
+    const tasks = [];
+    for (let index = 0; index < paths.length; index += 1) {
+        const filePath = paths[index];
+        if (filePath === undefined)
+            continue;
+        tasks.push({ filePath, index });
+    }
+    return tasks;
+}
 async function readFileInfoInParallel(paths, options) {
-    return await processInParallel(paths.map((filePath, index) => ({ filePath, index })), async ({ filePath, index }) => ({
+    return processInParallel(buildIndexedPathTasks(paths), async ({ filePath, index }) => ({
         index,
         value: await processFileInfo(filePath, options),
     }), PARALLEL_CONCURRENCY, options.signal);
@@ -94,14 +102,15 @@ function applyResults(output, results) {
 function applyErrors(output, errors, paths) {
     for (const failure of errors) {
         const { index } = failure;
-        if (index < 0 || index >= output.length)
+        if (!isValidOutputIndex(index, output.length))
             continue;
-        if (output[index] === undefined)
-            continue;
-        const filePath = paths[index] ?? '(unknown)';
+        const filePath = paths[index] ?? UNKNOWN_PATH;
         output[index] = { path: filePath, error: failure.error.message };
     }
 }
+function isValidOutputIndex(index, length) {
+    return index >= 0 && index < length;
+}
 function calculateSummary(results) {
     let succeeded = 0;
     let failed = 0;
@@ -125,7 +134,10 @@ function calculateSummary(results) {
 export async function getMultipleFileInfo(paths, options = {}) {
     if (paths.length === 0)
         return buildEmptyResult();
-    const output = paths.map((filePath) => ({ path: filePath }));
+    const output = new Array(paths.length);
+    for (let index = 0; index < paths.length; index += 1) {
+        output[index] = { path: paths[index] ?? UNKNOWN_PATH };
+    }
     const { results, errors } = await readFileInfoInParallel(paths, options);
     applyResults(output, results);
     applyErrors(output, errors, paths);

package/dist/lib/file-operations/gitignore.js

@@ -1,8 +1,17 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import ignore, {} from 'ignore';
-function normalizeToPosixPath(filePath) {
-    return filePath.replace(/\\/gu, '/');
+import { isNodeError } from '../errors.js';
+import { toPosixPath } from '../path-format.js';
+function parseGitignoreLines(contents) {
+    const lines = [];
+    for (const line of contents.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+            lines.push(trimmed);
+        }
+    }
+    return lines;
 }
 export async function loadRootGitignore(root, signal) {
     const gitignorePath = path.join(root, '.gitignore');
@@ -14,26 +23,20 @@ export async function loadRootGitignore(root, signal) {
         });
     }
     catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            error.code === 'ENOENT') {
+        if (isNodeError(error) && error.code === 'ENOENT') {
             return null;
         }
         throw error;
     }
     const matcher = ignore();
-    matcher.add(contents
-        .split(/\r?\n/u)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0));
+    matcher.add(parseGitignoreLines(contents));
     return matcher;
 }
 export function isIgnoredByGitignore(matcher, root, absolutePath, options = {}) {
     const relative = path.relative(root, absolutePath);
     if (relative.length === 0)
         return false;
-    const normalized = normalizeToPosixPath(relative);
+    const normalized = toPosixPath(relative);
     if (options.isDirectory) {
         return matcher.ignores(normalized.endsWith('/') ? normalized : `${normalized}/`);
     }

package/dist/lib/file-operations/glob-engine.d.ts

@@ -4,6 +4,7 @@ interface DirentLike {
     isFile(): boolean;
     isSymbolicLink(): boolean;
 }
+export declare function resolveEntryType(dirent: DirentLike): 'file' | 'directory' | 'symlink' | 'other';
 interface GlobEntry {
     path: string;
     dirent: DirentLike;

package/dist/lib/file-operations/glob-engine.js

@@ -2,19 +2,32 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { glob as fsGlob } from 'node:fs/promises';
 import { getToolContextSnapshot, publishOpsTraceEnd, publishOpsTraceError, publishOpsTraceStart, shouldPublishOpsTrace, startPerfMeasure, } from '../observability.js';
+import { toPosixPath } from '../path-format.js';
+import { isRecord } from '../type-guards.js';
+export function resolveEntryType(dirent) {
+    if (dirent.isDirectory())
+        return 'directory';
+    if (dirent.isSymbolicLink())
+        return 'symlink';
+    if (dirent.isFile())
+        return 'file';
+    return 'other';
+}
 const GLOB_MAGIC_RE = /[*?[\]{}!]/u;
 const DEFAULT_MAX_HIDDEN_DEPTH = 10;
+const GLOB_BATCH_CONCURRENCY = 32;
 const SEP = '/';
-const WIN_SEP = '\\';
 const DOT_CHAR_CODE = 46;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function toPosixSlashes(value) {
-    return value.includes(WIN_SEP) ? value.replace(/\\/gu, SEP) : value;
-}
+const GLOB_BOOLEAN_OPTION_KEYS = [
+    'includeHidden',
+    'baseNameMatch',
+    'caseSensitiveMatch',
+    'followSymbolicLinks',
+    'onlyFiles',
+    'stats',
+];
 function normalizePattern(pattern, baseNameMatch) {
-    const normalized = toPosixSlashes(pattern);
+    const normalized = toPosixPath(pattern);
     if (!baseNameMatch)
         return normalized;
     if (normalized.includes(SEP))
@@ -22,7 +35,7 @@ function normalizePattern(pattern, baseNameMatch) {
     return `**/${normalized}`;
 }
 function normalizeIgnorePatterns(patterns) {
-    return patterns.map(toPosixSlashes);
+    return patterns.map(toPosixPath);
 }
 function splitPatternPrefix(normalizedPattern) {
     if (!GLOB_MAGIC_RE.test(normalizedPattern)) {
@@ -67,12 +80,14 @@ function addDotfileCandidates(patterns, prefix, remainderSegments) {
 }
 function addGlobstarCandidates(patterns, prefix, remainder, maxDepth) {
     const afterGlobstar = remainder.slice(3);
+    const addDotFile = afterGlobstar.length > 0 && afterGlobstar.charCodeAt(0) !== DOT_CHAR_CODE;
+    let depthPrefix = '';
     for (let depth = 0; depth <= maxDepth; depth++) {
-        const depthPrefix = depth > 0 ? '*/'.repeat(depth) : '';
         patterns.add(`${prefix}${depthPrefix}.*/**/${afterGlobstar}`);
-        if (afterGlobstar && afterGlobstar.charCodeAt(0) !== DOT_CHAR_CODE) {
+        if (addDotFile) {
             patterns.add(`${prefix}${depthPrefix}.${afterGlobstar}`);
         }
+        depthPrefix += '*/';
     }
 }
 function buildHiddenPatterns(normalizedPattern, maxDepth) {
@@ -111,15 +126,7 @@ function assertOptionsShape(options) {
             throw new TypeError('globEntries: options.excludePatterns must contain only strings');
         }
     }
-    const boolKeys = [
-        'includeHidden',
-        'baseNameMatch',
-        'caseSensitiveMatch',
-        'followSymbolicLinks',
-        'onlyFiles',
-        'stats',
-    ];
-    for (const key of boolKeys) {
+    for (const key of GLOB_BOOLEAN_OPTION_KEYS) {
         if (typeof o[key] !== 'boolean') {
             throw new TypeError(`globEntries: options.${key} must be a boolean`);
         }
@@ -167,12 +174,10 @@ function getRelativeDepth(relativePath) {
 function isGlobDirentLike(value) {
     if (!isRecord(value))
         return false;
-    if (typeof value.name !== 'string')
-        return false;
-    const candidate = value;
-    return (typeof candidate.isDirectory === 'function' &&
-        typeof candidate.isFile === 'function' &&
-        typeof candidate.isSymbolicLink === 'function');
+    return (typeof value.name === 'string' &&
+        typeof value.isDirectory === 'function' &&
+        typeof value.isFile === 'function' &&
+        typeof value.isSymbolicLink === 'function');
 }
 function resolveDirentBase(cwd, parentPath) {
     if (!parentPath)
@@ -228,24 +233,32 @@ async function resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followS
 }
 async function* processIterable(iterable, context) {
     const { cwd, maxDepth, seen, onlyFiles, followSymlinks, returnStats, suppressErrors, } = context;
-    const CONCURRENCY = 32;
     const buffer = [];
     const flush = async function* () {
         if (buffer.length === 0)
             return;
-        const batch = buffer.slice();
+        const batchSize = buffer.length;
+        const requests = new Array(batchSize);
+        for (let index = 0; index < batchSize; index += 1) {
+            const match = buffer[index];
+            if (match === undefined) {
+                requests[index] = Promise.resolve(null);
+                continue;
+            }
+            requests[index] = resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followSymlinks, returnStats, suppressErrors);
+        }
         buffer.length = 0;
-        const results = await Promise.all(batch.map((m) => resolveStringMatch(m, cwd, maxDepth, seen, onlyFiles, followSymlinks, returnStats, suppressErrors)));
-        for (const res of results) {
-            if (res)
-                yield res;
+        const results = await Promise.all(requests);
+        for (const entry of results) {
+            if (entry !== null)
+                yield entry;
         }
     };
     try {
         for await (const match of iterable) {
             if (typeof match === 'string') {
                 buffer.push(match);
-                if (buffer.length >= CONCURRENCY) {
+                if (buffer.length >= GLOB_BATCH_CONCURRENCY) {
                     yield* flush();
                 }
                 continue;

package/dist/lib/file-operations/list-directory.js

@@ -4,7 +4,8 @@ import { DEFAULT_LIST_MAX_ENTRIES, DEFAULT_MAX_DEPTH, DEFAULT_SEARCH_TIMEOUT_MS,
 import { createTimedAbortSignal, processInParallel, withAbort, } from '../fs-helpers.js';
 import { isSensitivePath } from '../path-policy.js';
 import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
-import { globEntries } from './glob-engine.js';
+import { needsStatsForSort, withOptionalStoppedReason } from './common.js';
+import { globEntries, resolveEntryType } from './glob-engine.js';
 function normalizePattern(pattern) {
     if (!pattern || pattern.length === 0)
         return undefined;
@@ -33,9 +34,6 @@ function sortEntries(entries, sortBy) {
     }[sortBy];
     entries.sort(compare);
 }
-function needsStatsForSort(sortBy) {
-    return sortBy === 'size' || sortBy === 'modified';
-}
 function resolveMaxDepth(normalized) {
     if (!normalized.pattern) {
         return 1;
@@ -67,33 +65,37 @@ async function* readDirectoryEntries(basePath, normalized, needsStats, signal) {
         }
         return;
     }
-    const { results, errors } = await processInParallel(entries.map((entry, index) => ({ entry, index })), async ({ entry, index }) => ({
-        index,
-        stats: await withAbort(fsp.lstat(entry.entryPath), signal),
-    }), PARALLEL_CONCURRENCY, signal);
+    const { results, errors } = await processInParallel(entries.map((_, index) => index), async (index) => {
+        const candidate = entries[index];
+        if (!candidate) {
+            throw new Error(`Entry index out of range: ${String(index)}`);
+        }
+        return {
+            index,
+            stats: await withAbort(fsp.lstat(candidate.entryPath), signal),
+        };
+    }, PARALLEL_CONCURRENCY, signal);
     if (errors.length > 0) {
         throw errors[0]?.error ?? new Error('Failed to read entry stats');
     }
-    const statsByIndex = new Map();
+    const statsByIndex = [];
     for (const result of results) {
-        statsByIndex.set(result.index, result.stats);
+        statsByIndex[result.index] = result.stats;
     }
-    let index = 0;
-    for (const entry of entries) {
-        const stats = statsByIndex.get(index);
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (!entry)
+            continue;
+        const stats = statsByIndex[index];
         yield {
             path: entry.entryPath,
             dirent: entry.dirent,
             ...(stats ? { stats } : {}),
         };
-        index += 1;
     }
 }
 function createEntryStream(basePath, normalized, maxDepth, needsStats, signal) {
-    const canUseFastPath = !normalized.pattern &&
-        normalized.excludePatterns.length === 0 &&
-        maxDepth === 1;
-    if (canUseFastPath) {
+    if (shouldUseFastPath(normalized, maxDepth)) {
         return readDirectoryEntries(basePath, normalized, needsStats, signal);
     }
     return globEntries({
@@ -109,14 +111,10 @@ function createEntryStream(basePath, normalized, maxDepth, needsStats, signal) {
         stats: needsStats,
     });
 }
-function resolveEntryType(dirent) {
-    if (dirent.isDirectory())
-        return 'directory';
-    if (dirent.isSymbolicLink())
-        return 'symlink';
-    if (dirent.isFile())
-        return 'file';
-    return 'other';
+function shouldUseFastPath(normalized, maxDepth) {
+    return (!normalized.pattern &&
+        normalized.excludePatterns.length === 0 &&
+        maxDepth === 1);
 }
 function resolveRelativePath(basePath, entryPath) {
     return path.relative(basePath, entryPath) || path.basename(entryPath);
@@ -125,7 +123,7 @@ async function resolveSymlinkTarget(entryType, includeSymlinkTargets, entryPath)
     if (entryType !== 'symlink' || !includeSymlinkTargets) {
         return undefined;
     }
-    return await fsp.readlink(entryPath).catch(() => undefined);
+    return fsp.readlink(entryPath).catch(() => undefined);
 }
 function updateTotals(entryType, totals) {
     if (entryType === 'file')
@@ -151,10 +149,10 @@ function trackSymlink(entryType, includeSymlinkTargets, counters) {
         counters.symlinksNotFollowed += 1;
     }
 }
-async function isEntryAccessible(entryPath, entryType, basePath, signal, counters) {
+async function isEntryAccessible(entryPath, entryType, basePathDirectories, signal, counters) {
     if (entryType !== 'symlink') {
         const normalized = normalizePath(entryPath);
-        if (!isPathWithinDirectories(normalized, [basePath])) {
+        if (!isPathWithinDirectories(normalized, basePathDirectories)) {
             counters.skippedInaccessible += 1;
             return false;
         }
@@ -198,7 +196,7 @@ async function enqueueAppendEntry(entry, entryType, ctx, pending, flushPending)
     }
 }
 function buildSummary(entries, totals, maxDepth, truncated, stoppedReason, counters) {
-    const baseSummary = {
+    const summary = {
         totalEntries: entries.length,
         entriesScanned: entries.length,
         entriesVisible: entries.length,
@@ -209,15 +207,13 @@ function buildSummary(entries, totals, maxDepth, truncated, stoppedReason, count
         skippedInaccessible: counters.skippedInaccessible,
         symlinksNotFollowed: counters.symlinksNotFollowed,
     };
-    return {
-        ...baseSummary,
-        ...(stoppedReason !== undefined ? { stoppedReason } : {}),
-    };
+    return withOptionalStoppedReason(summary, stoppedReason);
 }
 async function collectEntries(basePath, normalized, signal, needsStats, maxDepth) {
     const entries = [];
     const totals = { files: 0, directories: 0 };
     const counters = { skippedInaccessible: 0, symlinksNotFollowed: 0 };
+    const basePathDirectories = [basePath];
     let truncated = false;
     let stoppedReason;
     const pending = [];
@@ -244,7 +240,7 @@ async function collectEntries(basePath, normalized, signal, needsStats, maxDepth
         }
         const entryType = resolveEntryType(entry.dirent);
         trackSymlink(entryType, normalized.includeSymlinkTargets, counters);
-        const accessible = await isEntryAccessible(entry.path, entryType, basePath, signal, counters);
+        const accessible = await isEntryAccessible(entry.path, entryType, basePathDirectories, signal, counters);
         if (!accessible) {
             continue;
         }