@nbtca/prompt 1.3.2 → 1.4.1

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

@@ -0,0 +1,111 @@
+import { type, space } from '../../core/theme.js';
+import { t } from '../../i18n/index.js';
+import { renderListFieldWithContext } from '../fields/list-field.js';
+import { renderCountdownBanner, renderEventBrief } from '../../features/calendar.js';
+import { renderHeatmap } from '../../features/calendar-heatmap.js';
+import { visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
+function wrappedIndentedLines(label, cols, style) {
+    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols ?? 1)) : Number.POSITIVE_INFINITY;
+    const styled = style(label);
+    const styledWidth = visualWidth(styled);
+    const preferredIndent = visualWidth(space.indent) < width ? space.indent : '';
+    const indent = preferredIndent
+        && styledWidth > width - visualWidth(preferredIndent)
+        && styledWidth <= width
+        ? ''
+        : preferredIndent;
+    const contentWidth = Math.max(1, width - visualWidth(indent));
+    return wrapAnsiToVisualWidth(styled, contentWidth).map((line) => `${indent}${line}`);
+}
+function wrappedRenderedLine(line, cols) {
+    const content = line.startsWith(space.indent) ? line.slice(space.indent.length) : line;
+    return wrappedIndentedLines(content, cols, (value) => value);
+}
+// Lines a fully-expanded hub needs: banner+blank (2) + heatmap+blank (12) +
+// recent-activity heading+up to 5 events+blank (7) + hubField
+// (title+blank+6 options, 8) = 29. Below this, a terminal can't fit the
+// heatmap without pushing the menu into scroll territory — better to keep
+// it as the existing drill-down destination than show a truncated grid.
+const EXPANDED_HUB_MIN_BODY_ROWS = 29;
+function renderHubBody(state, now, bodyRows, cols) {
+    const trans = t();
+    const lines = [];
+    const rows = Number.isFinite(bodyRows)
+        ? Math.max(0, Math.floor(bodyRows))
+        : Number.POSITIVE_INFINITY;
+    const banner = renderCountdownBanner(state.nextEvent, now, cols);
+    if (banner)
+        lines.push(...banner.split('\n'), '');
+    const buckets = state.heatmapBuckets;
+    if (bodyRows >= EXPANDED_HUB_MIN_BODY_ROWS && buckets && buckets.length > 0) {
+        lines.push(...renderHeatmap(buckets, now, { color: true, cols }).split('\n'));
+        lines.push('');
+    }
+    if (state.recentEvents && state.recentEvents.length > 0) {
+        const activityHeading = wrappedIndentedLines(trans.calendar.recentActivity, cols, type.heading);
+        const fieldRows = state.hubField
+            ? state.hubField.render(Number.POSITIVE_INFINITY, cols).length
+            : 0;
+        const collectEventLines = (reservedFieldRows) => {
+            const budget = Math.max(0, rows - lines.length - activityHeading.length - 1 - reservedFieldRows);
+            const collected = [];
+            for (const event of state.recentEvents ?? []) {
+                const wrapped = wrappedRenderedLine(renderEventBrief(event, now), cols);
+                if (collected.length + wrapped.length > budget)
+                    break;
+                collected.push(...wrapped);
+            }
+            return collected;
+        };
+        let eventLines = collectEventLines(fieldRows);
+        if (eventLines.length === 0 && state.hubField && fieldRows > 3) {
+            eventLines = collectEventLines(Math.min(3, rows));
+        }
+        if (eventLines.length > 0)
+            lines.push(...activityHeading, ...eventLines, '');
+    }
+    if (state.hubField) {
+        return renderListFieldWithContext(lines, state.hubField, bodyRows, cols);
+    }
+    return lines;
+}
+export function renderEvents(state, now, bodyRows = 100, cols) {
+    const trans = t();
+    switch (state.mode) {
+        case 'loading':
+            return wrappedIndentedLines(trans.calendar.loading, cols, type.hint);
+        case 'hub':
+            return renderHubBody(state, now, bodyRows, cols);
+        case 'heatmap':
+            // renderHeatmap() already prints its own title (space.indent +
+            // type.heading), so this mode doesn't add a second heading on top —
+            // unlike Schedule's 'week'/'unresolved' modes, which wrap a
+            // title-less renderer.
+            return state.heatmapBuckets && state.heatmapBuckets.length > 0
+                ? renderHeatmap(state.heatmapBuckets, now, { color: true, cols }).split('\n')
+                : wrappedIndentedLines(trans.calendar.noEvents, cols, type.hint);
+        case 'list':
+            return state.listField?.render(bodyRows, cols) ?? [];
+        case 'detail': {
+            const context = [
+                ...wrappedIndentedLines(state.detailTitle ?? '', cols, type.heading),
+                ...wrappedIndentedLines(state.detailMeta ?? '', cols, type.hint),
+                '',
+                ...(state.detailDescription
+                    ? state.detailDescription.split('\n').flatMap((line) => wrappedIndentedLines(line, cols, type.body))
+                    : wrappedIndentedLines(trans.calendar.noDescription, cols, type.hint)),
+                '',
+                ...(state.statusMessage ? [...wrappedIndentedLines(state.statusMessage, cols, type.hint), ''] : []),
+            ];
+            return state.detailField
+                ? renderListFieldWithContext(context, state.detailField, bodyRows, cols)
+                : Number.isFinite(bodyRows) ? context.slice(0, Math.max(0, Math.floor(bodyRows))) : context;
+        }
+        case 'search':
+            return state.searchField?.render(cols) ?? [];
+        case 'error':
+            return wrappedIndentedLines(state.errorMessage ?? trans.calendar.error, cols, type.hint);
+        default:
+            return [];
+    }
+}

package/dist/app/views/events.js

@@ -0,0 +1,228 @@
+import { captureFooterHint, passiveFooterHint } from '../chrome.js';
+import { ListField, computeMaxVisible } from '../fields/list-field.js';
+import { TextField } from '../fields/text-field.js';
+import { renderEvents } from './events-render.js';
+import { setVimKeysActive } from '../../core/vim-keys.js';
+import { pickIcon } from '../../core/icons.js';
+import { t } from '../../i18n/index.js';
+import { loadCalendarOrThrow, toDisplayEvent, exportEventIcs } from '../../features/calendar.js';
+import { weekRange, monthRange, filterEvents } from '../../features/calendar-query.js';
+let state = { mode: 'loading' };
+let calendar = null;
+let currentList = [];
+function backLabel() {
+    return t().common.back;
+}
+function buildHubField() {
+    const trans = t();
+    const options = [
+        { value: 'upcoming', label: trans.menu.events },
+        { value: 'week', label: trans.calendar.thisWeek },
+        { value: 'month', label: trans.calendar.thisMonth },
+        { value: 'search', label: trans.calendar.search },
+        { value: 'past', label: trans.calendar.pastEvents },
+        { value: 'heatmap', label: trans.calendar.heatmap.title },
+    ];
+    return new ListField({ title: trans.menu.events, options });
+}
+function buildListField(title, events, maxVisible) {
+    const trans = t();
+    const display = events.map(toDisplayEvent);
+    const options = [
+        ...events.map((_e, i) => ({
+            value: String(i),
+            label: `${display[i].date}${display[i].time ? ' ' + display[i].time : ''}  ${display[i].title}`,
+            hint: display[i].location,
+        })),
+        { value: '__back__', label: backLabel() },
+    ];
+    return new ListField({
+        title: title || trans.menu.events,
+        options: options.length > 1 ? options : [{ value: '__back__', label: `${trans.calendar.noEvents} — ${backLabel()}` }],
+        maxVisible,
+    });
+}
+function showList(title, events, ctx) {
+    currentList = events;
+    state = { mode: 'list', listField: buildListField(title, events, computeMaxVisible(ctx.bodyRows)) };
+}
+// A glance-panel ceiling, not "browse everything" (this tab's own "Events"
+// list is for that) — just needs to be at least as many as the tallest
+// reasonable terminal could fit; renderHubBody trims further based on the
+// real ctx.bodyRows.
+const RECENT_ACTIVITY_FETCH_CAP = 15;
+function goToHub() {
+    const upcoming = calendar ? calendar.upcoming({ days: 30 }) : [];
+    state = {
+        mode: 'hub',
+        hubField: buildHubField(),
+        nextEvent: upcoming[0] ? toDisplayEvent(upcoming[0]) : undefined,
+        heatmapBuckets: calendar
+            ? calendar.heatmap({ start: new Date(Date.now() - 365 * 86400000), end: new Date(), bucket: 'day' })
+            : [],
+        recentEvents: upcoming.slice(0, RECENT_ACTIVITY_FETCH_CAP).map(toDisplayEvent),
+    };
+}
+function showDetail(raw) {
+    const trans = t();
+    const e = toDisplayEvent(raw);
+    const dot = pickIcon('·', '-');
+    state = {
+        mode: 'detail',
+        detailTitle: e.title,
+        detailMeta: `${e.date}${e.time ? ' ' + e.time : ''}  ${dot}  ${e.location}${raw.recurring ? `  ${dot}  ${trans.calendar.recurringLabel}` : ''}`,
+        detailDescription: e.description,
+        detailEvent: raw,
+        detailField: new ListField({
+            // Empty, not e.title: renderEvents already prints the event title as
+            // its own heading right above (detailTitle) -- giving the field the
+            // same string a second time repeated it verbatim just above the
+            // Export/Back options.
+            title: '',
+            options: [
+                { value: 'export', label: trans.calendar.exportIcs },
+                { value: '__back__', label: backLabel() },
+            ],
+        }),
+    };
+}
+export const eventsView = {
+    id: 'events',
+    title: t().menu.events,
+    async load(ctx) {
+        state = { mode: 'loading' };
+        ctx.rerender();
+        try {
+            calendar = await loadCalendarOrThrow();
+            goToHub();
+        }
+        catch {
+            state = { mode: 'error', errorMessage: t().calendar.error };
+        }
+        ctx.rerender();
+    },
+    render(ctx) {
+        // Sync the list'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.listField?.setMaxVisible(computeMaxVisible(ctx.bodyRows));
+        return renderEvents(state, new Date(), ctx.bodyRows, ctx.size.cols);
+    },
+    capturesInput() {
+        return state.mode === 'search';
+    },
+    footerHint(tabCount, cols = Number.POSITIVE_INFINITY) {
+        if (state.mode === 'search')
+            return captureFooterHint(cols);
+        // A pure "read this, any key returns to the hub" drill-down (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 === 'error' || state.mode === 'heatmap';
+        return passive ? passiveFooterHint(tabCount, cols) : undefined;
+    },
+    handleBack() {
+        if (state.mode === 'list' || state.mode === 'detail' || state.mode === 'search' || state.mode === 'heatmap') {
+            if (state.mode === 'search')
+                setVimKeysActive(true);
+            goToHub();
+            return true;
+        }
+        return false;
+    },
+    handleKey(key, ctx) {
+        if (!calendar)
+            return;
+        switch (state.mode) {
+            case 'hub': {
+                const result = state.hubField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                const now = new Date();
+                if (result.selected === 'upcoming') {
+                    showList(t().menu.events, calendar.upcoming({ days: 30 }), ctx);
+                    return;
+                }
+                if (result.selected === 'week') {
+                    const r = weekRange(now);
+                    showList(t().calendar.thisWeek, calendar.inRange(r.start, r.end), ctx);
+                    return;
+                }
+                if (result.selected === 'month') {
+                    const r = monthRange(now);
+                    showList(t().calendar.thisMonth, calendar.inRange(r.start, r.end), ctx);
+                    return;
+                }
+                if (result.selected === 'past') {
+                    showList(t().calendar.pastEvents, calendar.past({ days: 30 }).reverse(), ctx);
+                    return;
+                }
+                if (result.selected === 'heatmap') {
+                    state = { ...state, mode: 'heatmap' };
+                    return;
+                }
+                if (result.selected === 'search') {
+                    setVimKeysActive(false);
+                    state = { mode: 'search', searchField: new TextField({ message: t().calendar.searchPrompt, placeholder: t().calendar.searchPlaceholder, allowEmpty: true }) };
+                }
+                return;
+            }
+            // A pure detail/drill-down view with no field of its own — any key
+            // returns to the hub, matching Schedule's 'week'/'unresolved' modes.
+            case 'heatmap': {
+                goToHub();
+                return;
+            }
+            case 'list': {
+                const result = state.listField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__back__') {
+                    goToHub();
+                    return;
+                }
+                const raw = currentList[Number.parseInt(result.selected, 10)];
+                if (raw)
+                    showDetail(raw);
+                return;
+            }
+            case 'detail': {
+                const result = state.detailField?.handleKey(key);
+                if (!result?.selected)
+                    return;
+                if (result.selected === '__back__') {
+                    showList('', currentList, ctx);
+                    return;
+                }
+                if (result.selected === 'export' && state.detailEvent) {
+                    const res = exportEventIcs(state.detailEvent);
+                    state = { ...state, statusMessage: res.ok ? `${t().calendar.exportSuccess}: ${res.path}` : `${t().calendar.exportError}: ${res.error ?? ''}` };
+                }
+                return;
+            }
+            case 'search': {
+                const result = state.searchField?.handleKey(key);
+                if (result?.cancelled) {
+                    setVimKeysActive(true);
+                    goToHub();
+                    return;
+                }
+                if (result?.submitted !== undefined) {
+                    setVimKeysActive(true);
+                    const query = result.submitted.trim();
+                    if (!query || !calendar) {
+                        goToHub();
+                        return;
+                    }
+                    const now = new Date();
+                    const pool = calendar.inRange(now, new Date(now.getTime() + 365 * 86400000));
+                    const results = filterEvents(pool, query);
+                    showList(`${t().calendar.search}: ${query}`, results, ctx);
+                }
+                return;
+            }
+            default:
+                return;
+        }
+    },
+};

package/dist/app/views/home.js

@@ -0,0 +1,236 @@
+import { c, type, space, glyph } from '../../core/theme.js';
+import { t } from '../../i18n/index.js';
+import { pickIcon } from '../../core/icons.js';
+import { padEndV, visualWidth, wrapAnsiToVisualWidth } from '../../core/text.js';
+import { peekNextClassLine, peekTodayLines, peekWeekAheadInfo, peekUnresolvedCount } from '../../features/schedule-view.js';
+import { loadCalendarOrThrow, toDisplayEvent, renderEventBrief } from '../../features/calendar.js';
+import { weekdayShortLabel } from '../../features/schedule-render.js';
+import { campusWeekday } from '../../features/schedule-query.js';
+import { passiveFooterHint } from '../chrome.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}`);
+}
+function panelHeading(label, cols) {
+    return wrappedIndentedLines(label, cols, type.heading);
+}
+function loadingLines(cols) {
+    return wrappedIndentedLines(t().common.loading, cols, type.hint);
+}
+function wrappedRenderedLines(line, cols) {
+    const content = line.startsWith(space.indent) ? line.slice(space.indent.length) : line;
+    return wrappedIndentedLines(content, cols, (value) => value);
+}
+const DAY_PROGRESS_WIDTH = 20;
+/** Pure: a block-character bar for how far into the calendar day `now` is. */
+function renderDayProgress(now, cols) {
+    const minutesElapsed = now.getHours() * 60 + now.getMinutes();
+    const fraction = Math.min(1, Math.max(0, minutesElapsed / 1440));
+    const pct = Math.round(fraction * 100);
+    const percentage = `${pct}%`;
+    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : Number.POSITIVE_INFINITY;
+    const indent = visualWidth(space.indent) + 2 + visualWidth(percentage) + 1 <= width ? space.indent : '';
+    const gap = visualWidth(indent) + 2 + visualWidth(percentage) + 1 <= width
+        ? '  '
+        : visualWidth(indent) + 1 + visualWidth(percentage) + 1 <= width ? ' ' : '';
+    const barWidth = Math.max(0, Math.min(DAY_PROGRESS_WIDTH, width - visualWidth(indent) - visualWidth(gap) - visualWidth(percentage)));
+    const filled = Math.round(fraction * barWidth);
+    const filledChar = glyph.barFilled();
+    const emptyChar = glyph.barEmpty();
+    const bar = filledChar.repeat(filled) + emptyChar.repeat(barWidth - filled);
+    return `${indent}${type.body(bar)}${gap}${type.hint(percentage)}`;
+}
+/** Combined class+event density grid for the coming campus week — the one
+ * visualization neither Schedule nor Events alone can produce, since it
+ * needs both data sources at once. Deliberately coarser (binary, not
+ * 5-level) than Schedule's own term-density strip, and deliberately
+ * uncolored (see the design spec's "Visual language decision") since it's
+ * an overview of two other already-colored things, not a third color
+ * language to learn. */
+function renderWeekAheadGrid(classDays, eventDays, cols) {
+    const trans = t();
+    const hasClassChar = pickIcon('▓▓', '##');
+    const freeChar = pickIcon('░░', '..');
+    const weekendChar = pickIcon('··', '..');
+    const blankCell = '  ';
+    const rowLabelW = Math.max(visualWidth(trans.timetable.weekAheadClasses), visualWidth(trans.menu.events)) + 1;
+    const days = [1, 2, 3, 4, 5, 6, 7];
+    const dayLabels = days.map((wd) => type.hint(weekdayShortLabel(wd))).join('  ');
+    const headerLine = `${space.indent}${padEndV('', rowLabelW)}${dayLabels}`;
+    // Class row: weekend is hardcoded to the "N/A" glyph regardless of
+    // classDays data (campus never has weekend classes) -- the same
+    // weekend treatment used throughout the Schedule tab's own renderers.
+    const classCells = days.map((wd) => {
+        const isWeekend = wd === 6 || wd === 7;
+        const glyphChar = isWeekend ? weekendChar : (classDays[wd - 1] ? hasClassChar : freeChar);
+        return type.body(glyphChar);
+    }).join('  ');
+    const classLine = `${space.indent}${type.hint(padEndV(trans.timetable.weekAheadClasses, rowLabelW))}${classCells}`;
+    // Event row: deliberately NOT hardcoding weekend -- a club event can
+    // happen on a Saturday, so this row checks real data for all 7 days.
+    // undefined eventDays (events still loading, or the fetch failed) means
+    // "not yet known" -- rendered as blank, not the "free" glyph, to
+    // visually distinguish "no data yet" from "checked, nothing happening".
+    const eventCells = days.map((wd) => {
+        if (!eventDays)
+            return blankCell;
+        return type.body(eventDays[wd - 1] ? hasClassChar : freeChar);
+    }).join('  ');
+    const eventLine = `${space.indent}${type.hint(padEndV(trans.menu.events, rowLabelW))}${eventCells}`;
+    const legend = `${space.indent}${type.hint(`${hasClassChar} ${trans.timetable.weekAheadBusy}  ${freeChar} ${trans.timetable.weekAheadFree}  ${weekendChar} ${trans.timetable.weekAheadNone}`)}`;
+    const wideLines = [headerLine, classLine, eventLine, legend];
+    const width = Number.isFinite(cols) ? Math.max(1, Math.floor(cols)) : Number.POSITIVE_INFINITY;
+    if (wideLines.every((line) => visualWidth(line) <= width))
+        return wideLines.join('\n');
+    const compactHeading = wrappedIndentedLines(`${trans.timetable.weekAheadClasses} / ${trans.menu.events}`, cols, type.hint);
+    const compactDays = days.flatMap((wd) => {
+        const classCell = wd === 6 || wd === 7
+            ? weekendChar
+            : classDays[wd - 1] ? hasClassChar : freeChar;
+        const eventCell = eventDays
+            ? eventDays[wd - 1] ? hasClassChar : freeChar
+            : blankCell;
+        const row = `${type.hint(weekdayShortLabel(wd))}  ${type.body(classCell)}  ${type.body(eventCell)}`;
+        return wrappedIndentedLines(row, cols, (value) => value);
+    });
+    const compactLegend = wrappedIndentedLines(`${hasClassChar} ${trans.timetable.weekAheadBusy}  ${freeChar} ${trans.timetable.weekAheadFree}  ${weekendChar} ${trans.timetable.weekAheadNone}`, cols, type.hint);
+    return [...compactHeading, ...compactDays, ...compactLegend].join('\n');
+}
+/** Pure: renders the schedule-first dashboard from already-fetched data. No I/O. */
+export function renderHome(data, now, bodyRows = 100, cols = 80) {
+    const trans = t();
+    const lines = [];
+    // Next class (cache-only, instant).
+    const nextClass = data.nextClassLine !== undefined && data.nextClassLine.trim().length > 0
+        ? wrappedRenderedLines(data.nextClassLine, cols)
+        : wrappedIndentedLines(trans.timetable.noNextClass, cols, type.hint);
+    lines.push(...panelHeading(trans.timetable.nextClass, cols));
+    lines.push(...nextClass);
+    lines.push('');
+    // Today's classes (cache-only, instant).
+    lines.push(...panelHeading(trans.timetable.hubToday, cols));
+    lines.push(renderDayProgress(now, cols));
+    if (data.todayLines && data.todayLines.length > 0) {
+        for (const line of data.todayLines)
+            lines.push(...wrappedRenderedLines(line, cols));
+    }
+    else {
+        lines.push(...wrappedIndentedLines(trans.timetable.noClassToday, cols, type.hint));
+    }
+    lines.push('');
+    // Week overview (Part D): only when the student has a set-up, in-term
+    // personal timetable -- mirrors peekWeekAheadInfo's own "not set up yet
+    // / term hasn't started" -> null contract, hiding the whole panel rather
+    // than showing empty/misleading cells.
+    if (data.weekAhead) {
+        lines.push(...panelHeading(trans.timetable.weekOverviewTitle, cols));
+        lines.push(...renderWeekAheadGrid(data.weekAhead.classDays, data.weekAhead.eventDays, cols).split('\n'));
+        lines.push('');
+    }
+    // Unresolved schedule items (Part E): surfaced directly on Home instead
+    // of only inside Schedule's own hub menu -- same c.warn + ⚠ treatment
+    // buildHubField() (schedule.ts) already uses for this exact condition,
+    // matching the "everything that needs your attention, in one place"
+    // spirit of a gh-status-like control center.
+    if ((data.unresolvedCount ?? 0) > 0) {
+        lines.push(...wrappedIndentedLines(`${pickIcon('⚠', '!')} ${trans.timetable.hubUnresolved} · ${data.unresolvedCount}`, cols, c.warn));
+        lines.push('');
+    }
+    // Upcoming events (network, best-effort). How many fit is whatever room
+    // is actually left after next-class/today above — on a tall terminal
+    // that's most of `data.eventLines`; on a normal one, still just a few,
+    // same as before this was ever adaptive.
+    lines.push(...panelHeading(trans.menu.events, cols));
+    if (data.eventLines && data.eventLines.length > 0) {
+        const remaining = Number.isFinite(bodyRows)
+            ? Math.max(0, Math.floor(bodyRows) - lines.length)
+            : Number.POSITIVE_INFINITY;
+        let usedRows = 0;
+        for (const line of data.eventLines) {
+            const wrapped = wrappedRenderedLines(line, cols);
+            if (usedRows + wrapped.length > remaining) {
+                if (usedRows === 0 && remaining === 0)
+                    lines.push(...wrapped);
+                break;
+            }
+            lines.push(...wrapped);
+            usedRows += wrapped.length;
+        }
+    }
+    else if (data.loading) {
+        lines.push(...loadingLines(cols));
+    }
+    else if (data.eventsError) {
+        lines.push(...wrappedIndentedLines(trans.calendar.error, cols, type.hint));
+    }
+    else {
+        lines.push(...wrappedIndentedLines(trans.calendar.noEvents, cols, type.hint));
+    }
+    return lines;
+}
+let data = { loading: true };
+export const homeView = {
+    id: 'home',
+    title: 'Home',
+    footerHint(tabCount, cols = Number.POSITIVE_INFINITY) {
+        return passiveFooterHint(tabCount, cols);
+    },
+    async load(ctx) {
+        // Schedule panels are cache-only and instant — populate them
+        // synchronously first. weekAheadSync is computed once here and reused
+        // below (peekWeekAheadInfo is itself cache-only/cheap, but capturing
+        // its result avoids a second, redundant cache read for weekStartDate).
+        const weekAheadSync = peekWeekAheadInfo();
+        try {
+            data = {
+                loading: true,
+                nextClassLine: peekNextClassLine(),
+                todayLines: peekTodayLines(),
+                unresolvedCount: peekUnresolvedCount(),
+                weekAhead: weekAheadSync ? { classDays: weekAheadSync.classDays } : undefined,
+            };
+        }
+        catch {
+            data = { loading: true };
+        }
+        ctx.rerender();
+        // Events is the only networked panel; best-effort. Fetches the calendar
+        // exactly once and reuses that same Calendar instance for both the
+        // upcoming-events list below and the week-ahead event row (when there's
+        // a personal timetable to correlate it against) — not two separate
+        // network round-trips for what both come from the same public feed.
+        const HOME_EVENT_FETCH_CAP = 15;
+        try {
+            const cal = await loadCalendarOrThrow();
+            const now = new Date();
+            const items = cal.upcoming({ days: 30 }).slice(0, HOME_EVENT_FETCH_CAP).map(toDisplayEvent);
+            const eventLines = items.map((e) => renderEventBrief(e, now));
+            let weekAhead = data.weekAhead;
+            if (weekAheadSync) {
+                const weekEnd = new Date(weekAheadSync.weekStartDate.getTime() + 7 * 86400000);
+                const weekEvents = cal.inRange(weekAheadSync.weekStartDate, weekEnd);
+                const daySet = new Set(weekEvents.map((e) => campusWeekday(e.start)));
+                weekAhead = { classDays: weekAheadSync.classDays, eventDays: [1, 2, 3, 4, 5, 6, 7].map((wd) => daySet.has(wd)) };
+            }
+            data = { ...data, eventLines, weekAhead };
+        }
+        catch {
+            data = { ...data, eventsError: true };
+        }
+        finally {
+            data = { ...data, loading: false };
+            ctx.rerender();
+        }
+    },
+    render(ctx) {
+        return renderHome(data, new Date(), ctx.bodyRows, ctx.size.cols);
+    },
+};

package/dist/app/views/schedule-grid-cursor.js

@@ -0,0 +1,52 @@
+import { meetingAtCursor } from '../../features/schedule-query.js';
+export const KEY_ARROW_LEFT = '\x1b[D';
+export const KEY_ARROW_RIGHT = '\x1b[C';
+export const KEY_ARROW_UP = '\x1b[A';
+export const KEY_ARROW_DOWN = '\x1b[B';
+export const KEY_ENTER_CR = '\r';
+export const KEY_ENTER_LF = '\n';
+/** The cursor's starting position on entering hub/week mode: today's own
+ * weekday (falling back to Monday on a weekend, since the grid's Sat/Sun
+ * columns are always empty for a personal timetable) and the first period
+ * this term's own period table actually defines. */
+export function defaultGridCursor(todayWeekday, periods) {
+    const sorted = [...periods].sort((a, b) => a.period - b.period);
+    const firstPeriod = sorted[0]?.period ?? 1;
+    const weekday = todayWeekday >= 1 && todayWeekday <= 5 ? todayWeekday : 1;
+    return { weekday, period: firstPeriod };
+}
+/** Moves the cursor one weekday left/right, clamped to [1, 7] with no
+ * wraparound -- a 7-day week has a real fixed edge, unlike a scrollable
+ * list where wrapping back to the top makes sense. */
+export function moveCursorWeekday(cursor, delta) {
+    return { ...cursor, weekday: Math.max(1, Math.min(7, cursor.weekday + delta)) };
+}
+/** Moves the cursor to the previous/next *defined* period in the sorted
+ * period table (not period±1 -- real period numbers aren't always
+ * contiguous), clamped at the first/last period with no wraparound. */
+export function moveCursorPeriod(cursor, periods, delta) {
+    const sorted = [...periods].sort((a, b) => a.period - b.period);
+    if (sorted.length === 0)
+        return cursor;
+    const idx = sorted.findIndex((p) => p.period === cursor.period);
+    const nextIdx = Math.max(0, Math.min(sorted.length - 1, (idx === -1 ? 0 : idx) + delta));
+    return { ...cursor, period: sorted[nextIdx].period };
+}
+/** Pure key-to-action mapping shared by hub mode's inline grid and the
+ * standalone full-screen 'week' mode -- both are cursor-navigable over the
+ * exact same rules, so this is the one place that logic lives. */
+export function handleGridKey(key, cursor, tt, week) {
+    if (key === KEY_ARROW_LEFT)
+        return { kind: 'moveCursor', cursor: moveCursorWeekday(cursor, -1) };
+    if (key === KEY_ARROW_RIGHT)
+        return { kind: 'moveCursor', cursor: moveCursorWeekday(cursor, 1) };
+    if (key === KEY_ARROW_UP)
+        return { kind: 'moveCursor', cursor: moveCursorPeriod(cursor, tt.periods, -1) };
+    if (key === KEY_ARROW_DOWN)
+        return { kind: 'moveCursor', cursor: moveCursorPeriod(cursor, tt.periods, 1) };
+    if (key === KEY_ENTER_CR || key === KEY_ENTER_LF) {
+        const meeting = meetingAtCursor(tt.meetings, week, cursor);
+        return meeting ? { kind: 'openDetail', meeting } : { kind: 'none' };
+    }
+    return { kind: 'none' };
+}