rvlib-shipkit 1.1.0 → 1.2.0

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

@@ -4,27 +4,15 @@
 // structure is read-only (kit.ts is code-reviewed); this edits WORKSPACE
 // state: picks, alts, prompt overlays, meta sidecars, geometry rects.
 import { makeAutoObservable, runInAction } from 'mobx'
-import type { HubSt } from './hub-st.ts'
+import type { RepoSt } from './repo-st.ts'
 import type { AssetDetail, CatRow, Rect, SideAsset } from './hub-types.ts'
 
-const MEDIA = '/media'
 // thumbs change in place when a pick changes → ~8s cache buckets; roll
 // files are immutable (one name = one file forever), so their URLs carry
 // no bust — an <audio> src that never changes never restarts playback
 const V = (): number => Date.now() >> 13
-export const rollUrl = (id: string, name: string): string => `${MEDIA}/img?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`
-export const thumbUrl = (id: string): string => `${MEDIA}/api/thumb?id=${encodeURIComponent(id)}&t=${V()}`
 export const isAud = (n: string): boolean => ['mp3', 'wav', 'ogg', 'm4a'].includes(String(n ?? '').split('.').pop() ?? '')
 
-const j = async (u: string): Promise<any> => {
-    const r = await fetch(MEDIA + u)
-    if (!r.ok) throw new Error(`${u}: ${r.status}`)
-    return r.json()
-}
-const post = async (u: string, b?: unknown): Promise<any> => {
-    const r = await fetch(MEDIA + u, { method: 'POST', body: JSON.stringify(b ?? {}) })
-    return r.json()
-}
 
 export class MediaSvc {
     assets: SideAsset[] = []
@@ -80,7 +68,7 @@ export class MediaSvc {
     /** stage overlay root (the image box) — registered by AssetStage, DOM only */
     overlayHost: HTMLElement | null = null
 
-    constructor(private st: HubSt) {
+    constructor(private st: RepoSt) {
         makeAutoObservable<this, 'st' | 'hbTimer' | 'rectTimer' | 'promptTimer' | 'savedPrompt' | 'overlayHost'>(
             this, { st: false, hbTimer: false, rectTimer: false, promptTimer: false, savedPrompt: false, overlayHost: false })
         if (typeof localStorage !== 'undefined') {
@@ -102,15 +90,41 @@ export class MediaSvc {
     }
 
     start(): void {
+        if (this.hbTimer != null || this.dead != null) return
         void this.heartbeat()
         this.hbTimer = setInterval(() => void this.heartbeat(), 1500)
     }
-    dispose(): void {
+    /** polling only: a pending prompt or rect save still lands */
+    stop(): void {
         if (this.hbTimer != null) clearInterval(this.hbTimer)
+        this.hbTimer = null
+    }
+    dispose(): void {
+        this.stop()
         if (this.rectTimer != null) clearTimeout(this.rectTimer)
         if (this.promptTimer != null) clearTimeout(this.promptTimer)
     }
 
+    /** the media API, under this repo's base */
+    private get api(): string {
+        return this.st.url('/media')
+    }
+    rollUrl(id: string, name: string): string {
+        return `${this.api}/img?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`
+    }
+    thumbUrl(id: string): string {
+        return `${this.api}/api/thumb?id=${encodeURIComponent(id)}&t=${V()}`
+    }
+    private async j(u: string): Promise<any> {
+        const r = await fetch(this.api + u)
+        if (!r.ok) throw new Error(`${u}: ${r.status}`)
+        return r.json()
+    }
+    private async post(u: string, b?: unknown): Promise<any> {
+        const r = await fetch(this.api + u, { method: 'POST', body: JSON.stringify(b ?? {}) })
+        return r.json()
+    }
+
     get curId(): string | null {
         return this.st.sel?.t === 'asset' ? this.st.sel.id : null
     }
@@ -145,7 +159,7 @@ export class MediaSvc {
         if (this.dead != null) return
         let s: any
         try {
-            const r = await fetch(MEDIA + '/api/state')
+            const r = await fetch(this.api + '/api/state')
             if (r.status === 404) {
                 // the mount failed at boot — it will not come back without a
                 // restart; say so once, loudly, and stop wasting the wire
@@ -174,6 +188,7 @@ export class MediaSvc {
         })
         if (this.curId != null) await this.refreshRolls()
         if (this.catMode != null) await this.fillCat()
+        this.st.cols.mediaListed()
         this.st.afterFirstBeat()
     }
 
@@ -184,7 +199,7 @@ export class MediaSvc {
         this.statusLine = ''
         const a = this.assets.find((x) => x.id === id)
         if (a != null) this.openCats.add(a.cat)
-        const r = (await j(`/api/asset?id=${encodeURIComponent(id)}`)) as AssetDetail
+        const r = (await this.j(`/api/asset?id=${encodeURIComponent(id)}`)) as AssetDetail
         if (this.curId !== id) return // selection changed mid-fetch — never clobber
         runInAction(() => {
             this.detail = r
@@ -206,7 +221,7 @@ export class MediaSvc {
     async refreshRolls(): Promise<void> {
         const id = this.curId
         if (id == null) return
-        const r = (await j(`/api/asset?id=${encodeURIComponent(id)}`)) as AssetDetail
+        const r = (await this.j(`/api/asset?id=${encodeURIComponent(id)}`)) as AssetDetail
         if (this.curId !== id) return
         runInAction(() => {
             if (this.detail == null) this.detail = r
@@ -223,23 +238,23 @@ export class MediaSvc {
 
     async generate(): Promise<void> {
         if (this.curId == null) return
-        await post('/api/generate', { id: this.curId, prompt: this.prompt, count: +this.n })
+        await this.post('/api/generate', { id: this.curId, prompt: this.prompt, count: +this.n })
         void this.heartbeat()
     }
     async genCat(cat: string, count: number): Promise<void> {
-        const r = await post('/api/generate-cat', { cat, count })
+        const r = await this.post('/api/generate-cat', { cat, count })
         if (r?.error != null) runInAction(() => { this.statusLine = r.error })
         void this.heartbeat()
     }
     clearQueue(): void {
-        void post('/api/queue/clear')
+        void this.post('/api/queue/clear')
     }
     stopCurrent(): void {
-        void post('/api/interrupt')
+        void this.post('/api/interrupt')
     }
 
     async pick(name: string): Promise<void> {
-        const res = await post('/api/pick', { id: this.curId, name })
+        const res = await this.post('/api/pick', { id: this.curId, name })
         runInAction(() => {
             this.statusLine = res.error != null ? `ship FAILED: ${res.error}` : res.shipped != null ? `shipped → ${res.shipped}` : 'picked (pick.json)'
             this.active = name
@@ -247,11 +262,11 @@ export class MediaSvc {
         await this.refreshRolls()
     }
     async alt(name: string): Promise<void> {
-        await post('/api/alt', { id: this.curId, name })
+        await this.post('/api/alt', { id: this.curId, name })
         await this.refreshRolls()
     }
     async discard(name: string): Promise<void> {
-        await post('/api/discard', { id: this.curId, name })
+        await this.post('/api/discard', { id: this.curId, name })
         runInAction(() => {
             if (this.active === name) this.active = null
             // the ✕ sits on the hovered tile and its unmount fires no
@@ -267,7 +282,7 @@ export class MediaSvc {
             const fd = new FormData()
             fd.append('id', this.curId)
             fd.append('file', f)
-            const r = await fetch(`${MEDIA}/api/upload`, { method: 'POST', body: fd }).then((x) => x.json()).catch((e: Error) => ({ error: String(e) }))
+            const r = await fetch(`${this.api}/api/upload`, { method: 'POST', body: fd }).then((x) => x.json()).catch((e: Error) => ({ error: String(e) }))
             if (r.error != null) runInAction(() => { this.statusLine = `upload FAIL: ${r.error}` })
         }
         await this.refreshRolls()
@@ -290,7 +305,7 @@ export class MediaSvc {
             const text = this.prompt
             if (text === this.savedPrompt) return // unchanged — not a save
             void (async () => {
-                const r = await post('/api/prompt', { id, prompt: text })
+                const r = await this.post('/api/prompt', { id, prompt: text })
                 runInAction(() => {
                     if (this.curId !== id) return // selection moved while the POST flew — a late response must not corrupt the new asset's baseline
                     if (r.error != null) {
@@ -330,7 +345,7 @@ export class MediaSvc {
         }
         const id = this.curId
         const name = this.active
-        const r = await j(`/api/rect?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`).catch(() => null)
+        const r = await this.j(`/api/rect?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`).catch(() => null)
         if (this.curId !== id || this.active !== name) return // roll switched mid-fetch
         runInAction(() => {
             this.rect = r?.rect ?? null
@@ -349,7 +364,7 @@ export class MediaSvc {
         if (this.rectTimer != null) clearTimeout(this.rectTimer)
         this.rectTimer = setTimeout(() => {
             void (async () => {
-                const r = await post('/api/rect', { id, name, rect })
+                const r = await this.post('/api/rect', { id, name, rect })
                 runInAction(() => {
                     if (this.curId !== id || this.active !== name) return // selection moved on — never adopt a stale rect
                     if (r.rect != null) this.rect = r.rect
@@ -360,7 +375,7 @@ export class MediaSvc {
     }
     async legsDefault(): Promise<void> {
         if (this.curId == null || this.active == null) return
-        const r = await post('/api/legs-default', { id: this.curId, name: this.active })
+        const r = await this.post('/api/legs-default', { id: this.curId, name: this.active })
         if (r.rect != null) runInAction(() => { this.rect = r.rect })
     }
     removeLegs(): void {
@@ -374,7 +389,7 @@ export class MediaSvc {
     async fillCat(): Promise<void> {
         const mode = this.catMode
         if (mode == null) return
-        const r = await j(`/api/catrects?cat=${encodeURIComponent(mode)}`)
+        const r = await this.j(`/api/catrects?cat=${encodeURIComponent(mode)}`)
         if (this.catMode !== mode) return // navigated away mid-fetch
         runInAction(() => { this.catRows = r.rows ?? [] })
     }
@@ -384,10 +399,10 @@ export class MediaSvc {
         const nv = Math.max(0.1, v || row.rect.size)
         if (nv === row.rect.size) return // blur without a change is not a save
         row.rect.size = nv
-        await post('/api/rect', { id, name, rect: row.rect })
+        await this.post('/api/rect', { id, name, rect: row.rect })
     }
     async toggleFlip(id: string, name: string): Promise<void> {
-        await post('/api/flip', { id, name })
+        await this.post('/api/flip', { id, name })
         await this.fillCat()
     }
     async applyAllSize(): Promise<void> {
@@ -397,7 +412,7 @@ export class MediaSvc {
         // one action for all mutations (post-await writes would land outside
         // it — mobx strict mode), then the POSTs
         runInAction(() => { for (const row of rows) row.rect!.size = v })
-        for (const row of rows) await post('/api/rect', { id: row.id, name: row.name, rect: row.rect })
+        for (const row of rows) await this.post('/api/rect', { id: row.id, name: row.name, rect: row.rect })
         runInAction(() => { this.allMsg = 'applied' })
         setTimeout(() => runInAction(() => { this.allMsg = '' }), 1200)
         await this.fillCat()
@@ -433,12 +448,16 @@ export class MediaSvc {
         if (kind != null && typeof localStorage !== 'undefined') localStorage.setItem(`hub:tools:${kind}`, [...this.tools].join(','))
         this.syncHash()
     }
-    /** the hash carries the working state: #<assetId>?tools=a,b — shareable, restored on load */
-    private syncHash(): void {
-        if (typeof location === 'undefined' || this.curId == null) return
+    /** the hash carries the working state: #<assetId>?tools=a,b — shareable,
+     *  restored on load. null while no asset is open */
+    get hash(): string | null {
+        if (this.curId == null) return null
         const t = [...this.tools].join(',')
-        const h = `${this.curId}${t === '' ? '' : `?tools=${t}`}`
-        if (location.hash.slice(1) !== h) history.replaceState(null, '', `#${h}`)
+        return `${this.curId}${t === '' ? '' : `?tools=${t}`}`
+    }
+    private syncHash(): void {
+        const h = this.hash
+        if (h != null) this.st.replaceHash(h)
     }
     /** tabs = kit-declared presets first, then autos for tools no tab covers.
      *  a tab swaps the enabled tool SET — the canvas underneath never moves */
@@ -493,12 +512,12 @@ export class MediaSvc {
     }
     async loadMeta(): Promise<void> {
         this.jsonMsg = ''
-        const r = this.curId != null && this.active != null ? await post('/api/meta', { id: this.curId, name: this.active }) : { text: '' }
+        const r = this.curId != null && this.active != null ? await this.post('/api/meta', { id: this.curId, name: this.active }) : { text: '' }
         runInAction(() => { this.jsonText = r.text ?? '' })
     }
     async saveMeta(): Promise<void> {
         if (this.curId == null || this.active == null) return
-        const r = await post('/api/meta', { id: this.curId, name: this.active, text: this.jsonText })
+        const r = await this.post('/api/meta', { id: this.curId, name: this.active, text: this.jsonText })
         runInAction(() => { this.jsonMsg = r.error != null ? `FAIL: ${r.error}` : 'saved' })
     }
     /** frozen per mount: a roll/asset switch remounts with a fresh api */
@@ -513,14 +532,14 @@ export class MediaSvc {
             /** the PICKED roll's name (null before any pick) — editors that
              *  target shipped art can warn when the shown roll differs */
             picked: this.detail?.rolls.find((x) => x.picked)?.name ?? null,
-            imgUrl: rollUrl(id, name),
+            imgUrl: this.rollUrl(id, name),
             getMeta: async () => {
-                const r = await post('/api/meta', { id, name })
+                const r = await this.post('/api/meta', { id, name })
                 if (r.error != null) throw new Error(r.error)
                 return r.text ? JSON.parse(r.text) : null
             },
             saveMeta: async (data: unknown) => {
-                const r = await post('/api/meta', { id, name, text: JSON.stringify(data) })
+                const r = await this.post('/api/meta', { id, name, text: JSON.stringify(data) })
                 if (r.error != null) throw new Error(r.error)
             },
             // an element covering the DISPLAYED roll image, so an editor can

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

@@ -5,8 +5,8 @@
 import { runInAction } from 'mobx'
 import { observer } from 'mobx-react-lite'
 import { useEffect, useRef, useState, type DragEvent, type ReactNode } from 'react'
-import type { HubSt } from './hub-st.ts'
-import { isAud, rollUrl, thumbUrl } from './media-svc.ts'
+import type { RepoSt } from './repo-st.ts'
+import { isAud, type MediaSvc } from './media-svc.ts'
 import { GeometryLayer, Rectbar, measureBox, type Box } from './geometry-view.tsx'
 import type { CatRow, CustomPanelRef } from './hub-types.ts'
 
@@ -14,7 +14,7 @@ const TEX = 1024
 const MIX_UNIT = 24
 const MIX_GROUND = 44
 
-export const MediaTopbar = observer(({ app }: { app: HubSt }) => {
+export const MediaTopbar = observer(({ app }: { app: RepoSt }) => {
     const m = app.media
     const fileRef = useRef<HTMLInputElement>(null)
     const taRef = useRef<HTMLTextAreaElement>(null)
@@ -71,7 +71,7 @@ export const MediaTopbar = observer(({ app }: { app: HubSt }) => {
     )
 })
 
-export const InfoChips = observer(({ app }: { app: HubSt }) => {
+export const InfoChips = observer(({ app }: { app: RepoSt }) => {
     const info = app.media.detail?.info
     if (info == null) return null
     const chips: { k: string; v: ReactNode; warn?: boolean }[] = [{ k: 'backend', v: info.backend }]
@@ -91,7 +91,7 @@ export const InfoChips = observer(({ app }: { app: HubSt }) => {
     )
 })
 
-export const AssetStage = observer(({ app }: { app: HubSt }) => {
+export const AssetStage = observer(({ app }: { app: RepoSt }) => {
     const m = app.media
     const stageRef = useRef<HTMLDivElement>(null)
     const imgRef = useRef<HTMLImageElement>(null)
@@ -116,9 +116,9 @@ export const AssetStage = observer(({ app }: { app: HubSt }) => {
     else if (isAud(shown)) content = (
         // key = the roll identity: heartbeats re-render but never recreate
         // the element, so playback survives; the src carries no cache-bust
-        <div className="stageaud" key={`${m.curId}/${shown}`}>🔊<audio controls src={rollUrl(m.curId!, shown)} /></div>
+        <div className="stageaud" key={`${m.curId}/${shown}`}>🔊<audio controls src={m.rollUrl(m.curId!, shown)} /></div>
     )
-    else content = <img className="roll" src={rollUrl(m.curId!, shown)} ref={imgRef} onLoad={remeasure} />
+    else content = <img className="roll" src={m.rollUrl(m.curId!, shown)} ref={imgRef} onLoad={remeasure} />
     const imgShown = shown != null && !isAud(shown)
     const measured = imgShown && box != null
     return (
@@ -137,7 +137,7 @@ export const AssetStage = observer(({ app }: { app: HubSt }) => {
     )
 })
 
-export const ToolsBar = observer(({ app }: { app: HubSt }) => {
+export const ToolsBar = observer(({ app }: { app: RepoSt }) => {
     const m = app.media
     const d = m.detail
     if (d == null || m.curId == null) return null
@@ -177,7 +177,7 @@ export const ToolsBar = observer(({ app }: { app: HubSt }) => {
 
 // variants live in a THIN resizable side bar — the stage keeps the room.
 // closed = a slim rail with the count; the drag handle resizes; drop = upload
-export const VariantsBar = observer(({ app }: { app: HubSt }) => {
+export const VariantsBar = observer(({ app }: { app: RepoSt }) => {
     const m = app.media
     const rolls = m.detail?.rolls ?? []
     const genHere = m.curId != null && m.pending.includes(m.curId)
@@ -213,7 +213,7 @@ export const VariantsBar = observer(({ app }: { app: HubSt }) => {
                         onMouseEnter={() => { if (!isAud(x.name)) runInAction(() => { m.hover = x.name }) }}
                         onMouseLeave={() => runInAction(() => { m.hover = null })}
                         onClick={() => m.setActive(x.name)}>
-                        {isAud(x.name) ? <>🔊<audio controls src={rollUrl(m.curId!, x.name)} /></> : <img src={rollUrl(m.curId!, x.name)} />}
+                        {isAud(x.name) ? <>🔊<audio controls src={m.rollUrl(m.curId!, x.name)} /></> : <img src={m.rollUrl(m.curId!, x.name)} />}
                         {x.picked ? <span className="st">★</span> : null}
                         <div className="btns">
                             <button className="b-pick" onClick={(e) => { e.stopPropagation(); void m.pick(x.name) }}>pick</button>
@@ -228,7 +228,7 @@ export const VariantsBar = observer(({ app }: { app: HubSt }) => {
 })
 
 // ── category grid + size-true lineup ─────────────────────────────────────
-const MixLineup = observer(({ rows }: { rows: CatRow[] }) => {
+const MixLineup = observer(({ m, rows }: { m: MediaSvc; rows: CatRow[] }) => {
     const items = rows.filter((r) => !r.icon && r.rect != null).sort((a, b) => a.rect!.size - b.rect!.size || a.label.localeCompare(b.label))
     const boxH = 420
     const baseY = boxH - MIX_GROUND
@@ -241,7 +241,7 @@ const MixLineup = observer(({ rows }: { rows: CatRow[] }) => {
         cx += slot / 2
         const fx = rect.flip === true ? TEX - rect.x - rect.w : rect.x
         sprites.push(
-            <img key={it.id} className="mixsprite" src={thumbUrl(it.id)} style={{
+            <img key={it.id} className="mixsprite" src={m.thumbUrl(it.id)} style={{
                 width: TEX * ts, height: TEX * ts,
                 left: cx - (fx + rect.w / 2) * ts, top: baseY - (rect.y + rect.h / 2) * ts,
                 transform: rect.flip === true ? 'scaleX(-1)' : undefined, zIndex: Math.round(cx),
@@ -262,7 +262,7 @@ const MixLineup = observer(({ rows }: { rows: CatRow[] }) => {
     )
 })
 
-export const CatGrid = observer(({ app }: { app: HubSt }) => {
+export const CatGrid = observer(({ app }: { app: RepoSt }) => {
     const m = app.media
     const cat = m.catMode
     if (cat == null) return null
@@ -288,9 +288,9 @@ export const CatGrid = observer(({ app }: { app: HubSt }) => {
                         // inner controls stopPropagation
                         <div className="card" key={row.id} onClick={() => app.selectAsset(row.id)}>
                             {isAud(row.name)
-                                ? <div className="aud">🔊<audio controls src={rollUrl(row.id, row.name)} onClick={(e) => e.stopPropagation()} />{m.pending.includes(row.id) ? <div className="spin" /> : null}</div>
+                                ? <div className="aud">🔊<audio controls src={m.rollUrl(row.id, row.name)} onClick={(e) => e.stopPropagation()} />{m.pending.includes(row.id) ? <div className="spin" /> : null}</div>
                                 : <div className="th">
-                                    <img src={thumbUrl(row.id)} style={fl ? { transform: 'scaleX(-1)' } : undefined} />
+                                    <img src={m.thumbUrl(row.id)} style={fl ? { transform: 'scaleX(-1)' } : undefined} />
                                     {row.rect != null ? <div className="ovmini" style={{
                                         left: pc(fl ? TEX - row.rect.x - row.rect.w : row.rect.x), top: pc(row.rect.y),
                                         width: pc(row.rect.w), height: pc(row.rect.h),
@@ -314,13 +314,13 @@ export const CatGrid = observer(({ app }: { app: HubSt }) => {
                     )
                 })}
             </div>
-            <MixLineup rows={m.catRows} />
+            <MixLineup m={m} rows={m.catRows} />
         </div>
     )
 })
 
 // ── dock: the active tools' panels, side by side under the stage ─────────
-const PanelHost = observer(({ app, c }: { app: HubSt; c: CustomPanelRef }) => {
+const PanelHost = observer(({ app, c }: { app: RepoSt; c: CustomPanelRef }) => {
     const m = app.media
     const ref = useRef<HTMLDivElement>(null)
     const key = `${m.curId}|${m.active}|${c.id}`
@@ -337,7 +337,7 @@ const PanelHost = observer(({ app, c }: { app: HubSt; c: CustomPanelRef }) => {
         void (async () => {
             try {
                 // repo-defined editor module, served by the media API
-                mod = (await import(`/media/${c.url}`)) as Record<string, unknown>
+                mod = (await import(app.url(`/media/${c.url}`))) as Record<string, unknown>
                 if (typeof mod.mount !== 'function') throw new Error(`${c.url} must export mount(el, api)`)
                 if (!dead) await (mod.mount as (el: HTMLElement, api: unknown) => unknown)(host, api)
             } catch (e) {
@@ -357,7 +357,7 @@ const PanelHost = observer(({ app, c }: { app: HubSt; c: CustomPanelRef }) => {
 // floating panels sit ON the canvas (drag by the title bar), so toggling
 // them never reflows the stage — canvas size/position survive tab switches
 const FloatPanel = observer(({ app, id, title, dx, dy, anchor, children }: {
-    app: HubSt; id: string; title: string; dx: number; dy: number; anchor?: 'tl' | 'bl'; children: ReactNode
+    app: RepoSt; id: string; title: string; dx: number; dy: number; anchor?: 'tl' | 'bl'; children: ReactNode
 }) => {
     const m = app.media
     const ref = useRef<HTMLDivElement>(null)
@@ -408,7 +408,7 @@ const FloatPanel = observer(({ app, id, title, dx, dy, anchor, children }: {
     )
 })
 
-export const FloatPanels = observer(({ app }: { app: HubSt }) => {
+export const FloatPanels = observer(({ app }: { app: RepoSt }) => {
     const m = app.media
     const customs = (m.detail?.asset.custom ?? []).filter((c) => m.tools.has(`c:${c.id}`))
     const showJson = m.tools.has('json')

package/src/serve/hub-app/next-run.ts

@@ -1,8 +1,9 @@
-// WHEN A CHECK RUNS NEXT, as a true statement. Nothing runs a check on a clock
-// except the hub's daily health pass (serve/health-schedule.ts), so the answer
-// is read off where the check runs (`when`), what it remembers, and that one
-// timer. Pure, so every case is pinned by a test rather than a screenshot.
-import type { Schedule, CheckFacts } from './hub-types.ts'
+// WHEN A CHECK RUNS NEXT, as a true statement. Nothing runs a check nobody
+// asked for but the plan (plan/planner.ts), so the answer is where the check
+// runs (`when`) and its row of that plan. Pure, so every case is pinned by a
+// test rather than a screenshot.
+import type { PlanRow } from '../../plan/planner.ts'
+import type { CheckFacts } from './hub-types.ts'
 
 export type NextRun = {
     /** the value the page shows */
@@ -37,32 +38,25 @@ export function spanWords(ms: number): string {
     return `${Math.round(ms / 1000)}s`
 }
 
-export type NextRunFacts = Pick<CheckFacts, 'when' | 'whenReason'> & { keepsUntil?: number | null }
+export type NextRunFacts = Pick<CheckFacts, 'when' | 'whenReason'>
 
-export function nextRun(u: NextRunFacts, s: Schedule | null, now: number): NextRun {
-    if (u.when === 'always')
-        return { words: 'next shipkit ci', at: null, help: 'it runs on every `shipkit ci` and in every health pass. A cached answer is used when nothing it depends on moved' }
-    if (u.when === 'release')
-        return { words: 'before a release', at: null, help: '`shipkit ci --full` and the release path run it, and so does the health pass. The quick gate you run while working does not' }
+/** a plan row in a few words: why it is due, or what makes it due */
+export function planWords(row: PlanRow, now: number): { words: string; at: number | null } {
+    if (row.state === 'running') return { words: 'running now', at: row.dueAt }
+    if (row.state === 'due') return { words: row.reason === 'asked' ? 'due now, asked' : row.reason === 'changed' ? 'due now, a save moved it' : 'due now', at: row.dueAt }
+    if (row.state === 'late') return { words: 'late, waits for the repo to be active', at: row.dueAt }
+    if (row.state === 'next' && row.dueAt != null) return { words: `in ${aheadWords(row.dueAt - now)}`, at: row.dueAt }
+    return { words: 'on the next save that moves what it reads', at: null }
+}
+
+export function nextRun(u: NextRunFacts, row: PlanRow | null, now: number): NextRun {
     if (u.when === 'off')
         return { words: u.whenReason != null && u.whenReason !== '' ? `never: ${u.whenReason}` : 'never', at: null, help: 'it is off: nothing runs it until the switch below puts it somewhere' }
-    if (s == null)
-        return { words: 'next health pass', at: null, help: 'this hub runs no daily timer, so it runs when `shipkit check` runs or when you press run the health pass' }
-    if (s.running) return { words: 'running now', at: now, help: 'the daily health pass is running right now' }
-    const pass = Math.max(now, s.nextAt)
-    const keeps = u.keepsUntil ?? null
-    if (keeps != null && keeps > pass) {
-        const k = Math.ceil((keeps - pass) / s.everyMs)
-        const at = pass + k * s.everyMs
-        return {
-            words: `in ${aheadWords(at - now)}`,
-            at,
-            help: `the health pass runs every ${spanWords(s.everyMs)}, and uses this check's cached answer until it runs out. The first pass after that runs it again`,
-        }
-    }
-    return {
-        words: pass <= now ? 'due now' : `in ${aheadWords(pass - now)}`,
-        at: pass,
-        help: `the next health pass: the hub runs it every ${spanWords(s.everyMs)} while it serves, and at startup when the last one is older than that`,
-    }
+    if (u.when === 'release')
+        return { words: 'before a release', at: null, help: '`shipkit ci --full` and the release path run it. The plan and the quick gate you run while working do not' }
+    if (row == null)
+        return { words: u.when === 'always' ? 'next shipkit ci' : 'next shipkit check', at: null, help: 'no plan covers it here, so it runs when a terminal or a button runs it' }
+    const w = planWords(row, now)
+    const inactive = row.state === 'late' || !row.active ? ` While the repo is inactive: ${row.inactive}.` : ''
+    return { words: w.words, at: w.at, help: `planned by: ${row.rule}.${inactive}${row.error != null ? ` Error: ${row.error}.` : ''} A shipkit ci or check from a terminal runs it too` }
 }

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

@@ -0,0 +1,88 @@
+// the one picker of the page (cmd+k, keys.ts), a node of the root: the
+// home's places (home, planned) first, then the shown repo's own jump
+// targets, then every other house repo as a place to go. Another repo's
+// resources are never listed: a jump to a repo selects it in place, and its
+// own targets are one more cmd+k away.
+import { makeAutoObservable } from 'mobx'
+import type { HomeSt } from './home-st.ts'
+import type { Jump } from './repo-st.ts'
+
+/** how many rows the picker shows */
+export const PAL_ROWS = 12
+
+export class PaletteSt {
+    open = false
+    query = ''
+    idx = 0
+
+    constructor(private st: HomeSt) {
+        makeAutoObservable<this, 'st'>(this, { st: false })
+    }
+
+    /** the home's places, first in the list: a hub of its own has none */
+    get places(): Jump[] {
+        const st = this.st
+        if (st.machine == null) return []
+        return [
+            { id: 'place:home', label: 'home', section: 'place', run: () => st.navigate('/') },
+            { id: 'place:planned', label: 'planned', section: 'place', run: () => st.navigate('/planned') },
+        ]
+    }
+
+    /** every other house repo, as a place to go */
+    get others(): Jump[] {
+        const st = this.st
+        if (st.machine == null) return []
+        return st.projects.list.filter((p) => p.name !== st.selected).map((p) => ({ id: `repo:${p.name}`, label: p.name, section: 'repo', run: () => st.select(p.name) }))
+    }
+
+    get jumps(): Jump[] {
+        return [...this.places, ...(this.st.shown?.jumps ?? []), ...this.others]
+    }
+
+    /** ranked: prefix matches first, then substring. With no query, home and
+     *  planned, then the shown repo's first targets, then every other repo,
+     *  so a jump elsewhere is always in reach */
+    get results(): Jump[] {
+        const q = this.query.trim().toLowerCase()
+        if (q === '') {
+            const own = this.st.shown?.jumps ?? []
+            const places = this.places
+            const others = this.others
+            return [...places, ...own.slice(0, Math.max(4, PAL_ROWS - places.length - others.length)), ...others]
+        }
+        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, PAL_ROWS * 2)
+    }
+
+    toggle(): void {
+        this.open = !this.open
+        this.query = ''
+        this.idx = 0
+    }
+    close(): void {
+        this.open = false
+    }
+    setQuery(v: string): void {
+        this.query = v
+        this.idx = 0
+    }
+    setIdx(n: number): void {
+        this.idx = n
+    }
+    move(d: number): void {
+        const n = this.results.length
+        if (n > 0) this.idx = (this.idx + d + n) % n
+    }
+    run(j: Jump | undefined = this.results[this.idx]): void {
+        if (j == null) return
+        this.open = false
+        j.run()
+    }
+}