inup 1.4.10 → 1.5.0

package/dist/services/background-audit.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundAuditTracker = void 0;
+const utils_1 = require("../utils");
+class BackgroundAuditTracker {
+    constructor() {
+        this.pending = new Map();
+        this.inFlight = new Set();
+        this.completed = new Set();
+    }
+    enqueue(packages) {
+        let added = 0;
+        for (const pkg of packages) {
+            if (!pkg.name || !pkg.version)
+                continue;
+            if (this.pending.has(pkg.name) ||
+                this.inFlight.has(pkg.name) ||
+                this.completed.has(pkg.name)) {
+                continue;
+            }
+            this.pending.set(pkg.name, pkg.version);
+            added++;
+        }
+        if (added > 0) {
+            utils_1.debugLog.info('background-audit', `queued ${added} package(s)`);
+        }
+        return added;
+    }
+    reserveNextBatch(limit = 20) {
+        const packages = new Map();
+        const packageNames = [];
+        for (const [name, version] of this.pending) {
+            packages.set(name, version);
+            packageNames.push(name);
+            this.pending.delete(name);
+            this.inFlight.add(name);
+            if (packageNames.length >= limit) {
+                break;
+            }
+        }
+        return { packages, packageNames };
+    }
+    markCompleted(packageNames) {
+        for (const packageName of packageNames) {
+            this.inFlight.delete(packageName);
+            this.completed.add(packageName);
+        }
+    }
+    getProgress() {
+        const total = this.pending.size + this.inFlight.size + this.completed.size;
+        return {
+            completed: this.completed.size,
+            total,
+            isRunning: this.pending.size > 0 || this.inFlight.size > 0,
+            hasData: this.completed.size > 0,
+        };
+    }
+}
+exports.BackgroundAuditTracker = BackgroundAuditTracker;
+//# sourceMappingURL=background-audit.js.map

package/dist/services/index.js

@@ -19,8 +19,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./npm-registry"), exports);
 __exportStar(require("./jsdelivr-registry"), exports);
-__exportStar(require("./changelog-fetcher"), exports);
+__exportStar(require("../features/changelog"), exports);
 __exportStar(require("./version-checker"), exports);
-__exportStar(require("./persistent-cache"), exports);
-__exportStar(require("./cache-manager"), exports);
+__exportStar(require("./vulnerability-checker"), exports);
+__exportStar(require("./background-audit"), exports);
 //# sourceMappingURL=index.js.map

package/dist/services/jsdelivr-registry.js

@@ -33,22 +33,18 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchExactPackageManifest = fetchExactPackageManifest;
 exports.getAllPackageDataFromJsdelivr = getAllPackageDataFromJsdelivr;
-exports.clearJsdelivrPackageCache = clearJsdelivrPackageCache;
 exports.closeJsdelivrPool = closeJsdelivrPool;
+exports.clearExactManifestCache = clearExactManifestCache;
 const undici_1 = require("undici");
 const semver = __importStar(require("semver"));
 const config_1 = require("../config");
-const npm_registry_1 = require("./npm-registry");
-const cache_manager_1 = require("./cache-manager");
-const utils_1 = require("../ui/utils");
-const utils_2 = require("../utils");
-// Batch configuration for progressive loading
-const BATCH_SIZE = 5;
-const BATCH_TIMEOUT_MS = 500;
+const utils_1 = require("../utils");
 const DEFAULT_JSDELIVR_RETRY_TIMEOUT_MS = 2000;
 const DEFAULT_JSDELIVR_POOL_TIMEOUT_MS = 60000;
 const MIN_JSDELIVR_CONNECT_TIMEOUT_MS = 500;
+const EXACT_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
 const toPositiveInteger = (value) => {
     if (!Number.isFinite(value) || value <= 0) {
         return null;
@@ -222,14 +218,9 @@ const sortVersionsDescending = (versions) => {
 };
 const isExpectedTransientError = (error) => isTimeoutError(error) || isTransientNetworkError(error);
 /**
- * Fetches package.json from jsdelivr CDN for a specific version tag using undici pool.
- * Uses connection pooling and keep-alive for maximum performance.
- * Retries on transient failures while keeping a short fallback budget.
- * @param packageName - The npm package name
- * @param versionTag - The version tag (e.g., '14', 'latest')
- * @returns The package.json content or null if not found
+ * Fetches a package.json manifest from jsDelivr for a version tag.
  */
-async function fetchPackageJsonFromJsdelivr(packageName, versionTag) {
+async function fetchPackageManifestFromJsdelivr(packageName, versionTag) {
     const url = `${config_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@${versionTag}/package.json`;
     for (let attempt = 0; attempt < RETRY_TIMEOUTS.length; attempt++) {
         const timeout = RETRY_TIMEOUTS[attempt];
@@ -249,26 +240,28 @@ async function fetchPackageJsonFromJsdelivr(packageName, versionTag) {
                 await consumeBodySafely(body);
                 if (isRetryableStatus(statusCode) && attempt < RETRY_TIMEOUTS.length - 1) {
                     const delay = getRetryDelay(attempt, headers);
-                    utils_2.debugLog.warn('jsdelivr', `${packageName}@${versionTag} HTTP ${statusCode}, retry ${attempt + 1} in ${delay}ms`);
+                    utils_1.debugLog.warn('jsdelivr', `${packageName}@${versionTag} HTTP ${statusCode}, retry ${attempt + 1} in ${delay}ms`);
                     if (delay > 0) {
                         await sleep(delay);
                     }
                     continue;
                 }
-                utils_2.debugLog.warn('jsdelivr', `${packageName}@${versionTag} HTTP ${statusCode}, no more retries`);
+                utils_1.debugLog.warn('jsdelivr', `${packageName}@${versionTag} HTTP ${statusCode}, no more retries`);
                 return null;
             }
             const text = await body.text();
             const data = JSON.parse(text);
-            const version = typeof data.version === 'string' ? data.version.trim() : '';
-            utils_2.debugLog.perf('jsdelivr', `fetch ${packageName}@${versionTag} → ${version || 'no version'}`, tReq);
-            return version ? { version } : null;
+            if (!data || typeof data !== 'object' || Array.isArray(data)) {
+                return null;
+            }
+            utils_1.debugLog.perf('jsdelivr', `fetch manifest ${packageName}@${versionTag}`, tReq);
+            return data;
         }
         catch (error) {
             if ((isTimeoutError(error) || isTransientNetworkError(error)) &&
                 attempt < RETRY_TIMEOUTS.length - 1) {
                 const delay = getRetryDelay(attempt);
-                utils_2.debugLog.warn('jsdelivr', `${packageName}@${versionTag} transient error on attempt ${attempt + 1}, retry in ${delay}ms`, error);
+                utils_1.debugLog.warn('jsdelivr', `${packageName}@${versionTag} transient error on attempt ${attempt + 1}, retry in ${delay}ms`, error);
                 if (delay > 0) {
                     await sleep(delay);
                 }
@@ -277,203 +270,126 @@ async function fetchPackageJsonFromJsdelivr(packageName, versionTag) {
             if (!isExpectedTransientError(error)) {
                 // Unexpected errors are logged for observability.
                 console.error(`jsDelivr fetch failed for ${packageName}@${versionTag} on attempt ${attempt + 1}/${RETRY_TIMEOUTS.length}`, error);
-                utils_2.debugLog.error('jsdelivr', `unexpected error for ${packageName}@${versionTag} attempt ${attempt + 1}`, error);
+                utils_1.debugLog.error('jsdelivr', `unexpected error for ${packageName}@${versionTag} attempt ${attempt + 1}`, error);
             }
             else {
-                utils_2.debugLog.warn('jsdelivr', `${packageName}@${versionTag} exhausted retries`, error);
+                utils_1.debugLog.warn('jsdelivr', `${packageName}@${versionTag} exhausted retries`, error);
             }
             return null;
         }
     }
     return null;
 }
-/**
- * Fetches package version data from jsdelivr CDN for multiple packages.
- * Uses undici connection pool for blazing fast performance with connection reuse.
- * Falls back to npm registry immediately when jsdelivr fails (interleaved, not sequential).
- * Supports batched callbacks for progressive UI updates.
- * @param packageNames - Array of package names to fetch
- * @param currentVersions - Optional map of package names to their current versions
- * @param onProgress - Optional progress callback
- * @param onBatchReady - Optional callback for batch updates (fires every BATCH_SIZE packages or BATCH_TIMEOUT_MS)
- * @returns Map of package names to their version data
- */
-async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onProgress, onBatchReady) {
+async function fetchPackageManifestFromNpmRegistry(packageName, version) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), config_1.REQUEST_TIMEOUT);
+    try {
+        const response = await fetch(`${config_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}`, {
+            method: 'GET',
+            headers: {
+                accept: 'application/json',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        utils_1.debugLog.warn('npm-registry', `exact manifest fallback failed for ${packageName}@${version}`, error);
+        return null;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+const inFlightManifests = new Map();
+async function fetchExactPackageManifest(packageName, version) {
+    const normalizedVersion = version.trim();
+    if (!EXACT_VERSION_PATTERN.test(normalizedVersion) || !semver.valid(normalizedVersion)) {
+        utils_1.debugLog.warn('jsdelivr', `skipping non-exact version lookup for ${packageName}@${version}`);
+        return null;
+    }
+    const cacheKey = `${packageName}@${normalizedVersion}`;
+    const inFlight = inFlightManifests.get(cacheKey);
+    if (inFlight) {
+        return await inFlight;
+    }
+    const lookupPromise = (async () => {
+        const jsdelivrManifest = await fetchPackageManifestFromJsdelivr(packageName, normalizedVersion);
+        if (jsdelivrManifest) {
+            return jsdelivrManifest;
+        }
+        return await fetchPackageManifestFromNpmRegistry(packageName, normalizedVersion);
+    })().finally(() => {
+        inFlightManifests.delete(cacheKey);
+    });
+    inFlightManifests.set(cacheKey, lookupPromise);
+    return await lookupPromise;
+}
+async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onProgress) {
     const packageData = new Map();
     if (packageNames.length === 0) {
         return packageData;
     }
     const total = packageNames.length;
     let completedCount = 0;
-    let progressCallback = onProgress;
-    let batchReadyCallback = onBatchReady;
-    // Batch buffer for progressive updates
-    let batchBuffer = [];
-    let batchTimer = null;
-    const emitProgress = (packageName, completed, packageTotal) => {
-        if (!progressCallback) {
-            return;
-        }
-        try {
-            progressCallback(packageName, completed, packageTotal);
-        }
-        catch (error) {
-            console.error('Progress callback failed, disabling progress updates for this run.', error);
-            progressCallback = undefined;
-        }
-    };
-    const emitBatch = (batch) => {
-        if (!batchReadyCallback) {
-            return;
-        }
-        try {
-            batchReadyCallback(batch);
-        }
-        catch (error) {
-            console.error('Batch callback failed, disabling batch updates for this run.', error);
-            batchReadyCallback = undefined;
-        }
-    };
-    // Helper to flush the current batch
-    const flushBatch = () => {
-        if (batchBuffer.length > 0) {
-            const batch = [...batchBuffer];
-            batchBuffer = [];
-            emitBatch(batch);
-        }
-        if (batchTimer) {
-            clearTimeout(batchTimer);
-            batchTimer = null;
-        }
-    };
-    // Helper to add package to batch and flush if needed
-    const addToBatch = (packageName, data) => {
-        if (!batchReadyCallback) {
-            return;
-        }
-        batchBuffer.push({ name: packageName, data });
-        // Flush if batch is full
-        if (batchBuffer.length >= BATCH_SIZE) {
-            flushBatch();
-        }
-        else if (!batchTimer) {
-            // Set timer to flush batch after timeout
-            batchTimer = setTimeout(flushBatch, BATCH_TIMEOUT_MS);
-        }
-    };
-    // Process individual package fetch with immediate npm fallback on failure
     const inFlightLookups = new Map();
-    const fetchFromNpmFallback = async (packageName) => {
-        const tFallback = Date.now();
-        utils_2.debugLog.info('jsdelivr', `falling back to npm registry for ${packageName}`);
-        try {
-            const npmData = await (0, npm_registry_1.getAllPackageData)([packageName]);
-            const result = npmData.get(packageName) ?? null;
-            if (result) {
-                cache_manager_1.packageCache.set(packageName, result);
-                utils_2.debugLog.perf('jsdelivr', `npm fallback resolved ${packageName} → ${result.latestVersion}`, tFallback);
-            }
-            else {
-                utils_2.debugLog.warn('jsdelivr', `npm fallback returned no data for ${packageName}`);
-            }
-            return result;
-        }
-        catch (error) {
-            utils_2.debugLog.error('jsdelivr', `npm fallback failed for ${packageName}`, error);
+    const fetchPackageData = async (packageName, currentVersion) => {
+        const latestManifest = await fetchPackageManifestFromJsdelivr(packageName, 'latest');
+        const latestVersion = typeof latestManifest?.version === 'string' ? latestManifest.version.trim() : '';
+        if (!latestVersion) {
             return null;
         }
-    };
-    const fetchFreshPackageData = async (packageName, currentVersion) => {
-        try {
-            const majorVersion = extractMajorVersion(currentVersion);
-            const latestResult = await fetchPackageJsonFromJsdelivr(packageName, 'latest');
-            if (!latestResult) {
-                return await fetchFromNpmFallback(packageName);
-            }
-            const latestVersion = latestResult.version;
-            const latestMajorVersion = extractMajorVersion(latestVersion);
-            const shouldFetchMajorVersion = Boolean(majorVersion && (latestMajorVersion === null || majorVersion !== latestMajorVersion));
-            const majorResult = shouldFetchMajorVersion
-                ? await fetchPackageJsonFromJsdelivr(packageName, majorVersion)
-                : null;
-            const allVersions = [latestVersion];
-            if (majorResult && majorResult.version !== latestVersion) {
-                allVersions.push(majorResult.version);
-            }
-            const sortedVersions = sortVersionsDescending(allVersions);
-            const orderedVersions = sortedVersions[0] === latestVersion
-                ? sortedVersions
-                : [latestVersion, ...sortedVersions.filter((version) => version !== latestVersion)];
-            const result = {
-                latestVersion,
-                allVersions: orderedVersions,
-            };
-            cache_manager_1.packageCache.set(packageName, result);
-            return result;
-        }
-        catch {
-            return await fetchFromNpmFallback(packageName);
-        }
+        const majorVersion = extractMajorVersion(currentVersion);
+        const latestMajorVersion = extractMajorVersion(latestVersion);
+        const shouldFetchMajorVersion = Boolean(majorVersion && (latestMajorVersion === null || latestMajorVersion !== majorVersion));
+        const majorManifest = shouldFetchMajorVersion
+            ? await fetchPackageManifestFromJsdelivr(packageName, majorVersion)
+            : null;
+        const majorResolvedVersion = typeof majorManifest?.version === 'string' ? majorManifest.version.trim() : '';
+        const sortedVersions = sortVersionsDescending([latestVersion, majorResolvedVersion].filter(Boolean));
+        const allVersions = sortedVersions[0] === latestVersion
+            ? sortedVersions
+            : [latestVersion, ...sortedVersions.filter((version) => version !== latestVersion)];
+        return {
+            latestVersion,
+            allVersions,
+        };
     };
     const getPackageData = async (packageName, currentVersion) => {
-        const cached = cache_manager_1.packageCache.get(packageName);
-        if (cached) {
-            utils_2.debugLog.info('jsdelivr', `cache hit: ${packageName} → ${cached.latestVersion}`);
-            return cached;
-        }
         const inFlight = inFlightLookups.get(packageName);
         if (inFlight) {
             return await inFlight;
         }
-        const lookupPromise = fetchFreshPackageData(packageName, currentVersion).finally(() => {
+        const lookupPromise = fetchPackageData(packageName, currentVersion).finally(() => {
             inFlightLookups.delete(packageName);
         });
         inFlightLookups.set(packageName, lookupPromise);
         return await lookupPromise;
     };
-    const fetchPackageWithFallback = async (packageName) => {
+    await Promise.all(packageNames.map(async (packageName) => {
         try {
-            const currentVersion = currentVersions?.get(packageName);
-            const result = await getPackageData(packageName, currentVersion);
+            const result = await getPackageData(packageName, currentVersions?.get(packageName));
             if (result) {
                 packageData.set(packageName, result);
-                addToBatch(packageName, result);
             }
         }
-        catch (error) {
-            console.error(`Failed to resolve package data for ${packageName}; continuing with others.`, error);
-        }
         finally {
             completedCount++;
-            emitProgress(packageName, completedCount, total);
-        }
-    };
-    try {
-        // Fire all requests simultaneously - each request internally handles retries/fallback.
-        await Promise.all(packageNames.map(fetchPackageWithFallback));
-    }
-    finally {
-        // Flush any remaining batch items
-        flushBatch();
-        // Flush persistent cache to disk
-        cache_manager_1.packageCache.flush();
-        // Clear the progress line if no custom progress handler
-        if (!onProgress) {
-            utils_1.ConsoleUtils.clearProgress();
+            onProgress?.(packageName, completedCount, total);
         }
-    }
+    }));
     return packageData;
 }
-/**
- * Clear the package cache (useful for testing)
- */
-function clearJsdelivrPackageCache() {
-    cache_manager_1.packageCache.clear();
-}
 /**
  * Close the jsDelivr connection pool (useful for graceful shutdown)
  */
 async function closeJsdelivrPool() {
     await jsdelivrPool.close();
 }
+function clearExactManifestCache() {
+    inFlightManifests.clear();
+}
 //# sourceMappingURL=jsdelivr-registry.js.map

package/dist/services/npm-registry.js

@@ -34,21 +34,48 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllPackageData = getAllPackageData;
+exports.getAllPackageDataBatched = getAllPackageDataBatched;
 exports.clearPackageCache = clearPackageCache;
 const semver = __importStar(require("semver"));
 const config_1 = require("../config");
-const cache_manager_1 = require("./cache-manager");
+const jsdelivr_registry_1 = require("./jsdelivr-registry");
 const utils_1 = require("../ui/utils");
+const inFlightLookups = new Map();
+const isRetryableStatus = (statusCode) => statusCode === 408 || statusCode === 429 || statusCode >= 500;
+const isTransientNetworkError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const maybeCode = error.code;
+    return (error.name === 'AbortError' ||
+        maybeCode === 'ENOTFOUND' ||
+        maybeCode === 'EAI_AGAIN' ||
+        maybeCode === 'ECONNRESET' ||
+        maybeCode === 'ECONNREFUSED' ||
+        maybeCode === 'ETIMEDOUT' ||
+        maybeCode === 'EPIPE');
+};
+const fetchFromJsdelivrFallback = async (packageName, currentVersion) => {
+    const jsdelivrData = await (0, jsdelivr_registry_1.getAllPackageDataFromJsdelivr)([packageName], currentVersion ? new Map([[packageName, currentVersion]]) : undefined);
+    return jsdelivrData.get(packageName) ?? { latestVersion: 'unknown', allVersions: [] };
+};
+async function getFreshPackageData(packageName, currentVersion) {
+    const cacheKey = `${packageName}@${currentVersion ?? ''}`;
+    const inFlight = inFlightLookups.get(cacheKey);
+    if (inFlight) {
+        return await inFlight;
+    }
+    const lookupPromise = fetchPackageFromRegistryWithFallback(packageName, currentVersion).finally(() => {
+        inFlightLookups.delete(cacheKey);
+    });
+    inFlightLookups.set(cacheKey, lookupPromise);
+    return await lookupPromise;
+}
 /**
  * Fetches package data from npm registry.
- * Uses the shared CacheManager for caching.
+ * Falls back to jsDelivr when npm is temporarily unavailable.
  */
-async function fetchPackageFromRegistry(packageName) {
-    // Use CacheManager for unified caching (memory + disk)
-    const cached = cache_manager_1.packageCache.get(packageName);
-    if (cached) {
-        return cached;
-    }
+async function fetchPackageFromRegistryWithFallback(packageName, currentVersion) {
     try {
         const url = `${config_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}`;
         const controller = new AbortController();
@@ -63,32 +90,29 @@ async function fetchPackageFromRegistry(packageName) {
             });
             clearTimeout(timeoutId);
             if (!response.ok) {
+                if (isRetryableStatus(response.status)) {
+                    return await fetchFromJsdelivrFallback(packageName, currentVersion);
+                }
                 throw new Error(`HTTP ${response.status}`);
             }
             const text = await response.text();
             const data = JSON.parse(text);
-            // Extract versions and filter to valid semver (X.Y.Z format, no pre-releases)
-            const allVersions = Object.keys(data.versions || {}).filter((version) => {
-                // Match only X.Y.Z format (no pre-release, no build metadata)
-                return /^[0-9]+\.[0-9]+\.[0-9]+$/.test(version);
-            });
-            // Sort versions to find the latest
+            const allVersions = Object.keys(data.versions || {}).filter((version) => /^[0-9]+\.[0-9]+\.[0-9]+$/.test(version));
             const sortedVersions = allVersions.sort(semver.rcompare);
             const latestVersion = sortedVersions.length > 0 ? sortedVersions[0] : 'unknown';
-            const result = {
+            return {
                 latestVersion,
                 allVersions,
             };
-            // Cache the result using CacheManager (handles both memory and disk)
-            cache_manager_1.packageCache.set(packageName, result);
-            return result;
         }
         finally {
             clearTimeout(timeoutId);
         }
     }
     catch (error) {
-        // Return fallback data for failed packages
+        if (isTransientNetworkError(error)) {
+            return await fetchFromJsdelivrFallback(packageName, currentVersion);
+        }
         return { latestVersion: 'unknown', allVersions: [] };
     }
 }
@@ -97,17 +121,15 @@ async function fetchPackageFromRegistry(packageName) {
  * Uses native fetch with timeout support for reliable performance.
  * Only returns valid semantic versions (X.Y.Z format, excluding pre-releases).
  */
-async function getAllPackageData(packageNames, onProgress) {
+async function getAllPackageData(packageNames, onProgress, currentVersions) {
     const packageData = new Map();
     if (packageNames.length === 0) {
         return packageData;
     }
     const total = packageNames.length;
     let completedCount = 0;
-    // Fire all requests simultaneously
-    // Concurrency is handled naturally by the event loop with fetch
     const allPromises = packageNames.map(async (packageName) => {
-        const data = await fetchPackageFromRegistry(packageName);
+        const data = await getFreshPackageData(packageName, currentVersions?.get(packageName));
         packageData.set(packageName, data);
         completedCount++;
         if (onProgress) {
@@ -116,18 +138,66 @@ async function getAllPackageData(packageNames, onProgress) {
     });
     // Wait for all requests to complete
     await Promise.all(allPromises);
-    // Flush persistent cache to disk
-    cache_manager_1.packageCache.flush();
     // Clear the progress line if no custom progress handler
     if (!onProgress) {
         utils_1.ConsoleUtils.clearProgress();
     }
     return packageData;
 }
+async function runWithConcurrencyLimit(items, concurrency, worker) {
+    if (items.length === 0) {
+        return;
+    }
+    const limit = Math.max(1, Math.min(concurrency, items.length));
+    let nextIndex = 0;
+    const runWorker = async () => {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex++;
+            await worker(items[currentIndex], currentIndex);
+        }
+    };
+    await Promise.all(Array.from({ length: limit }, () => runWorker()));
+}
+async function getAllPackageDataBatched(packageNames, onBatchReady, currentVersions, options = {}) {
+    const packageData = new Map();
+    if (packageNames.length === 0) {
+        return packageData;
+    }
+    const batchSizes = options.batchSizes && options.batchSizes.length > 0
+        ? options.batchSizes.map((size) => Math.max(1, size))
+        : [Math.max(1, options.batchSize ?? 20)];
+    const concurrency = Math.max(1, options.concurrency ?? 5);
+    const total = packageNames.length;
+    let completedCount = 0;
+    let batchStart = 0;
+    let batchIndex = 0;
+    while (batchStart < packageNames.length) {
+        const batchSize = batchSizes[Math.min(batchIndex, batchSizes.length - 1)];
+        const batchNames = packageNames.slice(batchStart, batchStart + batchSize);
+        const batchResults = new Array(batchNames.length);
+        await runWithConcurrencyLimit(batchNames, concurrency, async (packageName, itemIndex) => {
+            const data = await getFreshPackageData(packageName, currentVersions?.get(packageName));
+            packageData.set(packageName, data);
+            completedCount++;
+            batchResults[itemIndex] = {
+                packageName,
+                data,
+                completed: completedCount,
+                total,
+                batchIndex,
+                itemIndex,
+            };
+        });
+        onBatchReady?.(batchResults.filter(Boolean));
+        batchStart += batchSize;
+        batchIndex++;
+    }
+    return packageData;
+}
 /**
- * Clear the package cache (useful for testing)
+ * Retained for backward compatibility. Registry responses are fresh-by-default.
  */
 function clearPackageCache() {
-    cache_manager_1.packageCache.clear();
+    inFlightLookups.clear();
 }
 //# sourceMappingURL=npm-registry.js.map