@step-forge/step-forge 0.0.25-alpha.1 → 0.0.25-alpha.2

package/RUNTIME.md

@@ -166,8 +166,11 @@ population):
   every subsequent file change. Pressing Enter again forces a re-run.
 - **Editing the query** suspends auto-runs until you press Enter again — so you
   can retarget without a half-typed selection firing.
-- **↑ / ↓** move the selection highlight; **PgUp / PgDn** scroll the failures
-  pane when a run has more failures than fit on screen (the top stays pinned).
+- **↑ / ↓** move the selection highlight. The **mouse wheel** (or **PgUp /
+  PgDn**) scrolls the failures pane when a run has more failures than fit on
+  screen — the prompt, selection, and stats stay pinned. (While the dashboard is
+  up the wheel drives the results pane, so hold **Shift** for native terminal
+  text selection.)
 - **Esc** disarms and returns to browsing.
 - **Ctrl-C** quits and restores the terminal.
 

package/dist/cli.cjs

@@ -12,6 +12,7 @@ let node_util = require("node:util");
 let node_child_process = require("node:child_process");
 let node_readline = require("node:readline");
 node_readline = require_gherkinParser.__toESM(node_readline, 1);
+let node_stream = require("node:stream");
 //#region src/runtime/config.ts
 const DEFAULT_FEATURES = "**/*.feature";
 const DEFAULT_STEPS = "**/*.steps.ts";
@@ -528,9 +529,14 @@ var Prompt = class {
 	results = freshResults();
 	failScroll = 0;
 	started = false;
+	/** Filtered key stream: raw stdin minus the mouse sequences we handle. */
+	input;
 	keyListener;
+	dataListener;
 	resizeListener;
 	signalCleanup;
+	/** Carry an incomplete mouse sequence split across stdin chunks. */
+	mousePending = "";
 	constructor(options) {
 		this.handlers = options.handlers;
 		this.prefix = options.prefix ?? "› ";
@@ -585,11 +591,14 @@ var Prompt = class {
 	start() {
 		if (this.started) return;
 		this.started = true;
-		node_readline.emitKeypressEvents(process.stdin);
 		if (process.stdin.isTTY) process.stdin.setRawMode(true);
-		write("\x1B[?1049h");
+		write("\x1B[?1049h\x1B[?1000h\x1B[?1006h");
+		this.input = new node_stream.PassThrough();
+		node_readline.emitKeypressEvents(this.input);
 		this.keyListener = (str, key) => this.onKey(str, key ?? {});
-		process.stdin.on("keypress", this.keyListener);
+		this.input.on("keypress", this.keyListener);
+		this.dataListener = (chunk) => this.onStdinData(chunk);
+		process.stdin.on("data", this.dataListener);
 		process.stdin.resume();
 		this.resizeListener = () => this.render();
 		process.stdout.on("resize", this.resizeListener);
@@ -600,11 +609,14 @@ var Prompt = class {
 	stop() {
 		if (!this.started) return;
 		this.started = false;
-		if (this.keyListener) process.stdin.off("keypress", this.keyListener);
+		if (this.dataListener) process.stdin.off("data", this.dataListener);
+		if (this.keyListener) this.input?.off("keypress", this.keyListener);
 		if (this.resizeListener) process.stdout.off("resize", this.resizeListener);
 		this.signalCleanup?.();
 		this.restoreTerminal();
 		process.stdin.pause();
+		this.input = void 0;
+		this.mousePending = "";
 	}
 	/** Force a repaint (after mutating `status`, say). No-op until started. */
 	redraw() {
@@ -617,6 +629,7 @@ var Prompt = class {
 	*/
 	restoreTerminal() {
 		if (process.stdin.isTTY) process.stdin.setRawMode(false);
+		write("\x1B[?1006l\x1B[?1000l");
 		write("\x1B[?25h");
 		write("\x1B[?1049l");
 	}
@@ -720,12 +733,57 @@ var Prompt = class {
 		this.reWindow();
 		this.render();
 	}
-	/** Scroll the failures pane by a page (clamped in {@link render}). */
+	/** Scroll the failures pane by whole pages (PgUp/PgDn). */
 	scrollFailures(pages) {
-		this.failScroll = Math.max(0, this.failScroll + pages * this.failPage);
-		this.render();
+		this.adjustFailScroll(pages * this.failPage);
 	}
 	failPage = 1;
+	/** Move the failures viewport by `deltaLines` (clamped in {@link render}). */
+	adjustFailScroll(deltaLines) {
+		this.failScroll = Math.max(0, this.failScroll + deltaLines);
+		this.render();
+	}
+	/**
+	* Split a raw stdin chunk: decode SGR/legacy mouse sequences here (only the
+	* wheel is acted on — it scrolls the failures pane by a few lines) and forward
+	* everything else to readline. An incomplete trailing mouse sequence is held
+	* in {@link mousePending} for the next chunk. `latin1` keeps every byte 1:1 so
+	* the forwarded bytes reassemble exactly (including multibyte input).
+	*/
+	onStdinData(chunk) {
+		const buf = this.mousePending + chunk.toString("latin1");
+		let out = "";
+		let i = 0;
+		while (i < buf.length) {
+			if (buf.startsWith("\x1B[<", i)) {
+				const rel = /[Mm]/.exec(buf.slice(i + 3));
+				if (!rel) break;
+				const end = i + 3 + rel.index + 1;
+				this.handleMouse(buf.slice(i, end));
+				i = end;
+				continue;
+			}
+			if (buf.startsWith("\x1B[M", i)) {
+				if (i + 6 > buf.length) break;
+				this.handleMouse(buf.slice(i, i + 6));
+				i += 6;
+				continue;
+			}
+			out += buf[i];
+			i++;
+		}
+		this.mousePending = buf.slice(i);
+		if (out) this.input?.write(Buffer.from(out, "latin1"));
+	}
+	/** Act on a decoded mouse sequence — wheel up/down scrolls failures; else ignore. */
+	handleMouse(seq) {
+		let button = null;
+		const sgr = /^\x1b\[<(\d+);\d+;\d+[Mm]$/.exec(seq);
+		if (sgr) button = parseInt(sgr[1], 10);
+		else if (seq.length === 6) button = seq.charCodeAt(3) - 32;
+		if (button === null || (button & 64) === 0) return;
+		this.adjustFailScroll((button & 1) === 0 ? -3 : 3);
+	}
 	refilter() {
 		const q = this.query.trim().toLowerCase();
 		this.matches = this.all.map((s, index) => ({