modestbench 0.2.0 → 0.3.1

package/dist/reporters/human.js

@@ -13,8 +13,10 @@ import { ansiChars, colors } from "../utils/ansi.js";
 export class HumanReporter extends BaseReporter {
     currentFile = '';
     currentSuite = '';
+    currentSuiteMaxNameLen = 0; // Track max name length for current suite alignment
     failures = [];
     lastProgressLine = '';
+    maxTimePadWidth = 0; // Track maximum time padding width to prevent jitter
     progressWindowActive = false; // Track if progress window is rendered
     quiet;
     showProgress;
@@ -34,6 +36,63 @@ export class HumanReporter extends BaseReporter {
         this.quiet = options.quiet ?? false;
         this.showProgress = options.progress ?? true;
     }
+    /**
+     * Format bytes in human-readable format
+     */
+    static formatBytes(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        let size = bytes;
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        return `${size.toFixed(1)} ${units[unitIndex]}`;
+    }
+    /**
+     * Format file path - show relative path if within CWD, otherwise absolute
+     */
+    static formatPath(filePath) {
+        const cwd = process.cwd();
+        const absolutePath = path.resolve(filePath);
+        // Check if the file is within the current working directory
+        if (absolutePath.startsWith(cwd + path.sep) || absolutePath === cwd) {
+            return path.relative(cwd, absolutePath);
+        }
+        return absolutePath;
+    }
+    /**
+     * Simple pluralization helper
+     */
+    static pluralize(str, count) {
+        return count === 1 ? str : `${str}s`;
+    }
+    onBudgetResult(summary) {
+        if (summary.total === 0 || this.quiet) {
+            return;
+        }
+        this.clearProgress();
+        this.printLine();
+        const budgetHeader = `${this.colorize('magenta', ansiChars.block.full.repeat(2))} ${this.colorize('brightWhite', this.colorize('bold', 'Performance Budgets'))}`;
+        this.printLine(budgetHeader);
+        this.printLine();
+        for (const result of summary.results) {
+            const icon = result.passed ? ansiChars.checkmark : ansiChars.cross;
+            const iconColor = result.passed ? 'brightCyan' : 'brightRed';
+            this.printLine(`  ${this.colorize(iconColor, icon)} ${this.colorize('white', result.taskId)}`);
+            if (!result.passed && result.violations.length > 0) {
+                for (const violation of result.violations) {
+                    this.printLine(`      ${this.colorize('brightRed', violation.message)}`);
+                }
+            }
+        }
+        this.printLine();
+        const statusText = summary.failed === 0
+            ? `${this.colorize('brightCyan', ansiChars.checkmark)} All ${summary.total} budget(s) passed`
+            : `${this.colorize('brightRed', ansiChars.cross)} ${summary.failed} of ${summary.total} budget(s) failed`;
+        this.printLine(`  ${statusText}`);
+        this.printLine();
+    }
     onEnd(run) {
         if (this.quiet) {
             return;
@@ -45,11 +104,13 @@ export class HumanReporter extends BaseReporter {
         let totalSuites = 0;
         let totalPassed = 0;
         let totalFailed = 0;
+        let totalAborted = 0;
         for (const file of run.files) {
             totalSuites += file.suites.length;
             for (const suite of file.suites) {
-                totalPassed += suite.tasks.filter((t) => !t.error).length;
+                totalPassed += suite.tasks.filter((t) => !t.error && !t.aborted).length;
                 totalFailed += suite.tasks.filter((t) => t.error).length;
+                totalAborted += suite.tasks.filter((t) => t.aborted).length;
             }
         }
         // Results header
@@ -58,15 +119,22 @@ export class HumanReporter extends BaseReporter {
         this.printLine();
         this.printLine(`${this.colorize('brightBlue', '  Files:')} ${this.colorize('brightWhite', String(totalFiles))}`);
         this.printLine(`${this.colorize('brightBlue', '  Suites:')} ${this.colorize('brightWhite', String(totalSuites))}`);
-        this.printLine(`${this.colorize('brightBlue', '  Tasks:')} ${this.colorize('brightWhite', String(totalPassed + totalFailed))}`);
-        if (totalFailed > 0) {
-            this.printLine(`${this.colorize('brightRed', ansiChars.cross + ' Failed:')} ${this.colorize('brightWhite', String(totalFailed))}`);
-            this.printLine(`${this.colorize('brightCyan', ansiChars.checkmark + ' Passed:')} ${this.colorize('brightWhite', String(totalPassed))}`);
+        this.printLine(`${this.colorize('brightBlue', '  Tasks:')} ${this.colorize('brightWhite', String(totalPassed + totalFailed + totalAborted))}`);
+        if (totalFailed > 0 || totalAborted > 0) {
+            if (totalFailed > 0) {
+                this.printLine(`${this.colorize('brightRed', ansiChars.cross + ' Failed:')} ${this.colorize('brightWhite', String(totalFailed))}`);
+            }
+            if (totalPassed > 0) {
+                this.printLine(`${this.colorize('brightCyan', ansiChars.checkmark + ' Passed:')} ${this.colorize('brightWhite', String(totalPassed))}`);
+            }
+            if (totalAborted > 0) {
+                this.printLine(`${this.colorize('brightYellow', ansiChars.approx + ' Aborted:')} ${this.colorize('brightWhite', String(totalAborted))}`);
+            }
         }
         else {
             this.printLine(`${this.colorize('brightCyan', ansiChars.checkmark + ' All tasks passed:')} ${this.colorize('brightWhite', String(totalPassed))}`);
         }
-        this.printLine(`${this.colorize('cyan', ansiChars.approx + ' Duration:')} ${this.colorize('brightWhite', this.formatDuration(duration * 1000000))}`);
+        this.printLine(`${this.colorize('cyan', ansiChars.approx + ' Duration:')} ${this.colorize('brightWhite', BaseReporter.formatDuration(duration * 1000000))}`);
         this.printLine();
         if (totalFailed > 0) {
             // Display failed tasks with details
@@ -75,14 +143,15 @@ export class HumanReporter extends BaseReporter {
                 this.printLine(this.colorize('brightRed', this.colorize('bold', 'Failed Tasks:')));
                 this.printLine();
                 for (const failure of this.failures) {
-                    const displayPath = this.formatPath(failure.file);
+                    const displayPath = HumanReporter.formatPath(failure.file);
                     this.printLine(`  ${this.colorize('dim', displayPath)} ${this.colorize('dim', '›')} ${this.colorize('white', failure.suite)} ${this.colorize('dim', '›')} ${this.colorize('brightWhite', failure.task)}`);
                     this.printLine(`    ${this.colorize('brightRed', failure.error)}`);
                     this.printLine();
                 }
             }
         }
-        else {
+        else if (totalAborted === 0) {
+            // Only show "Rad" if no failures AND no aborts
             const successMessage = `${this.colorize('brightMagenta', 'Rad. ☮')}`;
             this.printLine(successMessage);
         }
@@ -108,7 +177,7 @@ export class HumanReporter extends BaseReporter {
             this.printLine(this.colorize('red', `  ${ansiChars.cross} ${totalFailed} failed, ${totalPassed} passed`));
         }
         else {
-            this.printLine(` ${this.colorize('magenta', ansiChars.checkmark)} ${totalPassed > 1 ? this.colorize('brightMagenta', 'All ') : ''}${this.colorize('bold', this.colorize('brightMagenta', `${totalPassed}`))} ${this.colorize('brightMagenta', `${this.pluralize('task', totalPassed)} passed`)}`);
+            this.printLine(` ${this.colorize('magenta', ansiChars.checkmark)} ${totalPassed > 1 ? this.colorize('brightMagenta', 'All ') : ''}${this.colorize('bold', this.colorize('brightMagenta', `${totalPassed}`))} ${this.colorize('brightMagenta', `${HumanReporter.pluralize('task', totalPassed)} passed`)}`);
         }
         this.printLine();
     }
@@ -117,7 +186,7 @@ export class HumanReporter extends BaseReporter {
         if (this.quiet) {
             return;
         }
-        const displayPath = this.formatPath(file);
+        const displayPath = HumanReporter.formatPath(file);
         const fileMarker = `${colors.magenta}${ansiChars.block.dark}${ansiChars.block.dark}${colors.reset}`;
         this.printLine(`${fileMarker} ${colors.underline}${this.colorize('brightMagenta', this.colorize('bold', displayPath))}${colors.reset}`);
     }
@@ -130,7 +199,7 @@ export class HumanReporter extends BaseReporter {
         if (!process.stdout.isTTY) {
             return;
         }
-        const { elapsed, percentage, tasksCompleted, totalTasks } = state;
+        const { currentTask, elapsed, percentage, tasksCompleted, totalTasks } = state;
         // Pad task counts for alignment
         const totalTasksWidth = String(totalTasks).length;
         const paddedTasksCompleted = String(tasksCompleted).padStart(totalTasksWidth, ' ');
@@ -139,7 +208,7 @@ export class HumanReporter extends BaseReporter {
         const elapsedStrRaw = this.formatTimeRemaining(elapsedSeconds);
         // Calculate ETA if we have completed tasks and determine padding width
         let etaStr = '';
-        let padWidth = elapsedStrRaw.length;
+        let padWidth = Math.max(this.maxTimePadWidth, elapsedStrRaw.length);
         if (tasksCompleted > 0) {
             const avgTimePerTask = elapsed / tasksCompleted;
             const remainingTasks = totalTasks - tasksCompleted;
@@ -147,12 +216,21 @@ export class HumanReporter extends BaseReporter {
             const etaSeconds = Math.round(etaMs / 1000);
             const etaTimeStr = this.formatTimeRemaining(etaSeconds);
             padWidth = Math.max(padWidth, etaTimeStr.length);
-            etaStr = ` ${this.colorize('dim', '|')} ${this.colorize('dim', 'ETA:')} ${this.colorize('brightBlue', etaTimeStr)}`;
+            etaStr = ` ${this.colorize('gray', '|')} ${this.colorize('gray', 'ETA:')} ${this.colorize('brightBlue', etaTimeStr)}`;
         }
+        // Remember the maximum width we've ever used to prevent jitter
+        this.maxTimePadWidth = Math.max(this.maxTimePadWidth, padWidth);
         // Pad elapsed time to match the longest time string
-        const elapsedStr = elapsedStrRaw.padStart(padWidth, ' ');
+        const elapsedStr = elapsedStrRaw.padStart(this.maxTimePadWidth, ' ');
         const roundedPercentage = percentage.toFixed(2);
-        const line = `${this.colorize('brightCyan', ansiChars.approx)} ${this.colorize('white', paddedTasksCompleted)}${this.colorize('dim', '/')}${this.colorize('white', String(totalTasks))} ${this.colorize('dim', 'tasks')} ${this.colorize('dim', '(')}${this.colorize('brightBlue', roundedPercentage + '%')}${this.colorize('dim', ')')} ${this.colorize('dim', '|')} ${this.colorize('dim', 'Elapsed:')} ${this.colorize('cyan', elapsedStr)}${etaStr}`;
+        // Build progress line with current task if available
+        let line = `${this.colorize('brightCyan', ansiChars.approx)} ${this.colorize('white', paddedTasksCompleted)}${this.colorize('gray', '/')}${this.colorize('white', String(totalTasks))} ${this.colorize('gray', 'tasks')} ${this.colorize('gray', '(')}${this.colorize('brightBlue', roundedPercentage + '%')}${this.colorize('gray', ')')} ${this.colorize('gray', '|')} ${this.colorize('gray', 'Elapsed:')} ${this.colorize('cyan', elapsedStr)}${etaStr}`;
+        if (currentTask) {
+            const truncatedTask = currentTask.length > 60
+                ? currentTask.substring(0, 57) + '...'
+                : currentTask;
+            line += ` ${this.colorize('gray', '|')} ${this.colorize('white', truncatedTask)}`;
+        }
         this.lastProgressLine = line;
         this.renderProgressWindow();
     }
@@ -160,6 +238,7 @@ export class HumanReporter extends BaseReporter {
         this.startTime = Date.now();
         this.failures = []; // Reset failures for new run
         this.lastProgressLine = ''; // Reset for new run
+        this.maxTimePadWidth = 0; // Reset time padding width for new run
         if (this.quiet) {
             return;
         }
@@ -175,7 +254,7 @@ export class HumanReporter extends BaseReporter {
     \x1b[48;5;0m \x1b[48;5;14m \x1b[38;5;30;48;5;38m▄\x1b[38;5;14;48;5;14m▄\x1b[48;5;14m      \x1b[38;5;45;48;5;14m▄\x1b[38;5;89;48;5;14m▄\x1b[38;5;89;48;5;89m▄\x1b[38;5;14;48;5;31m▄\x1b[48;5;14m \x1b[38;5;37;48;5;89m▄\x1b[48;5;198m \x1b[38;5;198;48;5;198m▄\x1b[38;5;31;48;5;14m▄\x1b[48;5;14m \x1b[48;5;0m \x1b[m \x1b[2mnode.js:\x1b[m \x1b[36m${run.environment.nodeVersion} \x1b[m
     \x1b[48;5;0m \x1b[48;5;14m \x1b[38;5;44;48;5;31m▄\x1b[48;5;14m      \x1b[38;5;126;48;5;38m▄\x1b[38;5;198;48;5;237m▄\x1b[38;5;237;48;5;37m▄\x1b[48;5;14m   \x1b[38;5;14;48;5;14m▄\x1b[38;5;162;48;5;198m▄▄\x1b[38;5;53;48;5;240m▄\x1b[48;5;14m \x1b[48;5;0m \x1b[m \x1b[2mplatform:\x1b[m \x1b[36m${run.environment.platform} ${run.environment.arch} \x1b[m
     \x1b[48;5;0m \x1b[38;5;45;48;5;14m▄\x1b[48;5;14m       \x1b[38;5;14;48;5;37m▄\x1b[38;5;14;48;5;5m▄\x1b[38;5;14;48;5;44m▄\x1b[48;5;14m       \x1b[38;5;45;48;5;14m▄\x1b[48;5;0m \x1b[m \x1b[2mcpu:\x1b[m \x1b[36m${run.environment.cpu.model} \x1b[2m(\x1b[m\x1b[36m${run.environment.cpu.cores} cores\x1b[2m) \x1b[m
-    \x1b[49;38;5;0m▀▀\x1b[38;5;0;48;5;6m▄\x1b[38;5;232;48;5;14m▄\x1b[38;5;38;48;5;14m▄\x1b[48;5;14m           \x1b[38;5;30;48;5;14m▄\x1b[38;5;0;48;5;14m▄\x1b[38;5;0;48;5;23m▄\x1b[49;38;5;0m▀▀\x1b[m \x1b[2mmem:\x1b[m \x1b[36m${this.formatBytes(run.environment.memory.total)} \x1b[m
+    \x1b[49;38;5;0m▀▀\x1b[38;5;0;48;5;6m▄\x1b[38;5;232;48;5;14m▄\x1b[38;5;38;48;5;14m▄\x1b[48;5;14m           \x1b[38;5;30;48;5;14m▄\x1b[38;5;0;48;5;14m▄\x1b[38;5;0;48;5;23m▄\x1b[49;38;5;0m▀▀\x1b[m \x1b[2mmem:\x1b[m \x1b[36m${HumanReporter.formatBytes(run.environment.memory.total)} \x1b[m
     \x1b[49m    \x1b[49;38;5;0m▀\x1b[38;5;0;48;5;236m▄\x1b[38;5;0;48;5;45m▄\x1b[38;5;23;48;5;14m▄\x1b[48;5;14m     \x1b[38;5;236;48;5;14m▄\x1b[38;5;0;48;5;44m▄\x1b[38;5;0;48;5;232m▄\x1b[49;38;5;0m▀\x1b[49m    \x1b[m
     \x1b[49m       \x1b[49;38;5;0m▀▀\x1b[38;5;0;48;5;37m▄\x1b[38;5;0;48;5;14m▄\x1b[38;5;0;48;5;30m▄\x1b[49;38;5;0m▀▀\x1b[49m       \x1b[m
     `;
@@ -210,22 +289,53 @@ export class HumanReporter extends BaseReporter {
         if (this.quiet) {
             return;
         }
-        // Print all buffered task results with aligned columns
-        this.printAlignedSuiteResults();
+        // Tasks are printed immediately in onTaskResult, so just print suite summary
         // Skip displaying summary for the implicit "default" suite
         if (result.name === 'default') {
             return;
         }
-        const passed = result.tasks.filter((t) => !t.error).length;
+        const passed = result.tasks.filter((t) => !t.error && !t.aborted).length;
         const failed = result.tasks.filter((t) => t.error).length;
+        const aborted = result.tasks.filter((t) => t.aborted).length;
+        const durationStr = BaseReporter.formatDuration(result.duration * 1000000); // ms to ns
+        // Build summary parts
+        const parts = [];
         if (failed > 0) {
-            this.printLine(`  ${this.colorize('red', `${ansiChars.cross} ${failed} failed`)}, ${this.colorize('green', `${passed} passed`)}`);
+            parts.push(this.colorize('red', `${ansiChars.cross} ${failed} failed`));
+        }
+        if (passed > 0) {
+            parts.push(this.colorize('green', `${passed} passed`));
+        }
+        if (aborted > 0) {
+            parts.push(this.colorize('brightYellow', `${aborted} aborted`));
+        }
+        const summary = parts.join(', ');
+        const timeInfo = `${this.colorize('gray', 'in')} ${this.colorize('cyan', durationStr)}`;
+        if (failed > 0 || aborted > 0) {
+            this.printLine(`  ${summary} ${timeInfo}`);
         }
         else {
-            this.printLine(`  ${this.colorize('magenta', ansiChars.checkmark)} ${this.colorize('bold', this.colorize('brightWhite', `${passed}`))} ${this.colorize('brightWhite', `${this.pluralize('task', passed)} passed`)}`);
+            this.printLine(`  ${this.colorize('magenta', ansiChars.checkmark)} ${this.colorize('bold', this.colorize('brightWhite', `${passed}`))} ${this.colorize('brightWhite', `${HumanReporter.pluralize('task', passed)} passed`)} ${timeInfo}`);
         }
         this.printLine();
     }
+    onSuiteInit(suite, taskNames) {
+        // Pre-calculate max name length for optimal alignment
+        const terminalWidth = process.stdout.columns || 80;
+        const STATS_RESERVED_WIDTH = 70;
+        const MAX_NAME_WIDTH = Math.max(40, Math.min(60, terminalWidth - 4 - 2 - 2 - STATS_RESERVED_WIDTH));
+        // Calculate the actual max name length from non-wrapped names
+        let maxLen = 0;
+        for (const name of taskNames) {
+            const nameLen = this.getVisibleLength(name.trim());
+            // Only count names that won't wrap
+            if (nameLen <= MAX_NAME_WIDTH) {
+                maxLen = Math.max(maxLen, nameLen);
+            }
+        }
+        // Use the max of actual names or MAX_NAME_WIDTH for consistency
+        this.currentSuiteMaxNameLen = Math.max(maxLen, MAX_NAME_WIDTH);
+    }
     onSuiteStart(suite) {
         this.currentSuite = suite;
         if (this.quiet) {
@@ -244,8 +354,14 @@ export class HumanReporter extends BaseReporter {
         if (this.quiet) {
             return;
         }
-        // Buffer the result for later printing with proper alignment
+        // Always buffer the result for suite summary (including aborted tasks)
         this.suiteResults.push(result);
+        // Skip printing aborted tasks (they're counted in summary but not shown individually)
+        if (result.aborted) {
+            return;
+        }
+        // Print immediately with current alignment
+        this.printTaskResult(result);
     }
     onTaskStart(task) {
         if (this.quiet) {
@@ -285,31 +401,6 @@ export class HumanReporter extends BaseReporter {
         }
         return `${colors[color]}${text}${colors.reset}`;
     }
-    /**
-     * Format bytes in human-readable format
-     */
-    formatBytes(bytes) {
-        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-        let size = bytes;
-        let unitIndex = 0;
-        while (size >= 1024 && unitIndex < units.length - 1) {
-            size /= 1024;
-            unitIndex++;
-        }
-        return `${size.toFixed(1)} ${units[unitIndex]}`;
-    }
-    /**
-     * Format file path - show relative path if within CWD, otherwise absolute
-     */
-    formatPath(filePath) {
-        const cwd = process.cwd();
-        const absolutePath = path.resolve(filePath);
-        // Check if the file is within the current working directory
-        if (absolutePath.startsWith(cwd + path.sep) || absolutePath === cwd) {
-            return path.relative(cwd, absolutePath);
-        }
-        return absolutePath;
-    }
     /**
      * Format duration in human-readable format for progress display
      */
@@ -336,12 +427,6 @@ export class HumanReporter extends BaseReporter {
         // eslint-disable-next-line no-control-regex
         return str.replace(/\x1b\[[0-9;]*m/g, '').length;
     }
-    /**
-     * Simple pluralization helper
-     */
-    pluralize(str, count) {
-        return count === 1 ? str : `${str}s`;
-    }
     /**
      * Print all task results in a suite with aligned columns
      */
@@ -349,10 +434,17 @@ export class HumanReporter extends BaseReporter {
         if (this.suiteResults.length === 0) {
             return;
         }
-        const MAX_NAME_WIDTH = 60;
         const BASE_INDENT = '    '; // 4 spaces
         const bullet = this.colorize('dim', this.colorize('gray', ansiChars.bullet));
-        const formatted = this.suiteResults.map((result) => {
+        // Calculate maximum name width based on terminal width
+        // Reserve space for: indent (4) + status (1) + space (1) + name + ": " (2) + stats (~60 chars)
+        const terminalWidth = process.stdout.columns || 80;
+        const STATS_RESERVED_WIDTH = 70; // Approx space for duration + rme + ops/sec with padding
+        const MAX_NAME_WIDTH = Math.max(40, Math.min(60, terminalWidth - BASE_INDENT.length - 2 - 2 - STATS_RESERVED_WIDTH));
+        // Filter out aborted tasks (they're counted in suite summary but not printed)
+        const formatted = this.suiteResults
+            .filter((result) => !result.aborted)
+            .map((result) => {
             const status = result.error
                 ? this.colorize('red', ansiChars.cross)
                 : this.colorize('brightCyan', ansiChars.checkmark);
@@ -374,9 +466,9 @@ export class HumanReporter extends BaseReporter {
                     status,
                 };
             }
-            const duration = this.formatDuration(result.mean); // already in nanoseconds
-            const opsPerSec = this.formatOpsPerSecond(result.opsPerSecond);
-            const rme = this.formatPercentage(result.marginOfError * 100);
+            const duration = BaseReporter.formatDuration(result.mean); // already in nanoseconds
+            const opsPerSec = BaseReporter.formatOpsPerSecond(result.opsPerSecond);
+            const rme = BaseReporter.formatPercentage(result.marginOfError); // already a percentage
             return {
                 durationLen: this.getVisibleLength(duration),
                 durationStr: duration,
@@ -399,9 +491,6 @@ export class HumanReporter extends BaseReporter {
         const maxDurationLen = Math.max(...formatted.filter((t) => !t.error).map((t) => t.durationLen), 0);
         const maxRmeLen = Math.max(...formatted.filter((t) => !t.error).map((t) => t.rmeLen), 0);
         const maxOpsLen = Math.max(...formatted.filter((t) => !t.error).map((t) => t.opsPerSecLen), 0);
-        // Calculate the position where numbers start for unwrapped lines
-        // BASE_INDENT (4) + status (1 char) + space (1) + maxNameLen + ": " (2) = 8 + maxNameLen
-        const numbersStartPos = BASE_INDENT.length + 2 + maxNameLen + 2;
         // Print each task with aligned columns
         for (const task of formatted) {
             if (task.error) {
@@ -415,15 +504,33 @@ export class HumanReporter extends BaseReporter {
                 this.printLine(`${BASE_INDENT}${task.status} ${this.colorize('white', task.name)} ${this.colorize('red', 'FAILED')}`);
             }
             else if (task.nameLength > MAX_NAME_WIDTH) {
-                // Long name - wrap to next line, but align numbers with unwrapped lines
-                this.printLine(`${BASE_INDENT}${task.status} ${this.colorize('white', task.name)}:`);
-                // Calculate padding to align with unwrapped lines
-                // We need to get to numbersStartPos from the beginning of the line
-                const leadingPad = ' '.repeat(numbersStartPos);
+                // Long name - wrap to multiple lines, align last line with short names
+                const wrappedLines = this.wrapText(task.name, MAX_NAME_WIDTH);
+                const continueIndent = BASE_INDENT + '  '; // 6 spaces for continuation lines
+                // Format stats string
                 const durationPad = ' '.repeat(maxDurationLen - task.durationLen);
                 const rmePad = ' '.repeat(maxRmeLen - task.rmeLen);
                 const opsPad = ' '.repeat(maxOpsLen - task.opsPerSecLen);
-                this.printLine(`${leadingPad}${durationPad}${this.colorize('cyan', task.durationStr)} ${bullet} ${ansiChars.plusMinus}${rmePad}${this.colorize('brightBlue', task.rmeStr)} ${bullet} ${opsPad}${this.colorize('magenta', task.opsPerSecStr)}`);
+                const statsStr = `${durationPad}${this.colorize('cyan', task.durationStr)} ${bullet} ${ansiChars.plusMinus}${rmePad}${this.colorize('brightBlue', task.rmeStr)} ${bullet} ${opsPad}${this.colorize('magenta', task.opsPerSecStr)}`;
+                // Print first line with status
+                this.printLine(`${BASE_INDENT}${task.status} ${this.colorize('white', wrappedLines[0])}`);
+                // Print middle continuation lines (all but first and last)
+                for (let i = 1; i < wrappedLines.length - 1; i++) {
+                    this.printLine(`${continueIndent}${this.colorize('white', wrappedLines[i])}`);
+                }
+                // Print last line with colon and stats aligned with short names
+                if (wrappedLines.length > 1) {
+                    const lastLine = wrappedLines[wrappedLines.length - 1];
+                    const lastLineLen = this.getVisibleLength(lastLine);
+                    // Pad the last line to align the ':' with short names
+                    const lastLinePad = ' '.repeat(Math.max(0, maxNameLen - lastLineLen));
+                    this.printLine(`${continueIndent}${this.colorize('white', lastLine)}${lastLinePad}: ${statsStr}`);
+                }
+                else {
+                    // Single wrapped line
+                    const lastLinePad = ' '.repeat(maxNameLen - task.nameLength);
+                    this.printLine(`${BASE_INDENT}${task.status} ${this.colorize('white', task.name)}${lastLinePad}: ${statsStr}`);
+                }
                 if (this.verbose && task.iterations > 0) {
                     this.printLine(`      ${this.colorize('dim', `${task.iterations} iterations`)}`);
                 }
@@ -451,6 +558,84 @@ export class HumanReporter extends BaseReporter {
         console.log(message);
         this.renderProgressWindow();
     }
+    /**
+     * Print a single task result immediately with current alignment
+     */
+    printTaskResult(result) {
+        // Clear progress bar temporarily
+        this.clearProgress();
+        const BASE_INDENT = '    '; // 4 spaces
+        const bullet = this.colorize('dim', this.colorize('gray', ansiChars.bullet));
+        // Calculate terminal width constraints
+        const terminalWidth = process.stdout.columns || 80;
+        const STATS_RESERVED_WIDTH = 70;
+        const MAX_NAME_WIDTH = Math.max(40, Math.min(60, terminalWidth - BASE_INDENT.length - 2 - 2 - STATS_RESERVED_WIDTH));
+        // Status marker
+        const status = result.error
+            ? this.colorize('red', ansiChars.cross)
+            : this.colorize('brightCyan', ansiChars.checkmark);
+        const name = result.name.trim();
+        const nameLength = this.getVisibleLength(name);
+        // Handle errors
+        if (result.error) {
+            this.failures.push({
+                error: result.error?.message || String(result.error),
+                file: this.currentFile,
+                suite: this.currentSuite,
+                task: name,
+            });
+            this.printLine(`${BASE_INDENT}${status} ${this.colorize('white', name)} ${this.colorize('red', 'FAILED')}`);
+            return;
+        }
+        // Format stats
+        const duration = BaseReporter.formatDuration(result.mean);
+        const opsPerSec = BaseReporter.formatOpsPerSecond(result.opsPerSecond);
+        const rme = BaseReporter.formatPercentage(result.marginOfError);
+        // Use fixed widths for stats columns (reasonable maximums)
+        const DURATION_WIDTH = 10; // "999.99ms" max
+        const RME_WIDTH = 8; // "±999.99%" max
+        const OPS_WIDTH = 15; // "999.99K ops/sec" max
+        const durationLen = this.getVisibleLength(duration);
+        const rmeLen = this.getVisibleLength(rme);
+        const opsLen = this.getVisibleLength(opsPerSec);
+        // Stats formatting with fixed widths
+        const durationPad = ' '.repeat(DURATION_WIDTH - durationLen);
+        const rmePad = ' '.repeat(RME_WIDTH - rmeLen);
+        const opsPad = ' '.repeat(OPS_WIDTH - opsLen);
+        const statsStr = `${durationPad}${this.colorize('cyan', duration)} ${bullet} ${ansiChars.plusMinus}${rmePad}${this.colorize('brightBlue', rme)} ${bullet} ${opsPad}${this.colorize('magenta', opsPerSec)}`;
+        // Handle long names (wrap)
+        if (nameLength > MAX_NAME_WIDTH) {
+            const wrappedLines = this.wrapText(name, MAX_NAME_WIDTH);
+            const continueIndent = BASE_INDENT + '  '; // 6 spaces for continuation lines
+            // Print first line with status
+            this.printLine(`${BASE_INDENT}${status} ${this.colorize('white', wrappedLines[0])}`);
+            // Print middle lines (all but first and last)
+            for (let i = 1; i < wrappedLines.length - 1; i++) {
+                this.printLine(`${continueIndent}${this.colorize('white', wrappedLines[i])}`);
+            }
+            // Print last line with colon and stats aligned
+            // Use pre-calculated currentSuiteMaxNameLen for perfect alignment
+            if (wrappedLines.length > 1) {
+                const lastLine = wrappedLines[wrappedLines.length - 1];
+                const lastLineLen = this.getVisibleLength(lastLine);
+                const lastLinePad = ' '.repeat(Math.max(0, this.currentSuiteMaxNameLen - lastLineLen));
+                this.printLine(`${continueIndent}${this.colorize('white', lastLine)}${lastLinePad}: ${statsStr}`);
+            }
+            else {
+                // Single wrapped line (shouldn't happen if nameLength > MAX but handle it)
+                const lastLinePad = ' '.repeat(Math.max(0, this.currentSuiteMaxNameLen - nameLength));
+                this.printLine(`${BASE_INDENT}${status} ${this.colorize('white', name)}${lastLinePad}: ${statsStr}`);
+            }
+        }
+        else {
+            // Normal length - print on same line with pre-calculated alignment
+            const namePad = ' '.repeat(Math.max(0, this.currentSuiteMaxNameLen - nameLength));
+            this.printLine(`${BASE_INDENT}${status} ${this.colorize('white', name)}${namePad}: ${statsStr}`);
+        }
+        if (this.verbose && result.iterations > 0) {
+            this.printLine(`      ${this.colorize('dim', `${result.iterations} iterations`)}`);
+        }
+    }
     /**
      * Render the progress window at the bottom
      */
@@ -467,5 +652,43 @@ export class HumanReporter extends BaseReporter {
         console.log(this.lastProgressLine);
         this.progressWindowActive = true;
     }
+    /**
+     * Wrap text to a maximum width, breaking at word boundaries when possible
+     */
+    wrapText(text, maxWidth) {
+        if (this.getVisibleLength(text) <= maxWidth) {
+            return [text];
+        }
+        const lines = [];
+        let currentLine = '';
+        const words = text.split(/(\s+)/); // Keep whitespace in split
+        for (const word of words) {
+            const testLine = currentLine + word;
+            if (this.getVisibleLength(testLine) <= maxWidth) {
+                currentLine = testLine;
+            }
+            else {
+                // If current line has content, save it
+                if (currentLine.trim()) {
+                    lines.push(currentLine.trimEnd());
+                    currentLine = word.trim() + ' ';
+                }
+                else {
+                    // Single word is too long, force break it
+                    if (this.getVisibleLength(word) > maxWidth) {
+                        lines.push(word.substring(0, maxWidth));
+                        currentLine = word.substring(maxWidth);
+                    }
+                    else {
+                        currentLine = word;
+                    }
+                }
+            }
+        }
+        if (currentLine.trim()) {
+            lines.push(currentLine.trimEnd());
+        }
+        return lines;
+    }
 }
 //# sourceMappingURL=human.js.map