@marcomigozzi/trailhead 0.14.0 → 0.16.0

package/plugins/trailhead/tests/map-pane-view.test.ts

@@ -5,22 +5,40 @@ import {
   axisStart,
   burndownEnd,
   burndownSeries,
+  CANCEL_LABEL,
+  countsLabel,
   failureReason,
   footerStatus,
   groupTickets,
+  headingRoom,
   HISTORY_LIMIT,
+  isTimerLate,
+  keepOpenTotal,
   mapRowLayout,
   nextViewed,
+  openTotalLabel,
+  openTotalQuery,
   parseActiveMap,
+  parseDashboard,
   parseHistory,
+  parseIssuesPage,
   parseMap,
   parseMaps,
+  parseMapsRead,
+  parseOpenTotal,
   parseTickets,
+  parseUatParents,
   rasterCells,
   refreshDecision,
   rowLayout,
   sparkline,
+  ticketsFromRows,
+  uatParentLine,
   viewTarget,
+  withUatParents,
+  whiteboardHeading,
+  whiteboardRowLayout,
+  withLabel,
 } from '../hooks/mod/map-pane-view'
 
 const issue = (over: Record<string, unknown> = {}) => ({
@@ -57,10 +75,10 @@ test('parseTickets maps a gh list to rows with type, state and holders', () => {
   )
   expect(out?.unverifiedCount).toBe(0)
   expect(out?.tickets).toEqual([
-    { number: 209, title: 'Burn-down view', type: 'build', state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209' },
-    { number: 212, title: 'Held', type: 'research', state: 'in-progress', assignees: ['alice'], url: 'https://github.com/o/r/issues/209' },
-    { number: 211, title: 'Gated', type: 'bug', state: 'blocked', assignees: ['bob'], url: 'https://github.com/o/r/issues/209' },
-    { number: 214, title: 'No type', type: null, state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209' },
+    { number: 209, title: 'Burn-down view', type: 'build', state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209', isUat: false, isNeedsYou: false, uatOf: null },
+    { number: 212, title: 'Held', type: 'research', state: 'in-progress', assignees: ['alice'], url: 'https://github.com/o/r/issues/209', isUat: false, isNeedsYou: false, uatOf: null },
+    { number: 211, title: 'Gated', type: 'bug', state: 'blocked', assignees: ['bob'], url: 'https://github.com/o/r/issues/209', isUat: false, isNeedsYou: false, uatOf: null },
+    { number: 214, title: 'No type', type: null, state: 'frontier', assignees: [], url: 'https://github.com/o/r/issues/209', isUat: false, isNeedsYou: false, uatOf: null },
   ])
 })
 
@@ -140,13 +158,124 @@ test('parseMap has a null destination when the section is missing or empty, and
 })
 
 test('groupTickets splits by state, ascending by number', () => {
-  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked') => ({
+  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked' | 'paused') => ({
     number, title: '', type: null, state, assignees: [], url: '',
   })
   const g = groupTickets([t(30, 'frontier'), t(5, 'blocked'), t(9, 'in-progress'), t(12, 'frontier'), t(2, 'blocked')])
   expect(g.frontier.map(x => x.number)).toEqual([12, 30])
   expect(g.inProgress.map(x => x.number)).toEqual([9])
   expect(g.blocked.map(x => x.number)).toEqual([2, 5])
+  expect(g.paused).toEqual([])
+})
+
+test('groupTickets puts a paused ticket in the Paused group only', () => {
+  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked' | 'paused') => ({
+    number, title: '', type: null, state, assignees: [], url: '',
+  })
+  const g = groupTickets([t(8, 'paused'), t(3, 'paused'), t(4, 'in-progress'), t(5, 'blocked'), t(6, 'frontier')])
+  expect(g.paused.map(x => x.number)).toEqual([3, 8])
+  expect([g.frontier, g.inProgress, g.blocked].map(x => x.map(y => y.number))).toEqual([[6], [4], [5]])
+})
+
+test('parseTickets: a paused label wins over blocked and in-progress, with the holder kept', () => {
+  const state = (names: string[], assignees: string[] = []) =>
+    parseTickets(list(issue({ labels: labels(...names), assignees: assignees.map(login => ({ login })) })))?.tickets[0]
+  expect(state(['trailhead:build', 'trailhead:paused'])).toMatchObject({ state: 'paused', assignees: [] })
+  expect(state(['trailhead:build', 'trailhead:paused', 'trailhead:blocked'], ['alice'])).toMatchObject({ state: 'paused', assignees: ['alice'] })
+  expect(state(['trailhead:build', 'trailhead:paused'], ['alice'])?.state).toBe('paused')
+  expect(state(['trailhead:build'], ['alice'])?.state).toBe('in-progress')
+})
+
+test('parseTickets sets isUat from the trailhead:uat label, with no parent yet', () => {
+  const t = (...names: string[]) => parseTickets(list(issue({ labels: labels(...names) })))?.tickets[0]
+  expect(t('trailhead:task', 'trailhead:uat')).toMatchObject({ isUat: true, uatOf: null, state: 'frontier' })
+  expect(t('trailhead:task')).toMatchObject({ isUat: false, uatOf: null })
+  // a marker, not a state: the state is unchanged
+  expect(t('trailhead:seed', 'trailhead:blocked', 'trailhead:uat')).toMatchObject({ isUat: true, state: 'blocked' })
+})
+
+test('parseTickets sets isNeedsYou from the trailhead:needs-you label and keeps the state', () => {
+  const t = (names: string[], assignees: { login: string }[] = []) => parseTickets(list(issue({ labels: labels(...names), assignees })))?.tickets[0]
+  expect(t(['trailhead:task', 'trailhead:needs-you'])).toMatchObject({ isNeedsYou: true, state: 'frontier' })
+  expect(t(['trailhead:task', 'trailhead:needs-you', 'trailhead:paused'])).toMatchObject({ isNeedsYou: true, state: 'paused' })
+  expect(t(['trailhead:task', 'trailhead:needs-you', 'trailhead:blocked'])).toMatchObject({ isNeedsYou: true, state: 'blocked' })
+  expect(t(['trailhead:task', 'trailhead:needs-you'], [{ login: 'alice' }])).toMatchObject({ isNeedsYou: true, state: 'in-progress' })
+  expect(t(['trailhead:task'])).toMatchObject({ isNeedsYou: false })
+})
+
+const body = (text: string, number = 5) => ({ number, body: text })
+const uatList = (...rows: unknown[]) => JSON.stringify(rows)
+
+test('parseUatParents maps a ticket to the parent named by its UAT of: line', () => {
+  const out = parseUatParents(
+    uatList(
+      body('Intro\n\nUAT of: [Burn-down view](https://github.com/o/r/issues/209)\n\n- [ ] step', 301),
+      body('UAT of: #210', 302),
+      body('no pointer here', 303),
+      body('mentions UAT of: [x](https://github.com/o/r/issues/1) mid-line', 304),
+      body('UAT of: [Win](https://github.com/o/r/issues/212)\r\nmore', 305),
+    ),
+  )
+  expect(out?.get(301)).toEqual({ number: 209, title: 'Burn-down view' })
+  expect(out?.get(302)).toEqual({ number: 210, title: '' })
+  expect(out?.get(303)).toBeUndefined()
+  expect(out?.get(304)).toBeUndefined()
+  expect(out?.get(305)).toEqual({ number: 212, title: 'Win' })
+})
+
+test('parseUatParents strips control characters from a parent title and skips unusable rows', () => {
+  const out = parseUatParents(
+    uatList(body('UAT of: [a\u0007b​c‮d](https://github.com/o/r/issues/7)', 1), { number: 'x', body: 'UAT of: #3' }, { number: 2, body: 5 }, 'junk', body('UAT of: [t](https://example.com/nope)', 3)),
+  )
+  expect(out?.get(1)).toEqual({ number: 7, title: 'abcd' })
+  expect(out?.size).toBe(1)
+})
+
+test('parseUatParents is null on non-JSON or a non-list', () => {
+  expect(parseUatParents('{nope')).toBeNull()
+  expect(parseUatParents('{}')).toBeNull()
+})
+
+test('withUatParents sets the parent on a UAT ticket only, and leaves the tickets alone without a read', () => {
+  const t = (number: number, isUat: boolean) => ({ number, title: '', type: null, state: 'frontier' as const, assignees: [], url: '', isUat, isNeedsYou: false, uatOf: null })
+  const tickets = [t(1, true), t(2, false), t(3, true)]
+  const out = withUatParents(tickets, new Map([[1, { number: 9, title: 'P' }], [2, { number: 8, title: 'Q' }]]))
+  expect(out.map(x => x.uatOf)).toEqual([{ number: 9, title: 'P' }, null, null])
+  expect(tickets[0]?.uatOf).toBeNull()
+  expect(withUatParents(tickets, null)).toEqual(tickets)
+})
+
+test('uatParentLine draws tests <title> #<n>, fitted to the width, and nothing without a parent', () => {
+  const t = (uatOf: { number: number; title: string } | null) => ({ number: 1, title: '', type: null, state: 'frontier' as const, assignees: [], url: '', isUat: true, isNeedsYou: false, uatOf })
+  expect(uatParentLine(t(null), 60)).toBeNull()
+  expect(uatParentLine(t({ number: 209, title: 'Burn-down view' }), 60)).toBe('tests Burn-down view #209')
+  expect(uatParentLine(t({ number: 210, title: '' }), 60)).toBe('tests #210')
+  const cut = uatParentLine(t({ number: 209, title: 'x'.repeat(200) }), 30) as string
+  expect(Array.from(cut).length).toBe(30)
+  expect(cut.endsWith('… #209')).toBe(true)
+})
+
+test('groupTickets lists a UAT ticket once, under UAT, ascending; a paused one stays under Paused', () => {
+  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked' | 'paused', isUat: boolean) => ({
+    number, title: '', type: null, state, assignees: [], url: '', isUat, isNeedsYou: false, uatOf: null,
+  })
+  const g = groupTickets([t(9, 'frontier', true), t(4, 'blocked', true), t(6, 'in-progress', true), t(7, 'paused', true), t(2, 'frontier', false), t(3, 'blocked', false)])
+  expect(g.uat.map(x => x.number)).toEqual([4, 6, 9])
+  expect(g.paused.map(x => x.number)).toEqual([7])
+  expect([g.frontier, g.inProgress, g.blocked].map(x => x.map(y => y.number))).toEqual([[2], [], [3]])
+})
+
+test('groupTickets lists a needs-you ticket once, under Needs you, ascending, whatever its state', () => {
+  const t = (number: number, state: 'frontier' | 'in-progress' | 'blocked' | 'paused', over: Record<string, unknown> = {}) => ({
+    number, title: '', type: null, state, assignees: [], url: '', isUat: false, isNeedsYou: true, uatOf: null, ...over,
+  })
+  const g = groupTickets([
+    t(9, 'frontier'), t(4, 'blocked'), t(6, 'in-progress', { assignees: ['alice'] }), t(7, 'paused'), t(8, 'frontier', { isUat: true }),
+    t(2, 'frontier', { isNeedsYou: false }), t(3, 'blocked', { isNeedsYou: false }),
+  ])
+  expect(g.needsYou.map(x => x.number)).toEqual([4, 6, 7, 8, 9])
+  expect([g.frontier, g.inProgress, g.uat, g.paused, g.blocked].map(x => x.map(y => y.number))).toEqual([[2], [], [], [], [3]])
+  expect(groupTickets([t(1, 'frontier', { isNeedsYou: false })]).needsYou).toEqual([])
 })
 
 test('failureReason names one short cause', () => {
@@ -172,6 +301,16 @@ test('refreshDecision runs now outside the floor and waits the remainder inside
   expect(refreshDecision(500, 1000, 15000)).toEqual({ run: false, waitMs: 15000 })
 })
 
+test('isTimerLate holds a timer dead only once its due time is past by more than the grace', () => {
+  // in time, or late within the grace: still alive
+  expect(isTimerLate(1000, 5000, 2000)).toBe(false)
+  expect(isTimerLate(7000, 5000, 2000)).toBe(false)
+  // past the grace: the host dropped it (a refused dispatch never fires)
+  expect(isTimerLate(7001, 5000, 2000)).toBe(true)
+  // a clock that moved back never makes a timer late
+  expect(isTimerLate(0, 5000, 2000)).toBe(false)
+})
+
 test('ageLabel reads just now, seconds, minutes, hours', () => {
   expect(ageLabel(0)).toBe('just now')
   expect(ageLabel(-5)).toBe('just now')
@@ -191,10 +330,11 @@ const ticket = (over: Record<string, unknown> = {}) => ({
   state: 'frontier' as const,
   assignees: [] as string[],
   url: 'https://github.com/o/r/issues/209',
+  isNeedsYou: false,
   ...over,
 })
 const layout = (t: ReturnType<typeof ticket>, over: Record<string, unknown> = {}) =>
-  rowLayout(t, { isInPlay: false, hasMarkColumn: false, pendingWork: null, columns: 60, ...over })
+  rowLayout(t, { isInPlay: false, hasMarkColumn: false, pendingWork: null, pendingPhase: null, columns: 60, ...over })
 
 test('rowLayout: a frontier row carries the work button, the number, the title and the type', () => {
   expect(layout(ticket())).toEqual({
@@ -208,10 +348,38 @@ test('rowLayout: a frontier row carries the work button, the number, the title a
 })
 
 test('rowLayout: the pending ticket shows queued in place of the button', () => {
-  expect(layout(ticket(), { pendingWork: 209 }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  expect(layout(ticket(), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
   expect(layout(ticket(), { pendingWork: 210 }).aside).toEqual({ kind: 'work', text: 'work' })
 })
 
+test('rowLayout: the queued aside counts the cancel button in the row width', () => {
+  const t = ticket({ title: 'x'.repeat(200) })
+  for (const columns of [30, 40, 60]) {
+    const r = layout(t, { columns, pendingWork: 209, pendingPhase: 'queued' })
+    const used = (r.mark?.length ?? 0) + r.label.length + (r.type?.length ?? 0) + (r.aside?.text.length ?? 0) + 1 + CANCEL_LABEL.length + 4 + 1
+    expect(used).toBeLessThanOrEqual(columns)
+    // Less title room than the work button leaves.
+    expect(r.label.length).toBeLessThan(layout(t, { columns }).label.length)
+  }
+})
+
+test('rowLayout: a starting row reads starting with no button room', () => {
+  expect(layout(ticket(), { pendingWork: 209, pendingPhase: 'starting' }).aside).toEqual({ kind: 'starting', text: 'starting' })
+  expect(layout(ticket(), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  // a pending press with no phase yet is never offered a cancel
+  expect(layout(ticket(), { pendingWork: 209, pendingPhase: null }).aside).toEqual({ kind: 'starting', text: 'starting' })
+  // another ticket's phase never touches this row
+  expect(layout(ticket(), { pendingWork: 210, pendingPhase: 'starting' }).aside).toEqual({ kind: 'work', text: 'work' })
+  const t = ticket({ title: 'x'.repeat(200) })
+  for (const columns of [30, 40, 60]) {
+    const r = layout(t, { columns, pendingWork: 209, pendingPhase: 'starting' })
+    const used = (r.mark?.length ?? 0) + r.label.length + (r.type?.length ?? 0) + (r.aside?.text.length ?? 0) + 1
+    expect(used).toBeLessThanOrEqual(columns)
+    // No cancel button to make room for: more title than the queued row keeps.
+    expect(r.label.length).toBeGreaterThan(layout(t, { columns, pendingWork: 209, pendingPhase: 'queued' }).label.length)
+  }
+})
+
 test('rowLayout: holders are drawn as @login on in-progress and blocked rows', () => {
   expect(layout(ticket({ state: 'in-progress', assignees: ['alice'] })).aside).toEqual({ kind: 'holder', text: '@alice' })
   expect(layout(ticket({ state: 'in-progress', assignees: ['alice', 'bob'] })).aside).toEqual({ kind: 'holder', text: '@alice @bob' })
@@ -223,6 +391,73 @@ test('rowLayout: holders are drawn as @login on in-progress and blocked rows', (
   expect(loose.isDim).toBe(true)
 })
 
+const needsYou = (over: Record<string, unknown> = {}) => ticket({ isNeedsYou: true, ...over })
+
+test('rowLayout: a needs-you row without a holder has a work button, a paused one too, never resume', () => {
+  expect(layout(needsYou()).aside).toEqual({ kind: 'work', text: 'work' })
+  expect(layout(needsYou({ state: 'paused' })).aside).toEqual({ kind: 'work', text: 'work' })
+})
+
+test('rowLayout: a needs-you row with any holder shows the holder, never a button', () => {
+  const holder = { kind: 'holder', text: '@alice' }
+  expect(layout(needsYou({ state: 'paused', assignees: ['alice'] })).aside).toEqual(holder)
+  expect(layout(needsYou({ state: 'blocked', assignees: ['alice'] })).aside).toEqual(holder)
+  expect(layout(needsYou({ state: 'in-progress', assignees: ['alice'] })).aside).toEqual(holder)
+  // a press pending does not turn a held row into a button either
+  expect(layout(needsYou({ state: 'paused', assignees: ['alice'] }), { pendingWork: 209 }).aside).toEqual(holder)
+})
+
+test('rowLayout: a needs-you row blocked with no holder shows nothing and is dim', () => {
+  const row = layout(needsYou({ state: 'blocked' }))
+  expect(row.aside).toBeNull()
+  expect(row.isDim).toBe(true)
+})
+
+test('rowLayout: a needs-you row shows queued while its press is pending and this session in play', () => {
+  expect(layout(needsYou(), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  expect(layout(needsYou({ state: 'paused' }), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  expect(layout(needsYou({ state: 'in-progress', assignees: ['alice'] }), { isInPlay: true }).aside).toEqual({ kind: 'self', text: 'this session' })
+})
+
+test('rowLayout: a paused row has a resume button, whoever holds it', () => {
+  expect(layout(ticket({ state: 'paused', assignees: ['alice'] })).aside).toEqual({ kind: 'resume', text: 'resume' })
+  expect(layout(ticket({ state: 'paused' })).aside).toEqual({ kind: 'resume', text: 'resume' })
+  expect(layout(ticket({ state: 'paused' })).isDim).toBe(false)
+})
+
+test('rowLayout: a paused row reads queued while its press is pending', () => {
+  expect(layout(ticket({ number: 209, state: 'paused' }), { pendingWork: 209, pendingPhase: 'queued' }).aside).toEqual({ kind: 'queued', text: 'queued' })
+  expect(layout(ticket({ number: 209, state: 'paused' }), { pendingWork: 7 }).aside).toEqual({ kind: 'resume', text: 'resume' })
+})
+
+test('rowLayout: a paused ticket in play keeps this session', () => {
+  expect(layout(ticket({ state: 'paused', assignees: ['me'] }), { isInPlay: true, hasMarkColumn: true }).aside).toEqual({ kind: 'self', text: 'this session' })
+})
+
+test('rowLayout: the resume button chrome is counted in the row width', () => {
+  const t = ticket({ title: 'x'.repeat(200), state: 'paused' })
+  for (const columns of [30, 40, 60]) {
+    const r = layout(t, { columns })
+    const used = (r.mark?.length ?? 0) + r.label.length + (r.type?.length ?? 0) + (r.aside?.text.length ?? 0) + 4 + 1
+    expect(used).toBeLessThanOrEqual(columns)
+  }
+})
+
+test('rowLayout: the ticket in play says this session instead of its holder', () => {
+  const r = layout(ticket({ state: 'in-progress', assignees: ['me'] }), { isInPlay: true, hasMarkColumn: true })
+  expect(r.aside).toEqual({ kind: 'self', text: 'this session' })
+  expect(layout(ticket({ state: 'in-progress', assignees: ['me'] }), { hasMarkColumn: true }).aside).toEqual({ kind: 'holder', text: '@me' })
+})
+
+test('rowLayout: the this-session aside is counted in the row width', () => {
+  const t = ticket({ title: 'x'.repeat(200), state: 'in-progress', assignees: ['me'] })
+  for (const columns of [30, 40, 60]) {
+    const r = layout(t, { columns, isInPlay: true, hasMarkColumn: true })
+    const used = (r.mark?.length ?? 0) + r.label.length + (r.type?.length ?? 0) + (r.aside?.text.length ?? 0) + 1
+    expect(used).toBeLessThanOrEqual(columns)
+  }
+})
+
 test('rowLayout: the mark column marks the ticket in play and pads the others', () => {
   expect(layout(ticket({ state: 'in-progress', assignees: ['me'] }), { isInPlay: true, hasMarkColumn: true })).toMatchObject({ mark: '▸ ', isInPlay: true })
   expect(layout(ticket(), { hasMarkColumn: true }).mark).toBe('  ')
@@ -473,9 +708,9 @@ test('parseMaps keeps the open maps sorted by number, titles flattened', () => {
     ]),
   )
   expect(out).toEqual([
-    { number: 14, title: 'older map' },
-    { number: 20, title: '' },
-    { number: 198, title: 'trailhead mod' },
+    { number: 14, title: 'older map', counts: null },
+    { number: 20, title: '', counts: null },
+    { number: 198, title: 'trailhead mod', counts: null },
   ])
   expect(parseMaps('[]')).toEqual([])
 })
@@ -486,6 +721,234 @@ test('parseMaps rejects what is not a list', () => {
   expect(parseMaps('null')).toBeNull()
 })
 
+const WB_FIELDS = { whiteboardOpen: { totalCount: 3 }, whiteboardAll: { totalCount: 9 } }
+const gql = (nodes: unknown[], extra: Record<string, unknown> = {}, repo: Record<string, unknown> = WB_FIELDS) =>
+  JSON.stringify({ data: { repository: { issues: { nodes }, ...repo } }, ...extra })
+
+test('parseMapsRead reads each map with its open and total sub-issues, sorted by number', () => {
+  const out = parseMapsRead(
+    gql([
+      { number: 198, title: 'trailhead\u202e mod\n', url: 'https://x/198', subIssuesSummary: { total: 23, completed: 16 } },
+      { number: 14, title: 'older map', url: 'https://x/14', subIssuesSummary: { total: 5, completed: 5 } },
+      { number: 0, title: 'bad number', subIssuesSummary: { total: 1, completed: 0 } },
+      'junk',
+    ]),
+  )
+  expect(out?.maps).toEqual([
+    { number: 14, title: 'older map', counts: { open: 0, total: 5 } },
+    { number: 198, title: 'trailhead mod', counts: { open: 7, total: 23 } },
+  ])
+  expect(parseMapsRead(gql([]))?.maps).toEqual([])
+  // completed above total never goes negative
+  expect(parseMapsRead(gql([{ number: 3, title: 't', subIssuesSummary: { total: 2, completed: 4 } }]))?.maps).toEqual([
+    { number: 3, title: 't', counts: { open: 0, total: 2 } },
+  ])
+})
+
+test('parseMapsRead keeps a row with a malformed summary, name-only', () => {
+  const out = parseMapsRead(
+    gql([
+      { number: 1, title: 'a' },
+      { number: 2, title: 'b', subIssuesSummary: { total: 'x', completed: 1 } },
+      { number: 3, title: 'c', subIssuesSummary: null },
+    ]),
+  )
+  expect(out?.maps).toEqual([
+    { number: 1, title: 'a', counts: null },
+    { number: 2, title: 'b', counts: null },
+    { number: 3, title: 'c', counts: null },
+  ])
+})
+
+test('parseMapsRead reads the whiteboard counts beside the maps', () => {
+  expect(parseMapsRead(gql([]))?.whiteboard).toEqual({ open: 3, total: 9 })
+  // nothing on the whiteboard is a real count, drawn as is
+  const none = { whiteboardOpen: { totalCount: 0 }, whiteboardAll: { totalCount: 0 } }
+  expect(parseMapsRead(gql([], {}, none))?.whiteboard).toEqual({ open: 0, total: 0 })
+})
+
+test('parseMapsRead gives a null whiteboard, maps intact, when its fields are missing or unusable', () => {
+  const node = { number: 1, title: 'a', subIssuesSummary: { total: 4, completed: 1 } }
+  const bad: Record<string, unknown>[] = [
+    {},
+    { whiteboardOpen: { totalCount: 3 } },
+    { whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: null, whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: { totalCount: -1 }, whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: { totalCount: 1.5 }, whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: { totalCount: '3' }, whiteboardAll: { totalCount: 9 } },
+    { whiteboardOpen: { totalCount: 10 }, whiteboardAll: { totalCount: 9 } },
+  ]
+  for (const repo of bad) {
+    expect(parseMapsRead(gql([node], {}, repo))).toEqual({
+      maps: [{ number: 1, title: 'a', counts: { open: 3, total: 4 } }],
+      whiteboard: null,
+      isMapsCapped: false,
+    })
+  }
+})
+
+test('parseMapsRead is null on anything but a clean reply', () => {
+  const node = { number: 1, title: 'a', subIssuesSummary: { total: 1, completed: 0 } }
+  expect(parseMapsRead('not json')).toBeNull()
+  expect(parseMapsRead('[]')).toBeNull()
+  expect(parseMapsRead('{}')).toBeNull()
+  expect(parseMapsRead('{"data":null}')).toBeNull()
+  expect(parseMapsRead('{"data":{"repository":null}}')).toBeNull()
+  expect(parseMapsRead('{"data":{"repository":{"issues":{"nodes":"x"}}}}')).toBeNull()
+  expect(parseMapsRead(JSON.stringify({ errors: [{ message: 'boom' }] }))).toBeNull()
+  // partial data next to errors is still a failed read
+  expect(parseMapsRead(gql([node], { errors: [{ message: 'partial' }] }))).toBeNull()
+})
+
+// A maps connection with a `totalCount` beside its nodes, as the maps read asks for.
+const gqlTotal = (nodes: unknown[], totalCount: unknown) =>
+  JSON.stringify({ data: { repository: { issues: { nodes, totalCount }, ...WB_FIELDS } } })
+const mapNodes = (n: number) => Array.from({ length: n }, (_, i) => ({ number: i + 1, title: `m${i + 1}`, subIssuesSummary: { total: 1, completed: 0 } }))
+
+test('parseMapsRead marks the maps read capped only when more open maps exist than were read', () => {
+  expect(parseMapsRead(gqlTotal(mapNodes(3), 3))?.isMapsCapped).toBe(false)
+  expect(parseMapsRead(gqlTotal(mapNodes(3), 4))?.isMapsCapped).toBe(true)
+  // exactly the limit, with no more behind it, is not capped
+  expect(parseMapsRead(gqlTotal(mapNodes(100), 100))?.isMapsCapped).toBe(false)
+  expect(parseMapsRead(gqlTotal(mapNodes(100), 101))?.isMapsCapped).toBe(true)
+})
+
+test('parseMapsRead without a usable totalCount falls back to the read limit', () => {
+  expect(parseMapsRead(gqlTotal(mapNodes(3), undefined))?.isMapsCapped).toBe(false)
+  expect(parseMapsRead(gqlTotal(mapNodes(100), undefined))?.isMapsCapped).toBe(true)
+  expect(parseMapsRead(gqlTotal(mapNodes(100), 'x'))?.isMapsCapped).toBe(true)
+})
+
+test('openTotalQuery counts the open tickets of each map and the whiteboard in one query', () => {
+  const q = openTotalQuery([3, 198])
+  expect(q).toContain('query($owner:String!,$repo:String!)')
+  expect(q).toContain('repository(owner:$owner,name:$repo)')
+  expect(q).toContain('m3:issues(states:OPEN,labels:["trailhead:map-3"]){totalCount}')
+  expect(q).toContain('m198:issues(states:OPEN,labels:["trailhead:map-198"]){totalCount}')
+  expect(q).toContain('wb:issues(states:OPEN,labels:["trailhead:whiteboard"]){totalCount}')
+})
+
+test('openTotalQuery with no open map still counts the whiteboard', () => {
+  const q = openTotalQuery([])
+  expect(q).toContain('wb:issues(states:OPEN,labels:["trailhead:whiteboard"]){totalCount}')
+  expect(q).not.toContain('trailhead:map-')
+})
+
+const totals = (counts: Record<string, unknown>) =>
+  JSON.stringify({ data: { repository: Object.fromEntries(Object.entries(counts).map(([k, v]) => [k, { totalCount: v }])) } })
+
+test('parseOpenTotal sums every map alias and the whiteboard', () => {
+  expect(parseOpenTotal(totals({ m3: 4, m198: 7, wb: 2 }), [3, 198])).toBe(13)
+  expect(parseOpenTotal(totals({ wb: 0 }), [])).toBe(0)
+  expect(parseOpenTotal(totals({ m3: 0, wb: 5 }), [3])).toBe(5)
+})
+
+test('parseOpenTotal is null on errors, a missing alias or a bad count (never a partial sum)', () => {
+  const ok = { m3: 4, wb: 2 }
+  expect(parseOpenTotal(totals(ok), [3])).toBe(6)
+  expect(parseOpenTotal('not json', [3])).toBeNull()
+  expect(parseOpenTotal('[]', [3])).toBeNull()
+  expect(parseOpenTotal('{"data":null}', [3])).toBeNull()
+  expect(parseOpenTotal('{"data":{"repository":null}}', [3])).toBeNull()
+  expect(parseOpenTotal(JSON.stringify({ errors: [{ message: 'boom' }] }), [3])).toBeNull()
+  expect(parseOpenTotal(JSON.stringify({ ...JSON.parse(totals(ok)), errors: [{ message: 'partial' }] }), [3])).toBeNull()
+  // a map alias or the whiteboard missing
+  expect(parseOpenTotal(totals({ wb: 2 }), [3])).toBeNull()
+  expect(parseOpenTotal(totals({ m3: 4 }), [3])).toBeNull()
+  expect(parseOpenTotal(totals({ m3: 4, wb: 2 }), [3, 198])).toBeNull()
+  // negative, fractional, textual, null counts
+  for (const bad of [-1, 1.5, '4', null]) expect(parseOpenTotal(totals({ m3: bad, wb: 2 }), [3])).toBeNull()
+})
+
+test('keepOpenTotal keeps the last total only over the same maps and the same cut', () => {
+  const kept = { total: 10, maps: [14, 198], isMapsCapped: false }
+  expect(keepOpenTotal(kept, [14, 198], false)).toBe(kept)
+  expect(keepOpenTotal(kept, [14], false)).toBeNull()
+  expect(keepOpenTotal(kept, [14, 198, 300], false)).toBeNull()
+  expect(keepOpenTotal(kept, [14, 199], false)).toBeNull()
+  expect(keepOpenTotal(kept, [14, 198], true)).toBeNull()
+  expect(keepOpenTotal(null, [14, 198], false)).toBeNull()
+  expect(keepOpenTotal({ total: 3, maps: [], isMapsCapped: false }, [], false)).toEqual({ total: 3, maps: [], isMapsCapped: false })
+})
+
+test('openTotalLabel words the total across all maps and the whiteboard', () => {
+  expect(openTotalLabel(13, false, 80)).toBe('13 open across all maps + whiteboard')
+  expect(openTotalLabel(0, false, 80)).toBe('0 open across all maps + whiteboard')
+})
+
+test('openTotalLabel words a truncated maps read as a lower bound', () => {
+  expect(openTotalLabel(13, true, 80)).toBe('at least 13 open across all maps + whiteboard')
+  expect(openTotalLabel(13, true, 20)).toBe('≥13 open in total')
+})
+
+test('openTotalLabel shortens when the long form does not fit, then gives up', () => {
+  const long = '13 open across all maps + whiteboard'
+  expect(openTotalLabel(13, false, long.length)).toBe(long)
+  expect(openTotalLabel(13, false, long.length - 1)).toBe('13 open in total')
+  expect(openTotalLabel(13, false, '13 open in total'.length)).toBe('13 open in total')
+  expect(openTotalLabel(13, false, '13 open in total'.length - 1)).toBeNull()
+  expect(openTotalLabel(13, true, '≥13 open in total'.length - 1)).toBeNull()
+})
+
+test('openTotalLabel is null when the total is unknown', () => {
+  expect(openTotalLabel(null, false, 80)).toBeNull()
+  expect(openTotalLabel(null, true, 80)).toBeNull()
+})
+
+test('countsLabel words open over total', () => {
+  expect(countsLabel({ open: 7, total: 23 })).toBe('7 open / 23')
+  expect(countsLabel({ open: 0, total: 0 })).toBe('0 open / 0')
+})
+
+test('whiteboardRowLayout puts the counts beside the name, a null read leaves it name-only', () => {
+  expect(whiteboardRowLayout({ open: 3, total: 9 }, 60)).toEqual({ mark: '  ', label: 'Whiteboard', aside: ' 3 open / 9' })
+  expect(whiteboardRowLayout({ open: 0, total: 0 }, 60).aside).toBe(' 0 open / 0')
+  expect(whiteboardRowLayout(null, 60)).toEqual({ mark: '  ', label: 'Whiteboard', aside: null })
+})
+
+test('whiteboardRowLayout keeps the name whole and drops the counts when they do not fit', () => {
+  // mark 2 + `[ Whiteboard ]` 14 + ` 3 open / 9` 11 = 27 cells
+  expect(whiteboardRowLayout({ open: 3, total: 9 }, 27).aside).toBe(' 3 open / 9')
+  const narrow = whiteboardRowLayout({ open: 3, total: 9 }, 26)
+  expect(narrow.aside).toBeNull()
+  expect(narrow.label).toBe('Whiteboard')
+})
+
+test('mapRowLayout asides: counts first, then active, joined by a dot', () => {
+  const m = { number: 198, title: 'trailhead mod', counts: { open: 7, total: 23 } }
+  expect(mapRowLayout(m, { active: 198, viewed: null, columns: 60 }).aside).toBe(' 7 open / 23 · active')
+  expect(mapRowLayout(m, { active: 14, viewed: null, columns: 60 }).aside).toBe(' 7 open / 23')
+  expect(mapRowLayout({ ...m, counts: null }, { active: 198, viewed: null, columns: 60 }).aside).toBe(' active')
+  expect(mapRowLayout({ ...m, counts: null }, { active: 14, viewed: null, columns: 60 }).aside).toBeNull()
+})
+
+test('mapRowLayout cuts the title before the counts, which stay whole', () => {
+  const m = { number: 14, title: 'x'.repeat(200), counts: { open: 7, total: 23 } }
+  const r = mapRowLayout(m, { active: 198, viewed: null, columns: 40 })
+  expect(r.aside).toBe(' 7 open / 23')
+  expect(r.label.endsWith('…')).toBe(true)
+  expect(r.mark.length + r.label.length + 4 + (r.aside?.length ?? 0)).toBeLessThanOrEqual(40)
+  // a map with no title falls back to the number
+  expect(mapRowLayout({ ...m, title: '' }, { active: 198, viewed: null, columns: 40 }).label).toBe('#14')
+})
+
+const wbTicket = (number: number, assignees: string[] = []) => ({
+  number,
+  title: `t${number}`,
+  type: null,
+  state: assignees.length > 0 ? ('in-progress' as const) : ('frontier' as const),
+  assignees,
+  url: '',
+})
+
+test('whiteboardHeading counts the open and the assigned tickets', () => {
+  expect(whiteboardHeading([wbTicket(1), wbTicket(2, ['a']), wbTicket(3, ['a', 'b'])], false)).toBe('Whiteboard · 3 open · 2 assigned')
+  expect(whiteboardHeading([], false)).toBe('Whiteboard · 0 open · 0 assigned')
+  expect(whiteboardHeading([wbTicket(1)], true)).toBe('Whiteboard · 200+ open · 0 assigned')
+  expect(whiteboardHeading(null, false)).toBe('Whiteboard')
+})
+
 test('viewTarget is the viewed map, else the active one', () => {
   expect(viewTarget(198, null)).toBe(198)
   expect(viewTarget(198, 14)).toBe(14)
@@ -494,10 +957,10 @@ test('viewTarget is the viewed map, else the active one', () => {
 })
 
 test('nextViewed resets when the active map changed or the viewed map left the open list', () => {
-  const maps = [{ number: 14, title: 'a' }, { number: 198, title: 'b' }]
+  const maps = [{ number: 14, title: 'a', counts: null }, { number: 198, title: 'b', counts: null }]
   expect(nextViewed(14, { activeChanged: false, maps })).toBe(14)
   expect(nextViewed(14, { activeChanged: true, maps })).toBeNull()
-  expect(nextViewed(14, { activeChanged: false, maps: [{ number: 198, title: 'b' }] })).toBeNull()
+  expect(nextViewed(14, { activeChanged: false, maps: [{ number: 198, title: 'b', counts: null }] })).toBeNull()
   expect(nextViewed(14, { activeChanged: false, maps: [] })).toBeNull()
   // no list read yet (or a failed read): nothing to judge by
   expect(nextViewed(14, { activeChanged: false, maps: null })).toBe(14)
@@ -505,7 +968,7 @@ test('nextViewed resets when the active map changed or the viewed map left the o
 })
 
 test('mapRowLayout marks the active map, bolds the viewed one and presses the others', () => {
-  const m = { number: 14, title: 'older map' }
+  const m = { number: 14, title: 'older map', counts: null }
   expect(mapRowLayout(m, { active: 198, viewed: null, columns: 60 })).toEqual({
     mark: '  ',
     label: '#14 older map',
@@ -514,10 +977,10 @@ test('mapRowLayout marks the active map, bolds the viewed one and presses the ot
     isViewed: false,
     isPressable: true,
   })
-  const act = mapRowLayout({ number: 198, title: 'trailhead mod' }, { active: 198, viewed: null, columns: 60 })
+  const act = mapRowLayout({ number: 198, title: 'trailhead mod', counts: null }, { active: 198, viewed: null, columns: 60 })
   expect(act).toMatchObject({ mark: '● ', aside: ' active', isActive: true, isViewed: true, isPressable: false })
   // viewing another map: the active one becomes pressable (back to active), the viewed one is not
-  expect(mapRowLayout({ number: 198, title: 't' }, { active: 198, viewed: 14, columns: 60 })).toMatchObject({
+  expect(mapRowLayout({ number: 198, title: 't', counts: null }, { active: 198, viewed: 14, columns: 60 })).toMatchObject({
     isActive: true,
     isViewed: false,
     isPressable: true,
@@ -526,14 +989,14 @@ test('mapRowLayout marks the active map, bolds the viewed one and presses the ot
 })
 
 test('mapRowLayout cuts the title to the room left by the mark and the aside', () => {
-  const long = { number: 198, title: 'x'.repeat(200) }
+  const long = { number: 198, title: 'x'.repeat(200), counts: null }
   const act = mapRowLayout(long, { active: 198, viewed: null, columns: 30 })
   expect(act.label.endsWith('…')).toBe(true)
   expect(act.mark.length + act.label.length + (act.aside?.length ?? 0)).toBeLessThanOrEqual(30)
-  const other = mapRowLayout({ number: 14, title: 'x'.repeat(200) }, { active: 198, viewed: null, columns: 30 })
+  const other = mapRowLayout({ number: 14, title: 'x'.repeat(200), counts: null }, { active: 198, viewed: null, columns: 30 })
   // a Button draws `[ label ]`: four cells of chrome
   expect(other.mark.length + other.label.length + 4).toBeLessThanOrEqual(30)
-  expect(mapRowLayout({ number: 14, title: '' }, { active: 198, viewed: null, columns: 30 }).label).toBe('#14')
+  expect(mapRowLayout({ number: 14, title: '', counts: null }, { active: 198, viewed: null, columns: 30 }).label).toBe('#14')
 })
 
 test('footerStatus keeps a status that fits beside the two buttons on their row', () => {
@@ -563,3 +1026,122 @@ test('footerStatus on a pane too narrow for the buttons never throws', () => {
   expect(footerStatus('updated just now', 10)).toEqual({ text: 'updated j…', isInline: false })
   expect(footerStatus('updated just now', 0)).toEqual({ text: '…', isInline: false })
 })
+
+test('parseTickets on the whiteboard keeps only the whiteboard rows, unverified ones still counted', () => {
+  const rows = [
+    { number: 1, title: 'map one', labels: [{ name: 'trailhead:build' }], assignees: [], url: '' },
+    { number: 2, title: 'loose', labels: [{ name: 'trailhead:whiteboard' }, { name: 'trailhead:bug' }], assignees: [], url: '' },
+    { number: 3, title: 'held', labels: [{ name: 'trailhead:whiteboard' }], assignees: [{ login: 'al' }], url: '' },
+    { number: 4, title: 'q', labels: [{ name: 'trailhead:whiteboard' }, { name: 'trailhead:unverified' }], assignees: [], url: '' },
+  ]
+  const parsed = parseTickets(JSON.stringify(rows), { isWhiteboard: true })
+  expect(parsed?.tickets.map(t => [t.number, t.type, t.state])).toEqual([
+    [2, 'bug', 'frontier'],
+    [3, null, 'in-progress'],
+  ])
+  expect(parsed?.unverifiedCount).toBe(1)
+  expect(parseTickets(JSON.stringify(rows))?.tickets.map(t => t.number)).toEqual([1])
+})
+
+test('parseDashboard takes the lowest numbered index, none when the repo has none, null when unreadable', () => {
+  expect(parseDashboard(JSON.stringify([{ number: 9, url: 'https://x/9' }, { number: 5, url: 'https://x/5' }]))).toEqual({
+    ref: { number: 5, url: 'https://x/5' },
+  })
+  expect(parseDashboard(JSON.stringify([{ number: 5, url: 'javascript:alert(1)' }]))).toEqual({ ref: { number: 5, url: '' } })
+  expect(parseDashboard('[]')).toEqual({ ref: null })
+  expect(parseDashboard('nope')).toBeNull()
+  expect(parseDashboard('{}')).toBeNull()
+})
+
+test('mapRowLayout on the dashboard makes every map pressable, the active one still marked', () => {
+  const r = mapRowLayout({ number: 198, title: 'trailhead mod', counts: null }, { active: 198, viewed: null, columns: 60, isDashboard: true })
+  expect(r).toMatchObject({ isActive: true, isViewed: false, isPressable: true, mark: '● ', aside: ' active' })
+  expect(mapRowLayout({ number: 198, title: 'trailhead mod', counts: null }, { active: 198, viewed: null, columns: 60 }).isPressable).toBe(false)
+})
+
+test('headingRoom leaves the switch button its cells, never below zero', () => {
+  // `[ dashboard ]` is 13 cells, plus one gap
+  expect(headingRoom(60, 'dashboard')).toBe(46)
+  expect(headingRoom(60, 'map')).toBe(52)
+  expect(headingRoom(5, 'dashboard')).toBe(0)
+})
+
+// One page of the GraphQL open-ticket read, as `gh api graphql` prints it.
+const node = (number: number, names: string[], logins: string[] = []) => ({
+  number,
+  title: `t${number}`,
+  url: `https://github.com/o/r/issues/${number}`,
+  labels: { nodes: labels(...names) },
+  assignees: { nodes: logins.map(login => ({ login })) },
+})
+const page = (nodes: unknown[], pageInfo: unknown = { hasNextPage: false, endCursor: null }) =>
+  JSON.stringify({ data: { repository: { issues: { nodes, pageInfo } } } })
+
+test('parseIssuesPage flattens the nodes to the rows gh issue list prints, with the page info', () => {
+  const out = parseIssuesPage(page([node(7, ['trailhead:build', 'trailhead:map-1'], ['alice'])], { hasNextPage: true, endCursor: 'abc' }))
+  expect(out).toEqual({
+    rows: [
+      {
+        number: 7,
+        title: 't7',
+        url: 'https://github.com/o/r/issues/7',
+        labels: [{ name: 'trailhead:build' }, { name: 'trailhead:map-1' }],
+        assignees: [{ login: 'alice' }],
+      },
+    ],
+    hasNextPage: true,
+    endCursor: 'abc',
+  })
+  // the flattened rows go through the same parser as a gh list
+  expect(parseTickets(JSON.stringify(out?.rows))?.tickets.map(t => [t.number, t.state])).toEqual([[7, 'in-progress']])
+})
+
+test('parseIssuesPage carries a string body and leaves any other out', () => {
+  const withBody = { ...node(7, ['trailhead:uat']), body: 'UAT of: #3' }
+  const out = parseIssuesPage(page([withBody, node(8, ['trailhead:uat']), { ...node(9, []), body: null }, { ...node(10, []), body: 5 }]))
+  expect(out?.rows[0]).toEqual({
+    number: 7,
+    title: 't7',
+    url: 'https://github.com/o/r/issues/7',
+    labels: [{ name: 'trailhead:uat' }],
+    assignees: [],
+    body: 'UAT of: #3',
+  })
+  expect(out?.rows.slice(1).map(r => 'body' in r)).toEqual([false, false, false])
+})
+
+test('parseIssuesPage is null on anything but a clean page', () => {
+  expect(parseIssuesPage('nope')).toBeNull()
+  expect(parseIssuesPage('[]')).toBeNull()
+  expect(parseIssuesPage(JSON.stringify({ data: { repository: null } }))).toBeNull()
+  expect(parseIssuesPage(JSON.stringify({ data: { repository: { issues: { nodes: {} } } } }))).toBeNull()
+  // errors beside partial data, a missing or malformed pageInfo, a next page with no cursor
+  expect(parseIssuesPage(JSON.stringify({ data: { repository: { issues: { nodes: [], pageInfo: { hasNextPage: false } } } }, errors: [{ message: 'x' }] }))).toBeNull()
+  expect(parseIssuesPage(JSON.stringify({ data: { repository: { issues: { nodes: [] } } } }))).toBeNull()
+  expect(parseIssuesPage(page([], { hasNextPage: 'yes', endCursor: null }))).toBeNull()
+  expect(parseIssuesPage(page([], { hasNextPage: true, endCursor: null }))).toBeNull()
+})
+
+test('parseIssuesPage skips a malformed node and keeps an empty page', () => {
+  expect(parseIssuesPage(page([node(1, []), null, 'x']))?.rows).toHaveLength(1)
+  expect(parseIssuesPage(page([]))).toEqual({ rows: [], hasNextPage: false, endCursor: null })
+})
+
+test('the whiteboard read keeps the rows that carry both labels (GraphQL labels is any-of)', () => {
+  const rows = parseIssuesPage(
+    page([
+      node(1, ['trailhead:whiteboard', 'trailhead:ticket', 'trailhead:bug']),
+      node(2, ['trailhead:whiteboard']),
+      node(3, ['trailhead:whiteboard', 'trailhead:ticket', 'trailhead:unverified']),
+    ]),
+  )?.rows as unknown[]
+  const parsed = ticketsFromRows(withLabel(rows, 'trailhead:ticket'), { isWhiteboard: true })
+  expect(parsed?.tickets.map(t => t.number)).toEqual([1])
+  expect(parsed?.unverifiedCount).toBe(1)
+})
+
+test('ticketsFromRows says capped at the limit, as parseTickets does', () => {
+  const rows = Array.from({ length: 200 }, (_, i) => issue({ number: i + 1 }))
+  expect(ticketsFromRows(rows)?.isCapped).toBe(true)
+  expect(ticketsFromRows(rows.slice(1))?.isCapped).toBe(false)
+})