rvlib-shipkit 1.1.0 → 1.2.0

package/src/serve/hub-app/projects-svc.ts

@@ -1,14 +1,41 @@
-// the project gutter's state: every repo on this disk that shares the house
-// wiki, polled from /api/projects.json while the gutter is mounted. The
+// the project list's state: every repo on this disk that shares the house
+// wiki, polled from /api/projects.json while the list is mounted. The
 // server measures at most once per 5s whatever the number of tabs, so this
 // poll is cheap.
 import { makeAutoObservable, observableRef, runInAction } from 'mobx'
 import type { ProjectRow as Project, Release } from '../project-gutter-route.ts'
-import type { HubSt } from './hub-st.ts'
+import { identityOfName, type Identity } from '../../core/identity-color.ts'
 
 export type { ProjectRow as Project, Release } from '../project-gutter-route.ts'
 
 export const PROJECTS_POLL_MS = 5_000
+/** how long the colour picker rests before its colour is written */
+export const IDENTITY_SAVE_MS = 400
+
+/** where this browser keeps the last project list, painted at once on the
+ *  next load while the daemon is asked again */
+export const LIST_KEY = 'hub:projects'
+
+/** the project list this browser last saw, or [] when storage is absent,
+ *  blocked or holds anything else */
+export function loadList(): Project[] {
+    try {
+        const v = JSON.parse(globalThis.localStorage?.getItem(LIST_KEY) ?? '[]') as unknown
+        return Array.isArray(v) && v.every((p) => typeof (p as Project)?.name === 'string') ? (v as Project[]) : []
+    } catch {
+        return []
+    }
+}
+
+/** keeps the list for the next load; false when storage refused it */
+export function saveList(list: Project[]): boolean {
+    try {
+        globalThis.localStorage?.setItem(LIST_KEY, JSON.stringify(list))
+        return true
+    } catch {
+        return false
+    }
+}
 
 /** one of six kind hues, hashed from the name, so an initial keeps its
  *  colour from one load to the next */
@@ -51,6 +78,11 @@ export const byActivity = (list: Project[]): string[] =>
         .sort((a, b) => (b.p.activity ?? -Infinity) - (a.p.activity ?? -Infinity) || a.i - b.i)
         .map(({ p }) => p.name)
 
+
+/** the hub state dot the home draws on a tile, only when it needs a look:
+ *  its hub starts or crashed. A hub that is up is the normal case and draws none */
+export type HubDot = 'starting' | 'crashed' | null
+
 /** what the icon face shows, and nothing more: at most ONE badge (the open
  *  asks, the only fact that needs a human's hands), dim while VS Code does
  *  not have the folder open, and a pulsing edge while Claude sessions run */
@@ -99,22 +131,104 @@ export function cardModel(p: Project, now: number): CardModel {
     }
 }
 
+/** a page of the home that is no repo's */
+export type Place = 'overview' | 'planned'
+
 export class ProjectsSvc {
-    list: Project[] = []
-    /** why the last poll or open failed, shown in the gutter's tooltip */
+    /** the last list this browser saw until the first poll answers, so the
+     *  list paints at once and nothing moves when the daemon answers */
+    list: Project[] = loadList()
+    /** why the last poll or open failed, shown on the list's head */
     error = ''
-    /** the icon under the pointer and the middle of its row, for the card */
-    hover: { name: string; y: number } | null = null
+    /** the daemon answered once: until then the list is the kept one */
+    fresh = false
+    /** the row under the pointer, whose hover card shows */
+    hover: string | null = null
     /** the tile being dragged, and the gap it would land in */
     drag: string | null = null
     gap: number | null = null
+    /** the repo the home page shows; null on the overview, the plan, and a
+     *  hub of its own, whose repo is `current`. The list's api is always the
+     *  page origin's own: the home's machine wide one, or this hub's */
+    selected: string | null = null
+    /** what a single click does: the home shows that repo in place, a hub
+     *  of its own opens the home on it. Default: the folder in VS Code */
+    onSelect: (name: string) => void = (name) => void this.open(name)
+    /** the two places at the top of the list, the overview and the plan:
+     *  the home sets it, a hub of its own has none */
+    onPlace: ((p: Place) => void) | null = null
+    /** the place shown, marked at the top of the list; null on a repo page */
+    place: Place | null = null
+    /** the home's hub state per repo; a hub draws none */
+    dotOf: (name: string) => HubDot = () => null
+    /** one line when a machine resource the repo uses is off */
+    warnOf: (name: string) => string | null = () => null
     private gen = 0
+    /** a colour write waiting for the picker to rest, per repo: a poll keeps
+     *  the colour shown for that repo meanwhile */
+    private identitySaves = new Map<string, ReturnType<typeof setTimeout>>()
     /** bumped by every reorder, so a poll that left before it cannot put
      *  the old order back */
     private orderGen = 0
 
-    constructor(private st: HubSt) {
-        makeAutoObservable<this, 'st' | 'gen' | 'orderGen'>(this, { st: false, gen: false, orderGen: false, list: observableRef })
+    constructor() {
+        makeAutoObservable<this, 'gen' | 'orderGen' | 'identitySaves' | 'saveIdentity' | 'kept' | 'keep'>(this, { gen: false, orderGen: false, identitySaves: false, saveIdentity: false, kept: false, keep: false, list: observableRef, onSelect: false, onPlace: false, dotOf: false, warnOf: false })
+    }
+
+    /** the tile drawn as the current one */
+    isCurrent(p: Project): boolean {
+        return this.selected != null ? p.name === this.selected : p.current
+    }
+
+    select(name: string): void {
+        this.selected = name
+        this.onSelect(name)
+    }
+
+
+    /** a click selects once it is sure no second click follows */
+    click(name: string): void {
+        this.select(name)
+    }
+
+    /** a double click also opens the folder in VS Code (its first click already selected) */
+    doubleClick(name: string): void {
+        void this.open(name)
+    }
+
+    /** a repo's colours: what its config declares, else the ones SK024 would
+     *  derive from its name, so every repo reads in a colour of its own */
+    identityOf(name: string): Identity {
+        return this.list.find((p) => p.name === name)?.identity ?? identityOfName(name)
+    }
+
+    /** one colour set by hand: shown at once, written into the repo's
+     *  repo.config.ts once the picker rests, so a drag across the colour
+     *  field is one write, not one per frame */
+    setIdentity(name: string, patch: Partial<Identity>): void {
+        const next = { ...this.identityOf(name), ...patch }
+        this.list = this.list.map((p) => (p.name === name ? { ...p, identity: next } : p))
+        const t = this.identitySaves.get(name)
+        if (t != null) clearTimeout(t)
+        const h: ReturnType<typeof setTimeout> = setTimeout(() => void this.saveIdentity(name, next, h), IDENTITY_SAVE_MS)
+        this.identitySaves.set(name, h)
+    }
+
+    private async saveIdentity(name: string, id: Identity, h: ReturnType<typeof setTimeout>): Promise<void> {
+        try {
+            const r = await fetch('/api/projects/identity', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name, ...id }) })
+            if (!r.ok) throw new Error(await r.text())
+            const j = (await r.json()) as { identity: Identity }
+            runInAction(() => {
+                if (this.identitySaves.get(name) === h) this.list = this.list.map((p) => (p.name === name ? { ...p, identity: j.identity } : p))
+                this.error = ''
+            })
+        } catch (e) {
+            runInAction(() => { this.error = `colours of ${name}: ${(e as Error).message}` })
+        } finally {
+            // a later pick rests on its own timer, which keeps the guard
+            if (this.identitySaves.get(name) === h) this.identitySaves.delete(name)
+        }
     }
 
     get dragFrom(): number {
@@ -127,16 +241,12 @@ export class ProjectsSvc {
         return this.gap
     }
 
-    hoverIn(name: string, y: number): void {
-        if (this.drag == null) this.hover = { name, y }
+    hoverIn(name: string): void {
+        if (this.drag == null) this.hover = name
     }
 
     hoverOut(name: string): void {
-        if (this.hover?.name === name) this.hover = null
-    }
-
-    get hovered(): Project | null {
-        return this.hover == null ? null : this.list.find((p) => p.name === this.hover!.name) ?? null
+        if (this.hover === name) this.hover = null
     }
 
     dragStart(name: string): void {
@@ -187,6 +297,7 @@ export class ProjectsSvc {
         const gen = ++this.gen
         const tick = async (): Promise<void> => {
             await this.load()
+            this.keep()
             if (gen === this.gen) timer = setTimeout(() => void tick(), PROJECTS_POLL_MS)
         }
         let timer: ReturnType<typeof setTimeout> | null = null
@@ -197,6 +308,15 @@ export class ProjectsSvc {
         }
     }
 
+    /** the list as it is now, kept for the next load. Only a change is
+     *  written: the poll repeats the same rows every five seconds */
+    private kept = ''
+    private keep(): void {
+        if (!this.fresh) return
+        const s = JSON.stringify(this.list)
+        if (s !== this.kept && saveList(this.list)) this.kept = s
+    }
+
     async load(): Promise<void> {
         const order = this.orderGen
         try {
@@ -206,8 +326,10 @@ export class ProjectsSvc {
             runInAction(() => {
                 // a reorder since this left, or a drag in flight: the next poll answers
                 if (order !== this.orderGen || this.drag != null) return
-                this.list = j.projects
+                const mine = new Map(this.list.filter((p) => this.identitySaves.has(p.name)).map((p) => [p.name, p.identity]))
+                this.list = mine.size === 0 ? j.projects : j.projects.map((p) => (mine.has(p.name) ? { ...p, identity: mine.get(p.name)! } : p))
                 this.error = ''
+                this.fresh = true
             })
         } catch (e) {
             runInAction(() => { this.error = `projects: ${(e as Error).message}` })

package/src/serve/hub-app/prose-hits-st.ts

@@ -5,7 +5,7 @@
 // the same reasons a switch is.
 import { makeAutoObservable, observableRef, runInAction } from 'mobx'
 import type { ProseGroup, ProseView } from '../../prose/prose-view.ts'
-import type { HubSt } from './hub-st.ts'
+import type { RepoSt } from './repo-st.ts'
 
 export type TierFilter = 'all' | 'blocking' | 'soft'
 export type ListKind = 'allow' | 'ban'
@@ -29,7 +29,7 @@ export class ProseHitsSt {
     full = new Set<string>()
     form: { kind: ListKind; word: string; to: string; reason: string } = { kind: 'allow', word: '', to: '', reason: '' }
 
-    constructor(private st: HubSt) {
+    constructor(private st: RepoSt) {
         // .ref: the view is swapped whole on every load, never edited in place
         makeAutoObservable<this, 'st'>(this, { st: false, view: observableRef })
     }
@@ -37,7 +37,7 @@ export class ProseHitsSt {
     async load(): Promise<void> {
         runInAction(() => { this.loading = true })
         try {
-            const r = await fetch('/api/prose.json')
+            const r = await fetch(this.st.url('/api/prose.json'))
             if (!r.ok) throw new Error(await r.text())
             const v = (await r.json()) as ProseView
             runInAction(() => { this.view = v; this.error = '' })

package/src/serve/hub-app/prose-hits-view.tsx

@@ -9,7 +9,7 @@ import type { ProseGroup, ProseViewHit } from '../../prose/prose-view.ts'
 import type { ProseWords } from '../../prose/ste.ts'
 import { editorHref } from './check-words.ts'
 import { Help } from './help.tsx'
-import type { HubSt } from './hub-st.ts'
+import type { RepoSt } from './repo-st.ts'
 import { GROUP_CAP, HIT_CAP, ProseHitsSt, type ListKind, type TierFilter } from './prose-hits-st.ts'
 
 /** blocking tiers read red, the soft tier reads as a warning */
@@ -47,7 +47,7 @@ const HitLine = ({ root, h, shape }: { root: string; h: ProseViewHit; shape: boo
     )
 }
 
-const Group = observer(({ app, s, g }: { app: HubSt; s: ProseHitsSt; g: ProseGroup }) => {
+const Group = observer(({ app, s, g }: { app: RepoSt; s: ProseHitsSt; g: ProseGroup }) => {
     const open = s.open.has(g.key)
     const t = TIER_WORD[g.tier] ?? { word: g.tier, tone: '' }
     const shown = s.full.has(g.key) ? g.hits : g.hits.slice(0, HIT_CAP)
@@ -77,7 +77,7 @@ const Group = observer(({ app, s, g }: { app: HubSt; s: ProseHitsSt; g: ProseGro
     )
 })
 
-const Hits = observer(({ app, s }: { app: HubSt; s: ProseHitsSt }) => {
+const Hits = observer(({ app, s }: { app: RepoSt; s: ProseHitsSt }) => {
     const v = s.view
     if (v == null) return <div className="dim">{s.error !== '' ? s.error : 'reading the hits…'}</div>
     if (!v.scoped) return <div className="dim">this repo declares no prose scope, so the check reads no file: add `prose: {'{'} include: [...] {'}'}` to repo.config.ts</div>
@@ -130,7 +130,7 @@ const ListRows = ({ s, words }: { s: ProseHitsSt; words: ProseWords }) => {
     )
 }
 
-const Lists = observer(({ app, s }: { app: HubSt; s: ProseHitsSt }) => {
+const Lists = observer(({ app, s }: { app: RepoSt; s: ProseHitsSt }) => {
     const f = s.form
     const g = app.checks.gate
     return (
@@ -154,7 +154,7 @@ const Lists = observer(({ app, s }: { app: HubSt; s: ProseHitsSt }) => {
 })
 
 /** the two sections over one state, the part a test renders headless */
-export const ProseSections = observer(({ app, s }: { app: HubSt; s: ProseHitsSt }) => (
+export const ProseSections = observer(({ app, s }: { app: RepoSt; s: ProseHitsSt }) => (
     <>
         <section className="csec">
             <div className="cstitle">hits<Help text="every hit of the last read, grouped by the word or the rule that fired, the noisiest first. A file:line opens the editor on that line" /></div>
@@ -169,7 +169,7 @@ export const ProseSections = observer(({ app, s }: { app: HubSt; s: ProseHitsSt
 
 /** mounted by the check page for SK014 only: the state lives while the page
  *  is open, and reads the hits once on the way in */
-export const ProseHits = observer(({ app }: { app: HubSt }) => {
+export const ProseHits = observer(({ app }: { app: RepoSt }) => {
     const s = useMemo(() => new ProseHitsSt(app), [app])
     useEffect(() => { void s.load() }, [s])
     return <ProseSections app={app} s={s} />

package/src/serve/hub-app/{hub-st.ts → repo-st.ts}

@@ -1,9 +1,10 @@
-// HubSt — the ONE root store (build/app-state-tree: one central tree,
-// instantiated once at boot, services with backrefs, exposed as
-// window.app). Owns cross-service state: selection, the severity filter
-// (an ADDRESS: /?f=needs · /?f=red), and the hash router: every page and
-// every tab is a selection, every selection has an address (hash-route.ts),
-// and setSel is the one place both move together.
+// RepoSt: one repo's hub page as a node of the page tree (home-st.ts owns
+// the root, build/app-state-tree). Owns cross-service state: selection, the
+// severity filter (an ADDRESS: ?f=needs · ?f=red), and the hash router: every
+// page and every tab is a selection, every selection has an address
+// (hash-route.ts), and setSel is the one place both move together. A repo
+// that is not shown keeps all of it and polls nothing (resume, pause), and
+// only the shown one writes the url.
 import { RUNS_ID } from '../../collections/collection-types.ts'
 import { makeAutoObservable } from 'mobx'
 import { ClockSvc } from './clock-svc.ts'
@@ -16,114 +17,197 @@ import { MediaSvc } from './media-svc.ts'
 import { TimelineSvc } from './timeline-svc.ts'
 import { TreeSvc } from './tree-svc.ts'
 import { ChecksSvc } from './checks-svc.ts'
-import { ProjectsSvc } from './projects-svc.ts'
+import { ProcessesSvc } from './processes-svc.ts'
 import { TestsSvc } from './tests-svc.ts'
 import type { Resource } from './hub-types.ts'
+import type { HomeSt } from './home-st.ts'
 
 export type Sel = HashSel | null
 
-/** one cmd+j target — run() fires the SAME action clicking would */
+/** one picker target (cmd+k): run() fires the SAME action clicking would */
 export type Jump = { id: string; label: string; section: string; run: () => void }
 
 /** all · needs (yellow+red) · red — one severity ladder for every section */
 export type Filter = 'all' | 'needs' | 'red'
-const parseFilter = (search: string): Filter => {
+export const parseFilter = (search: string): Filter => {
     const f = new URLSearchParams(search).get('f')
     return f === 'needs' || f === 'red' ? f : 'all'
 }
 
-export class HubSt {
-    name = ''
+export class RepoSt {
+    /** the repo's name, from /hub.json; its key until that answers */
+    name: string
     /** where this repo sits on disk, from /hub.json: what makes a source
      *  path on a page a link that opens his editor */
     root = ''
-    /** the one second tick every age on the page reads (clock-svc.ts) */
-    clock = new ClockSvc()
-    media = new MediaSvc(this)
-    cols = new ColsSvc(this)
-    tree = new TreeSvc(this)
-    health = new HealthSvc(this)
-    checks = new ChecksSvc(this)
-    comfy = new ComfySvc(this)
-    timeline = new TimelineSvc(this)
+    /** the one second tick every age of this repo reads (clock-svc.ts). It
+     *  ticks only while the repo is shown, so a hidden page repaints nothing */
+    clock: ClockSvc
+    media: MediaSvc
+    cols: ColsSvc
+    tree: TreeSvc
+    health: HealthSvc
+    checks: ChecksSvc
+    comfy: ComfySvc
+    timeline: TimelineSvc
     /** the runs in flight, whoever started them (live-svc.ts) */
-    live = new LiveSvc(this)
-    projects = new ProjectsSvc(this)
+    live: LiveSvc
+    processes: ProcessesSvc
     /** the pages behind the test groups of the tree (tests-svc.ts) */
-    tests = new TestsSvc(this)
+    tests: TestsSvc
     sel: Sel = null
-    filter: Filter = parseFilter(location.search)
+    filter: Filter = 'all'
     /** sidebar search — live substring filter over asset + collection rows */
     query = ''
-    palOpen = false
-    palQuery = ''
-    palIdx = 0
-    private booted = false
+    /** the first resume or prefetch ran: on the home, only once this repo's
+     *  hub answered */
+    started = false
+    /** the page showed it once: only a repo shown has a region mounted, so a
+     *  repo read ahead in the background costs no render */
+    seen = false
+    /** the sidebar search box, so `/` focuses this repo's own */
+    searchEl: HTMLInputElement | null = null
+    /** its timers run: only the shown repo's do */
+    polling = false
+    private beat = false
+    /** the hub name, the gate block and STATUS.md were asked for */
+    private onceRead = false
 
-    constructor() {
-        makeAutoObservable<this, 'booted'>(this, { media: false, cols: false, tree: false, health: false, checks: false, comfy: false, timeline: false, live: false, projects: false, tests: false, booted: false })
+    /** `key` names the repo in the root's map, `base` is where its hub
+     *  answers: '/r/<repo>' on the home, '' on a hub of its own */
+    constructor(readonly home: HomeSt, readonly key: string, readonly base: string) {
+        this.name = key
+        // children built in the ctor body: a field initializer would run
+        // before `home` is assigned
+        this.clock = new ClockSvc()
+        this.media = new MediaSvc(this)
+        this.cols = new ColsSvc(this)
+        this.tree = new TreeSvc(this)
+        this.health = new HealthSvc(this)
+        this.checks = new ChecksSvc(this)
+        this.comfy = new ComfySvc(this)
+        this.timeline = new TimelineSvc(this)
+        this.live = new LiveSvc(this)
+        this.processes = new ProcessesSvc(this)
+        this.tests = new TestsSvc(this)
+        makeAutoObservable<this, 'beat' | 'onceRead'>(this, { onceRead: false, home: false, key: false, base: false, clock: false, media: false, cols: false, tree: false, health: false, checks: false, comfy: false, timeline: false, live: false, processes: false, tests: false, searchEl: false, beat: false })
     }
 
-    boot(): void {
-        void fetch('/hub.json')
+    /** an absolute hub path ('/api/…', '/media/…', '/hub.json') as this
+     *  repo's hub answers it. Every request of the repo goes through here */
+    url(path: string): string {
+        return path.startsWith('/') ? `${this.base}${path}` : path
+    }
+
+    /** the repo the page shows now: only it writes the url */
+    get isShown(): boolean {
+        return this.home.shown === this
+    }
+
+    /** what the url carries for this repo: its filter, then its selection */
+    get search(): string {
+        return this.filter === 'all' ? '' : `?f=${this.filter}`
+    }
+    get hash(): string {
+        const h = this.sel?.t === 'asset' ? this.media.hash : hashFor(this.sel)
+        return h == null ? '' : `#${h}`
+    }
+
+    /** what is read once, the first time the repo starts or is read ahead */
+    private readOnce(): Promise<unknown> {
+        this.started = true
+        this.onceRead = true
+        return Promise.all([this.readHub(), this.checks.loadGate(), this.health.load()])
+    }
+
+    /** the repo's name and where it sits on disk, from /hub.json */
+    private readHub(): Promise<void> {
+        return fetch(this.url('/hub.json'))
             .then((r) => r.json() as Promise<{ name: string; root?: string }>)
             .then((h) => { this.setHub(h.name, h.root ?? '') })
             .catch(() => {})
+    }
+
+    /** the first screen of the repo, read in the background while another
+     *  one shows, so its first visit has its data at once. One step at a
+     *  time: the browser opens six connections to the home, and the repo on
+     *  screen keeps most of them. Nothing polls: a resume takes over when it
+     *  shows */
+    async prefetch(): Promise<void> {
+        if (this.started) return
+        this.started = true
+        const steps: (() => Promise<unknown>)[] = [
+            () => this.cols.poll(),
+            () => this.readOnce(),
+            () => this.processes.load(),
+            () => this.media.heartbeat(),
+            () => this.live.poll(),
+            () => this.timeline.load(),
+        ]
+        for (const step of steps) {
+            // shown meanwhile: its resume polls everything, so stop here
+            if (this.polling) return
+            await step()
+        }
+    }
+
+    /** start polling. The first one also reads what is read once */
+    resume(): void {
+        if (this.polling) return
+        this.polling = true
+        if (!this.onceRead) {
+            void this.readOnce()
+            this.applyHash()
+        }
         this.clock.start()
+        this.processes.start()
         this.media.start()
         this.cols.start()
         this.live.start()
-        void this.checks.loadGate()
-        void this.health.load()
-        // back, forward, a pasted link and a hand edited hash all arrive
-        // here; applyHash is idempotent, so the two events firing together
-        // for one move cost nothing
-        window.addEventListener('hashchange', () => this.applyHash())
-        window.addEventListener('popstate', () => this.applyHash())
-        this.applyHash()
     }
+
+    /** stop polling, keep every state: a resume shows the same page */
+    pause(): void {
+        if (!this.polling) return
+        this.polling = false
+        this.clock.stop()
+        this.processes.stop()
+        this.media.stop()
+        this.cols.stop()
+        this.live.stop()
+    }
+
+    dispose(): void {
+        this.pause()
+        this.media.dispose()
+        this.checks.dispose()
+        this.comfy.dispose()
+    }
+
+    markSeen(): void {
+        this.seen = true
+    }
+
     private setHub(n: string, root: string): void {
         this.name = n
         this.root = root
-        document.title = `${n} · hub`
     }
 
     setFilter(v: Filter): void {
         this.filter = v
+        if (!this.isShown) return
         const u = new URL(location.href)
         v === 'all' ? u.searchParams.delete('f') : u.searchParams.set('f', v)
         history.replaceState(null, '', u)
     }
+    /** the atelier rewrites its tool set in place: same page, no entry */
+    replaceHash(h: string): void {
+        if (this.isShown && location.hash.slice(1) !== h) history.replaceState(null, '', `#${h}`)
+    }
     setQuery(v: string): void {
         this.query = v
     }
 
-    // ── cmd+j palette ─────────────────────────────────────────────────────
-    palToggle(): void {
-        this.palOpen = !this.palOpen
-        this.palQuery = ''
-        this.palIdx = 0
-    }
-    palClose(): void {
-        this.palOpen = false
-    }
-    setPalQuery(v: string): void {
-        this.palQuery = v
-        this.palIdx = 0
-    }
-    setPalIdx(n: number): void {
-        this.palIdx = n
-    }
-    palMove(d: number): void {
-        const n = this.palResults.length
-        if (n > 0) this.palIdx = (this.palIdx + d + n) % n
-    }
-    palRun(): void {
-        const j = this.palResults[this.palIdx]
-        if (j == null) return
-        this.palOpen = false
-        j.run()
-    }
     /** every jump target: section titles, media assets, collection instances */
     get jumps(): Jump[] {
         const out: Jump[] = []
@@ -140,20 +224,6 @@ export class HubSt {
         }
         return out
     }
-    /** ranked: prefix matches first, then substring; capped at 12 */
-    get palResults(): Jump[] {
-        const q = this.palQuery.trim().toLowerCase()
-        if (q === '') return this.jumps.slice(0, 12)
-        const pre: Jump[] = []
-        const sub: Jump[] = []
-        for (const j of this.jumps) {
-            const l = j.label.toLowerCase()
-            if (l.startsWith(q)) pre.push(j)
-            else if (l.includes(q)) sub.push(j)
-        }
-        return [...pre, ...sub].slice(0, 12)
-    }
-
     // ── selection + hash deep-links ───────────────────────────────────────
     selectAsset(id: string): void {
         this.setSel({ t: 'asset', id })
@@ -182,7 +252,7 @@ export class HubSt {
     setSel(sel: Sel): void {
         this.sel = sel
         const h = hashFor(sel)
-        if (h == null) return
+        if (h == null || !this.isShown) return
         const cur = parseHash(currentHash())
         const next = parseHash(h)
         // the tool set rides after the asset id (media-svc syncHash), so an
@@ -220,6 +290,7 @@ export class HubSt {
     /** the url decides the page: a reload, back, forward and a pasted link
      *  all land here, and only a hash naming something else moves the view */
     applyHash(): void {
+        if (!this.isShown) return
         const p = parseHash(currentHash())
         const named = selOf(p)
         if (named == null) return
@@ -243,8 +314,8 @@ export class HubSt {
     }
     /** first heartbeat has the asset list — only then can a hash resolve */
     afterFirstBeat(): void {
-        if (this.booted) return
-        this.booted = true
+        if (this.beat || !this.isShown) return
+        this.beat = true
         this.applyHash()
     }
 }

package/src/serve/hub-app/runs-tabs.ts

@@ -7,7 +7,7 @@ export type RunsTab = 'runs' | 'files' | 'slowest' | 'longest'
 
 /** the four lists, in tab order. `key` is what the address carries */
 export const RUNS_TABS: { key: RunsTab; label: string; help: string }[] = [
-    { key: 'runs', label: 'runs', help: `every run on record, newest first: shipkit ci, shipkit check, the hub's buttons, its save trigger and its daily health pass. One line per run: when, who started it, what ran, its wall time, how many checks ${RAN}, how many were ${CACHED} (answered from the cache, nothing ran), and its reds. Unfold a run for one line per check, named by its title with its id as the small tag, in a box that scrolls: its reds first, then what ${RAN}, slowest first, then what was ${CACHED}. Click a check for its page. Every run in time, and how many ran at once, is the live strip under the header: unfold it and press fit` },
+    { key: 'runs', label: 'runs', help: `every run on record, newest first: shipkit ci, shipkit check, the hub's buttons, and the runs the plan starts. One line per run: when, who started it, what ran, its wall time, how many checks ${RAN}, how many were ${CACHED} (answered from the cache, nothing ran), and its reds. Unfold a run for one line per check, named by its title with its id as the small tag, in a box that scrolls: its reds first, then what ${RAN}, slowest first, then what was ${CACHED}. Click a check for its page. Every run in time, and how many ran at once, is the live strip under the header: unfold it and press fit` },
     { key: 'files', label: 'test files to fix', help: "bun test files, not checks: each file's last recorded run inside the check that ran it (test, test:<unit>), kept when a test in it failed or when it broke the quick tier budget per file. The same verdict colours the file in the tree under tests. Click a file for its page, the check tag for the check" },
     { key: 'slowest', label: 'slowest checks', help: 'the checks that cost the most when they really run: the mean and the worst of the runs that ran. A check whose worst run passed half its ceiling is flagged, because the next slow machine trips it' },
     { key: 'longest', label: 'longest runs', help: 'the invocations on record that took the longest, start to end, whatever ran them' },