@elaraai/e3-ui-cli 1.0.73 → 1.0.75

package/dist/tui/ui/views/dashboard.js

@@ -10,7 +10,7 @@ import { datasetStatusCell, eventCell, executionDuration, executionStatusCell, s
 import { registerViewHooks } from '../../controller.js';
 import { isRunLive, lockHolderText } from '../../data/dataflow.js';
 import { b, blank, d, lineWidth, lrLine, t } from '../lines.js';
-import { centredBlock, renderTable, sectionLine, withScrollbar } from '../shell/widgets.js';
+import { centredBlock, sectionLine, tableLine, tablePlan, withScrollbar } from '../shell/widgets.js';
 import { registerView } from './index.js';
 /** Event rows the execution panel shows at most. */
 export const MAX_EVENT_ROWS = 6;
@@ -147,7 +147,7 @@ function countsLines(status, dctx) {
     return out;
 }
 // ---------------------------------------------------------------------------
-// Execution
+// The model
 // ---------------------------------------------------------------------------
 /**
  * The latest event of each task, in order of first appearance.
@@ -170,17 +170,149 @@ export function latestPerTask(events) {
 function isLive(execution) {
     return execution !== undefined && (execution.state?.status.type === 'running' || execution.settling || execution.stopping);
 }
-/** The execution panel: a header line, the event rows, and which rows open logs. */
-function executionLines(execution, tasksTotal, sel, dctx) {
+/** Whether an event's row opens the task's logs. */
+function opensLogs(event) {
+    return event.type === 'failed' || event.type === 'error';
+}
+let cached = null;
+function sameKey(a, b) {
+    return a.ws === b.ws && a.status === b.status && a.statusError === b.statusError && a.workspaceState === b.workspaceState
+        && a.execution === b.execution && a.datasets === b.datasets && a.taskList === b.taskList
+        && a.columns === b.columns && a.bp === b.bp && a.g === b.g;
+}
+/**
+ * The dashboard model for a workspace — built once per data change and
+ * returned as the same object until the status, the execution, the
+ * dataset list, the task list, the width or the breakpoint changes. The
+ * clock, the spinner and the selection are not inputs: they restyle lines
+ * at render ({@link dashboardLines}).
+ *
+ * @param state - The store state
+ * @param ws - The workspace
+ * @param dctx - The dashboard context (its width and breakpoint key the cache)
+ * @returns The model
+ */
+export function dashboardModel(state, ws, dctx) {
+    const key = {
+        ws,
+        status: state.data.status[ws]?.result,
+        statusError: state.data.statusError[ws],
+        workspaceState: state.data.workspaceState[ws],
+        execution: state.data.execution[ws],
+        datasets: state.data.datasets[ws],
+        taskList: state.data.taskList[ws],
+        columns: dctx.columns,
+        bp: dctx.bp,
+        g: dctx.g,
+    };
+    if (cached !== null && sameKey(cached.key, key))
+        return cached.model;
+    const model = buildModel(state, ws, dctx, key);
+    cached = { key, model };
+    return model;
+}
+/** Builds the model (the cache's miss path). */
+function buildModel(state, ws, dctx, key) {
+    const g = dctx.g;
+    const width = dctx.columns - 1;
+    const status = key.status;
+    const execution = key.execution;
+    const empty = {
+        status, placeholder: [], counts: [], execution, live: false, done: 0, events: [], latest: new Map(),
+        taskPlan: [], tasks: [], inputPlan: [], inputs: [], inputNames: [], rows: [], total: 0, panelAt: 0, tasksAt: 0, inputsAt: 0,
+    };
+    if (status === undefined) {
+        const placeholder = [];
+        if (key.workspaceState === null) {
+            placeholder.push(...centredBlock(g.empty, 'muted', 'NOTHING DEPLOYED', [`${ws} has no package yet`, `e3 workspace deploy <repo> ${ws} <package>[@version]   deploy one`, '/workspaces   pick another workspace'], width));
+        }
+        else if (key.statusError !== undefined) {
+            placeholder.push([t(' '), b(`${g.cross} ${key.statusError}`, 'neg')]);
+        }
+        else {
+            placeholder.push([t(' '), d('loading…')]);
+        }
+        return { ...empty, placeholder, total: placeholder.length };
+    }
+    // The dataset map and the latest event per task: once per build, shared by every row.
+    const entries = datasetEntries(state, ws);
+    const latest = new Map(latestPerTask(execution?.events ?? []).map(e => [e.value.task, e]));
+    const live = isLive(execution);
+    const done = execution === undefined ? 0 : execution.events.filter(e => e.type !== 'start').length;
+    const events = execution === undefined || execution.state === null ? []
+        : live ? [...latest.values()].slice(-MAX_EVENT_ROWS)
+            : [...latest.values()].filter(opensLogs);
+    const tasks = status.tasks.map(task => {
+        const cell = taskStatusCell(task.status, g);
+        // The reason / pid / cached detail lives in the last column; only a failure's exit code / message stays inline.
+        const bare = task.status.type !== 'failed' && task.status.type !== 'error';
+        const inputs = task.inputs.filter(p => p.startsWith('.inputs.')).map(p => p.slice('.inputs.'.length));
+        const entry = entries.get(task.output);
+        return {
+            task,
+            event: latest.get(task.name),
+            size: entry?.size != null ? formatSize(entry.size) : '—',
+            cells: {
+                name: task.name,
+                status: { text: bare ? `${cell.glyph} ${cell.word}` : statusText(cell), tone: cell.tone },
+                dependsOn: task.dependsOn.length > 0 ? task.dependsOn.join(', ') : '—',
+                inputs: inputs.length > 0 ? inputs.join(', ') : '—',
+                output: entry?.type ?? '—',
+            },
+        };
+    });
+    const inputDatasets = status.datasets.filter(ds => !ds.isTaskOutput && ds.path.startsWith('.inputs.'));
+    const inputNames = inputDatasets.map(ds => ds.path.slice('.inputs.'.length));
+    const inputs = inputDatasets.map((ds, i) => {
+        const cell = datasetStatusCell(ds.status.type, g);
+        const entry = entries.get(ds.path);
+        return {
+            cells: {
+                name: inputNames[i],
+                status: { text: statusText(cell), tone: cell.tone },
+                type: entry?.type ?? '—',
+                size: entry?.size != null ? formatSize(entry.size) : '—',
+                hash: ds.hash.type === 'some' ? hashShort(ds.hash.value) : '—',
+            },
+        };
+    });
+    const taskPlan = tablePlan(columnPlan('tasks', dctx.bp), tasks, width);
+    const inputPlan = tablePlan(columnPlan('inputs', dctx.bp), inputs, width);
+    const counts = countsLines(status, dctx);
+    // The geometry: every selectable row's line, numbered in column order — failures, tasks, inputs.
+    const rows = [];
+    let line = counts.length + 1;
+    const panelAt = line;
+    const shown = events.slice(0, MAX_EVENT_ROWS);
+    shown.forEach((event, i) => {
+        if (opensLogs(event))
+            rows.push({ kind: 'logs', name: event.value.task, line: panelAt + 1 + i });
+    });
+    line += 1 + shown.length + (events.length > shown.length ? 1 : 0) + 1;
+    const tasksAt = line;
+    line += 2;
+    status.tasks.forEach((task, i) => rows.push({ kind: 'task', name: task.name, line: line + i }));
+    line += Math.max(1, tasks.length) + 1;
+    const inputsAt = line;
+    line += 2;
+    inputNames.forEach((name, i) => rows.push({ kind: 'input', name, line: line + i }));
+    line += Math.max(1, inputs.length);
+    return { ...empty, counts, live, done, events, latest, taskPlan, tasks, inputPlan, inputs, inputNames, rows, total: line, panelAt, tasksAt, inputsAt };
+}
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+/** The execution panel: a header line, then the event rows (the header and the ages carry the clock and the spinner). */
+function executionLines(model, sel, dctx) {
     const g = dctx.g;
     const sep = g.sep;
     const width = dctx.columns - 1;
     const spin = g.spinner[dctx.spinner % g.spinner.length];
+    const execution = model.execution;
+    const tasksTotal = model.status?.tasks.length ?? 0;
     const lines = [];
-    const logs = [];
     let title = 'LAST EXECUTION';
     let right;
-    let events = [];
     if (execution === undefined) {
         right = [d('…')];
     }
@@ -189,13 +321,10 @@ function executionLines(execution, tasksTotal, sel, dctx) {
         if (execution.settling)
             title = 'EXECUTION';
     }
-    else if (isLive(execution)) {
+    else if (model.live) {
         title = 'EXECUTION';
-        const state = execution.state;
-        const done = execution.events.filter(e => e.type !== 'start').length;
         const head = execution.stopping ? b(`${g.square} STOPPING`, 'warn') : b(`${g.quarter} RUNNING`, 'info');
-        right = [head, d(` ${sep} started ${timeAgo(state.startedAt, dctx.now)} ${sep} ${done} of ${tasksTotal} tasks ${sep} ${spin}`)];
-        events = latestPerTask(execution.events).slice(-MAX_EVENT_ROWS);
+        right = [head, d(` ${sep} started ${timeAgo(execution.state.startedAt, dctx.now)} ${sep} ${model.done} of ${tasksTotal} tasks ${sep} ${spin}`)];
     }
     else {
         const state = execution.state;
@@ -206,14 +335,13 @@ function executionLines(execution, tasksTotal, sel, dctx) {
             detail += ` ${sep} ${formatDuration(executionDuration(state) ?? s.duration)} ${sep} executed ${s.executed} ${sep} cached ${s.cached} ${sep} failed ${s.failed} ${sep} skipped ${s.skipped}`;
         }
         right = [b(`${cell.glyph} ${cell.word}`, cell.tone), d(detail)];
-        events = latestPerTask(execution.events).filter(e => e.type === 'failed' || e.type === 'error');
     }
     lines.push(lrLine([t(' '), b(title)], [...right, t(' ')], width));
-    const shown = events.slice(0, MAX_EVENT_ROWS);
+    const shown = model.events.slice(0, MAX_EVENT_ROWS);
     for (const event of shown) {
         const cell = eventCell(event, g);
-        const opensLogs = event.type === 'failed' || event.type === 'error';
-        const selected = opensLogs && sel?.kind === 'logs' && sel.name === cell.task;
+        const logs = opensLogs(event);
+        const selected = logs && sel?.kind === 'logs' && sel.name === cell.task;
         const left = [
             t(' '),
             selected ? b(g.sel, 'brand') : t(' '),
@@ -228,20 +356,15 @@ function executionLines(execution, tasksTotal, sel, dctx) {
             detail.push(d(`${spin} ${ageBare(cell.timestamp, dctx.now)}`));
         else if (cell.detail !== '')
             detail.push(d(cell.detail));
-        if (opensLogs) {
-            logs.push({ task: cell.task, at: lines.length });
+        if (logs)
             detail.push(t('     '), b(`${g.enter} logs`, 'brand'));
-        }
         lines.push(lrLine(left, [...detail, t(' ')], width));
     }
-    if (events.length > shown.length) {
-        lines.push([t('   '), d(`… ${events.length - shown.length} more failed ${sep} /logs <task>`)]);
+    if (model.events.length > shown.length) {
+        lines.push([t('   '), d(`… ${model.events.length - shown.length} more failed ${sep} /logs <task>`)]);
     }
-    return { lines, logs };
+    return lines;
 }
-// ---------------------------------------------------------------------------
-// Tables
-// ---------------------------------------------------------------------------
 /** The `SIZE · LAST RUN` cell of a task row. */
 function lastRunText(task, event, size, dctx) {
     const g = dctx.g;
@@ -265,138 +388,66 @@ function lastRunText(task, event, size, dctx) {
     }
 }
 /**
- * The tasks table rows.
+ * The column's lines in `[top, top + visible)` — the window the screen
+ * shows, rendered from the model with the selected row restyled and the
+ * clock and the spinner stamped in.
  *
- * @param state - The store state
- * @param ws - The workspace
- * @param status - Its status
- * @param dctx - The dashboard context
- * @returns The rows, in the status order
- */
-export function taskRows(state, ws, status, dctx) {
-    const g = dctx.g;
-    const entries = datasetEntries(state, ws);
-    const latest = new Map(latestPerTask(state.data.execution[ws]?.events ?? []).map(e => [e.value.task, e]));
-    return status.tasks.map(task => {
-        const cell = taskStatusCell(task.status, g);
-        // The reason / pid / cached detail lives in the last column; only a failure's exit code / message stays inline.
-        const bare = task.status.type !== 'failed' && task.status.type !== 'error';
-        const inputs = task.inputs.filter(p => p.startsWith('.inputs.')).map(p => p.slice('.inputs.'.length));
-        const entry = entries.get(task.output);
-        const size = entry?.size != null ? formatSize(entry.size) : '—';
-        return {
-            cells: {
-                name: task.name,
-                status: { text: bare ? `${cell.glyph} ${cell.word}` : statusText(cell), tone: cell.tone },
-                dependsOn: task.dependsOn.length > 0 ? task.dependsOn.join(', ') : '—',
-                inputs: inputs.length > 0 ? inputs.join(', ') : '—',
-                output: entry?.type ?? '—',
-                size: lastRunText(task, latest.get(task.name), size, dctx),
-            },
-        };
-    });
-}
-/**
- * The inputs table rows (`.inputs.*` datasets that no task produces).
- *
- * @param state - The store state
- * @param ws - The workspace
- * @param status - Its status
- * @param dctx - The dashboard context
- * @returns The rows, in the status order
- */
-export function inputRows(state, ws, status, dctx) {
-    const entries = datasetEntries(state, ws);
-    return status.datasets.filter(ds => !ds.isTaskOutput && ds.path.startsWith('.inputs.')).map(ds => {
-        const cell = datasetStatusCell(ds.status.type, dctx.g);
-        const entry = entries.get(ds.path);
-        return {
-            cells: {
-                name: ds.path.slice('.inputs.'.length),
-                status: { text: statusText(cell), tone: cell.tone },
-                type: entry?.type ?? '—',
-                size: entry?.size != null ? formatSize(entry.size) : '—',
-                hash: ds.hash.type === 'some' ? hashShort(ds.hash.value) : '—',
-            },
-        };
-    });
-}
-// ---------------------------------------------------------------------------
-// The column
-// ---------------------------------------------------------------------------
-/**
- * Builds the column under the title.
- *
- * @param state - The store state
- * @param ws - The workspace
+ * @param model - The dashboard model
  * @param dctx - The dashboard context
  * @param sel - The selected row index
- * @returns The lines and the selectable rows
+ * @param top - The first line
+ * @param visible - Lines in the window
+ * @returns The lines (fewer when the column ends first)
  */
-export function dashboardColumn(state, ws, dctx, sel) {
+export function dashboardLines(model, dctx, sel, top, visible) {
     const g = dctx.g;
     const width = dctx.columns - 1;
-    const lines = [];
-    const rows = [];
-    const status = state.data.status[ws]?.result;
-    if (status === undefined) {
-        const error = state.data.statusError[ws];
-        const wsState = state.data.workspaceState[ws];
-        if (wsState === null) {
-            lines.push(...centredBlock(g.empty, 'muted', 'NOTHING DEPLOYED', [`${ws} has no package yet`, `e3 workspace deploy <repo> ${ws} <package>[@version]   deploy one`, '/workspaces   pick another workspace'], width));
-        }
-        else if (error !== undefined) {
-            lines.push([t(' '), b(`${g.cross} ${error}`, 'neg')]);
+    const first = Math.max(0, top);
+    const end = Math.min(model.total, first + visible);
+    if (model.status === undefined)
+        return model.placeholder.slice(first, end);
+    const selected = model.rows[Math.max(0, Math.min(sel, model.rows.length - 1))];
+    const panel = executionLines(model, selected, dctx);
+    const taskSel = selected?.kind === 'task' ? model.tasks.findIndex(row => row.task.name === selected.name) : -1;
+    const inputSel = selected?.kind === 'input' ? model.inputNames.indexOf(selected.name) : -1;
+    const tasksFirst = model.tasksAt + 2;
+    const inputsFirst = model.inputsAt + 2;
+    const out = [];
+    for (let i = first; i < end; i++) {
+        if (i < model.counts.length)
+            out.push(model.counts[i]);
+        else if (i < model.panelAt)
+            out.push(blank(width));
+        else if (i < model.panelAt + panel.length)
+            out.push(panel[i - model.panelAt]);
+        else if (i < model.tasksAt)
+            out.push(blank(width));
+        else if (i === model.tasksAt)
+            out.push(sectionLine('TASKS', '', width));
+        else if (i === model.tasksAt + 1)
+            out.push(tableLine(model.taskPlan, null, false, width, g));
+        else if (i < model.inputsAt - 1) {
+            const row = model.tasks[i - tasksFirst];
+            if (row === undefined)
+                out.push([t('  '), d('no tasks')]);
+            else
+                out.push(tableLine(model.taskPlan, { cells: { ...row.cells, size: lastRunText(row.task, row.event, row.size, dctx) } }, i - tasksFirst === taskSel, width, g));
         }
+        else if (i < model.inputsAt)
+            out.push(blank(width));
+        else if (i === model.inputsAt)
+            out.push(sectionLine('INPUTS', '', width));
+        else if (i === model.inputsAt + 1)
+            out.push(tableLine(model.inputPlan, null, false, width, g));
         else {
-            lines.push([t(' '), d('loading…')]);
+            const row = model.inputs[i - inputsFirst];
+            if (row === undefined)
+                out.push([t('  '), d('no inputs')]);
+            else
+                out.push(tableLine(model.inputPlan, row, i - inputsFirst === inputSel, width, g));
         }
-        return { lines, rows };
     }
-    // The selectable rows are numbered in column order: failures, tasks, inputs — so the
-    // selected row is resolved from a first pass over the same data.
-    const tasks = taskRows(state, ws, status, dctx);
-    const inputs = inputRows(state, ws, status, dctx);
-    const execution = state.data.execution[ws];
-    const probe = executionLines(execution, status.tasks.length, undefined, dctx);
-    const order = [
-        ...probe.logs.map(l => ({ kind: 'logs', name: l.task })),
-        ...status.tasks.map(task => ({ kind: 'task', name: task.name })),
-        ...status.datasets.filter(ds => !ds.isTaskOutput && ds.path.startsWith('.inputs.')).map(ds => ({ kind: 'input', name: ds.path.slice('.inputs.'.length) })),
-    ];
-    const selected = order[Math.max(0, Math.min(sel, order.length - 1))];
-    const selectedRow = selected === undefined ? undefined : { ...selected, line: -1 };
-    lines.push(...countsLines(status, dctx));
-    lines.push(blank(width));
-    const panel = executionLines(execution, status.tasks.length, selectedRow, dctx);
-    const panelStart = lines.length;
-    for (const l of panel.logs)
-        rows.push({ kind: 'logs', name: l.task, line: panelStart + l.at });
-    lines.push(...panel.lines);
-    lines.push(blank(width));
-    lines.push(sectionLine('TASKS', '', width));
-    const taskSel = selectedRow?.kind === 'task' ? status.tasks.findIndex(task => task.name === selectedRow.name) : -1;
-    const taskTable = renderTable(columnPlan('tasks', dctx.bp), tasks, taskSel, 0, tasks.length, width, g);
-    lines.push(taskTable[0]);
-    status.tasks.forEach((task, i) => {
-        rows.push({ kind: 'task', name: task.name, line: lines.length });
-        lines.push(taskTable[i + 1]);
-    });
-    if (tasks.length === 0)
-        lines.push([t('  '), d('no tasks')]);
-    lines.push(blank(width));
-    lines.push(sectionLine('INPUTS', '', width));
-    const inputNames = order.filter(r => r.kind === 'input').map(r => r.name);
-    const inputSel = selectedRow?.kind === 'input' ? inputNames.indexOf(selectedRow.name) : -1;
-    const inputTable = renderTable(columnPlan('inputs', dctx.bp), inputs, inputSel, 0, inputs.length, width, g);
-    lines.push(inputTable[0]);
-    inputNames.forEach((name, i) => {
-        rows.push({ kind: 'input', name, line: lines.length });
-        lines.push(inputTable[i + 1]);
-    });
-    if (inputs.length === 0)
-        lines.push([t('  '), d('no inputs')]);
-    return { lines, rows };
+    return out;
 }
 /**
  * The dashboard body: the fixed title, then the column window with its
@@ -412,15 +463,16 @@ export function renderDashboard(state, ctx) {
     const ws = state.view.ws;
     const width = ctx.layout.columns;
     const out = [dashboardTitle(state, ws, ctx)];
-    const column = dashboardColumn(state, ws, dashboardCtx(state, ctx), state.view.list.sel);
+    const dctx = dashboardCtx(state, ctx);
+    const model = dashboardModel(state, ws, dctx);
     const visible = Math.max(1, ctx.layout.bodyRows - 1);
-    const total = column.lines.length;
+    const total = model.total;
     const top = Math.max(0, Math.min(state.view.list.top, Math.max(0, total - visible)));
-    const window = column.lines.slice(top, top + visible);
+    const window = dashboardLines(model, dctx, state.view.list.sel, top, visible);
     while (window.length < visible)
         window.push(blank(width - 1));
     out.push(...withScrollbar(window, width, total, visible, top, ctx.g));
-    const hits = column.rows
+    const hits = model.rows
         .map((row, index) => ({ row, index }))
         .filter(({ row }) => row.line >= top && row.line < top + visible)
         .map(({ row, index }) => ({ row: 1 + (row.line - top), x0: 0, x1: width, target: { kind: 'dashboard', index } }));
@@ -438,16 +490,16 @@ export function scrollDashboard(state, controller, to) {
     const nav = navigation(state, controller);
     if (nav === null || state.view.kind !== 'dashboard')
         return;
-    const { column, visible } = nav;
-    const total = column.lines.length;
+    const { model, visible } = nav;
+    const total = model.total;
     const current = state.view.list.top;
     const top = Math.max(0, Math.min('delta' in to ? current + to.delta : to.top, Math.max(0, total - visible)));
     let sel = state.view.list.sel;
-    if (column.rows.length > 0) {
-        const line = column.rows[Math.max(0, Math.min(sel, column.rows.length - 1))].line;
+    if (model.rows.length > 0) {
+        const line = model.rows[Math.max(0, Math.min(sel, model.rows.length - 1))].line;
         if (line < top || line >= top + visible) {
             // The selection follows the window: the first (or last) row inside it.
-            const inside = column.rows.map((r, i) => ({ r, i })).filter(({ r }) => r.line >= top && r.line < top + visible);
+            const inside = model.rows.map((r, i) => ({ r, i })).filter(({ r }) => r.line >= top && r.line < top + visible);
             const pick = line < top ? inside[0] : inside[inside.length - 1];
             if (pick !== undefined)
                 sel = pick.i;
@@ -472,13 +524,13 @@ export function dashboardHints(state, ctx) {
 // ---------------------------------------------------------------------------
 // Navigation
 // ---------------------------------------------------------------------------
-/** The column and the window geometry for navigation (no theme needed). */
+/** The model and the window geometry for navigation (no theme needed; the model comes from the cache). */
 function navigation(state, controller) {
     if (state.view.kind !== 'dashboard')
         return null;
     const layout = layoutOf(state);
     const dctx = { g: controller.deps.glyphs, now: controller.deps.now(), columns: layout.columns, bp: breakpoint(state.size), spinner: 0 };
-    return { column: dashboardColumn(state, state.view.ws, dctx, state.view.list.sel), visible: Math.max(1, layout.bodyRows - 1) };
+    return { model: dashboardModel(state, state.view.ws, dctx), visible: Math.max(1, layout.bodyRows - 1) };
 }
 /**
  * Selects a row of the column (by index) and scrolls it into view.
@@ -491,11 +543,11 @@ export function selectDashboardRow(state, controller, index) {
     const nav = navigation(state, controller);
     if (nav === null || state.view.kind !== 'dashboard')
         return;
-    const { column, visible } = nav;
-    if (column.rows.length === 0)
+    const { model, visible } = nav;
+    if (model.rows.length === 0)
         return;
-    const sel = Math.max(0, Math.min(index, column.rows.length - 1));
-    const top = scrollIntoView(state.view.list.top, column.rows[sel].line, visible, column.lines.length);
+    const sel = Math.max(0, Math.min(index, model.rows.length - 1));
+    const top = scrollIntoView(state.view.list.top, model.rows[sel].line, visible, model.total);
     controller.dispatch({ type: 'view/set', view: { ...state.view, list: { sel, top } } });
 }
 /**
@@ -510,9 +562,9 @@ export function moveDashboard(state, controller, op) {
     const nav = navigation(state, controller);
     if (nav === null || state.view.kind !== 'dashboard')
         return;
-    const { column, visible } = nav;
-    const total = column.lines.length;
-    const count = column.rows.length;
+    const { model, visible } = nav;
+    const total = model.total;
+    const count = model.rows.length;
     const page = Math.max(1, visible - 1);
     if (count === 0) {
         const delta = op === 'up' ? -1 : op === 'down' ? 1 : op === 'pageUp' ? -page : op === 'pageDown' ? page : op === 'home' ? -total : total;
@@ -522,7 +574,7 @@ export function moveDashboard(state, controller, op) {
     }
     const last = count - 1;
     const current = Math.max(0, Math.min(state.view.list.sel, last));
-    const line = column.rows[current].line;
+    const line = model.rows[current].line;
     let sel = current;
     switch (op) {
         case 'up':
@@ -540,7 +592,7 @@ export function moveDashboard(state, controller, op) {
         case 'pageUp': {
             const target = line - page;
             let i = current;
-            while (i > 0 && column.rows[i - 1].line >= target)
+            while (i > 0 && model.rows[i - 1].line >= target)
                 i--;
             sel = i === current ? Math.max(0, current - 1) : i;
             break;
@@ -548,7 +600,7 @@ export function moveDashboard(state, controller, op) {
         case 'pageDown': {
             const target = line + page;
             let i = current;
-            while (i < last && column.rows[i + 1].line <= target)
+            while (i < last && model.rows[i + 1].line <= target)
                 i++;
             sel = i === current ? Math.min(last, current + 1) : i;
             break;
@@ -557,7 +609,7 @@ export function moveDashboard(state, controller, op) {
     // Home shows the column from its start and End from its end; the other moves scroll minimally.
     const top = op === 'home' ? 0
         : op === 'end' ? Math.max(0, total - visible)
-            : scrollIntoView(state.view.list.top, column.rows[sel].line, visible, total);
+            : scrollIntoView(state.view.list.top, model.rows[sel].line, visible, total);
     controller.dispatch({ type: 'view/set', view: { ...state.view, list: { sel, top } } });
 }
 // The generic list model is not used: the column's rows sit at irregular
@@ -578,7 +630,7 @@ registerViewHooks('dashboard', {
         const nav = navigation(state, controller);
         if (nav === null || state.view.kind !== 'dashboard')
             return;
-        const row = nav.column.rows[Math.max(0, Math.min(state.view.list.sel, nav.column.rows.length - 1))];
+        const row = nav.model.rows[Math.max(0, Math.min(state.view.list.sel, nav.model.rows.length - 1))];
         if (row === undefined)
             return;
         const ws = state.view.ws;