windscout 0.6.4 → 0.7.0

package/dist/probe.js

@@ -1,62 +1,100 @@
 // One attempt: connect to a location over a protocol, measure through the tunnel, disconnect.
-import { latencyMs, speedMbps } from "./measure.js";
+// windscout connect makes the same attempt and, when it works, stays connected.
+import { latencyMs, SPEED_SECONDS, speedMbps } from "./measure.js";
 import { now, sleep } from "./time.js";
 import { connectState, windscribe } from "./windscribe.js";
+// Stop at the first ends the scan at one connection, so that one has to last: a tunnel can connect and then be cut or throttled
+// once traffic flows. It counts once it downloads at MIN_MBPS or more, then stays up with internet for STEADY_CHECKS round trips
+export const MIN_MBPS = 1;
+const STEADY_CHECKS = 5, STEADY_GAP = 2; // seconds between the round trips
+// shortcut: guesses ~5 s to connect and the whole speed test; refine from real runs
+export const STEADY_SECONDS = 5 + SPEED_SECONDS + STEADY_CHECKS * (STEADY_GAP + 0.5);
+/** Whether stop at the first can stop at this result: it worked, held up, and is fast enough for real use */
+export const reliable = (r) => r.status === "ok" && (r.speedMbps ?? 0) >= MIN_MBPS;
 // "Connected: Miami - Vice" → "Miami - Vice"
 const place = (state) => state.split(":").slice(1).join(":").trim();
-export async function probe(query, protocol, { timeout, speedTest, stopped = () => false, onStep = () => { }, measure = (fn) => fn() }) {
+export async function probe(query, protocol, options) {
+    try {
+        return await attempt(query, protocol, options);
+    }
+    finally {
+        options.onStep?.("disconnecting");
+        await disconnect();
+    }
+}
+/** Disconnects, and waits until the app has */
+export async function disconnect() {
+    await windscribe("disconnect");
+    // the CLI's disconnect can return while the app is still tearing down (it does after a timed-out connect);
+    // a connect sent then is swallowed and the next attempt reads as an instant "failed", so wait it out
+    for (let i = 0; i < 30 && (await connectState()) === "Disconnecting"; i++)
+        await sleep(1000);
+}
+/** Connects and measures through the tunnel, as probe does, but leaves the connection as it is: up when it worked */
+export async function attempt(query, protocol, { timeout, speedTest, steady = false, stopped = () => false, onStep = () => { }, measure = (fn) => fn() }) {
     const r = { query, protocol, location: "", connectS: null, latencyMs: null, speedMbps: null };
     const end = (status) => ({ ...r, status });
     onStep("connecting");
     await windscribe("connect", "-n", query, protocol);
     const t = now();
-    try {
-        for (;;) {
-            if (stopped())
-                return end("interrupted");
-            if (now() - t >= timeout)
-                return end("timeout");
-            const s = await connectState();
-            if (s.startsWith("Connecting:"))
+    for (;;) {
+        if (stopped())
+            return end("interrupted");
+        if (now() - t >= timeout)
+            return end("timeout");
+        const s = await connectState();
+        if (s.startsWith("Connecting:"))
+            r.location = place(s);
+        else if (s.startsWith("Connected")) {
+            if (s.includes(":"))
                 r.location = place(s);
-            else if (s.startsWith("Connected")) {
-                if (s.includes(":"))
-                    r.location = place(s);
-                r.connectS = now() - t;
-                break;
-            }
-            else if (s.includes("does not exist"))
-                return end("no such location");
-            // Windscribe refused this app another WireGuard key for the account: says nothing about this network
-            else if (s.includes("WireGuard key limit") && now() - t > 3)
-                return end("key limit");
-            else if (s === "Disconnected" && now() - t > 3)
-                return end("failed");
-            onStep(`connecting ${r.location}`.trim());
-            await sleep(1000);
+            r.connectS = now() - t;
+            break;
         }
-        // a port the app doesn't offer for the protocol: it connects on the protocol's default instead, so this port wasn't tried
-        const port = protocol.split(":")[1], shown = (await windscribe("status")).match(/^Protocol: .*:(\d+)\s*$/m)?.[1];
-        if (port && shown && shown !== port)
-            return end("no such port");
-        await measure(async () => {
-            onStep(`measuring latency · ${r.location}`);
-            r.latencyMs = await latencyMs();
-            if (r.latencyMs !== null && speedTest) {
-                onStep(`measuring speed · ${r.location}`);
-                r.speedMbps = await speedMbps();
-            }
-        });
-        return end(r.latencyMs === null ? "no internet" : "ok");
+        else if (s.includes("does not exist"))
+            return end("no such location");
+        // Windscribe refused this app another WireGuard key for the account: says nothing about this network
+        else if (s.includes("WireGuard key limit") && now() - t > 3)
+            return end("key limit");
+        else if (s === "Disconnected" && now() - t > 3)
+            return end("failed");
+        onStep(`connecting ${r.location}`.trim());
+        await sleep(1000);
     }
-    finally {
-        onStep("disconnecting");
-        await windscribe("disconnect");
-        // the CLI's disconnect can return while the app is still tearing down (it does after a timed-out connect);
-        // a connect sent then is swallowed and the next attempt reads as an instant "failed", so wait it out
-        for (let i = 0; i < 30 && (await connectState()) === "Disconnecting"; i++)
-            await sleep(1000);
+    // a port the app doesn't offer for the protocol: it connects on the protocol's default instead, so this port wasn't tried
+    const port = protocol.split(":")[1], shown = (await windscribe("status")).match(/^Protocol: .*:(\d+)\s*$/m)?.[1];
+    if (port && shown && shown !== port)
+        return end("no such port");
+    let measured = false, holds = true;
+    await measure(async () => {
+        // a stopping scan waits for no more measurements: a parallel scan's containers measure one at a time, so they'd queue up
+        if (stopped())
+            return;
+        measured = true;
+        onStep(`measuring latency · ${r.location}`);
+        r.latencyMs = await latencyMs();
+        if (r.latencyMs === null)
+            return;
+        if (speedTest || steady) {
+            onStep(`measuring speed · ${r.location}`);
+            r.speedMbps = await speedMbps();
+        }
+        if (steady)
+            holds = await holdsUp(r.location, onStep);
+    });
+    if (!measured)
+        return end("interrupted");
+    return end(r.latencyMs === null ? "no internet" : holds ? "ok" : "unreliable");
+}
+/** Whether the connection stays up with internet through it: STEADY_CHECKS round trips, STEADY_GAP seconds apart, each with a retry */
+async function holdsUp(location, onStep) {
+    for (let i = 1; i <= STEADY_CHECKS; i++) {
+        onStep(`checking it holds up ${i}/${STEADY_CHECKS} · ${location}`);
+        await sleep(STEADY_GAP * 1000);
+        if (!(await connectState()).startsWith("Connected") || (await latencyMs(2)) === null)
+            return false;
     }
+    return true;
 }
 /** The attempts that worked, best first: fastest, then lowest latency */
 export const sortOk = (results) => results.filter((r) => r.status === "ok")

package/dist/scan.js

@@ -1,10 +1,28 @@
-// A scan: every country × protocol pair, tried in order, with pause and stop.
+// A scan: the attempts its scanning type plans (plan()), tried in order, with pause and stop.
 // Each slot runs one attempt at a time: one slot here, or one per docker container in a parallel scan.
-import { probe } from "./probe.js";
+import { probe, reliable } from "./probe.js";
 import { now } from "./time.js";
 // ponytail: rough per-attempt cost: a failure burns the timeout, a success ~connect+speed test; refine from real runs
 export const attemptSeconds = (timeout) => timeout + 5;
 export const estimate = (attempts, timeout, slots = 1) => Math.ceil(attempts / slots) * attemptSeconds(timeout);
+export const ORDERS = ["default", "random", "last-first", "last-only"];
+const base = (protocol) => protocol.split(":")[0]; // "tcp:443" → "tcp"
+/** What a scan of these countries and protocols tries, in the order of the scanning type, each once. saved: the last result's
+ * connections, best first. ports: each protocol's ports, its default first, so "tcp" and "tcp:443" are one attempt */
+export function plan(order, countries, protocols, saved = [], ports = new Map()) {
+    const seen = new Set();
+    const once = ({ country, protocol }) => {
+        const [p, port] = protocol.split(":"), key = `${country} ${p}:${port ?? ports.get(p)?.[0] ?? ""}`;
+        return !seen.has(key) && !!seen.add(key);
+    };
+    const last = saved.map((r) => ({ country: r.query, protocol: r.protocol, saved: true }));
+    if (order === "last-only")
+        return last.filter(once);
+    const bases = new Set(protocols.map(base));
+    const first = order === "last-first" ? last.filter((a) => countries.includes(a.country) && bases.has(base(a.protocol))) : [];
+    const list = order === "random" ? countries.map((c) => [Math.random(), c]).sort(([x], [y]) => x - y).map(([, c]) => c) : countries;
+    return [...first, ...list.flatMap((country) => protocols.map((protocol) => ({ country, protocol })))].filter(once);
+}
 /** Progress views read the fields; their keys call togglePause() and stop() */
 export class Scan {
     countries;
@@ -20,6 +38,7 @@ export class Scan {
     started = now();
     done = 0;
     stopping = false; // stop after the current attempts
+    found = false; // stopAtFirst: a connection held up, so the scan is stopping
     // a pause lands between attempts, so the VPN is disconnected while waiting
     paused = false;
     waiting = false; // paused, and no attempt running
@@ -33,7 +52,7 @@ export class Scan {
         this.options = options;
         this.probers = probers;
         this.after = after;
-        this.total = countries.length * protocols.length;
+        this.total = this.attempts().length;
         this.slots = probers.map(() => ({ current: null, step: "", attemptStart: now() }));
         if (after)
             this.slots.push({ current: null, step: "", attemptStart: now(), name: after.name });
@@ -59,9 +78,15 @@ export class Scan {
         this.waiting = false;
         this.resume();
     }
+    attempts() {
+        return this.options.only?.map((a) => ({ ...a }))
+            ?? this.countries.flatMap((country) => this.protocols.map((protocol) => ({ country, protocol })));
+    }
     async run(hooks = {}) {
-        const queue = this.countries.flatMap((country) => this.protocols.map((protocol) => ({ country, protocol })));
-        const left = new Map(this.countries.map((c) => [c, this.protocols.length])); // attempts to go, per country
+        const queue = this.attempts();
+        const left = new Map(); // attempts to go, per country
+        for (const { country } of queue)
+            left.set(country, (left.get(country) ?? 0) + 1);
         const later = this.after?.protocols ?? new Set();
         await Promise.all(this.probers.map((prober, i) => this.work(prober, this.slots[i], (p) => !later.has(p), queue, left, hooks)));
         // then the rest, also what slots whose container stopped left over
@@ -71,7 +96,7 @@ export class Scan {
     }
     /** One slot: takes the attempts it can make from the queue, one at a time, until there are none */
     async work(prober, slot, can, queue, left, hooks) {
-        const { timeout, speedTest } = this.options;
+        const { timeout, speedTest, stopAtFirst = false } = this.options;
         for (;;) {
             while (this.paused && !this.stopping) {
                 if (!this.waiting && this.slots.every((s) => !s.current)) { // the last running attempt is over
@@ -89,7 +114,7 @@ export class Scan {
             hooks.attempt?.(country, protocol);
             let r;
             try {
-                r = await prober(country, protocol, { timeout, speedTest, stopped: () => this.stopping, onStep: (s) => (slot.step = s) });
+                r = await prober(country, protocol, { timeout, speedTest, steady: stopAtFirst, stopped: () => this.stopping, onStep: (s) => (slot.step = s) });
             }
             catch (e) { // this slot is done for (its container stopped): the others take over its attempt
                 queue.unshift(next);
@@ -109,6 +134,10 @@ export class Scan {
             if (!left.get(country))
                 this.finished.push(country);
             hooks.result?.(r);
+            if (stopAtFirst && reliable(r) && !this.stopping) {
+                this.found = true;
+                this.stop();
+            }
         }
     }
 }

package/dist/tui/docker.js

@@ -3,7 +3,7 @@ import { duration, now } from "../time.js";
 import { session } from "../windscribe.js";
 import { draw, enterScreen, input, leaveScreen, out } from "./terminal.js";
 import { bold, cyan, dim, vw, yellow } from "./text.js";
-import { box, centerIn } from "./widgets.js";
+import { box, centerIn, spin } from "./widgets.js";
 const tty = () => Boolean(process.stdin.isTTY && out.isTTY);
 const clip = (s, n = 76) => (s.length > n ? s.slice(0, n - 1) + "…" : s);
 // lines of at most n columns, broken at spaces: an error can be longer than the screen is wide
@@ -75,7 +75,7 @@ async function busy(status, work) {
     }
     const t = now();
     let frame = 0;
-    const tick = () => paint({ lines: [`${cyan("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[frame++ % 10])} ${status.label} ${dim("· " + duration(now() - t))}`,
+    const tick = () => paint({ lines: [`${cyan(spin(frame++))} ${status.label} ${dim("· " + duration(now() - t))}`,
             dim(clip(status.line)), "", dim("esc quits")] });
     // the exit handlers remove containers already started
     const quit = (_, key = {}) => (key.name === "escape" || key.name === "q" || (key.ctrl && key.name === "c"))

package/dist/tui/picker.js

@@ -1,23 +1,39 @@
 import { loadDockerWireGuard, MIN_TIMEOUT, saveConfig, SPEED_TEST } from "../config.js";
 import { dockerState, loginSeconds, notInContainers, workerCount } from "../docker.js";
-import { attemptSeconds, estimate } from "../scan.js";
+import { STEADY_SECONDS } from "../probe.js";
+import { attemptSeconds, estimate, ORDERS, plan } from "../scan.js";
 import { duration } from "../time.js";
 import { canUpdate, checkUpdate, versionLines } from "../update.js";
-import { COUNTRIES, protocolPorts, PROTOCOLS } from "../windscribe.js";
+import { COUNTRIES, protocolPorts, PROTOCOLS, withPorts } from "../windscribe.js";
 import { countryName, flag } from "./country.js";
 import { setupDocker } from "./docker.js";
-import { draw, enterScreen, input, leaveScreen, out, repoLink } from "./terminal.js";
+import { draw, drawUntilNext, enterScreen, input, leaveScreen, out, repoLink } from "./terminal.js";
 import { bold, cyan, dim, green, under, vw, yellow } from "./text.js";
-import { box, centerIn, grid } from "./widgets.js";
+import { box, centerIn, grid, spin } from "./widgets.js";
+const ORDER_NAMES = {
+    default: "default",
+    random: "by random country",
+    "last-first": "by last success result first",
+    "last-only": "only the last results",
+};
+const needsLast = (o) => o === "last-first" || o === "last-only";
+// only the last results: the countries, protocols and ports are greyed out, and their keys and clicks say why
+const SKIPPED = "skipped with only the last results: o changes the scanning type";
 const flip = (set, value) => (set.has(value) ? set.delete(value) : set.add(value));
+// "5m ago", "3h ago", "2 days ago"
+const ago = (ms) => {
+    const m = Math.max(0, Math.round((Date.now() - ms) / 60000)), h = Math.round(m / 60), d = Math.round(h / 24);
+    return m < 1 ? "just now" : m < 60 ? `${m}m ago` : h < 48 ? `${h}h ago` : `${d} days ago`;
+};
 /** Resolves to the choice (also saved for next time), null when the user quits, or "update" for u */
-export function pick(saved, { timeout, speedTest, firewall, random, allPorts, docker }) {
+export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst, allPorts, docker, last }) {
     const selected = new Set(saved?.countries ?? []);
     const protos = new Set(saved?.protocols.length ? saved.protocols : PROTOCOLS);
     let cursor = 0, top = 0, message = "", query = "", searching = false;
     let seconds = String(timeout), editing = false; // the timeout, as typed
     let dockerAt = null, inDialog = false; // docker's state once checked; a docker dialog has the screen
     let portLists = null; // each protocol's ports, once the app said
+    let starting = -1; // once start is pressed: the start button's spinner frame, until the next screen shows
     let hit;
     const visible = () => {
         const q = query.toLowerCase();
@@ -25,7 +41,11 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
     };
     const ports = (p) => (allPorts && portLists?.get(p)?.length) || 1; // attempts per country for the protocol
     const perCountry = (ps) => [...ps].reduce((n, p) => n + ports(p), 0);
-    const attempts = () => selected.size * perCountry(protos);
+    // what start scans, in its order: as the CLI plans it, so the estimate counts the same attempts
+    const todo = () => {
+        const ps = PROTOCOLS.filter((p) => protos.has(p));
+        return plan(order, COUNTRIES.filter((c) => selected.has(c)), allPorts && portLists ? withPorts(ps, portLists) : ps, last?.results, portLists ?? undefined);
+    };
     const wireguard = loadDockerWireGuard(); // in docker containers, as the last parallel scan found
     enterScreen();
     return new Promise((resolve) => {
@@ -35,88 +55,112 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
             const rows = out.rows || 24;
             const version = versionLines(true);
             const matches = visible();
-            const height = Math.max(3, rows - 23 - version.length);
+            const height = Math.max(3, rows - 24 - version.length);
             cursor = Math.max(0, Math.min(cursor, matches.length - 1));
             if (cursor < top)
                 top = cursor;
             if (cursor >= top + height)
                 top = cursor - height + 1;
             top = Math.max(0, Math.min(top, matches.length - height));
-            const protoLine = PROTOCOLS.map((p, i) => `${dim(under(String(i + 1)))} ${protos.has(p) ? green("● " + p) : dim("○ " + p)}`).join("   ");
+            const off = order === "last-only"; // only the saved connections: the countries, protocols and ports are skipped
+            const missing = needsLast(order) && !last; // a type by the last result, and no saved scan: start is off
+            timeout = Number(seconds);
+            const list = todo(), n = list.length;
+            const base = (p) => p.split(":")[0]; // "wireguard:443" → "wireguard"
+            const scanned = new Set(list.map((a) => base(a.protocol)));
+            const here = PROTOCOLS.filter((p) => docker && scanned.has(p) && notInContainers(PROTOCOLS, wireguard).has(p)); // after the containers
+            const inContainers = list.filter((a) => !here.includes(base(a.protocol))).length;
+            const parallel = docker && dockerAt === "ready" && inContainers > 0;
+            const slots = parallel ? workerCount(inContainers) : 1;
+            const login = parallel ? loginSeconds(slots) : 0; // the containers log in before the scan starts
+            const protoLine = PROTOCOLS.map((p, i) => `${dim(under(String(i + 1)))} ${protos.has(p) ? (off ? dim : green)("● " + p) : dim("○ " + p)}`).join("   ");
             const listed = portLists && [...portLists.values()].some((l) => l.length), each = perCountry(protos);
-            const portsLine = `${dim(under("p"))} ${allPorts ? green("● all ports") : dim("○ all ports")}  ${dim(!allPorts
-                ? "off: each protocol on its default port"
-                : !portLists ? "checking the ports…"
-                    : !listed ? "this Windscribe app can't list its ports: 2.22 and newer can"
-                        : `every port of each protocol: ${each} attempt${each === 1 ? "" : "s"} per country${each > protos.size ? `, not ${protos.size}` : ""}`)}`;
+            const portsLine = `${dim(under("p"))} ${allPorts ? (off ? dim : green)("● all ports") : dim("○ all ports")}  ${dim(off
+                ? "not used: each saved connection on its own protocol and port"
+                : !allPorts
+                    ? "off: each protocol on its default port"
+                    : !portLists ? "checking the ports…"
+                        : !listed ? "this Windscribe app can't list its ports: 2.22 and newer can"
+                            : `every port of each protocol: ${each} attempt${each === 1 ? "" : "s"} per country${each > protos.size ? `, not ${protos.size}` : ""}`)}`;
             const speedLine = `${dim(under("s"))} ${speedTest ? green("● speed test") : dim("○ speed test")}  ${dim(speedTest
                 ? "ranks by download speed · adds ~15s per working connection"
-                : "off: connect-only, ranks by latency")}`;
+                : stopAtFirst ? "off · stop at the first still runs it on each connection"
+                    : "off: connect-only, ranks by latency")}`;
             const fwLabel = "block internet while scanning (firewall)";
             const fwLine = `${dim(under("f"))} ${firewall ? green("● " + fwLabel) : dim("○ " + fwLabel)}  ${dim(docker
                 ? "not used with docker"
                 : firewall ? "only VPN traffic gets through" : "off: apps may leak in between")}`;
-            const randomLine = `${dim(under("r"))} ${random ? green("● random order") : dim("○ random order")}  ${dim(random
-                ? "scans the countries shuffled, a new order each run"
-                : "off: scans in list order")}`;
-            timeout = Number(seconds);
             const short = timeout < MIN_TIMEOUT;
             const timeoutLine = `${dim(under("t"))} timeout ${editing ? bold(seconds) + cyan("▏") : (short ? yellow : bold)(seconds || "?")} s  ${dim(`per connection · at least ${MIN_TIMEOUT}`)}`;
-            const n = attempts();
-            const here = PROTOCOLS.filter((p) => docker && protos.has(p) && notInContainers(PROTOCOLS, wireguard).has(p)); // after the containers
-            const inContainers = selected.size * perCountry([...protos].filter((p) => !here.includes(p)));
-            const parallel = docker && dockerAt === "ready" && inContainers > 0;
-            const slots = parallel ? workerCount(inContainers) : 1;
-            const login = parallel ? loginSeconds(slots) : 0; // the containers log in before the scan starts
             const dockerLabel = "parallel scan in docker containers";
             const dockerLine = `${dim(under("d"))} ${docker ? green("● " + dockerLabel) : dim("○ " + dockerLabel)}  ${dim(!docker
                 ? "off: one attempt at a time"
                 : dockerAt === "ready" ? `${slots} at a time${here.length ? ` · ${here.join(" and ")} here, after them` : ""}`
                     : dockerAt ? "docker isn't ready: start sets it up" : "checking docker…")}`;
-            const search = searching
-                ? `${cyan("🔍")} ${bold(query)}${cyan("▏")}`
-                : query ? `🔍 ${query}` : dim("🔍 press / to search");
+            const saves = last ? plan("last-only", [], [], last.results, portLists ?? undefined).length : 0; // the saved connections, each once
+            const firsts = list.filter((a) => a.saved).length; // those this scan tries first
+            const orderLine = `${dim(under("o"))} scanning type ${bold(ORDER_NAMES[order])}  ${dim(missing
+                ? "no saved scan yet"
+                : order === "default" ? "countries in list order"
+                    : order === "random" ? "countries shuffled, a new order each run"
+                        : order === "last-first" ? `${firsts} of ${saves} saved selected · ${ago(last.at)}`
+                            : `${saves} saved working connection${saves === 1 ? "" : "s"} · ${ago(last.at)}`)}`;
+            const stopLabel = "stop at the first working connection";
+            // the best saved connection goes first (unless it waits for the containers): when it still holds up, the scan ends there
+            const lead = list[0]?.saved && !here.includes(base(list[0].protocol)) ? list[0] : null;
+            const stopLine = `${dim(under("w"))} ${stopAtFirst ? green("● " + stopLabel) : dim("○ " + stopLabel)}  ${dim(!stopAtFirst
+                ? "off: tries every attempt"
+                : lead ? `≈ ${duration(login + STEADY_SECONDS)} if ${lead.country} ${lead.protocol} still holds up`
+                    : "after a speed and stability check")}`;
+            const search = off
+                ? yellow("countries skipped: only the last results are scanned")
+                : searching ? `${cyan("🔍")} ${bold(query)}${cyan("▏")}`
+                    : query ? `🔍 ${query}` : dim("🔍 press / to search");
             const shown = matches.slice(top, top + height);
             const range = matches.length > height ? `${top + 1}–${top + shown.length} of ${matches.length}` : `${matches.length} countries`;
             const body = shown.map((code, j) => {
-                const here = top + j === cursor;
-                const mark = selected.has(code) ? green("●") : dim("○");
+                const current = !off && top + j === cursor;
+                const mark = selected.has(code) ? (off ? dim : green)("●") : dim("○");
                 const name = `${flag(code)} ${countryName(code)}`;
-                return [`${here ? cyan("❯") : " "} ${mark}`, here ? bold(code) : dim(code), here ? bold(cyan(name)) : name];
+                return [`${current ? cyan("❯") : " "} ${mark}`, current ? bold(code) : dim(code), current ? bold(cyan(name)) : off ? dim(name) : name];
             });
             if (!body.length)
                 body.push(["   ", "", dim("no country matches")]);
             const buttons = [
-                ["start", "▶ Start"],
+                ["start", starting < 0 ? "▶ Start" : `${spin(starting++)} Starting…`],
                 ["all", under("A") + (query ? "ll shown" : "ll")],
                 ["none", under("N") + (query ? "one shown" : "one")],
                 ["quit", under("Q") + "uit"],
             ];
-            const buttonLine = buttons.map(([id, label]) => (id === "start" ? bold(cyan(`[ ${label} ]`)) : dim(`[ ${label} ]`))).join("  ");
-            const settings = [protoLine, portsLine, ...(SPEED_TEST ? [speedLine] : []), fwLine, randomLine, timeoutLine, dockerLine];
+            const buttonLine = buttons.map(([id, label]) => (id === "start" && n && !missing ? bold(cyan(`[ ${label} ]`)) : dim(`[ ${label} ]`))).join("  ");
+            const settings = [protoLine, portsLine, ...(SPEED_TEST ? [speedLine] : []), fwLine, timeoutLine, dockerLine, orderLine, stopLine];
             const table = grid([{ title: "" }, { title: "Code" }, { title: "Country" }], body, { caption: search, captionRight: dim(range), minWidth: Math.max(...settings.map(vw)) + 4 });
             const width = vw(table[0]);
             const head = box(settings, {
                 title: bold(cyan("WindScout")),
-                right: `${bold(String(selected.size))}${dim(`/${COUNTRIES.length} selected`)}`,
+                right: `${(off ? dim : bold)(String(selected.size))}${dim(`/${COUNTRIES.length} selected`)}`,
                 width: width - 4,
             });
+            const total = login + estimate(inContainers, timeout, slots) + estimate(n - inContainers, timeout);
+            const costs = dim(`(~${attemptSeconds(timeout)}s each${slots > 1 ? `, ${slots} at a time` : ""}${login ? `, + ~${duration(login)} login` : ""})`);
             const lines = [
                 ...head,
                 ...table,
                 "",
                 centerIn(buttonLine, width),
                 "",
-                centerIn(n
-                    ? `${bold(String(n))} attempts · estimated ${bold("≈ " + duration(login + estimate(inContainers, timeout, slots) + estimate(n - inContainers, timeout)))} ${dim(`(~${attemptSeconds(timeout)}s each${slots > 1 ? `, ${slots} at a time` : ""}${login ? `, + ~${duration(login)} login` : ""})`)}`
-                    : yellow("select at least one country and one protocol"), width),
+                centerIn(missing
+                    ? yellow("no saved scan yet, so start is off: press o for another scanning type")
+                    : !n ? yellow(`select at least one country and one protocol${last ? ", or o for only the last results" : ""}`)
+                        : stopAtFirst // it can end at any attempt: this is when none holds up
+                            ? `up to ${bold(String(n))} attempts · at most ${bold("≈ " + duration(total))} ${costs}`
+                            : `${bold(String(n))} attempts · estimated ${bold("≈ " + duration(total))} ${costs}`, width),
                 centerIn(dim(editing
                     ? "type the seconds to wait for each connection · enter/esc done"
                     : searching
                         ? "type to filter · ↑↓ move · enter/esc done"
-                        // both lines fit 80 columns
                         : `↑↓ move · space select · a/n ${query ? "all/none shown · esc clear" : "all/none · / search"} · enter start · q quit`), width),
-                centerIn(dim(searching || editing ? "" : `1-${PROTOCOLS.length} protocols · p ports${SPEED_TEST ? " · s speed" : ""} · f firewall · r random · t timeout · d docker`), width),
+                centerIn(dim(searching || editing ? "" : `1-${PROTOCOLS.length} protocols · p ports${SPEED_TEST ? " · s speed" : ""} · f firewall · t timeout · d docker · o type · w first`), width),
             ];
             if (message)
                 lines.push(centerIn(yellow(message), width));
@@ -140,7 +184,7 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
             });
             hit = {
                 protoRow: row(protoLine), protoHits, portsRow: row(portsLine), speedRow: SPEED_TEST ? row(speedLine) : -1,
-                firewallRow: row(fwLine), randomRow: row(randomLine), timeoutRow: row(timeoutLine), dockerRow: row(dockerLine),
+                firewallRow: row(fwLine), timeoutRow: row(timeoutLine), dockerRow: row(dockerLine), orderRow: row(orderLine), stopRow: row(stopLine),
                 searchRow: at.top + head.length + 1,
                 firstRow: at.top + head.length + 5, shown: shown.length,
                 buttonRow: at.top + head.length + table.length + 1, buttonHits,
@@ -161,7 +205,9 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
             resolve(value);
         };
         const start = () => {
-            if (!attempts()) {
+            if (needsLast(order) && !last)
+                return false; // start is off: the warning under the table says why
+            if (!todo().length) {
                 message = "nothing to scan yet";
                 return false;
             }
@@ -175,15 +221,20 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
                 protocols: PROTOCOLS.filter((p) => protos.has(p)),
                 speed: speedTest,
                 firewall,
-                random,
+                order,
+                stopAtFirst,
                 allPorts,
                 timeout,
                 docker,
             };
             saveConfig(choice);
             finish(choice);
+            // the scan can take a moment to show (the firewall, docker): the button spins until its screen, or a docker one, draws
+            starting = 0;
+            drawUntilNext(render);
             return true;
         };
+        const cycleOrder = () => (order = ORDERS[(ORDERS.indexOf(order) + 1) % ORDERS.length]); // o: the next scanning type
         // turning it on gets docker going first: installs or starts it (after asking), unless it answers already
         const toggleDocker = async () => {
             if (!docker && (dockerAt = await dockerState()) !== "ready") {
@@ -205,14 +256,20 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
             if (!m.press)
                 return;
             message = "";
-            const matches = visible();
+            const matches = visible(), off = order === "last-only";
             const { x, y } = m;
+            const button = y === hit.buttonRow ? hit.buttonHits.find(([, a, b]) => x >= a && x < b)?.[0] : undefined;
+            const onCountries = y === hit.searchRow || (y >= hit.firstRow && y < hit.firstRow + hit.shown) || button === "all" || button === "none";
+            if (off && (m.button === 64 || m.button === 65))
+                return; // the skipped countries don't scroll
             if (m.button === 64)
                 cursor = Math.max(0, cursor - 3); // wheel up
             else if (m.button === 65)
                 cursor = Math.min(matches.length - 1, cursor + 3); // wheel down
             else if (m.button !== 0)
                 return; // left button only
+            else if (off && (onCountries || y === hit.protoRow || y === hit.portsRow))
+                message = SKIPPED;
             else if (y === hit.searchRow)
                 searching = true, editing = false;
             else if (y === hit.timeoutRow)
@@ -236,19 +293,20 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
                     speedTest = !speedTest;
                 else if (y === hit.firewallRow)
                     firewall = !firewall;
-                else if (y === hit.randomRow)
-                    random = !random;
                 else if (y === hit.dockerRow)
                     return void toggleDocker();
+                else if (y === hit.orderRow)
+                    cycleOrder();
+                else if (y === hit.stopRow)
+                    stopAtFirst = !stopAtFirst;
                 else if (y === hit.buttonRow) {
-                    const id = hit.buttonHits.find(([, a, b]) => x >= a && x < b)?.[0];
-                    if (id === "start" && start())
+                    if (button === "start" && start())
                         return;
-                    if (id === "quit")
+                    if (button === "quit")
                         return finish(null);
-                    if (id === "all")
+                    if (button === "all")
                         matches.forEach((c) => selected.add(c));
-                    if (id === "none")
+                    if (button === "none")
                         matches.forEach((c) => selected.delete(c));
                 }
             }
@@ -267,9 +325,14 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
                 flip(selected, c);
                 cursor = Math.min(matches.length - 1, cursor + 1);
             };
+            // only the last results: the keys for the countries, protocols and ports change nothing
+            const skipped = order === "last-only" && !editing && !searching
+                && (["up", "down", "pageup", "pagedown", "home", "end", "j", "k", "space", "a", "n", "p"].includes(k ?? "") || str === "/" || /^[1-9]$/.test(str ?? ""));
             if (key.ctrl && k === "c")
                 return finish(null);
-            if (k === "up")
+            if (skipped)
+                message = SKIPPED;
+            else if (k === "up")
                 cursor = Math.max(0, cursor - 1);
             else if (k === "down")
                 cursor = Math.min(matches.length - 1, cursor + 1);
@@ -318,12 +381,14 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
                 speedTest = !speedTest;
             else if (k === "f")
                 firewall = !firewall;
-            else if (k === "r")
-                random = !random;
             else if (k === "t")
                 editing = true, seconds = "";
             else if (k === "d")
                 return void toggleDocker();
+            else if (k === "o")
+                cycleOrder();
+            else if (k === "w")
+                stopAtFirst = !stopAtFirst;
             else if (k === "u" && canUpdate())
                 return finish("update");
             else if (/^[1-9]$/.test(str ?? "") && PROTOCOLS[Number(str) - 1])