@nbtca/prompt 1.4.2 → 1.5.1

package/dist/app/views/schedule.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { createNbtTimetableClient, timetableToIcs, } from '@nbtca/nbtcal/timetable';
+import { createNbtTimetableClient, createTimetableSchedule, timetableToIcs, } from '@nbtca/nbtcal/timetable';
 import { captureFooterHint, passiveFooterHint } from '../chrome.js';
 import { ListField, computeMaxVisible } from '../fields/list-field.js';
 import { TextField } from '../fields/text-field.js';
@@ -8,35 +8,72 @@ import { defaultGridCursor, handleGridKey } from './schedule-grid-cursor.js';
 import { setVimKeysActive } from '../../core/vim-keys.js';
 import { t } from '../../i18n/index.js';
 import { AuthError } from '../../auth/errors.js';
-import { loginWithStudentPassword, restoreNbtSession } from '../../auth/nbt-auth.js';
+import { loginWithStudentPassword, restoreNbtSession, } from '../../auth/nbt-auth.js';
 import { createSessionStore } from '../../auth/session-store.js';
 import { resolveTerm, relevantTerms, writePrivateIcs, isSessionExpired, JWXT_ORIGIN, safeMessage, } from '../../features/student-timetable.js';
 import { termKey, loadWeekOne, saveWeekOne, saveTimetableCache, saveCurrentPointer, loadCurrentPointer, loadTimetableCache, clearScheduleCache, } from '../../features/schedule-store.js';
 import { loadCalendarOrThrow, toDisplayEvent } from '../../features/calendar.js';
 import { currentAcademicWindow, inferWeekOneMonday, isAcademicBreakEvent, } from '@nbtca/nbtcal';
-import { currentWeekNumber, campusWeekday } from '../../features/schedule-query.js';
+import { sanitizeAcademicTerm, sanitizeTimetable } from '../../features/timetable-sanitize.js';
+import { addLocalDays, parseLocalMonday } from '../../core/calendar-day.js';
 let state = { mode: 'loading' };
 let session = null;
 let client = null;
 let catalog = [];
 let pendingId = '';
+let lifecycleGeneration = 0;
+const closingSessions = new WeakMap();
+function isLifecycleActive(ctx, generation) {
+    return generation === lifecycleGeneration && ctx.signal?.aborted !== true;
+}
+async function closeSession(target) {
+    let closing = closingSessions.get(target);
+    if (!closing) {
+        closing = Promise.resolve()
+            .then(() => target.close())
+            .catch(() => undefined);
+        closingSessions.set(target, closing);
+    }
+    await closing;
+}
+async function releaseSession(target = session) {
+    if (!target)
+        return;
+    if (session === target) {
+        session = null;
+        client = null;
+    }
+    await closeSession(target);
+}
 function isTimetableLike(value) {
-    return !!value && typeof value === 'object'
-        && Array.isArray(value.meetings)
-        && Array.isArray(value.periods);
+    return (!!value &&
+        typeof value === 'object' &&
+        Array.isArray(value.meetings) &&
+        Array.isArray(value.periods));
+}
+function readCachedTimetable(value) {
+    if (!isTimetableLike(value))
+        return null;
+    try {
+        return sanitizeTimetable(value);
+    }
+    catch {
+        return null;
+    }
 }
 function returnToHub() {
     const tt = state.timetable;
     const backKey = state.key;
     const backWeekOne = state.weekOne;
     if (tt && backKey && backWeekOne) {
-        // Carries over the existing cursor rather than resetting it -- closing a
-        // meeting's detail card (or backing out of term density/unresolved)
-        // should leave the student's grid navigation exactly where it was, not
-        // silently jump back to today.
+        const schedule = createTimetableSchedule(tt, { weekOneMonday: backWeekOne });
         state = {
-            mode: 'hub', key: backKey, term: state.term, weekOne: backWeekOne, timetable: tt,
-            gridCursor: state.gridCursor ?? defaultGridCursor(campusWeekday(new Date()), tt.periods),
+            mode: 'hub',
+            key: backKey,
+            ...(state.term ? { term: state.term } : {}),
+            weekOne: backWeekOne,
+            timetable: tt,
+            gridCursor: state.gridCursor ?? defaultGridCursor(schedule.weekdayAt(new Date()), tt.periods),
         };
         return true;
     }
@@ -47,8 +84,11 @@ function goToLoginId(errorMessage) {
     setVimKeysActive(false);
     state = {
         mode: 'needsLoginId',
-        errorMessage,
-        idField: new TextField({ message: t().timetable.studentId, placeholder: t().timetable.studentIdHint }),
+        ...(errorMessage === undefined ? {} : { errorMessage }),
+        idField: new TextField({
+            message: t().timetable.studentId,
+            placeholder: t().timetable.studentIdHint,
+        }),
     };
 }
 function buildPublicField() {
@@ -59,67 +99,74 @@ function buildPublicField() {
         footer: trans.menu.hintMove,
     });
 }
-// A glance-panel ceiling, not "browse everything" (matches the same-purpose
-// constants in events.ts/home.ts) — renderPublicBody trims further based on
-// the real ctx.bodyRows.
 const PUBLIC_UPCOMING_FETCH_CAP = 15;
-/** The default, no-login Schedule view: public term/week status sourced from
- * the same public calendar feed Events already uses. Login is now something
- * the student opts into from here, not a gate they hit immediately. */
-async function goToPublic(ctx) {
+async function goToPublic(ctx, generation = lifecycleGeneration) {
+    if (!isLifecycleActive(ctx, generation))
+        return;
     setVimKeysActive(true);
     state = { mode: 'public', publicField: buildPublicField() };
     ctx.rerender();
     try {
-        const cal = await loadCalendarOrThrow();
+        const cal = await loadCalendarOrThrow(ctx.signal);
+        if (!isLifecycleActive(ctx, generation))
+            return;
         const now = new Date();
-        const windowEvents = cal.inRange(new Date(now.getTime() - 400 * 86400000), new Date(now.getTime() + 400 * 86400000));
+        const windowEvents = cal.inRange(addLocalDays(now, -400), addLocalDays(now, 400));
         const publicWindow = currentAcademicWindow(windowEvents, now);
-        const publicUpcoming = cal.upcoming({ days: 30 })
+        const publicUpcoming = cal
+            .upcoming({ days: 30 })
             .filter((e) => !isAcademicBreakEvent(e))
             .slice(0, PUBLIC_UPCOMING_FETCH_CAP)
             .map(toDisplayEvent);
         state = { ...state, publicWindow, publicUpcoming };
     }
     catch {
+        if (!isLifecycleActive(ctx, generation))
+            return;
         state = { ...state, publicWindow: null };
     }
-    ctx.rerender();
+    if (isLifecycleActive(ctx, generation))
+        ctx.rerender();
 }
-/** Best-effort: try to auto-fill "week one Monday" from the same public
- * calendar feed before falling back to the manual prompt. Never throws —
- * any failure here just means the student sees today's existing prompt. */
-async function tryInferWeekOne() {
+async function tryInferWeekOne(ctx, generation) {
     try {
-        const cal = await loadCalendarOrThrow();
+        const cal = await loadCalendarOrThrow(ctx.signal);
+        if (!isLifecycleActive(ctx, generation))
+            return null;
         const now = new Date();
-        // Symmetric window (matches goToPublic's): inferWeekOneMonday can look
-        // forward to an *upcoming* semester-start marker while on break (e.g. a
-        // student logging in mid-summer, months before the next term's own
-        // start date) — a narrow forward window would silently miss exactly the
-        // event this is meant to find.
-        const events = cal.inRange(new Date(now.getTime() - 400 * 86400000), new Date(now.getTime() + 400 * 86400000));
+        const events = cal.inRange(addLocalDays(now, -400), addLocalDays(now, 400));
         return inferWeekOneMonday(events, now);
     }
     catch {
         return null;
     }
 }
-async function afterAuthenticated(ctx, s) {
-    // Captured before any state mutation below, so it reflects whether a
-    // cached hub was already on screen when this call started (e.g. a
-    // background session restore on launch) as opposed to a fresh login
-    // (where state is 'authenticating', so hadCache is false).
+async function afterAuthenticated(ctx, s, generation) {
+    if (!isLifecycleActive(ctx, generation)) {
+        await closeSession(s);
+        return;
+    }
     const hadCache = state.mode === 'hub';
+    if (session && session !== s)
+        await releaseSession(session);
+    if (!isLifecycleActive(ctx, generation)) {
+        await closeSession(s);
+        return;
+    }
     session = s;
     client = createNbtTimetableClient(s.timetableTransport, { baseUrl: JWXT_ORIGIN });
     try {
-        catalog = await client.listTerms();
+        const nextCatalog = (await client.listTerms(ctx.signal === undefined ? {} : { signal: ctx.signal })).map(sanitizeAcademicTerm);
+        if (!isLifecycleActive(ctx, generation))
+            return;
+        catalog = nextCatalog;
         const term = resolveTerm(catalog);
         const key = termKey(term);
         let weekOne = loadWeekOne(key);
         if (!weekOne) {
-            weekOne = await tryInferWeekOne();
+            weekOne = await tryInferWeekOne(ctx, generation);
+            if (!isLifecycleActive(ctx, generation))
+                return;
             if (weekOne)
                 saveWeekOne(key, weekOne);
         }
@@ -130,111 +177,156 @@ async function afterAuthenticated(ctx, s) {
                 key,
                 term,
                 errorMessage: t().timetable.weekOneAutoFailed,
-                weekOneField: new TextField({ message: t().timetable.weekOne, placeholder: t().timetable.weekOneHint }),
+                weekOneField: new TextField({
+                    message: t().timetable.weekOne,
+                    placeholder: t().timetable.weekOneHint,
+                }),
             };
             ctx.rerender();
             return;
         }
-        await fetchAndShowHub(ctx, term, key, weekOne);
+        await fetchAndShowHub(ctx, term, key, weekOne, generation);
     }
     catch (err) {
+        if (!isLifecycleActive(ctx, generation))
+            return;
         if (isSessionExpired(err)) {
             createSessionStore().clear();
+            await releaseSession(s);
             if (!hadCache)
                 goToLoginId(t().timetable.expiredRelogin);
         }
-        else if (!hadCache) {
-            state = { mode: 'error', errorMessage: safeMessage(err) };
+        else {
+            await releaseSession(s);
+            if (!hadCache)
+                state = { mode: 'error', errorMessage: safeMessage(err) };
         }
         ctx.rerender();
     }
 }
-async function fetchAndShowHub(ctx, term, key, weekOne) {
-    if (!client)
+async function fetchAndShowHub(ctx, term, key, weekOne, generation = lifecycleGeneration) {
+    if (!client || !isLifecycleActive(ctx, generation))
         return;
     state = { mode: 'loading', statusMessage: t().calendar.loading };
     ctx.rerender();
     try {
-        const timetable = await client.fetchTerm(term);
+        const timetable = sanitizeTimetable(await client.fetchTerm(term, ctx.signal === undefined ? {} : { signal: ctx.signal }));
+        if (!isLifecycleActive(ctx, generation))
+            return;
+        const schedule = createTimetableSchedule(timetable, { weekOneMonday: weekOne });
         saveTimetableCache(key, timetable);
         saveCurrentPointer(key, weekOne);
         state = {
-            mode: 'hub', key, term, weekOne, timetable,
-            gridCursor: defaultGridCursor(campusWeekday(new Date()), timetable.periods),
+            mode: 'hub',
+            key,
+            term,
+            weekOne,
+            timetable,
+            gridCursor: defaultGridCursor(schedule.weekdayAt(new Date()), timetable.periods),
         };
     }
     catch (err) {
+        if (!isLifecycleActive(ctx, generation))
+            return;
         if (isSessionExpired(err)) {
             createSessionStore().clear();
+            await releaseSession();
             goToLoginId(t().timetable.expiredRelogin);
         }
         else {
             state = { mode: 'error', errorMessage: safeMessage(err) };
         }
     }
-    ctx.rerender();
+    if (isLifecycleActive(ctx, generation))
+        ctx.rerender();
 }
-async function refreshFromNetwork(ctx) {
+async function refreshFromNetwork(ctx, generation) {
+    if (!isLifecycleActive(ctx, generation))
+        return;
     const hadCache = state.mode === 'hub';
     try {
         const store = createSessionStore();
         const persisted = store.load();
         if (!persisted) {
             if (!hadCache)
-                await goToPublic(ctx);
+                await goToPublic(ctx, generation);
             return;
         }
         const restored = await restoreNbtSession(persisted);
-        await afterAuthenticated(ctx, restored);
+        if (!isLifecycleActive(ctx, generation)) {
+            await closeSession(restored);
+            return;
+        }
+        await afterAuthenticated(ctx, restored, generation);
     }
     catch (err) {
+        if (!isLifecycleActive(ctx, generation))
+            return;
         if (!hadCache) {
             if (err instanceof AuthError && isSessionExpired(err)) {
                 createSessionStore().clear();
             }
-            await goToPublic(ctx);
+            await goToPublic(ctx, generation);
         }
-        // best-effort: a cached hub already showed, keep it as-is on refresh failure.
     }
 }
 export const scheduleView = {
     id: 'schedule',
     title: t().timetable.menuEntry,
     async load(ctx) {
+        const generation = ++lifecycleGeneration;
+        if (!isLifecycleActive(ctx, generation))
+            return;
         const ptr = loadCurrentPointer();
-        const cached = ptr ? loadTimetableCache(ptr.termKey) : null;
-        if (ptr && isTimetableLike(cached)) {
+        const cached = readCachedTimetable(ptr ? loadTimetableCache(ptr.termKey) : null);
+        if (ptr && cached) {
+            const schedule = createTimetableSchedule(cached, { weekOneMonday: ptr.weekOneMonday });
             state = {
-                mode: 'hub', key: ptr.termKey, weekOne: ptr.weekOneMonday, timetable: cached,
-                gridCursor: defaultGridCursor(campusWeekday(new Date()), cached.periods),
+                mode: 'hub',
+                key: ptr.termKey,
+                weekOne: ptr.weekOneMonday,
+                timetable: cached,
+                gridCursor: defaultGridCursor(schedule.weekdayAt(new Date()), cached.periods),
             };
         }
         else {
             state = { mode: 'loading' };
         }
         ctx.rerender();
-        await refreshFromNetwork(ctx);
+        await refreshFromNetwork(ctx, generation);
+    },
+    async dispose() {
+        lifecycleGeneration += 1;
+        setVimKeysActive(true);
+        await releaseSession();
     },
     render(ctx) {
-        // Sync every visible field's scroll window to the *current* terminal
-        // size on every frame (not just construction time) — this is what
-        // keeps a long list correctly windowed across a live resize.
         state.termField?.setMaxVisible(computeMaxVisible(ctx.bodyRows));
         return renderSchedule(state, new Date(), ctx.bodyRows, ctx.size.cols);
     },
+    isBusy() {
+        return state.mode === 'loading';
+    },
     capturesInput() {
-        return state.mode === 'needsLoginId' || state.mode === 'needsLoginPassword' || state.mode === 'needsWeekOne';
+        return (state.mode === 'needsLoginId' ||
+            state.mode === 'needsLoginPassword' ||
+            state.mode === 'needsWeekOne');
+    },
+    capturesPageKeys() {
+        return state.mode === 'public' || state.mode === 'termPicker';
     },
     footerHint(tabCount, cols = Number.POSITIVE_INFINITY) {
-        const capturing = state.mode === 'needsLoginId' || state.mode === 'needsLoginPassword' || state.mode === 'needsWeekOne';
+        const capturing = state.mode === 'needsLoginId' ||
+            state.mode === 'needsLoginPassword' ||
+            state.mode === 'needsWeekOne';
         if (capturing)
             return captureFooterHint(cols);
-        // These three are pure "read this, any key returns to the hub" drill-
-        // downs (see handleKey below) — no field to move a cursor within or
-        // open an item from, so the generic "move · open" hint would promise
-        // keys that don't do that here.
-        const passive = state.mode === 'loading' || state.mode === 'authenticating' || state.mode === 'error'
-            || state.mode === 'meetingDetail' || state.mode === 'unresolved' || state.mode === 'termDensity';
+        const passive = state.mode === 'loading' ||
+            state.mode === 'authenticating' ||
+            state.mode === 'error' ||
+            state.mode === 'meetingDetail' ||
+            state.mode === 'unresolved' ||
+            state.mode === 'termDensity';
         return passive ? passiveFooterHint(tabCount, cols) : undefined;
     },
     handleBack(ctx) {
@@ -247,16 +339,16 @@ export const scheduleView = {
             return true;
         }
         if (state.mode === 'meetingDetail') {
-            // Esc respects where the detail card was opened from -- from the
-            // standalone 'week' mode, it steps back there, not all the way to hub.
             if (state.detailFrom === 'week') {
                 state = { ...state, mode: 'week' };
                 return true;
             }
             return returnToHub();
         }
-        if (state.mode === 'week' || state.mode === 'unresolved' || state.mode === 'termPicker'
-            || state.mode === 'termDensity') {
+        if (state.mode === 'week' ||
+            state.mode === 'unresolved' ||
+            state.mode === 'termPicker' ||
+            state.mode === 'termDensity') {
             return returnToHub();
         }
         return false;
@@ -279,7 +371,11 @@ export const scheduleView = {
                     pendingId = result.submitted;
                     state = {
                         mode: 'needsLoginPassword',
-                        passwordField: new TextField({ message: t().timetable.password, placeholder: t().timetable.passwordHint, secret: true }),
+                        passwordField: new TextField({
+                            message: t().timetable.password,
+                            placeholder: t().timetable.passwordHint,
+                            secret: true,
+                        }),
                     };
                 }
                 return;
@@ -292,15 +388,33 @@ export const scheduleView = {
                 }
                 if (result?.submitted !== undefined) {
                     const password = result.submitted;
+                    const generation = lifecycleGeneration;
                     setVimKeysActive(true);
                     state = { mode: 'authenticating', statusMessage: t().timetable.loginWillSave };
                     ctx.rerender();
-                    void loginWithStudentPassword(pendingId, password)
+                    void loginWithStudentPassword(pendingId, password, ctx.signal === undefined ? {} : { signal: ctx.signal })
                         .then(async (s) => {
-                        createSessionStore().save(await s.snapshot());
-                        await afterAuthenticated(ctx, s);
+                        try {
+                            if (!isLifecycleActive(ctx, generation)) {
+                                await closeSession(s);
+                                return;
+                            }
+                            const snapshot = await s.snapshot();
+                            if (!isLifecycleActive(ctx, generation)) {
+                                await closeSession(s);
+                                return;
+                            }
+                            createSessionStore().save(snapshot);
+                            await afterAuthenticated(ctx, s, generation);
+                        }
+                        catch (error) {
+                            await closeSession(s);
+                            throw error;
+                        }
                     })
                         .catch((err) => {
+                        if (!isLifecycleActive(ctx, generation))
+                            return;
                         goToLoginId(safeMessage(err));
                         ctx.rerender();
                     });
@@ -315,7 +429,13 @@ export const scheduleView = {
                 }
                 if (result?.submitted !== undefined) {
                     const trimmed = result.submitted.trim();
-                    const valid = /^\d{4}-\d{2}-\d{2}$/.test(trimmed) && !Number.isNaN(new Date(`${trimmed}T00:00:00`).getTime());
+                    let valid = true;
+                    try {
+                        parseLocalMonday(trimmed);
+                    }
+                    catch {
+                        valid = false;
+                    }
                     const targetKey = state.key;
                     const targetTerm = state.term;
                     if (!valid || !targetKey || !targetTerm) {
@@ -324,7 +444,7 @@ export const scheduleView = {
                     }
                     saveWeekOne(targetKey, trimmed);
                     setVimKeysActive(true);
-                    void fetchAndShowHub(ctx, targetTerm, targetKey, trimmed);
+                    void fetchAndShowHub(ctx, targetTerm, targetKey, trimmed, lifecycleGeneration);
                 }
                 return;
             }
@@ -335,15 +455,22 @@ export const scheduleView = {
                 if (!tt || !hubKey || !hubWeekOne)
                     return;
                 {
-                    const cursor = state.gridCursor ?? defaultGridCursor(campusWeekday(new Date()), tt.periods);
-                    const week = Math.max(1, currentWeekNumber(hubWeekOne, new Date()));
+                    const schedule = createTimetableSchedule(tt, { weekOneMonday: hubWeekOne });
+                    const now = new Date();
+                    const cursor = state.gridCursor ?? defaultGridCursor(schedule.weekdayAt(now), tt.periods);
+                    const week = Math.max(1, schedule.weekAt(now));
                     const nav = handleGridKey(key, cursor, tt, week);
                     if (nav.kind === 'moveCursor') {
                         state = { ...state, gridCursor: nav.cursor };
                         return;
                     }
                     if (nav.kind === 'openDetail') {
-                        state = { ...state, mode: 'meetingDetail', detailMeeting: nav.meeting, detailFrom: 'hub' };
+                        state = {
+                            ...state,
+                            mode: 'meetingDetail',
+                            detailMeeting: nav.meeting,
+                            detailFrom: 'hub',
+                        };
                         return;
                     }
                 }
@@ -366,19 +493,26 @@ export const scheduleView = {
                     const options = relevantTerms(catalog).map((tm) => ({
                         value: `${tm.academicYear}:${tm.semester}`,
                         label: tm.academicYearLabel,
-                        hint: tm.current ? t().common.current : undefined,
+                        ...(tm.current ? { hint: t().common.current } : {}),
                     }));
-                    options.push({ value: '__back__', label: t().common.back, hint: undefined });
+                    options.push({ value: '__back__', label: t().common.back });
                     state = {
                         ...state,
                         mode: 'termPicker',
-                        termField: new ListField({ title: t().timetable.hubSwitchTerm, options, maxVisible: computeMaxVisible(ctx.bodyRows) }),
+                        termField: new ListField({
+                            title: t().timetable.hubSwitchTerm,
+                            options,
+                            maxVisible: computeMaxVisible(ctx.bodyRows),
+                        }),
                     };
                     return;
                 }
                 if (shortcut.key === 'e') {
                     try {
-                        const ics = timetableToIcs(tt, { weekOneMonday: hubWeekOne, calendarName: `NBT ${state.term?.academicYearLabel ?? ''}` });
+                        const ics = timetableToIcs(tt, {
+                            weekOneMonday: hubWeekOne,
+                            calendarName: `NBT ${state.term?.academicYearLabel ?? ''}`,
+                        });
                         const out = `timetable-${hubKey}.ics`;
                         writePrivateIcs(out, ics);
                         state = { ...state, statusMessage: `${t().common.success}: ${path.resolve(out)}` };
@@ -389,12 +523,11 @@ export const scheduleView = {
                     return;
                 }
                 if (shortcut.key === 'x') {
+                    const generation = ++lifecycleGeneration;
                     createSessionStore().clear();
                     clearScheduleCache();
-                    void session?.close();
-                    session = null;
-                    client = null;
-                    void goToPublic(ctx);
+                    void releaseSession();
+                    void goToPublic(ctx, generation);
                 }
                 return;
             }
@@ -405,15 +538,22 @@ export const scheduleView = {
                     returnToHub();
                     return;
                 }
-                const cursor = state.gridCursor ?? defaultGridCursor(campusWeekday(new Date()), tt.periods);
-                const week = Math.max(1, currentWeekNumber(weekOne, new Date()));
+                const schedule = createTimetableSchedule(tt, { weekOneMonday: weekOne });
+                const now = new Date();
+                const cursor = state.gridCursor ?? defaultGridCursor(schedule.weekdayAt(now), tt.periods);
+                const week = Math.max(1, schedule.weekAt(now));
                 const nav = handleGridKey(key, cursor, tt, week);
                 if (nav.kind === 'moveCursor') {
                     state = { ...state, gridCursor: nav.cursor };
                     return;
                 }
                 if (nav.kind === 'openDetail') {
-                    state = { ...state, mode: 'meetingDetail', detailMeeting: nav.meeting, detailFrom: 'week' };
+                    state = {
+                        ...state,
+                        mode: 'meetingDetail',
+                        detailMeeting: nav.meeting,
+                        detailFrom: 'week',
+                    };
                     return;
                 }
                 returnToHub();
@@ -449,14 +589,19 @@ export const scheduleView = {
                         mode: 'needsWeekOne',
                         key: newTermKey,
                         term,
-                        weekOneField: new TextField({ message: t().timetable.weekOne, placeholder: t().timetable.weekOneHint }),
+                        weekOneField: new TextField({
+                            message: t().timetable.weekOne,
+                            placeholder: t().timetable.weekOneHint,
+                        }),
                     };
                     return;
                 }
-                void fetchAndShowHub(ctx, term, newTermKey, weekOne);
+                void fetchAndShowHub(ctx, term, newTermKey, weekOne, lifecycleGeneration);
                 return;
             }
-            default:
+            case 'loading':
+            case 'authenticating':
+            case 'error':
                 return;
         }
     },

package/dist/app/views/settings-render.js

@@ -1,23 +1,16 @@
 import { space, type } from '../../core/theme.js';
-import { visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
+import { wrapAnsiWithIndent } from '../../core/text.js';
 import { renderListFieldWithContext } from '../fields/list-field.js';
 function wrappedIndentedLines(label, cols, style) {
-    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : Number.POSITIVE_INFINITY;
-    const styled = style(label);
-    const preferredIndent = visualWidth(space.indent) < width ? space.indent : '';
-    const indent = preferredIndent
-        && visualWidth(styled) > width - visualWidth(preferredIndent)
-        && visualWidth(styled) <= width
-        ? ''
-        : preferredIndent;
-    const contentWidth = Math.max(1, width - visualWidth(indent));
-    return wrapAnsiToVisualWidth(styled, contentWidth).map((line) => `${indent}${line}`);
+    return wrapAnsiWithIndent(style(label), cols, space.indent);
 }
 export function renderSettings(state, bodyRows = Number.POSITIVE_INFINITY, cols = Number.POSITIVE_INFINITY) {
     switch (state.mode) {
         case 'menu': {
             const context = [
-                ...(state.statusMessage ? [...wrappedIndentedLines(state.statusMessage, cols, type.hint), ''] : []),
+                ...(state.statusMessage
+                    ? [...wrappedIndentedLines(state.statusMessage, cols, type.hint), '']
+                    : []),
             ];
             return state.menuField
                 ? renderListFieldWithContext(context, state.menuField, bodyRows, cols)
@@ -29,7 +22,7 @@ export function renderSettings(state, bodyRows = Number.POSITIVE_INFINITY, cols
             return state.subField?.render(bodyRows, cols) ?? [];
         case 'about': {
             const context = [
-                ...(state.aboutLines ?? []).flatMap((line) => (line ? wrappedIndentedLines(line, cols, (value) => value) : [''])),
+                ...(state.aboutLines ?? []).flatMap((line) => line ? wrappedIndentedLines(line, cols, (value) => value) : ['']),
                 '',
             ];
             if (!state.backField)
@@ -39,13 +32,9 @@ export function renderSettings(state, bodyRows = Number.POSITIVE_INFINITY, cols
                 return [...context, ...fieldLines];
             }
             const rows = Math.max(0, Math.floor(bodyRows));
-            const visibleField = fieldLines.length <= rows
-                ? fieldLines
-                : state.backField.render(rows, cols);
+            const visibleField = fieldLines.length <= rows ? fieldLines : state.backField.render(rows, cols);
             const content = context.at(-1) === '' ? context.slice(0, -1) : context;
-            return content.length > 0
-                ? [...visibleField, '', ...content]
-                : visibleField;
+            return content.length > 0 ? [...visibleField, '', ...content] : visibleField;
         }
         default:
             return [];