rvlib-shipkit 1.2.0 → 1.4.0

package/src/serve/hub-app/dock-st.ts

@@ -0,0 +1,329 @@
+// THE DOCK, as the page holds it: the run chart docked under the whole page,
+// every house repo's runs on one clock, one group of lanes per repo that ran
+// something in the window. A node of the root (home-st.ts).
+//
+// Three sizes, cycled by one key (keys.ts), and never nothing: the line, one
+// row saying what runs, what waits and the last check that ended; slim, the
+// last two minutes in thin lanes; open, the last ten in the full chart, its
+// height dragged and kept. The size and the height are read from this browser
+// before the first render, so the page paints at its final layout and a
+// toggle moves nothing but the boundary.
+//
+// the one constraint a reader breaks first: it polls ONE route for every repo
+// (/api/house-runs.json, cached on the server), and only while the page is
+// visible. In a background tab it costs nothing.
+import { makeAutoObservable, observableRef, runInAction } from 'mobx'
+import type { HouseGroup, HouseView } from '../../ledger/house-runs.ts'
+import type { TimelineBar } from '../../ledger/run-timeline.ts'
+import { ChartView, type ChartSource } from './chart-view.ts'
+import { nextOption, type CycleOption } from './cycle-button.tsx'
+import { ClockSvc } from './clock-svc.ts'
+import { serverNow } from './live-svc.ts'
+import { ROWS, type RowSize } from './timeline-geometry.ts'
+import { ageWords } from './time-ago.tsx'
+import type { HomeSt } from './home-st.ts'
+
+export type DockSize = 'line' | 'slim' | 'open'
+
+/** the sizes, in the order the size button and the key cycle them */
+export const DOCK_SIZES = [{ value: 'line', label: 'line' }, { value: 'slim', label: 'slim' }, { value: 'open', label: 'open' }] as const satisfies readonly CycleOption<DockSize>[]
+
+/** the one key's cycle: the line, slim, open, the line again */
+export const nextSize = (s: DockSize): DockSize => nextOption(DOCK_SIZES, s)
+
+/** where this browser keeps the dock, and its heights in px */
+export const DOCK = { sizeKey: 'hub:dock', heightKey: 'hub:dock-height', line: 22, slim: 72, min: 140, max: 720, def: 280 } as const
+
+/** how often it asks while it shows: the server shares one answer a second,
+ *  and the open dock redraws at this pace */
+export const DOCK_POLL_MS = 2_000
+/** the slim dock's window; open, the server's whole window (LIVE_HISTORY_MS) */
+export const SLIM_WINDOW_MS = 120_000
+/** the most lanes one repo takes */
+export const LANE_CAP: Record<Exclude<DockSize, 'line'>, number> = { slim: 3, open: 8 }
+/** the height a group's label needs beside its lanes */
+export const LABEL_PX = 14
+/** the fewest lanes a group takes at a lane size, so its label fits */
+export const minLanesFor = (rows: RowSize): number => Math.ceil(LABEL_PX / (ROWS[rows].lane + ROWS[rows].gap))
+
+/** a kept size, read. `hidden`, which an older build kept, is the line now */
+export const parseSize = (v: unknown): DockSize => (v === 'line' || v === 'hidden' ? 'line' : v === 'open' ? 'open' : 'slim')
+
+/** an open height in its bounds, or the default for anything else */
+export const clampHeight = (v: unknown): number => {
+    const n = typeof v === 'string' ? Number(v) : typeof v === 'number' ? v : NaN
+    return Number.isFinite(n) && n >= DOCK.min && n <= DOCK.max ? Math.round(n) : DOCK.def
+}
+
+/** the dock as this browser left it: slim at the default height when it
+ *  kept nothing or cannot say */
+export function readDock(): { size: DockSize; height: number } {
+    try {
+        return { size: parseSize(globalThis.localStorage?.getItem(DOCK.sizeKey)), height: clampHeight(globalThis.localStorage?.getItem(DOCK.heightKey)) }
+    } catch {
+        return { size: 'slim', height: DOCK.def }
+    }
+}
+
+const keep = (key: string, v: string): void => {
+    try {
+        globalThis.localStorage?.setItem(key, v)
+    } catch { /* private window or blocked site data: the dock lasts the tab */ }
+}
+
+/** the dock's height in px at a size */
+export const dockPx = (size: DockSize, height: number): number => (size === 'line' ? DOCK.line : size === 'slim' ? DOCK.slim : height)
+
+/** a verdict as one glyph */
+const MARK: Record<TimelineBar['status'], string> = { pass: '✓', fail: '✗', warn: '!', skip: '○' }
+
+/** the line's words: `2 running · 5 queued · last: app-one typecheck ✓ 12s
+ *  ago`, `idle` with the last check when the window holds one. Queued is
+ *  every check of a run in flight that is neither done nor running */
+export function lineWords(view: HouseView | null, now: number): string {
+    if (view == null) return 'reading…'
+    let last: { repo: string; bar: TimelineBar } | null = null
+    let queued = 0
+    for (const g of view.groups) {
+        queued += g.runs.reduce((a, r) => a + r.total - r.done, 0) - g.busy
+        for (const i of g.invocations) for (const b of i.bars) if (b.running !== true && (last == null || b.end > last.bar.end)) last = { repo: g.repo, bar: b }
+    }
+    const lastWords = last == null ? '' : `last: ${last.repo} ${last.bar.id} ${MARK[last.bar.status]}${last.bar.replayed ? ' cached' : ''} ${ageWords(last.bar.end, now)}`
+    const head = view.busy > 0 ? `${view.busy} running · ${Math.max(0, queued)} queued` : 'idle'
+    return [head, lastWords, ...(view.held ?? [])].filter((w) => w !== '').join(' · ')
+}
+
+/** a pill of the dock's header: a word or two in a dim box, its hover the
+ *  whole story. The last run adds its repo, its verdict and its age */
+export type DockPill = {
+    key: 'state' | 'queued' | 'held' | 'last' | 'settling' | 'window'
+    tone: 'dim' | 'accent' | 'warn'
+    text: string
+    title: string
+    repo?: string
+    mark?: string
+    markTone?: 'ok' | 'red' | 'warn' | 'dim'
+    age?: string
+}
+
+/** the verdict glyph a pill wears, and its colour */
+const PILL_MARK: Record<TimelineBar['status'], { mark: string; tone: 'ok' | 'red' | 'warn' | 'dim' }> = {
+    pass: { mark: '✓', tone: 'ok' }, fail: { mark: '✕', tone: 'red' }, warn: { mark: '!', tone: 'warn' }, skip: { mark: '○', tone: 'dim' },
+}
+
+export const windowWords = (ms: number): string => `last ${Math.round(ms / 60_000)} min`
+
+/** the longest check id a pill shows whole */
+export const ID_MAX = 16
+export const cutId = (id: string): string => (id.length <= ID_MAX ? id : `${id.slice(0, ID_MAX - 1)}…`)
+
+/** `settling: app-one, 48s`, one line of Planner.held */
+const SETTLING = /^settling: (.+), (\d+s)$/
+
+/** the header's status, left to right: what runs or idle, what waits, what
+ *  holds the plan, the last check that ended, the settling repos as one,
+ *  and slim and open their window. The row folds from the end */
+export function dockPills(view: HouseView | null, now: number, size: DockSize): DockPill[] {
+    if (view == null) return [{ key: 'state', tone: 'dim', text: 'reading…', title: 'the runs of every repo are being read' }]
+    let last: { repo: string; bar: TimelineBar } | null = null
+    let queued = 0
+    for (const g of view.groups) {
+        queued += g.runs.reduce((a, r) => a + r.total - r.done, 0) - g.busy
+        for (const i of g.invocations) for (const b of i.bars) if (b.running !== true && (last == null || b.end > last.bar.end)) last = { repo: g.repo, bar: b }
+    }
+    queued = Math.max(0, queued)
+    const flight = `${view.busy} check(s) in flight in every repo, cap ${view.cap}, ${queued} waiting for a slot`
+    const out: DockPill[] = [view.busy > 0
+        ? { key: 'state', tone: 'accent', text: `${view.busy} running`, title: flight }
+        : { key: 'state', tone: 'dim', text: 'idle', title: flight }]
+    if (queued > 0) out.push({ key: 'queued', tone: 'dim', text: `${queued} queued`, title: flight })
+    const settling: string[] = []
+    for (const line of view.held ?? []) {
+        const m = line.match(SETTLING)
+        if (m != null) settling.push(`${m[1]} ${m[2]}`)
+        else out.push({ key: 'held', tone: 'warn', text: line.replace(/ on \d+ cores$/, ''), title: line })
+    }
+    if (last != null) {
+        const v = PILL_MARK[last.bar.status]
+        out.push({
+            key: 'last', tone: 'dim', repo: last.repo, mark: v.mark, markTone: v.tone, text: cutId(last.bar.id), age: ageWords(last.bar.end, now),
+            title: `the last check that ended: ${last.repo} ${last.bar.id} ${v.mark}${last.bar.replayed ? ' cached' : ''} ${ageWords(last.bar.end, now)}`,
+        })
+    }
+    if (settling.length > 0) out.push({ key: 'settling', tone: 'dim', text: `settling ${settling.length}`, title: settling.join('\n') })
+    if (size !== 'line') {
+        const ms = size === 'open' ? view.historyMs : SLIM_WINDOW_MS
+        out.push({ key: 'window', tone: 'dim', text: windowWords(ms), title: 'the window the chart draws, ending now' })
+    }
+    return out
+}
+
+/** the groups a window draws: a repo that ran nothing since `from` has none,
+ *  and the rest stand in the order of the project list, a repo it does not
+ *  list after them by name */
+export function dockGroups(view: HouseView, from: number, order: readonly string[]): HouseGroup[] {
+    const at = (repo: string): number => {
+        const i = order.indexOf(repo)
+        return i < 0 ? order.length : i
+    }
+    return view.groups
+        .filter((g) => g.invocations.some((i) => i.running === true || i.ended >= from))
+        .sort((a, b) => at(a.repo) - at(b.repo) || a.repo.localeCompare(b.repo))
+}
+
+/** what the chart draws at a size: the window that ends now, one group per repo */
+export function dockSource(view: HouseView | null, now: number, size: DockSize, order: readonly string[]): ChartSource | null {
+    if (view == null || size === 'line') return null
+    const windowMs = size === 'open' ? view.historyMs : SLIM_WINDOW_MS
+    const groups = dockGroups(view, now - windowMs, order)
+    return {
+        invocations: groups.flatMap((g) => g.invocations),
+        groups: groups.map((g) => ({ key: g.repo, invocations: g.invocations })),
+        now,
+        windowMs,
+        laneCap: LANE_CAP[size],
+        minLanes: minLanesFor(size === 'open' ? 'full' : 'slim'),
+        zoomable: size === 'open',
+        cap: view.cap,
+    }
+}
+
+export class DockSt {
+    size: DockSize
+    /** the open height, kept even while the line or slim shows */
+    height: number
+    view: HouseView | null = null
+    /** the page clock when `view` arrived */
+    receivedAt = 0
+    error = ''
+    /** the page is in front: a background tab asks nothing */
+    visible = true
+    clock = new ClockSvc()
+    chart: ChartView
+    private timer: ReturnType<typeof setInterval> | null = null
+    private inFlight = false
+    private readonly onVisibility = (): void => this.setVisible(globalThis.document?.visibilityState !== 'hidden')
+
+    constructor(private home: HomeSt) {
+        const kept = readDock()
+        this.size = kept.size
+        this.height = kept.height
+        this.chart = new ChartView(null, () => dockSource(this.view, this.now, this.size, this.home.projects.list.map((p) => p.name)))
+        makeAutoObservable<this, 'home' | 'timer' | 'inFlight' | 'onVisibility'>(this, { home: false, timer: false, inFlight: false, onVisibility: false, view: observableRef, chart: false, clock: false })
+    }
+
+    /** its height on the page now */
+    get px(): number {
+        return dockPx(this.size, this.height)
+    }
+    get rows(): RowSize {
+        return this.size === 'open' ? 'full' : 'slim'
+    }
+    get windowMs(): number {
+        return this.size === 'open' ? (this.view?.historyMs ?? SLIM_WINDOW_MS) : SLIM_WINDOW_MS
+    }
+    /** the server clock, as of the page clock's last tick */
+    get now(): number {
+        return this.view == null ? this.clock.now : serverNow(this.view, this.receivedAt, this.clock.now)
+    }
+    get groups(): HouseGroup[] {
+        return this.view == null ? [] : dockGroups(this.view, this.now - this.windowMs, this.home.projects.list.map((p) => p.name))
+    }
+    /** it asks while the page is in front: every size shows something */
+    get wanted(): boolean {
+        return this.visible
+    }
+    /** the line's words, on the clock: the header's whole status on hover */
+    get line(): string {
+        return lineWords(this.view, this.now)
+    }
+    /** the header's status as pills, on the clock */
+    get pills(): DockPill[] {
+        return dockPills(this.view, this.now, this.size)
+    }
+
+    cycle(): void {
+        this.setSize(nextSize(this.size))
+    }
+    setSize(s: DockSize): void {
+        if (s === this.size) return
+        this.size = s
+        keep(DOCK.sizeKey, s)
+        // a size opens live, on its whole window
+        this.chart.home()
+        this.chart.attach()
+        this.sync()
+    }
+    /** a drag of the separator above the open dock ended at this height */
+    setHeight(px: number): void {
+        this.height = clampHeight(Math.round(Math.min(DOCK.max, Math.max(DOCK.min, px))))
+        keep(DOCK.heightKey, String(this.height))
+    }
+    setVisible(v: boolean): void {
+        this.visible = v
+        this.sync()
+    }
+
+    /** start or stop asking, as `wanted` says */
+    sync(): void {
+        if (this.wanted && this.timer == null) {
+            void this.poll()
+            this.timer = setInterval(() => void this.poll(), DOCK_POLL_MS)
+        } else if (!this.wanted && this.timer != null) {
+            clearInterval(this.timer)
+            this.timer = null
+        }
+        // the line's ages and the slim chart's two minutes move every second,
+        // so they tick. Open, a thousand bars over ten minutes redraw only
+        // when an answer lands (each answer ticks the clock): a second's
+        // slide is under two px there, and a redraw a second is what costs
+        if (this.wanted && this.size !== 'open') this.clock.start()
+        else this.clock.stop()
+    }
+
+    boot(): void {
+        globalThis.document?.addEventListener('visibilitychange', this.onVisibility)
+        this.onVisibility()
+    }
+    dispose(): void {
+        globalThis.document?.removeEventListener('visibilitychange', this.onVisibility)
+        this.visible = false
+        this.sync()
+    }
+
+    async poll(): Promise<void> {
+        // a slow answer must not stack a second request behind it
+        if (this.inFlight) return
+        this.inFlight = true
+        try {
+            const r = await fetch('/api/house-runs.json')
+            if (!r.ok) throw new Error(await r.text())
+            const v = (await r.json()) as HouseView
+            runInAction(() => {
+                this.view = v
+                this.receivedAt = Date.now()
+                this.clock.tick(this.receivedAt)
+                this.error = ''
+            })
+        } catch (e) {
+            runInAction(() => { this.error = `the runs could not be read: ${(e as Error).message}` })
+        } finally {
+            this.inFlight = false
+        }
+    }
+
+    /** a bar: its check's page in its repo */
+    openCheck(repo: string, check: string): void {
+        const h = this.home
+        if (h.machine != null) return h.openCheck(repo, check)
+        const own = h.shown
+        if (own != null && own.name === repo) own.cols.select('checks', `check:${check}`)
+        else h.projects.onSelect(repo)
+    }
+    /** a group's label: its repo's page */
+    openRepo(repo: string): void {
+        const h = this.home
+        if (h.machine != null) return h.select(repo)
+        if (h.shown?.name !== repo) h.projects.onSelect(repo)
+    }
+}

package/src/serve/hub-app/dock-view.tsx

@@ -0,0 +1,68 @@
+// THE DOCK, drawn: under the whole page, on every page, what shipkit runs in
+// every house repo, as the one run chart (timeline-chart.tsx) with one group
+// of lanes per repo. Its header is one row: the size as a cycling button,
+// then the status as small pills that fold into +N rather than wrap. The
+// state is dock-st.ts; the height is the page's panel (hub-app.tsx).
+import { observer } from 'mobx-react-lite'
+import type { HomeSt } from './home-st.ts'
+import { CycleButton } from './cycle-button.tsx'
+import { DOCK_KEY } from './keys.ts'
+import { DOCK_SIZES, SLIM_WINDOW_MS, windowWords, type DockPill } from './dock-st.ts'
+import { PillRow } from './pill-row.tsx'
+import { TimelineChart } from './timeline-chart.tsx'
+import type { PlacedGroup } from './timeline-geometry.ts'
+
+/** what the dock is, on its size button's hover */
+export const DOCK_HELP = `every check shipkit runs in every repo, whoever started it: a page, an agent in a terminal, the plan. The line, the pills alone; slim, the last two minutes, one group of lanes per repo; open, the last ten, zoomed by the wheel and panned by a drag, its height dragged at the top edge`
+
+/** a group's label: the repo's icon and its name in its colour */
+const GroupLabel = observer(({ app, g }: { app: HomeSt; g: PlacedGroup }) => {
+    const p = app.projects.list.find((x) => x.name === g.key)
+    const id = app.projects.identityOf(g.key)
+    return (
+        <button className="dgroup" onClick={() => app.dock.openRepo(g.key)}
+            title={`${g.key}: open the repo${g.hidden > 0 ? `\n${g.hidden} check run(s) did not fit in its lanes` : ''}`}>
+            {p?.icon != null ? <img src={p.icon} alt="" width={12} height={12} draggable={false} /> : <i className="dgico" style={{ background: id.colorDark }} />}
+            <span style={{ color: id.colorDark }}>{g.key}</span>
+            {/* slim folds its lanes on purpose: the count is news only open */}
+            {g.hidden > 0 && app.dock.size === 'open' ? <b>+{g.hidden}</b> : null}
+        </button>
+    )
+})
+
+/** one pill's face: the repo icon on the last run, its verdict, its words, its age */
+const PillFace = observer(({ app, p }: { app: HomeSt; p: DockPill }) => {
+    const pj = p.repo == null ? null : app.projects.list.find((x) => x.name === p.repo)
+    return (
+        <span className={`pchip ${p.tone}`}>
+            {p.repo == null ? null : pj?.icon != null
+                ? <img src={pj.icon} alt="" width={12} height={12} draggable={false} />
+                : <i className="dgico" style={{ background: app.projects.identityOf(p.repo).colorDark }} />}
+            {p.mark == null ? null : <b className={`pcmark ${p.markTone ?? 'dim'}`}>{p.mark}</b>}
+            <span className="pctext">{p.text}</span>
+            {p.age == null ? null : <span className="pcage">{p.age}</span>}
+        </span>
+    )
+})
+
+export const Dock = observer(({ app }: { app: HomeSt }) => {
+    const d = app.dock
+    const v = d.view
+    const groups = d.groups
+    return (
+        <div className={`dock ${d.size}`}>
+            <div className="dhead">
+                <CycleButton options={DOCK_SIZES} value={d.size} onChange={(s) => d.setSize(s)} shortcut={DOCK_KEY} title={DOCK_HELP} />
+                <PillRow items={d.pills.map((p) => ({ key: p.key, title: p.title, node: <PillFace app={app} p={p} /> }))} />
+                {d.error !== '' ? <span className="warnline">{d.error}</span> : null}
+            </div>
+            {d.size === 'line' ? null : <div className="dbody">
+                {v == null ? null : groups.length === 0
+                    ? <div className="dempty">nothing ran in the {windowWords(d.size === 'open' ? v.historyMs : SLIM_WINDOW_MS)}</div>
+                    : <TimelineChart view={d.chart} compact={d.size === 'slim'} rows={d.rows} follow zoomable={d.size === 'open'}
+                        onBar={(b) => { if (b.group != null) d.openCheck(b.group, b.id) }}
+                        groupLabel={(g) => <GroupLabel app={app} g={g} />} />}
+            </div>}
+        </div>
+    )
+})

package/src/serve/hub-app/dock.css

@@ -0,0 +1,35 @@
+/* ── the dock (dock-view.tsx): the run chart under the whole page, every
+   repo's runs, one group of lanes each. Its height is its panel's, set by
+   the page before the first paint, so nothing inside it sizes the page. The
+   header is one row, the chart under it scrolls when the groups outgrow it ── */
+.dock{display:flex;flex-direction:column;height:100%;background:var(--bg-dock);font-size:11px;color:var(--dim)}
+.dhead{display:flex;gap:var(--s2);align-items:center;height:22px;flex:none;padding:0 var(--s3)}
+/* the status pills take the room left, and fold rather than wrap */
+.dhead .pchips{flex:1}
+.dbody{flex:1;min-height:0;overflow-y:auto;overflow-x:hidden;padding:0 var(--s3) var(--s1);scrollbar-width:thin;scrollbar-color:var(--line) transparent}
+.dempty{padding:var(--s1) 0;color:var(--dim)}
+.dock .tlax.compact{height:auto;padding-top:0}
+/* a group's label stands in a gutter left of the chart, level with its lanes */
+.tlgroups{display:flex;align-items:flex-start}
+.tlgroups > .tlax,.tlgroups > .tlchart{flex:1;min-width:0}
+.tlgutter{position:relative;flex:none;width:132px}
+.tlglbl{position:absolute;left:0;right:0;display:flex;align-items:center;overflow:hidden}
+.dgroup{display:flex;gap:var(--s1);align-items:center;max-width:100%;padding:0;border:0;background:transparent;font-size:10px;line-height:12px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;cursor:pointer}
+.dgroup img{flex:none;border-radius:2px}
+.dgroup span{overflow:hidden;text-overflow:ellipsis}
+.dgroup:hover span{text-decoration:underline}
+.dgroup b{font-weight:500;color:var(--warn)}
+.dgico{flex:none;width:8px;height:8px;border-radius:2px}
+.tlgrp{stroke:var(--line)}
+/* the separator over the dock: a 1px rule, dragged only while the dock is open */
+.rsep.hsep{width:auto;height:1px}
+.rsep.hsep::before{top:-4px;bottom:-4px;left:0;right:0;cursor:row-resize}
+.rsep.hsep.fixed::before{cursor:default;pointer-events:none}
+.rsep.hsep.fixed:hover{background:var(--line)}
+/* a size change of the dock slides the boundary (dock-anim.ts): the class is
+   on the split only while it runs, so a drag and the first paint stay instant */
+.dockanim>[data-panel]{transition:flex-grow 180ms ease-out}
+@media (prefers-reduced-motion:reduce){.dockanim>[data-panel]{transition:none}}
+/* the runs page's record chart: its (?) in its top left corner */
+.rchart{position:relative;flex:none;overflow:hidden;margin-top:var(--s3)}
+.rchelp{position:absolute;top:0;left:0;z-index:4}

package/src/serve/hub-app/hash-route.ts

@@ -20,9 +20,11 @@ export type HashSel =
     /** where the test checks' time goes: every one of them (check null), or
      *  one test check (`test`, `test:<unit>`) */
     | { t: 'tests'; check: string | null }
+    /** what administers the repo: archive, reload its hub, keep it active */
+    | { t: 'admin' }
 
 export type ParsedHash = {
-    kind: 'asset' | 'cat' | 'col' | 'item' | 'status' | 'tests' | 'none'
+    kind: 'asset' | 'cat' | 'col' | 'item' | 'status' | 'tests' | 'admin' | 'none'
     /** the collection, for an item. null for everything else */
     col: string | null
     id: string
@@ -37,6 +39,7 @@ const CAT = 'cat-'
 /** prefixed, so no asset id can shadow it */
 const STATUS = 'page:status'
 const TESTS = 'page:tests'
+const ADMIN = 'page:admin'
 
 /** what this selection puts in the url. null only for no selection at all,
  *  and then the hash is left alone rather than wiped */
@@ -49,6 +52,7 @@ export function hashFor(sel: HashSel | null): string | null {
         case 'item': return `${ITEM}${sel.col}:${sel.id}`
         case 'status': return STATUS
         case 'tests': return sel.check == null ? TESTS : `${TESTS}:${sel.check}`
+        case 'admin': return ADMIN
     }
 }
 
@@ -57,6 +61,7 @@ export function parseHash(raw: string): ParsedHash {
     if (raw === '') return none
     if (raw === STATUS) return { kind: 'status', col: null, id: '', tools: null }
     if (raw === TESTS) return { kind: 'tests', col: null, id: '', tools: null }
+    if (raw === ADMIN) return { kind: 'admin', col: null, id: '', tools: null }
     // a check id carries colons of its own (`test:rvlib-shipkit`)
     if (raw.startsWith(`${TESTS}:`)) {
         const check = raw.slice(TESTS.length + 1)
@@ -98,6 +103,7 @@ export function selOf(p: ParsedHash): HashSel | null {
         case 'item': return { t: 'item', col: p.col!, id: p.id }
         case 'status': return { t: 'status' }
         case 'tests': return { t: 'tests', check: p.id === '' ? null : p.id }
+        case 'admin': return { t: 'admin' }
     }
 }