inup 1.5.1 → 1.5.2

package/dist/core/package-detector.js

@@ -40,12 +40,13 @@ const services_1 = require("../services");
 const config_1 = require("../config");
 const utils_2 = require("../ui/utils");
 const utils_3 = require("../utils");
+const debug_1 = require("../features/debug");
 class PackageDetector {
     constructor(options) {
         this.packageJsonPath = null;
         this.packageJson = null;
         this.batchSize = 25;
-        this.batchConcurrency = 5;
+        this.batchConcurrency = 25;
         this.cwd = options?.cwd || process.cwd();
         this.excludePatterns = options?.excludePatterns || [];
         this.ignorePackages = options?.ignorePackages || [];
@@ -89,9 +90,14 @@ class PackageDetector {
         const packageLookup = new Map();
         let resolved = 0;
         let failed = 0;
+        const performanceTracker = (0, debug_1.getPerformanceTracker)();
+        let batchIndex = 0;
+        let lastBatchEndAt = Date.now();
         const tFetch = Date.now();
         utils_3.debugLog.info('PackageDetector', 'fetching version data via npm registry in batches');
         await (0, services_1.getAllPackageDataBatched)(prepared.uniquePackages, (batch) => {
+            const batchStart = lastBatchEndAt;
+            let batchFailedCount = 0;
             const batchItems = batch.map((batchItem) => {
                 const packageInfo = this.resolvePackageGroup(batchItem.packageName, prepared.allDependencies, batchItem.data);
                 packageLookup.set(batchItem.packageName, packageInfo);
@@ -99,6 +105,8 @@ class PackageDetector {
                 const isFailed = batchItem.data.latestVersion === 'unknown';
                 if (isFailed) {
                     failed++;
+                    batchFailedCount++;
+                    performanceTracker.recordFailedPackage(batchItem.packageName);
                 }
                 return {
                     packageName: batchItem.packageName,
@@ -106,6 +114,15 @@ class PackageDetector {
                     failed: isFailed,
                 };
             });
+            const batchEnd = Date.now();
+            performanceTracker.recordBatch({
+                index: batchIndex++,
+                size: batch.length,
+                durationMs: batchEnd - batchStart,
+                failedCount: batchFailedCount,
+            });
+            lastBatchEndAt = batchEnd;
+            performanceTracker.recordCounts({ resolved, failed });
             const progress = this.createProgressSnapshot(prepared.uniquePackages.length, resolved, failed, resolved < prepared.uniquePackages.length);
             onEvent({
                 type: 'batch',
@@ -119,6 +136,7 @@ class PackageDetector {
             concurrency: this.batchConcurrency,
         });
         utils_3.debugLog.perf('PackageDetector', `registry fetch (${resolved}/${prepared.uniquePackages.length} resolved)`, tFetch);
+        performanceTracker.recordPhaseDuration('registryFetch', Date.now() - tFetch);
         const finalPackages = prepared.uniquePackages.flatMap((packageName) => packageLookup.get(packageName) ?? []);
         const progress = this.createProgressSnapshot(prepared.uniquePackages.length, resolved, failed, false);
         utils_3.debugLog.perf('PackageDetector', `total scan complete (${finalPackages.filter((p) => p.isOutdated).length} outdated of ${finalPackages.length} deps)`, t0);
@@ -133,12 +151,15 @@ class PackageDetector {
         return finalPackages;
     }
     async prepareDependencies() {
+        const performanceTracker = (0, debug_1.getPerformanceTracker)();
         this.showProgress('🔍 Scanning repository for package.json files...');
         const tScan = Date.now();
         const allPackageJsonFiles = await this.findPackageJsonFilesWithTimeout(30000);
         utils_3.debugLog.perf('PackageDetector', `file scan (${allPackageJsonFiles.length} files)`, tScan, {
             files: allPackageJsonFiles,
         });
+        performanceTracker.recordPhaseDuration('discovery', Date.now() - tScan);
+        performanceTracker.recordCounts({ packageJsonFiles: allPackageJsonFiles.length });
         this.showProgress(`🔍 Found ${allPackageJsonFiles.length} package.json file${allPackageJsonFiles.length === 1 ? '' : 's'}`);
         this.showProgress('🔍 Reading dependencies from package.json files...');
         const tDeps = Date.now();
@@ -147,7 +168,10 @@ class PackageDetector {
             includeOptionalDeps: true,
         });
         utils_3.debugLog.perf('PackageDetector', `dependency collection (${allDepsRaw.length} raw deps)`, tDeps);
+        performanceTracker.recordPhaseDuration('depCollection', Date.now() - tDeps);
+        performanceTracker.recordCounts({ rawDependencies: allDepsRaw.length });
         this.showProgress('🔍 Identifying unique packages...');
+        const tFilter = Date.now();
         const uniquePackageNames = new Set();
         const allDependencies = [];
         let ignoredCount = 0;
@@ -191,6 +215,12 @@ class PackageDetector {
             return a.localeCompare(b);
         });
         utils_3.debugLog.info('PackageDetector', `${uniquePackages.length} unique packages to check, ${ignoredCount} ignored`);
+        performanceTracker.recordPhaseDuration('filter', Date.now() - tFilter);
+        performanceTracker.recordCounts({
+            uniquePackages: uniquePackages.length,
+            ignoredPackages: ignoredCount,
+            workspaceRefsSkipped: seenWorkspaceRefs.size,
+        });
         const currentVersions = new Map();
         for (const dep of allDependencies) {
             if (!currentVersions.has(dep.name)) {

package/dist/core/upgrade-runner.js

@@ -10,6 +10,7 @@ const interactive_ui_1 = require("../interactive-ui");
 const upgrader_1 = require("./upgrader");
 const package_manager_detector_1 = require("../services/package-manager-detector");
 const utils_1 = require("../ui/utils");
+const debug_1 = require("../features/debug");
 /**
  * Main orchestrator for the inup upgrade process
  */
@@ -35,6 +36,9 @@ class UpgradeRunner {
         try {
             // Check prerequisites
             this.checkPrerequisites();
+            const performanceTracker = (0, debug_1.getPerformanceTracker)();
+            performanceTracker.start();
+            performanceTracker.setPackageManager(this.packageManager.name);
             const progress = {
                 discovered: 0,
                 resolved: 0,
@@ -71,6 +75,7 @@ class UpgradeRunner {
                         progress.total = event.payload.progress.total;
                         progress.failed = event.payload.progress.failed;
                         progress.isLoading = event.payload.progress.isLoading;
+                        performanceTracker.mark('firstBatch');
                         this.ui.appendOutdatedBatchToSelectionStates(selectionStates, event.payload.batch, previousSelections);
                         refreshUI?.();
                     }
@@ -81,6 +86,8 @@ class UpgradeRunner {
                         progress.total = event.payload.progress.total;
                         progress.failed = event.payload.progress.failed;
                         progress.isLoading = event.payload.progress.isLoading;
+                        performanceTracker.mark('firstBatch');
+                        performanceTracker.mark('allLoaded');
                         refreshUI?.();
                     }
                 });

package/dist/features/debug/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/debug.types"), exports);
+__exportStar(require("./services/performance-tracker"), exports);
+__exportStar(require("./renderer/performance-modal"), exports);
+//# sourceMappingURL=index.js.map

package/dist/features/debug/renderer/performance-modal.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPerformanceModal = renderPerformanceModal;
+const chalk_1 = __importDefault(require("chalk"));
+const modal_1 = require("../../../ui/modal");
+function formatMs(value) {
+    if (value === undefined || value === null)
+        return chalk_1.default.gray('—');
+    return chalk_1.default.yellow(`${value} ms`);
+}
+function formatCount(value) {
+    if (value === undefined)
+        return chalk_1.default.gray('—');
+    return chalk_1.default.cyan(String(value));
+}
+function labelValue(label, value, labelWidth = 22) {
+    const padded = label.padEnd(labelWidth, ' ');
+    return `${chalk_1.default.white(padded)} ${value}`;
+}
+function buildSections(snapshot) {
+    const { phases, counts, batches, failedPackages, packageManager, totalMs } = snapshot;
+    const pinned = [
+        {
+            key: 'header',
+            rows: [
+                chalk_1.default.cyan('⚡ Performance'),
+                chalk_1.default.gray(`Package manager: ${packageManager ? chalk_1.default.white(packageManager) : chalk_1.default.gray('unknown')}`),
+            ],
+            required: true,
+            behavior: 'pinned',
+        },
+    ];
+    const bodyRows = [];
+    bodyRows.push(chalk_1.default.bold('Timings'));
+    bodyRows.push(labelValue('Discovery', formatMs(phases.discovery)));
+    bodyRows.push(labelValue('Dep collection', formatMs(phases.depCollection)));
+    bodyRows.push(labelValue('Filter', formatMs(phases.filter)));
+    bodyRows.push(labelValue('Registry fetch', formatMs(phases.registryFetch)));
+    bodyRows.push(labelValue('First batch ready', formatMs(phases.firstBatch)));
+    bodyRows.push(labelValue('All packages loaded', formatMs(phases.allLoaded)));
+    bodyRows.push(labelValue('Elapsed total', formatMs(totalMs ?? undefined)));
+    bodyRows.push('');
+    bodyRows.push(chalk_1.default.bold('Counts'));
+    bodyRows.push(labelValue('package.json files', formatCount(counts.packageJsonFiles)));
+    bodyRows.push(labelValue('Raw dependencies', formatCount(counts.rawDependencies)));
+    bodyRows.push(labelValue('Unique packages', formatCount(counts.uniquePackages)));
+    bodyRows.push(labelValue('Ignored', formatCount(counts.ignoredPackages)));
+    bodyRows.push(labelValue('Workspace refs', formatCount(counts.workspaceRefsSkipped)));
+    bodyRows.push(labelValue('Resolved', formatCount(counts.resolved)));
+    bodyRows.push(labelValue('Failed', formatCount(counts.failed)));
+    bodyRows.push('');
+    bodyRows.push(chalk_1.default.bold('Batches'));
+    if (batches.length > 0) {
+        const durations = batches.map((b) => b.durationMs);
+        const total = durations.reduce((a, b) => a + b, 0);
+        const avg = Math.round(total / batches.length);
+        const slowest = Math.max(...durations);
+        const slowestBatch = batches.find((b) => b.durationMs === slowest);
+        bodyRows.push(labelValue('Batch count', formatCount(batches.length)));
+        bodyRows.push(labelValue('Avg batch', formatMs(avg)));
+        bodyRows.push(labelValue('Slowest batch', `${formatMs(slowest)} ${chalk_1.default.gray(`(#${slowestBatch?.index})`)}`));
+    }
+    else {
+        bodyRows.push(chalk_1.default.gray('  (no batches recorded)'));
+    }
+    bodyRows.push('');
+    bodyRows.push(chalk_1.default.bold('Failures'));
+    if (failedPackages.length > 0) {
+        for (const name of failedPackages) {
+            bodyRows.push(`  ${chalk_1.default.red('✗')} ${name}`);
+        }
+    }
+    else {
+        bodyRows.push(chalk_1.default.gray('  (none)'));
+    }
+    const body = [
+        {
+            key: 'body',
+            rows: bodyRows,
+            required: true,
+            behavior: 'body',
+        },
+    ];
+    return { pinned, body };
+}
+function renderPerformanceModal(snapshot, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0) {
+    const modalWidth = (0, modal_1.getModalWidth)(terminalWidth, 60, 84);
+    const padding = Math.floor((terminalWidth - modalWidth) / 2);
+    const fixedModalHeight = Math.max(10, terminalHeight - 2);
+    const { pinned, body } = buildSections(snapshot);
+    const pinnedRowCount = pinned.reduce((sum, s) => sum + s.rows.length, 0);
+    // frame: top border + pinned rows + separator + body rows + bottom border
+    const availableForBody = Math.max(3, fixedModalHeight - 2 - pinnedRowCount - 1);
+    const bodyRows = body[0].rows;
+    const totalScrollableRows = bodyRows.length;
+    const needsScroll = totalScrollableRows > availableForBody;
+    const visibleBodyRows = needsScroll ? Math.max(1, availableForBody - 1) : availableForBody;
+    const maxScroll = Math.max(0, totalScrollableRows - visibleBodyRows);
+    const clampedOffset = Math.min(Math.max(0, scrollOffset), maxScroll);
+    const visibleSlice = bodyRows.slice(clampedOffset, clampedOffset + visibleBodyRows);
+    const lines = [];
+    const topPadding = Math.max(0, Math.floor((terminalHeight - fixedModalHeight) / 2));
+    for (let i = 0; i < topPadding; i++) {
+        lines.push('');
+    }
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╭' + '─'.repeat(modalWidth - 2) + '╮'));
+    for (const section of pinned) {
+        for (const row of section.rows) {
+            lines.push((0, modal_1.renderModalRow)(padding, modalWidth, row));
+        }
+    }
+    lines.push((0, modal_1.renderModalSeparator)(padding, modalWidth));
+    let renderedBodyRows = 0;
+    for (const row of visibleSlice) {
+        lines.push((0, modal_1.renderModalRow)(padding, modalWidth, row));
+        renderedBodyRows++;
+    }
+    const footer = needsScroll
+        ? chalk_1.default.gray(`Lines ${clampedOffset + 1}-${Math.min(clampedOffset + visibleBodyRows, totalScrollableRows)} of ${totalScrollableRows}`)
+        : null;
+    const usedContentRows = pinnedRowCount + 1 + renderedBodyRows + (footer ? 1 : 0);
+    const totalContentSlots = fixedModalHeight - 2;
+    const emptyRows = Math.max(0, totalContentSlots - usedContentRows);
+    for (let i = 0; i < emptyRows; i++) {
+        lines.push((0, modal_1.renderModalRow)(padding, modalWidth, ''));
+    }
+    if (footer) {
+        lines.push((0, modal_1.renderModalRow)(padding, modalWidth, footer));
+    }
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╰' + '─'.repeat(modalWidth - 2) + '╯'));
+    return {
+        lines,
+        maxScrollOffset: maxScroll,
+        totalContentRows: totalScrollableRows,
+        usesInternalScroll: needsScroll,
+    };
+}
+//# sourceMappingURL=performance-modal.js.map

package/dist/features/debug/services/performance-tracker.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPerformanceTracker = getPerformanceTracker;
+class PerformanceTracker {
+    constructor() {
+        this.startedAt = null;
+        this.phases = {};
+        this.counts = {};
+        this.batches = [];
+        this.failedPackages = [];
+        this.packageManager = null;
+    }
+    start() {
+        this.startedAt = Date.now();
+        this.phases = {};
+        this.counts = {};
+        this.batches = [];
+        this.failedPackages = [];
+        this.packageManager = null;
+    }
+    mark(phase) {
+        if (this.startedAt === null || this.phases[phase] !== undefined)
+            return;
+        this.phases[phase] = Date.now() - this.startedAt;
+    }
+    recordPhaseDuration(phase, durationMs) {
+        this.phases[phase] = durationMs;
+    }
+    recordCounts(partial) {
+        this.counts = { ...this.counts, ...partial };
+    }
+    recordBatch(batch) {
+        this.batches.push(batch);
+    }
+    recordFailedPackage(name) {
+        if (!this.failedPackages.includes(name)) {
+            this.failedPackages.push(name);
+        }
+    }
+    setPackageManager(name) {
+        this.packageManager = name;
+    }
+    snapshot() {
+        const totalMs = this.startedAt === null
+            ? null
+            : (this.phases.allLoaded ?? Date.now() - this.startedAt);
+        return {
+            startedAt: this.startedAt,
+            phases: { ...this.phases },
+            totalMs,
+            counts: { ...this.counts },
+            batches: [...this.batches],
+            failedPackages: [...this.failedPackages],
+            packageManager: this.packageManager,
+        };
+    }
+    reset() {
+        this.startedAt = null;
+        this.phases = {};
+        this.counts = {};
+        this.batches = [];
+        this.failedPackages = [];
+        this.packageManager = null;
+    }
+}
+let instance = null;
+function getPerformanceTracker() {
+    if (!instance)
+        instance = new PerformanceTracker();
+    return instance;
+}
+//# sourceMappingURL=performance-tracker.js.map

package/dist/features/debug/types/debug.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=debug.types.js.map

package/dist/interactive-ui.js

@@ -43,6 +43,7 @@ const ui_1 = require("./ui");
 const controllers_1 = require("./ui/controllers");
 const themes_1 = require("./ui/themes");
 const themes_colors_1 = require("./ui/themes-colors");
+const debug_1 = require("./features/debug");
 const DEFAULT_VULNERABILITY_DISPLAY_OPTIONS = {
     showPeerDependencyVulnerabilities: false,
     showOptionalDependencyVulnerabilities: false,
@@ -236,6 +237,8 @@ class InteractiveUI {
             stateManager.setRenderableItems([]);
             // Track the current max scroll offset for the info modal
             let infoModalMaxScrollOffset = 0;
+            // Track the current max scroll offset for the debug modal
+            let debugModalMaxScrollOffset = 0;
             let previousViewportMode = null;
             let previousModalViewportLineCount = null;
             const handleAction = (action) => {
@@ -332,6 +335,19 @@ class InteractiveUI {
                             return;
                         }
                         break;
+                    case 'toggle_debug_modal':
+                        stateManager.toggleDebugModal();
+                        break;
+                    case 'scroll_debug_modal_up':
+                        if (!stateManager.scrollDebugModalUp()) {
+                            return;
+                        }
+                        break;
+                    case 'scroll_debug_modal_down':
+                        if (!stateManager.scrollDebugModalDown(debugModalMaxScrollOffset)) {
+                            return;
+                        }
+                        break;
                     case 'navigate_info_modal_version':
                         {
                             if (uiState.infoModalRow >= 0 && uiState.infoModalRow < filteredStates.length) {
@@ -511,6 +527,18 @@ class InteractiveUI {
                     const modalLines = this.renderer.renderThemeSelectorModal(themeManager.getCurrentTheme(), themeManager.getPreviewTheme(), terminalWidth, terminalHeight);
                     renderModalViewport('theme-modal', chalk_1.default.bold.white('T ') + chalk_1.default.gray('/ Esc Exit theme selector'), modalLines, terminalWidth, terminalHeight, bgCode);
                 }
+                else if (uiState.showDebugModal) {
+                    const terminalWidth = process.stdout.columns || 80;
+                    const terminalHeight = this.getTerminalHeight();
+                    const snapshot = (0, debug_1.getPerformanceTracker)().snapshot();
+                    const result = (0, debug_1.renderPerformanceModal)(snapshot, terminalWidth, Math.max(8, terminalHeight - 4), uiState.debugModalScrollOffset);
+                    debugModalMaxScrollOffset = result.maxScrollOffset;
+                    stateManager.clampDebugModalScrollOffset(debugModalMaxScrollOffset);
+                    const scrollHint = result.usesInternalScroll && result.maxScrollOffset > 0
+                        ? chalk_1.default.bold.white('↑/↓ ') + chalk_1.default.gray('Scroll  ·  ')
+                        : '';
+                    renderModalViewport('info-modal', scrollHint + chalk_1.default.bold.white('! / Esc ') + chalk_1.default.gray('Close'), result.lines, terminalWidth, terminalHeight, bgCode);
+                }
                 else if (uiState.showInfoModal &&
                     uiState.infoModalRow >= 0 &&
                     uiState.infoModalRow < filteredStates.length) {

package/dist/services/npm-registry.js

@@ -36,11 +36,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllPackageData = getAllPackageData;
 exports.getAllPackageDataBatched = getAllPackageDataBatched;
 exports.clearPackageCache = clearPackageCache;
+exports.closeRegistryPool = closeRegistryPool;
 const semver = __importStar(require("semver"));
+const undici_1 = require("undici");
+const node_zlib_1 = require("node:zlib");
+const node_util_1 = require("node:util");
+const gunzipAsync = (0, node_util_1.promisify)(node_zlib_1.gunzip);
+const inflateAsync = (0, node_util_1.promisify)(node_zlib_1.inflate);
+const brotliDecompressAsync = (0, node_util_1.promisify)(node_zlib_1.brotliDecompress);
 const config_1 = require("../config");
 const jsdelivr_registry_1 = require("./jsdelivr-registry");
 const utils_1 = require("../ui/utils");
 const inFlightLookups = new Map();
+const registryOrigin = new URL(config_1.NPM_REGISTRY_URL).origin;
+const registryPathPrefix = new URL(config_1.NPM_REGISTRY_URL).pathname.replace(/\/$/, '');
+const registryPool = new undici_1.Pool(registryOrigin, {
+    connections: 64,
+    pipelining: 10,
+    keepAliveTimeout: 30000,
+    keepAliveMaxTimeout: 600000,
+    headersTimeout: config_1.REQUEST_TIMEOUT,
+    bodyTimeout: config_1.REQUEST_TIMEOUT,
+    allowH2: false,
+});
 const isRetryableStatus = (statusCode) => statusCode === 408 || statusCode === 429 || statusCode >= 500;
 const isTransientNetworkError = (error) => {
     if (!(error instanceof Error)) {
@@ -48,6 +66,14 @@ const isTransientNetworkError = (error) => {
     }
     const maybeCode = error.code;
     return (error.name === 'AbortError' ||
+        error.name === 'HeadersTimeoutError' ||
+        error.name === 'BodyTimeoutError' ||
+        error.name === 'ConnectTimeoutError' ||
+        error.name === 'SocketError' ||
+        maybeCode === 'UND_ERR_HEADERS_TIMEOUT' ||
+        maybeCode === 'UND_ERR_BODY_TIMEOUT' ||
+        maybeCode === 'UND_ERR_CONNECT_TIMEOUT' ||
+        maybeCode === 'UND_ERR_SOCKET' ||
         maybeCode === 'ENOTFOUND' ||
         maybeCode === 'EAI_AGAIN' ||
         maybeCode === 'ECONNRESET' ||
@@ -71,43 +97,56 @@ async function getFreshPackageData(packageName, currentVersion) {
     inFlightLookups.set(cacheKey, lookupPromise);
     return await lookupPromise;
 }
-/**
- * Fetches package data from npm registry.
- * Falls back to jsDelivr when npm is temporarily unavailable.
- */
+function parseVersions(raw) {
+    const data = JSON.parse(raw);
+    const allVersions = Object.keys(data.versions || {}).filter((v) => /^[0-9]+\.[0-9]+\.[0-9]+$/.test(v));
+    const sortedVersions = allVersions.sort(semver.rcompare);
+    const latestVersion = sortedVersions.length > 0 ? sortedVersions[0] : 'unknown';
+    return { latestVersion, allVersions };
+}
 async function fetchPackageFromRegistryWithFallback(packageName, currentVersion) {
     try {
-        const url = `${config_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), config_1.REQUEST_TIMEOUT);
-        try {
-            const response = await fetch(url, {
-                method: 'GET',
-                headers: {
-                    accept: 'application/vnd.npm.install-v1+json',
-                },
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                if (isRetryableStatus(response.status)) {
-                    return await fetchFromJsdelivrFallback(packageName, currentVersion);
-                }
-                throw new Error(`HTTP ${response.status}`);
+        const encodedName = packageName.startsWith('@')
+            ? `@${encodeURIComponent(packageName.slice(1).split('/')[0])}/${encodeURIComponent(packageName.slice(packageName.indexOf('/') + 1))}`
+            : encodeURIComponent(packageName);
+        const path = `${registryPathPrefix}/${encodedName}`;
+        const { statusCode, headers, body } = await registryPool.request({
+            path,
+            method: 'GET',
+            headers: {
+                accept: 'application/vnd.npm.install-v1+json',
+                'accept-encoding': 'gzip, deflate, br',
+            },
+            headersTimeout: config_1.REQUEST_TIMEOUT,
+            bodyTimeout: config_1.REQUEST_TIMEOUT,
+            blocking: false,
+        });
+        if (statusCode < 200 || statusCode >= 300) {
+            await body.dump();
+            if (isRetryableStatus(statusCode)) {
+                return await fetchFromJsdelivrFallback(packageName, currentVersion);
             }
-            const text = await response.text();
-            const data = JSON.parse(text);
-            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';
-            return {
-                latestVersion,
-                allVersions,
-            };
+            return { latestVersion: 'unknown', allVersions: [] };
         }
-        finally {
-            clearTimeout(timeoutId);
+        const raw = Buffer.from(await body.arrayBuffer());
+        const encodingHeader = headers['content-encoding'];
+        const encoding = (Array.isArray(encodingHeader) ? encodingHeader[0] : encodingHeader)
+            ?.toString()
+            .toLowerCase();
+        let decoded;
+        if (encoding === 'gzip') {
+            decoded = await gunzipAsync(raw);
         }
+        else if (encoding === 'br') {
+            decoded = await brotliDecompressAsync(raw);
+        }
+        else if (encoding === 'deflate') {
+            decoded = await inflateAsync(raw);
+        }
+        else {
+            decoded = raw;
+        }
+        return parseVersions(decoded.toString('utf8'));
     }
     catch (error) {
         if (isTransientNetworkError(error)) {
@@ -118,7 +157,7 @@ async function fetchPackageFromRegistryWithFallback(packageName, currentVersion)
 }
 /**
  * Fetches package version data from npm registry for multiple packages.
- * Uses native fetch with timeout support for reliable performance.
+ * Uses an undici Pool with HTTP/1.1 pipelining for high throughput.
  * Only returns valid semantic versions (X.Y.Z format, excluding pre-releases).
  */
 async function getAllPackageData(packageNames, onProgress, currentVersions) {
@@ -136,9 +175,7 @@ async function getAllPackageData(packageNames, onProgress, currentVersions) {
             onProgress(packageName, completedCount, total);
         }
     });
-    // Wait for all requests to complete
     await Promise.all(allPromises);
-    // Clear the progress line if no custom progress handler
     if (!onProgress) {
         utils_1.ConsoleUtils.clearProgress();
     }
@@ -171,11 +208,23 @@ async function getAllPackageDataBatched(packageNames, onBatchReady, currentVersi
     let completedCount = 0;
     let batchStart = 0;
     let batchIndex = 0;
+    const batchPromises = [];
+    const pendingEmissions = new Map();
+    let nextEmitIndex = 0;
+    const flushPending = () => {
+        while (pendingEmissions.has(nextEmitIndex)) {
+            const ready = pendingEmissions.get(nextEmitIndex);
+            pendingEmissions.delete(nextEmitIndex);
+            onBatchReady?.(ready);
+            nextEmitIndex++;
+        }
+    };
     while (batchStart < packageNames.length) {
         const batchSize = batchSizes[Math.min(batchIndex, batchSizes.length - 1)];
         const batchNames = packageNames.slice(batchStart, batchStart + batchSize);
+        const capturedBatchIndex = batchIndex;
         const batchResults = new Array(batchNames.length);
-        await runWithConcurrencyLimit(batchNames, concurrency, async (packageName, itemIndex) => {
+        const batchPromise = runWithConcurrencyLimit(batchNames, concurrency, async (packageName, itemIndex) => {
             const data = await getFreshPackageData(packageName, currentVersions?.get(packageName));
             packageData.set(packageName, data);
             completedCount++;
@@ -184,14 +233,18 @@ async function getAllPackageDataBatched(packageNames, onBatchReady, currentVersi
                 data,
                 completed: completedCount,
                 total,
-                batchIndex,
+                batchIndex: capturedBatchIndex,
                 itemIndex,
             };
+        }).then(() => {
+            pendingEmissions.set(capturedBatchIndex, batchResults.filter(Boolean));
+            flushPending();
         });
-        onBatchReady?.(batchResults.filter(Boolean));
+        batchPromises.push(batchPromise);
         batchStart += batchSize;
         batchIndex++;
     }
+    await Promise.all(batchPromises);
     return packageData;
 }
 /**
@@ -200,4 +253,7 @@ async function getAllPackageDataBatched(packageNames, onBatchReady, currentVersi
 function clearPackageCache() {
     inFlightLookups.clear();
 }
+async function closeRegistryPool() {
+    await registryPool.close();
+}
 //# sourceMappingURL=npm-registry.js.map

package/dist/ui/input-handler.js

@@ -47,6 +47,29 @@ class InputHandler {
             }
             return;
         }
+        // Handle debug modal input (scroll and close)
+        if (uiState.showDebugModal) {
+            if (str === '!') {
+                this.onAction({ type: 'toggle_debug_modal' });
+                return;
+            }
+            if (key) {
+                switch (key.name) {
+                    case 'escape':
+                        this.onAction({ type: 'toggle_debug_modal' });
+                        return;
+                    case 'up':
+                        this.onAction({ type: 'scroll_debug_modal_up' });
+                        return;
+                    case 'down':
+                        this.onAction({ type: 'scroll_debug_modal_down' });
+                        return;
+                    default:
+                        return; // consume other keys while modal is open
+                }
+            }
+            return;
+        }
         // Handle info modal input (scroll and close)
         if (uiState.showInfoModal) {
             if (key) {
@@ -76,6 +99,11 @@ class InputHandler {
             }
             return;
         }
+        // '!' toggles the debug/performance modal (outside of filter mode)
+        if (str === '!' && !uiState.filterMode) {
+            this.onAction({ type: 'toggle_debug_modal' });
+            return;
+        }
         // Check for '/' character to handle filter mode (only when not in modal)
         if (str === '/') {
             if (uiState.filterMode) {

package/dist/ui/state/modal-manager.js

@@ -9,8 +9,42 @@ class ModalManager {
             isLoadingModalInfo: false,
             infoModalScrollOffset: 0,
             infoModalSessionId: 0,
+            showDebugModal: false,
+            debugModalScrollOffset: 0,
         };
     }
+    isDebugModalOpen() {
+        return this.state.showDebugModal;
+    }
+    toggleDebugModal() {
+        this.state.showDebugModal = !this.state.showDebugModal;
+        this.state.debugModalScrollOffset = 0;
+    }
+    closeDebugModal() {
+        this.state.showDebugModal = false;
+        this.state.debugModalScrollOffset = 0;
+    }
+    scrollDebugModalUp() {
+        if (this.state.debugModalScrollOffset > 0) {
+            this.state.debugModalScrollOffset--;
+            return true;
+        }
+        return false;
+    }
+    scrollDebugModalDown(maxOffset) {
+        if (this.state.debugModalScrollOffset < maxOffset) {
+            this.state.debugModalScrollOffset++;
+            return true;
+        }
+        return false;
+    }
+    clampDebugModalScrollOffset(maxOffset) {
+        const nextOffset = Math.max(0, Math.min(this.state.debugModalScrollOffset, maxOffset));
+        if (nextOffset === this.state.debugModalScrollOffset)
+            return false;
+        this.state.debugModalScrollOffset = nextOffset;
+        return true;
+    }
     getState() {
         return { ...this.state };
     }

package/dist/ui/state/state-manager.js

@@ -43,6 +43,8 @@ class StateManager {
             infoModalRow: modalState.infoModalRow,
             isLoadingModalInfo: modalState.isLoadingModalInfo,
             infoModalScrollOffset: modalState.infoModalScrollOffset,
+            showDebugModal: modalState.showDebugModal,
+            debugModalScrollOffset: modalState.debugModalScrollOffset,
             filterMode: filterState.filterMode,
             filterQuery: filterState.filterQuery,
             showThemeModal: themeState.showThemeModal,
@@ -187,6 +189,21 @@ class StateManager {
     clampInfoModalScrollOffset(maxOffset) {
         return this.modalManager.clampScrollOffset(maxOffset);
     }
+    toggleDebugModal() {
+        this.modalManager.toggleDebugModal();
+    }
+    closeDebugModal() {
+        this.modalManager.closeDebugModal();
+    }
+    scrollDebugModalUp() {
+        return this.modalManager.scrollDebugModalUp();
+    }
+    scrollDebugModalDown(maxOffset) {
+        return this.modalManager.scrollDebugModalDown(maxOffset);
+    }
+    clampDebugModalScrollOffset(maxOffset) {
+        return this.modalManager.clampDebugModalScrollOffset(maxOffset);
+    }
     // Filter delegation
     enterFilterMode(preserveQuery = false) {
         this.filterManager.enterFilterMode(preserveQuery);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inup",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "Interactive dependency upgrader for npm, yarn, pnpm & bun. Zero-config, monorepo-ready. Upgrade-interactive for every package manager.",
   "main": "dist/index.js",
   "bin": {