inup 1.5.1 → 1.5.4

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.batchSize = 10;
+        this.maxConcurrency = 10;
         this.cwd = options?.cwd || process.cwd();
         this.excludePatterns = options?.excludePatterns || [];
         this.ignorePackages = options?.ignorePackages || [];
@@ -89,36 +90,55 @@ 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 batchItems = batch.map((batchItem) => {
-                const packageInfo = this.resolvePackageGroup(batchItem.packageName, prepared.allDependencies, batchItem.data);
-                packageLookup.set(batchItem.packageName, packageInfo);
-                resolved++;
-                const isFailed = batchItem.data.latestVersion === 'unknown';
-                if (isFailed) {
-                    failed++;
-                }
-                return {
-                    packageName: batchItem.packageName,
-                    packageInfo,
-                    failed: isFailed,
-                };
-            });
-            const progress = this.createProgressSnapshot(prepared.uniquePackages.length, resolved, failed, resolved < prepared.uniquePackages.length);
-            onEvent({
-                type: 'batch',
-                payload: {
-                    batch: batchItems,
-                    progress,
-                },
-            });
-        }, prepared.currentVersions, {
+        await (0, services_1.fetchPackageVersions)(prepared.uniquePackages, {
+            currentVersions: prepared.currentVersions,
             batchSize: this.batchSize,
-            concurrency: this.batchConcurrency,
+            maxConcurrency: this.maxConcurrency,
+            onBatchReady: (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);
+                    resolved++;
+                    const isFailed = batchItem.data.latestVersion === 'unknown';
+                    if (isFailed) {
+                        failed++;
+                        batchFailedCount++;
+                        performanceTracker.recordFailedPackage(batchItem.packageName);
+                    }
+                    return {
+                        packageName: batchItem.packageName,
+                        packageInfo,
+                        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',
+                    payload: {
+                        batch: batchItems,
+                        progress,
+                    },
+                });
+            },
         });
         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 +153,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 +170,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 +217,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,24 @@ 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 'switch_info_modal_tab': {
+                        const nextTab = stateManager.getInfoModalTab() === 'info' ? 'usedBy' : 'info';
+                        stateManager.setInfoModalTab(nextTab);
+                        break;
+                    }
                     case 'navigate_info_modal_version':
                         {
                             if (uiState.infoModalRow >= 0 && uiState.infoModalRow < filteredStates.length) {
@@ -511,6 +532,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) {
@@ -525,15 +558,20 @@ class InteractiveUI {
                     }
                     else {
                         // Show full info with scroll support
-                        const result = this.renderer.renderPackageInfoModal(selectedState, terminalWidth, Math.max(8, terminalHeight - 4), uiState.infoModalScrollOffset);
+                        const activeTab = uiState.infoModalTab;
+                        const result = this.renderer.renderPackageInfoModal(selectedState, terminalWidth, Math.max(8, terminalHeight - 4), uiState.infoModalScrollOffset, activeTab);
                         infoModalMaxScrollOffset = result.maxScrollOffset;
                         stateManager.clampInfoModalScrollOffset(infoModalMaxScrollOffset);
                         const scrollHint = result.usesInternalScroll && result.maxScrollOffset > 0
                             ? chalk_1.default.bold.white('↑/↓ ') + chalk_1.default.gray('Scroll  ·  ')
                             : '';
+                        const versionHint = activeTab === 'info'
+                            ? chalk_1.default.bold.white('←/→ ') + chalk_1.default.gray('Version  ·  ')
+                            : '';
                         renderModalViewport('info-modal', scrollHint +
-                            chalk_1.default.bold.white('←/→ ') +
-                            chalk_1.default.gray('Version  ·  ') +
+                            versionHint +
+                            chalk_1.default.bold.white('Tab ') +
+                            chalk_1.default.gray('Switch tab  ·  ') +
                             chalk_1.default.bold.white('I / Esc ') +
                             chalk_1.default.gray('Exit this view'), result.lines, terminalWidth, terminalHeight, bgCode);
                     }

package/dist/services/npm-registry.js

@@ -33,14 +33,37 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllPackageData = getAllPackageData;
-exports.getAllPackageDataBatched = getAllPackageDataBatched;
+exports.fetchPackageVersions = fetchPackageVersions;
 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(/\/$/, '');
+// Few connections + many requests per connection = maximum keep-alive reuse.
+// No per-request timeouts: correctness matters more than speed for a CLI that
+// runs on demand. Slow responses are tolerated; only true errors cause retry.
+const registryPool = new undici_1.Pool(registryOrigin, {
+    connections: 6,
+    pipelining: 1,
+    keepAliveTimeout: 30000,
+    keepAliveMaxTimeout: 600000,
+    headersTimeout: 0,
+    bodyTimeout: 0,
+    connectTimeout: 15000,
+    allowH2: false,
+});
+const MAX_REGISTRY_ATTEMPTS = 3;
+const RETRY_BACKOFF_MS = [500, 1500, 3000];
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const isRetryableStatus = (statusCode) => statusCode === 408 || statusCode === 429 || statusCode >= 500;
 const isTransientNetworkError = (error) => {
     if (!(error instanceof Error)) {
@@ -48,6 +71,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,127 +102,187 @@ 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.
- */
-async function fetchPackageFromRegistryWithFallback(packageName, currentVersion) {
+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 };
+}
+const encodeRegistryPath = (packageName) => {
+    const encodedName = packageName.startsWith('@')
+        ? `@${encodeURIComponent(packageName.slice(1).split('/')[0])}/${encodeURIComponent(packageName.slice(packageName.indexOf('/') + 1))}`
+        : encodeURIComponent(packageName);
+    return `${registryPathPrefix}/${encodedName}`;
+};
+async function attemptRegistryFetch(path) {
     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 { statusCode, headers, body } = await registryPool.request({
+            path,
+            method: 'GET',
+            headers: {
+                accept: 'application/vnd.npm.install-v1+json',
+                'accept-encoding': 'gzip, deflate, br',
+            },
+            headersTimeout: 0,
+            bodyTimeout: 0,
+            blocking: false,
+        });
+        if (statusCode < 200 || statusCode >= 300) {
+            await body.dump().catch(() => undefined);
+            if (isRetryableStatus(statusCode)) {
+                return { kind: 'retryable' };
             }
-            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 { kind: 'not-found' };
+        }
+        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);
         }
-        finally {
-            clearTimeout(timeoutId);
+        else {
+            decoded = raw;
         }
+        return { kind: 'success', data: parseVersions(decoded.toString('utf8')) };
     }
     catch (error) {
         if (isTransientNetworkError(error)) {
-            return await fetchFromJsdelivrFallback(packageName, currentVersion);
+            return { kind: 'transient' };
         }
-        return { latestVersion: 'unknown', allVersions: [] };
+        // Unknown error: treat as transient so we try the fallback rather than
+        // silently returning 'unknown'.
+        return { kind: 'transient' };
     }
 }
-/**
- * Fetches package version data from npm registry for multiple packages.
- * 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, currentVersions) {
-    const packageData = new Map();
-    if (packageNames.length === 0) {
-        return packageData;
-    }
-    const total = packageNames.length;
-    let completedCount = 0;
-    const allPromises = packageNames.map(async (packageName) => {
-        const data = await getFreshPackageData(packageName, currentVersions?.get(packageName));
-        packageData.set(packageName, data);
-        completedCount++;
-        if (onProgress) {
-            onProgress(packageName, completedCount, total);
+async function fetchFromRegistryWithRetries(path) {
+    let lastOutcome = { kind: 'transient' };
+    for (let attempt = 0; attempt < MAX_REGISTRY_ATTEMPTS; attempt++) {
+        const outcome = await attemptRegistryFetch(path);
+        if (outcome.kind === 'success' || outcome.kind === 'not-found') {
+            return outcome;
+        }
+        lastOutcome = outcome;
+        if (attempt < MAX_REGISTRY_ATTEMPTS - 1) {
+            const backoff = RETRY_BACKOFF_MS[Math.min(attempt, RETRY_BACKOFF_MS.length - 1)];
+            await sleep(backoff);
         }
-    });
-    // 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();
     }
-    return packageData;
+    return lastOutcome;
 }
-async function runWithConcurrencyLimit(items, concurrency, worker) {
-    if (items.length === 0) {
-        return;
+async function fetchPackageFromRegistryWithFallback(packageName, currentVersion) {
+    const path = encodeRegistryPath(packageName);
+    const outcome = await fetchFromRegistryWithRetries(path);
+    if (outcome.kind === 'success') {
+        return outcome.data;
     }
-    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()));
+    if (outcome.kind === 'not-found') {
+        return { latestVersion: 'unknown', allVersions: [] };
+    }
+    // Only reach here after exhausted retries against real errors — try jsdelivr
+    // as last-resort safety net so we don't silently return 'unknown'.
+    const fallback = await fetchFromJsdelivrFallback(packageName, currentVersion).catch(() => null);
+    return fallback ?? { latestVersion: 'unknown', allVersions: [] };
 }
-async function getAllPackageDataBatched(packageNames, onBatchReady, currentVersions, options = {}) {
+/**
+ * Fetches version data for a list of packages from the npm registry.
+ *
+ * Concurrency model:
+ * - `maxConcurrency` is a global cap on in-flight fetches at any moment.
+ *   It doesn't interact with batch size — batches exist only to group
+ *   emissions for the UI.
+ * - No per-request timeouts: slow responses are allowed to finish. Real
+ *   network errors are retried with exponential backoff; after that, we
+ *   fall back to jsdelivr as a last resort. A result is never silently
+ *   dropped due to slowness.
+ *
+ * Callbacks:
+ * - `onBatchReady` fires once a whole emission batch has resolved, in
+ *   original batch order.
+ */
+async function fetchPackageVersions(packageNames, 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);
+        : [Math.max(1, options.batchSize ?? 25)];
+    const maxConcurrency = Math.max(1, options.maxConcurrency ?? 10);
     const total = packageNames.length;
     let completedCount = 0;
+    const pendingEmissions = new Map();
+    let nextEmitIndex = 0;
+    const flushPending = () => {
+        while (pendingEmissions.has(nextEmitIndex)) {
+            const ready = pendingEmissions.get(nextEmitIndex);
+            pendingEmissions.delete(nextEmitIndex);
+            options.onBatchReady?.(ready);
+            nextEmitIndex++;
+        }
+    };
+    // Global semaphore: `maxConcurrency` is the total in-flight cap across
+    // all batches. Batches don't gate concurrency — only emission order.
+    let inFlight = 0;
+    const waiters = [];
+    const acquire = async () => {
+        if (inFlight < maxConcurrency) {
+            inFlight++;
+            return;
+        }
+        await new Promise((resolve) => waiters.push(resolve));
+        inFlight++;
+    };
+    const release = () => {
+        inFlight--;
+        const next = waiters.shift();
+        if (next)
+            next();
+    };
+    const batchPromises = [];
     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 capturedBatchIndex = batchIndex;
         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,
-            };
+        const batchPromise = Promise.all(batchNames.map(async (packageName, itemIndex) => {
+            await acquire();
+            try {
+                const data = await getFreshPackageData(packageName, options.currentVersions?.get(packageName));
+                packageData.set(packageName, data);
+                completedCount++;
+                batchResults[itemIndex] = {
+                    packageName,
+                    data,
+                    completed: completedCount,
+                    total,
+                    batchIndex: capturedBatchIndex,
+                    itemIndex,
+                };
+            }
+            finally {
+                release();
+            }
+        })).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 +291,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) {
@@ -58,6 +81,9 @@ class InputHandler {
                     case 'I':
                         this.onAction({ type: 'toggle_info_modal' });
                         return;
+                    case 'tab':
+                        this.onAction({ type: 'switch_info_modal_tab' });
+                        return;
                     case 'up':
                         this.onAction({ type: 'scroll_info_modal_up' });
                         return;
@@ -65,10 +91,14 @@ class InputHandler {
                         this.onAction({ type: 'scroll_info_modal_down' });
                         return;
                     case 'left':
-                        this.onAction({ type: 'navigate_info_modal_version', direction: 'newer' });
+                        if (uiState.infoModalTab === 'info') {
+                            this.onAction({ type: 'navigate_info_modal_version', direction: 'newer' });
+                        }
                         return;
                     case 'right':
-                        this.onAction({ type: 'navigate_info_modal_version', direction: 'older' });
+                        if (uiState.infoModalTab === 'info') {
+                            this.onAction({ type: 'navigate_info_modal_version', direction: 'older' });
+                        }
                         return;
                     default:
                         return; // Consume all other keys while modal is open
@@ -76,6 +106,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/modal/package-info-sections.js

@@ -4,7 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildReleaseNotesSections = buildReleaseNotesSections;
+exports.buildUsedBySections = buildUsedBySections;
 exports.buildPackageInfoSections = buildPackageInfoSections;
+const node_path_1 = __importDefault(require("node:path"));
 const chalk_1 = __importDefault(require("chalk"));
 const themes_colors_1 = require("../themes-colors");
 const vulnerability_1 = require("../presenters/vulnerability");
@@ -240,8 +242,47 @@ function formatNumber(num) {
         return (num / 1000).toFixed(1) + 'K';
     return num.toString();
 }
-function buildPackageInfoSections(state, modalWidth) {
-    const title = chalk_1.default.cyan.bold(`Package: ${state.name}`);
+function getUsedByPaths(state) {
+    return state.packageJsonPaths ?? [state.packageJsonPath];
+}
+function buildTabBarSuffix(activeTab, usedByCount) {
+    const styleFor = (tab) => tab === activeTab ? chalk_1.default.bold.underline : chalk_1.default.gray;
+    const usedByLabel = `Used by${usedByCount > 0 ? ` (${usedByCount})` : ''}`;
+    return ('  ' +
+        chalk_1.default.gray('[ ') +
+        styleFor('info')('Info') +
+        chalk_1.default.gray(' │ ') +
+        styleFor('usedBy')(usedByLabel) +
+        chalk_1.default.gray(' ]'));
+}
+function buildUsedBySections(state, modalWidth) {
+    const paths = getUsedByPaths(state);
+    const cwd = process.cwd();
+    const contentWidth = Math.max(10, modalWidth - 4);
+    const formatRelative = (absolutePath) => {
+        const display = node_path_1.default.relative(cwd, absolutePath) || absolutePath;
+        return (0, utils_1.truncatePlainText)(display, contentWidth);
+    };
+    return [
+        {
+            key: 'used-by-summary',
+            rows: [
+                chalk_1.default.bold(`${paths.length} package.json file${paths.length === 1 ? '' : 's'} depend on ${state.name}`),
+                chalk_1.default.gray(`Type: ${state.type}`),
+            ],
+            required: true,
+            behavior: 'pinned',
+        },
+        {
+            key: 'used-by-list',
+            rows: paths.map((p) => `${chalk_1.default.gray('•')} ${formatRelative(p)}`),
+            behavior: 'body',
+        },
+    ];
+}
+function buildPackageInfoSections(state, modalWidth, activeTab) {
+    const title = chalk_1.default.cyan.bold(`Package: ${state.name}`) +
+        buildTabBarSuffix(activeTab, getUsedByPaths(state).length);
     const authorLicense = chalk_1.default.gray(`${state.author || 'Unknown'} • ${state.license || 'MIT'}`);
     const currentVersion = chalk_1.default.yellow(state.currentVersionSpecifier);
     const targetVersion = chalk_1.default.green(state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion);
@@ -252,18 +293,22 @@ function buildPackageInfoSections(state, modalWidth) {
             required: true,
             behavior: 'pinned',
         },
-        {
-            key: 'meta',
-            rows: [
-                `Current: ${currentVersion}  Target: ${targetVersion}`,
-                ...(state.weeklyDownloads !== undefined
-                    ? [(0, themes_colors_1.getThemeColor)('primary')(`Downloads/week: ${formatNumber(state.weeklyDownloads)}`)]
-                    : []),
-            ],
-            required: true,
-            behavior: 'pinned',
-        },
     ];
+    if (activeTab === 'usedBy') {
+        sections.push(...buildUsedBySections(state, modalWidth));
+        return sections;
+    }
+    sections.push({
+        key: 'meta',
+        rows: [
+            `Current: ${currentVersion}  Target: ${targetVersion}`,
+            ...(state.weeklyDownloads !== undefined
+                ? [(0, themes_colors_1.getThemeColor)('primary')(`Downloads/week: ${formatNumber(state.weeklyDownloads)}`)]
+                : []),
+        ],
+        required: true,
+        behavior: 'pinned',
+    });
     if (state.homepage) {
         sections.push({
             key: 'homepage',

package/dist/ui/modal/package-info.js

@@ -29,9 +29,9 @@ function renderPackageInfoLoading(state, terminalWidth = 80, terminalHeight = 24
         usesInternalScroll: false,
     };
 }
-function renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0) {
+function renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0, activeTab = 'info') {
     const modalWidth = (0, layout_1.getModalWidth)(terminalWidth, 60, 120);
-    const allSections = (0, package_info_sections_1.buildPackageInfoSections)(state, modalWidth);
+    const allSections = (0, package_info_sections_1.buildPackageInfoSections)(state, modalWidth, activeTab);
     const maxHeight = Math.max(10, terminalHeight - 2);
     const trimOrder = ['homepage', 'changelog', 'description'];
     const compactSections = (0, layout_1.fitModalSections)(allSections, maxHeight, trimOrder);

package/dist/ui/renderer/index.js

@@ -65,8 +65,8 @@ class UIRenderer {
     renderPackageInfoLoading(state, terminalWidth = 80, terminalHeight = 24) {
         return Modal.renderPackageInfoLoading(state, terminalWidth, terminalHeight);
     }
-    renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0) {
-        return Modal.renderPackageInfoModal(state, terminalWidth, terminalHeight, scrollOffset);
+    renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0, activeTab = 'info') {
+        return Modal.renderPackageInfoModal(state, terminalWidth, terminalHeight, scrollOffset, activeTab);
     }
     renderThemeSelectorModal(currentTheme, previewTheme, terminalWidth = 80, terminalHeight = 24) {
         return Modal.renderThemeSelectorModal(currentTheme, previewTheme, terminalWidth, terminalHeight);

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

@@ -9,8 +9,53 @@ class ModalManager {
             isLoadingModalInfo: false,
             infoModalScrollOffset: 0,
             infoModalSessionId: 0,
+            infoModalTab: 'info',
+            showDebugModal: false,
+            debugModalScrollOffset: 0,
         };
     }
+    getInfoModalTab() {
+        return this.state.infoModalTab;
+    }
+    setInfoModalTab(tab) {
+        if (this.state.infoModalTab === tab)
+            return false;
+        this.state.infoModalTab = tab;
+        this.state.infoModalScrollOffset = 0;
+        return true;
+    }
+    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 };
     }
@@ -65,6 +110,7 @@ class ModalManager {
         this.state.infoModalRow = currentRow;
         this.state.infoModalScrollOffset = 0;
         this.state.isLoadingModalInfo = false;
+        this.state.infoModalTab = 'info';
         this.state.infoModalSessionId += 1;
         return this.state.infoModalSessionId;
     }
@@ -73,6 +119,7 @@ class ModalManager {
         this.state.infoModalRow = -1;
         this.state.isLoadingModalInfo = false;
         this.state.infoModalScrollOffset = 0;
+        this.state.infoModalTab = 'info';
         this.state.infoModalSessionId += 1;
     }
     setModalLoading(isLoading, sessionId) {

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

@@ -43,6 +43,9 @@ class StateManager {
             infoModalRow: modalState.infoModalRow,
             isLoadingModalInfo: modalState.isLoadingModalInfo,
             infoModalScrollOffset: modalState.infoModalScrollOffset,
+            infoModalTab: modalState.infoModalTab,
+            showDebugModal: modalState.showDebugModal,
+            debugModalScrollOffset: modalState.debugModalScrollOffset,
             filterMode: filterState.filterMode,
             filterQuery: filterState.filterQuery,
             showThemeModal: themeState.showThemeModal,
@@ -187,6 +190,31 @@ class StateManager {
     clampInfoModalScrollOffset(maxOffset) {
         return this.modalManager.clampScrollOffset(maxOffset);
     }
+    setInfoModalTab(tab) {
+        const changed = this.modalManager.setInfoModalTab(tab);
+        if (changed) {
+            this.renderState.forceFullRender = true;
+        }
+        return changed;
+    }
+    getInfoModalTab() {
+        return this.modalManager.getInfoModalTab();
+    }
+    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.4",
   "description": "Interactive dependency upgrader for npm, yarn, pnpm & bun. Zero-config, monorepo-ready. Upgrade-interactive for every package manager.",
   "main": "dist/index.js",
   "bin": {