@nbtca/prompt 1.4.1 → 1.5.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 NingboTech University, Computer Association.
+Copyright (c) 2025 NBTCA
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,89 +1,58 @@
 # NBTCA Prompt
 
-Terminal-based information system for NingboTech Computer Association.
+Terminal client for NBTCA events, documentation, status and personal timetables.
 
 [![npm version](https://img.shields.io/npm/v/@nbtca/prompt)](https://www.npmjs.com/package/@nbtca/prompt)
 [![License](https://img.shields.io/npm/l/@nbtca/prompt)](LICENSE)
 
+## Requirements
+
+- Node.js 20.12 or newer
+
 ## Install
 
 ```bash
-npm install -g @nbtca/prompt
+npm install --global @nbtca/prompt
+nbtca
 ```
 
-Or run directly:
+Run a command without installing:
 
 ```bash
-npx @nbtca/prompt
+npx @nbtca/prompt --help
 ```
 
-## Personal timetable
+## Commands
 
-Prompt owns the school login and local session; `@nbtca/nbtcal` owns timetable
-normalization and ICS generation.
-
-For a persistent local session:
-
-```bash
+```text
+nbtca events [--json]
+nbtca docs
+nbtca status
 nbtca schedule login
 nbtca schedule terms
 nbtca schedule export --term=2026:3 --week-one=YYYY-MM-DD
 nbtca schedule logout
 ```
 
-For a single run that neither reads nor saves a session (`--no-save` is an
-alias):
+Use `--plain` for stable output without color. `schedule export --one-shot`
+avoids reading or saving a campus session.
+
+Prompt never stores passwords. Persisted sessions contain only a masked account
+hint and a CookieJar, protected with user-only permissions on POSIX systems.
+Treat exported calendars and session files as private data. See [SECURITY.md](SECURITY.md).
+
+## Development
 
 ```bash
-npx @nbtca/prompt schedule export --one-shot
+npm ci
+npm run check
 ```
 
-Both the student id and password are masked in the terminal. The password is
-never saved. A persistent login stores only a masked account hint and the
-CookieJar in the user's state directory:
-
-- Unix/macOS default: `~/.local/state/nbtca/session.json`
-- Windows default: `%LOCALAPPDATA%/nbtca/session.json`
-- `$XDG_STATE_HOME` is honored when it is an absolute path
-
-On POSIX systems the directory is `0700` and the file is `0600`. `npx`, a local
-installation and a global installation therefore share the same state without
-depending on npm's disposable package cache. The session is a bearer secret;
-use `--one-shot` on shared machines and `schedule logout` when finished.
-Saved sessions use a sliding seven-day local expiry and are cleared immediately
-when the school reports that they have expired.
-
-JWXT currently returns week numbers and period times but not the first calendar
-date of a term. When no authoritative date map is available, Prompt asks for
-the first teaching Monday or accepts `--week-one=YYYY-MM-DD`. Confirm it against
-the official school calendar; Prompt will not guess. A slider or other browser
-challenge is also never bypassed—the CLI stops with an actionable message.
-Without an authoritative date map, the result is a base teaching-week schedule:
-holidays, make-up classes and temporary changes still require school notices.
-
-## Documentation
-
-Project documentation has been moved to the GitHub Wiki.
-
-- [Home](https://github.com/nbtca/Prompt/wiki)
-- [Getting Started](https://github.com/nbtca/Prompt/wiki/Getting-Started)
-- [Development Guide](https://github.com/nbtca/Prompt/wiki/Development-Guide)
-- [Terminal UX](https://github.com/nbtca/Prompt/wiki/Terminal-UX)
-- [Release Notes](https://github.com/nbtca/Prompt/wiki/Release-Notes)
-- [Features](https://github.com/nbtca/Prompt/wiki/Features)
-- [Terminal Compatibility](https://github.com/nbtca/Prompt/wiki/Terminal-Compatibility)
-- [FAQ](https://github.com/nbtca/Prompt/wiki/FAQ)
-
-## Requirements
+`check` runs formatting, lint, full TypeScript validation, tests, build, package
+consumer checks and dependency audit.
 
-- Node.js >= 20.12.0
+Project guides and release notes live in the [Wiki](https://github.com/nbtca/Prompt/wiki).
 
 ## License
 
 MIT
-
-## Links
-
-- Website: https://nbtca.space
-- GitHub: https://github.com/nbtca
-- NPM: https://www.npmjs.com/package/@nbtca/prompt

package/SECURITY.md

@@ -1,47 +1,18 @@
 # Security Policy
 
-## School credentials
-
-Prompt sends the student id and an in-memory encrypted password only to the
-school's WebVPN/CAS login flow. It does not offer `--password`, password
-environment variables or credential files. Password and verification input is
-masked and is never written to preferences, state, cache, ICS or logs.
-
-If the school requests a slider, OTP, FIDO or another browser challenge, Prompt
-fails closed. It does not automate or bypass the challenge.
-
-## Authenticated transport
-
-Authentication redirects are restricted to exact HTTPS hosts and routes for
-the NingboTech WebVPN, authentication service and JWXT. CAS `service` and
-WebVPN `origin` parameters are validated against explicit callback routes.
-Caller-supplied `Cookie`, `Authorization` and `Host` headers are rejected.
-
-Errors expose only stable local codes and stages. Response bodies, redirect
-queries, cookies, encrypted passwords and underlying network error objects are
-not included in user-facing output.
-
-## Persisted session
-
-The optional persisted CookieJar is a bearer secret. It is stored under the
-user's state directory with a versioned schema, an atomic write, a `0700`
-directory and a `0600` file on POSIX systems. The saved account hint is masked,
-and Prompt never adds the full student id or password to the state schema. The
-opaque school cookies must still be treated as bearer secrets. Sessions have a
-sliding seven-day local expiry.
-
-Use `nbtca schedule logout` to clear it. Use `--one-shot` on a shared or
-untrusted computer so no session is read or written.
-
-## Timetable and ICS privacy
-
-Raw JWXT responses are processed in memory. Only timetable fields needed for
-normalization are passed to `@nbtca/nbtcal`; the student profile object is
-discarded. Generated ICS files can reveal a person's location and routine, so
-they are created with mode `0600` where supported and should not be uploaded to
-public or "secret-link" hosting.
-
-## Reporting vulnerabilities
-
-Use the repository's GitHub Security Advisory page. Do not include credentials,
-cookies, raw school responses or a personal ICS in a public issue.
+Prompt sends credentials only to the allowlisted campus WebVPN and CAS login
+flow. Passwords stay in memory, are masked during entry and are never accepted
+through flags, environment variables or files. Interactive browser challenges
+fail closed.
+
+An optional persisted CookieJar is a bearer secret. Prompt writes it atomically
+to the user's state directory with `0700` directory and `0600` file permissions
+on POSIX systems. Use `nbtca schedule logout` to remove it, or `--one-shot` to
+avoid reading or writing a session.
+
+Exported calendars may reveal a person's routine and location. Keep session and
+ICS files private.
+
+Report vulnerabilities through GitHub Security Advisories. Never include
+credentials, cookies, raw campus responses or personal calendars in public
+issues.

package/dist/app/app.js

@@ -1,24 +1,13 @@
 import { ansi, ensureCursorRestored } from '../core/canvas.js';
 import { composeFrame, computeBodyRows } from './frame.js';
 import { routeGlobalKey } from './keys.js';
-import { renderHeader, renderFooter, HEADER_LINES, FOOTER_LINES } from './chrome.js';
+import { renderHeader, renderFooter, resolveChromeLayout } from './chrome.js';
 import { homeView } from './views/home.js';
 import { scheduleView } from './views/schedule.js';
 import { docsView } from './views/docs.js';
 import { eventsView } from './views/events.js';
 import { settingsView } from './views/settings.js';
 import { getAppTabs } from './tabs.js';
-/**
- * Event-driven full-screen app loop. Owns the alt-screen + raw-mode lifecycle
- * and composes every tab as a native `View` rendered in place. `ctx.runClassic`
- * remains as a scoped escape hatch a view can call itself when a single action
- * genuinely needs the real terminal (e.g. Docs handing off to glow/less to
- * read a file) — the app loop no longer dispatches whole tabs through it.
- *
- * Resolves once the user quits (q / Ctrl+C / Esc from home). Terminal state
- * (alt-screen, raw mode, cursor) is always restored before this resolves,
- * on SIGINT, on process exit, and even if an unexpected error is thrown.
- */
 export async function runApp() {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
         return;
@@ -27,7 +16,6 @@ export async function runApp() {
     let running = true;
     let suspended = false;
     const viewIds = getAppTabs().map((tab) => tab.id);
-    // Every tab is a native View rendered in place inside the alt-screen frame.
     const nativeViews = {
         home: homeView,
         schedule: scheduleView,
@@ -35,16 +23,41 @@ export async function runApp() {
         events: eventsView,
         settings: settingsView,
     };
+    const pendingLoads = new Map();
+    function loadView(id) {
+        const target = nativeViews[id];
+        if (!target?.load || pendingLoads.has(id))
+            return;
+        const pending = target
+            .load(ctx)
+            .catch(() => undefined)
+            .finally(() => pendingLoads.delete(id));
+        pendingLoads.set(id, pending);
+    }
     function size() {
         return { rows: process.stdout.rows || 24, cols: process.stdout.columns || 80 };
     }
     const ctx = {
-        get size() { return size(); },
-        get bodyRows() { return computeBodyRows(size().rows, HEADER_LINES, FOOTER_LINES); },
-        rerender() { render(); },
-        resetScroll() { scroll = 0; },
-        runClassic(fn) { return runClassic(fn); },
-        quit() { quit(); },
+        get size() {
+            return size();
+        },
+        get bodyRows() {
+            const { rows } = size();
+            const chrome = resolveChromeLayout(rows);
+            return computeBodyRows(rows, chrome.headerLines, chrome.footerLines);
+        },
+        rerender() {
+            render();
+        },
+        resetScroll() {
+            scroll = 0;
+        },
+        runClassic(fn) {
+            return runClassic(fn);
+        },
+        quit() {
+            quit();
+        },
     };
     function render() {
         if (suspended || !running)
@@ -52,10 +65,12 @@ export async function runApp() {
         const { rows, cols } = size();
         const active = nativeViews[view];
         const tabs = getAppTabs();
-        const header = renderHeader(tabs, view, cols);
-        const footer = renderFooter(view, cols, tabs.length, active?.footerHint?.(tabs.length, cols));
+        const chrome = resolveChromeLayout(rows);
+        const header = renderHeader(tabs, view, cols, chrome.headerLines);
+        const footer = renderFooter(view, cols, tabs.length, active?.footerHint?.(tabs.length, cols), chrome.footerLines);
         const body = active?.render(ctx) ?? [];
-        process.stdout.write(ansi.home + composeFrame(header, body, footer, rows, cols, scroll) + ansi.eraseDown);
+        const bodyScroll = active?.capturesInput?.() ? Number.MAX_SAFE_INTEGER : scroll;
+        process.stdout.write(ansi.home + composeFrame(header, body, footer, rows, cols, bodyScroll) + ansi.eraseDown);
     }
     function onKey(data) {
         const key = data.toString();
@@ -64,12 +79,6 @@ export async function runApp() {
             return;
         } // Ctrl-C always quits, even mid-capture.
         const active = nativeViews[view];
-        // Esc always reaches global routing, even while a view "captures" input
-        // for a focused field (login/search text entry). Without this carve-out,
-        // a view whose own Esc-handling doesn't escape its captured mode would
-        // trap the user on that tab with no way out except Ctrl-C (quitting the
-        // whole app). Esc must never be swallowed silently — it's the universal
-        // way out of anything.
         if (active?.capturesInput?.() && key !== '\x1b') {
             active.handleKey?.(key, ctx);
             render();
@@ -81,17 +90,13 @@ export async function runApp() {
             return;
         }
         if (g.back) {
-            // Esc steps back one level within the view first (e.g. its week grid
-            // back to its own hub) — only once the view has nowhere left to step
-            // back to does Esc leave the tab for Home. Matches how k9s/lazygit
-            // treat Esc: back one level, not straight to the root.
             if (active?.handleBack?.(ctx)) {
                 scroll = 0; // the new sub-view's content height has nothing to do with the old one's
                 render();
                 return;
             }
             view = 'home';
-            void nativeViews['home']?.load?.(ctx)?.catch(() => { });
+            loadView('home');
             render();
             return;
         }
@@ -100,9 +105,12 @@ export async function runApp() {
             return;
         }
         if (g.scrollBy) {
-            // fitBody (frame.ts) clamps this to [0, content.length - bodyRows]
-            // on every render regardless of what's requested here, so this never
-            // needs to know the current body's height to stay in bounds.
+            if (active?.capturesPageKeys?.()) {
+                active.handleKey?.(key, ctx);
+                scroll = 0;
+                render();
+                return;
+            }
             const page = Math.max(1, ctx.bodyRows - 2);
             scroll = Math.max(0, scroll + g.scrollBy * page);
             render();
@@ -124,22 +132,14 @@ export async function runApp() {
         if (process.stdin.isTTY)
             process.stdin.setRawMode(false);
         process.stdout.write(ansi.showCursor + ansi.leaveAlt);
-        // `enter()` calls `stdin.resume()`; a resumed stdin stream keeps the
-        // Node event loop alive by design even with no listeners attached. The
-        // classic bridge calls `enter()` again right after, so pausing here is
-        // always safe — either it's about to be resumed, or the app is quitting
-        // for good and this is what lets the process actually exit.
         process.stdin.pause();
     }
     function switchTo(id) {
         scroll = 0;
         view = id;
-        void nativeViews[id]?.load?.(ctx)?.catch(() => { });
+        loadView(id);
         render();
     }
-    // A classic surface (currently only Docs' glow/less pager) owns its own
-    // raw-mode + rendering, so the app must fully leave() the alt-screen
-    // before invoking it and re-enter() after it returns.
     async function runClassic(fn) {
         suspended = true;
         leave();
@@ -147,11 +147,10 @@ export async function runApp() {
             await fn();
         }
         catch (err) {
-            // Classic surfaces are expected to surface their own errors, but if
-            // one throws anyway, don't swallow it silently: leave() has already
-            // restored cooked mode, so writing to stderr here is visible.
             process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
         }
+        if (!running)
+            return;
         enter();
         suspended = false;
         render();
@@ -164,9 +163,8 @@ export async function runApp() {
     }
     function onSigint() {
         quit();
-        process.exit(0);
     }
-    let resolveRun = () => { };
+    let resolveRun;
     const done = new Promise((resolve) => {
         resolveRun = resolve;
     });
@@ -189,14 +187,14 @@ export async function runApp() {
     process.once('SIGINT', onSigint);
     try {
         enter();
-        void nativeViews['home']?.load?.(ctx)?.catch(() => { });
+        loadView('home');
         render();
         await done;
     }
     finally {
-        // Safety net: if we got here via an unexpected throw rather than quit(),
-        // make sure the terminal is restored and listeners don't leak.
-        if (running)
-            quit();
+        quit();
+        await Promise.allSettled(Object.values(nativeViews).map(async (target) => {
+            await target.dispose?.();
+        }));
     }
 }

package/dist/app/chrome.js

@@ -2,70 +2,89 @@ import { type, space, glyph, brandMark } from '../core/theme.js';
 import { pickIcon } from '../core/icons.js';
 import { t } from '../i18n/index.js';
 import { visualWidth } from '../core/text.js';
-/** `renderHeader` always returns exactly this many lines (brand, tabs, rule). */
 export const HEADER_LINES = 3;
-/** `renderFooter` always returns exactly this many lines (rule, keyhints). */
 export const FOOTER_LINES = 2;
+export function resolveChromeLayout(rows) {
+    const height = Math.max(0, Math.floor(rows));
+    if (height >= 11)
+        return { headerLines: 3, footerLines: 2 };
+    if (height >= 9)
+        return { headerLines: 3, footerLines: 1 };
+    if (height >= 7)
+        return { headerLines: 2, footerLines: 1 };
+    if (height >= 4)
+        return { headerLines: 1, footerLines: 1 };
+    if (height >= 2)
+        return { headerLines: 1, footerLines: 0 };
+    return { headerLines: 0, footerLines: 0 };
+}
+function renderRule(cols) {
+    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : 80;
+    const indent = visualWidth(space.indent) < width ? space.indent : '';
+    const ruleWidth = Math.max(1, width - visualWidth(indent) * 2);
+    return indent + type.hint(glyph.rule().repeat(ruleWidth));
+}
 function renderTabs(views, active, cols) {
     const dot = pickIcon('·', '-');
-    const full = space.indent + views
-        .map((view) => view.id === active ? type.active(`[${view.title}]`) : type.hint(view.title))
-        .join(`  ${dot}  `);
+    const full = space.indent +
+        views
+            .map((view) => (view.id === active ? type.active(`[${view.title}]`) : type.hint(view.title)))
+            .join(`  ${dot}  `);
     if (visualWidth(full) <= cols)
         return full;
-    const compact = space.indent + views
-        .map((view, index) => view.id === active
-        ? type.active(`[${index + 1} ${view.title}]`)
-        : type.hint(String(index + 1)))
-        .join(` ${dot} `);
+    const compact = space.indent +
+        views
+            .map((view, index) => view.id === active
+            ? type.active(`[${index + 1} ${view.title}]`)
+            : type.hint(String(index + 1)))
+            .join(` ${dot} `);
     if (visualWidth(compact) <= cols)
         return compact;
-    return space.indent + views
-        .map((view, index) => view.id === active
-        ? type.active(`[${index + 1}]`)
-        : type.hint(String(index + 1)))
-        .join(' ');
+    const numeric = space.indent +
+        views
+            .map((view, index) => view.id === active ? type.active(`[${index + 1}]`) : type.hint(String(index + 1)))
+            .join(' ');
+    if (visualWidth(numeric) <= cols)
+        return numeric;
+    const activeIndex = views.findIndex((view) => view.id === active);
+    const activeView = views[activeIndex];
+    if (!activeView)
+        return '';
+    const activeWithTitle = `${space.indent}${type.active(`[${activeIndex + 1} ${activeView.title}]`)}`;
+    if (visualWidth(activeWithTitle) <= cols)
+        return activeWithTitle;
+    const activeNumber = `${space.indent}${type.active(`[${activeIndex + 1}]`)}`;
+    if (visualWidth(activeNumber) <= cols)
+        return activeNumber;
+    return type.active(String(activeIndex + 1));
 }
-// The header's persistent brand mark. A literal shrunk-down copy of the
-// emblem doesn't survive down to header height (verified: even the boldest
-// inner icon alone dissolves into noise below ~12 character-rows), so this
-// is a wordmark painted in the same gradient as the startup logo instead --
-// ties the two together by color, the one dimension that still reads at
-// one line tall, rather than attempting a shape reproduction this small
-// can't carry.
-export function renderHeader(views, active, cols) {
-    const brand = `${space.indent}${brandMark('nbtca')}`;
+export function renderHeader(views, active, cols, lineCount = HEADER_LINES) {
+    if (lineCount === 0)
+        return [];
+    const mark = brandMark('nbtca');
+    const brand = `${visualWidth(space.indent + mark) <= cols ? space.indent : ''}${mark}`;
     const tabs = renderTabs(views, active, cols);
-    const rule = space.indent + type.hint(glyph.rule().repeat(Math.max(1, cols - 6)));
+    const rule = renderRule(cols);
+    if (lineCount === 1)
+        return [tabs];
+    if (lineCount === 2)
+        return [brand, tabs];
     return [brand, tabs, rule];
 }
-/** Shared footer hint for any view mode that captures all input (a focused
- * text field or a modal-like list) — the only keys that still do something
- * are Ctrl-C/Esc/Enter, so this is what every such view's `footerHint()`
- * should return instead of each re-declaring an identical string. Digits/Tab
- * are deliberately absent: while input is captured they're typed into the
- * field, not routed to global tab-switching, so promising them would itself
- * be the false-promise this hint exists to avoid. */
 export function fitFooterHint(cols, ...candidates) {
-    return candidates.find((candidate) => visualWidth(space.indent + candidate) <= cols)
-        ?? candidates[candidates.length - 1]
-        ?? '';
+    return (candidates.find((candidate) => visualWidth(space.indent + candidate) <= cols) ??
+        candidates[candidates.length - 1] ??
+        '');
 }
 export function captureFooterHint(cols = Number.POSITIVE_INFINITY) {
     const trans = t();
     const dot = pickIcon('·', '-');
     return fitFooterHint(cols, `Ctrl+C ${trans.common.exit}  ${dot}  Esc ${trans.common.back}  ${dot}  Enter ${trans.common.confirm}`, 'Ctrl+C Esc Enter', 'Ctrl+C Esc', 'Ctrl+C');
 }
-/** The "1-N / Tab" tab-switch prefix, factored out so a view's own
- * `footerHint()` override can still include it accurately (tab count isn't
- * knowable inside a view module otherwise) instead of either hardcoding a
- * digit range that goes stale, or dropping a still-true promise entirely. */
 export function digitTabHint(tabCount) {
     const dot = pickIcon('·', '-');
     return tabCount > 1 ? `1-${tabCount} / Tab ${dot} ` : '';
 }
-/** Shared hint for a non-interactive state: digits/Tab still switch tabs,
- * while move/open do nothing and must not be advertised. */
 export function passiveFooterHint(tabCount, cols = Number.POSITIVE_INFINITY) {
     const trans = t();
     const dot = pickIcon('·', '-');
@@ -91,14 +110,12 @@ function interactiveFooterHint(tabCount, cols) {
     ];
     return fitFooterHint(cols, ...candidates);
 }
-/** `overrideHint`: a view supplies this (via `View.footerHint()`) when the
- * generic tab-switching hint would be false — e.g. while a text field has
- * focus, digits/Tab/q are typed characters, not shortcuts, and only Ctrl-C/
- * Esc/Enter actually do anything. The footer must never promise a key that
- * doesn't work. */
-export function renderFooter(_active, cols, tabCount, overrideHint) {
-    const rule = space.indent + type.hint(glyph.rule().repeat(Math.max(1, cols - 6)));
+export function renderFooter(_active, cols, tabCount, overrideHint, lineCount = FOOTER_LINES) {
+    if (lineCount === 0)
+        return [];
+    const rule = renderRule(cols);
     const hintText = overrideHint ?? interactiveFooterHint(tabCount, cols);
-    const hint = space.indent + type.hint(hintText);
-    return [rule, hint];
+    const indent = visualWidth(space.indent + hintText) <= cols ? space.indent : '';
+    const hint = indent + type.hint(hintText);
+    return lineCount === 1 ? [hint] : [rule, hint];
 }

package/dist/app/fields/list-field.js

@@ -3,10 +3,6 @@ import { space, type } from '../../core/theme.js';
 import { pickIcon } from '../../core/icons.js';
 import { t, fmt } from '../../i18n/index.js';
 import { visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
-/** A conservative rows-to-options budget for a ListField that fills a
- * view's whole body (title + blank + up to N options + an optional
- * more-indicator + footer). Reserves ~4 lines for that non-option chrome
- * so the field never itself overflows `bodyRows`. */
 export function computeMaxVisible(bodyRows) {
     return Math.max(3, bodyRows - 4);
 }
@@ -16,10 +12,6 @@ function renderIndentedOutput(value, cols) {
     const contentWidth = Math.max(1, width - visualWidth(indent));
     return wrapAnsiToVisualWidth(value, contentWidth).map((line) => `${indent}${line}`);
 }
-/** Non-blocking equivalent of `runMenu`: a view holds one of these in its own
- * state and drives it from the app loop's single stdin listener via
- * `handleKey`, instead of `runMenu` attaching a second listener and blocking
- * on a Promise. */
 export class ListField {
     config;
     index;
@@ -34,18 +26,9 @@ export class ListField {
     get selectedIndex() {
         return this.index;
     }
-    /** How many options this field actually has — lets a caller reserve
-     * exactly enough room for this specific menu instead of guessing a
-     * shared constant that's wrong for every menu of a different size. */
     get optionCount() {
         return this.config.options.length;
     }
-    /** Updates the visible-row budget in place (re-clamping the scroll window
-     * so the selection stays visible) instead of losing the field's current
-     * selection/scroll by rebuilding it. Views call this from their own
-     * `render(ctx)` on every frame — cheap, and it's what keeps a field's
-     * window in sync with the *current* terminal size even though the field
-     * itself was constructed against whatever size was current at the time. */
     setMaxVisible(maxVisible) {
         this.maxVisible = maxVisible;
         this.clampScroll();
@@ -60,7 +43,12 @@ export class ListField {
         const { title, options, footer } = this.config;
         const maxVisible = this.maxVisible;
         if (!maxVisible || options.length <= maxVisible) {
-            return renderMenu({ title, options, selectedIndex: this.index, footer }, cols).split('\n');
+            return renderMenu({
+                title,
+                options,
+                selectedIndex: this.index,
+                ...(footer === undefined ? {} : { footer }),
+            }, cols).split('\n');
         }
         const visible = options.slice(this.scrollTop, this.scrollTop + maxVisible);
         const lines = renderMenu({
@@ -130,17 +118,18 @@ export class ListField {
         const parsed = parseKey(key);
         if (parsed === 'cancel')
             return { cancelled: true };
-        if (parsed === 'enter')
-            return { selected: this.config.options[this.index]?.value };
-        const next = nextIndex(this.index, parsed, this.config.options.length);
+        if (parsed === 'enter') {
+            const selected = this.config.options[this.index]?.value;
+            return selected === undefined ? {} : { selected };
+        }
+        const pageSize = Math.max(1, (this.maxVisible ?? 6) - 1);
+        const next = nextIndex(this.index, parsed, this.config.options.length, pageSize);
         if (next !== this.index) {
             this.index = next;
             this.clampScroll();
         }
         return {};
     }
-    /** Keeps `index` within [scrollTop, scrollTop + maxVisible) after any move
-     * or after maxVisible itself changes (e.g. a terminal resize). */
     clampScroll() {
         const maxVisible = this.maxVisible;
         if (!maxVisible) {
@@ -151,8 +140,6 @@ export class ListField {
             this.scrollTop = this.index;
         else if (this.index >= this.scrollTop + maxVisible)
             this.scrollTop = this.index - maxVisible + 1;
-        // The window may also need to slide backward if it shrank enough that
-        // scrollTop..scrollTop+maxVisible now runs past the end of the list.
         this.scrollTop = Math.max(0, Math.min(this.scrollTop, Math.max(0, this.config.options.length - maxVisible)));
     }
 }