rvlib-shipkit 1.5.0 → 1.6.0

package/src/serve/hub-app/project-list.tsx

@@ -24,7 +24,7 @@ import { useEffect, type CSSProperties } from 'react'
 import { middleware, OPEN_MS } from './floating.tsx'
 import { Icon, ICON } from './icons.tsx'
 import { plainClick } from './home-st.ts'
-import { PICKER_KEY, PLACE_KEY } from './keys.ts'
+import { PICKER_KEY, PLACE_KEY, STEP_KEYS } from './keys.ts'
 import { cardModel, faceOf, hueOf, SORTS, type Place, type Project, type ProjectsSvc } from './projects-svc.ts'
 
 /** what the list needs of its page: the hub and the home both carry one */
@@ -195,6 +195,9 @@ export const ProjectList = observer(({ app }: { app: ListHost }) => {
             ) : null}
             <div className="pjfoot">
                 <SortButton s={s} />
+                <span className="pjstep" title={`${STEP_KEYS[0]} and ${STEP_KEYS[1]} open the repo above or below, from any page`}>
+                    {STEP_KEYS.map((k) => <kbd key={k}>{k}</kbd>)}
+                </span>
                 {s.archived.length === 0 || s.onArchived == null ? null : (
                     <button className={`pjarbtn${s.archivedOpen ? ' on' : ''}`} aria-pressed={s.archivedOpen}
                         title={`${s.archivedOpen ? 'hide' : 'show'} the ${s.archived.length} archived repos: nothing runs there, a row opens the archived page`}
@@ -213,7 +216,7 @@ const orderWords = (s: ProjectsSvc): string => {
     return m === 'manual' ? 'manual order' : SORTS.find((x) => x.id === m)!.label
 }
 
-/** the sort button: it names the order the list is in and opens the menu,
+/** the sort button: its title names the order the list is in, it opens the menu,
  *  and sorts nothing itself */
 const SortButton = observer(({ s }: { s: ProjectsSvc }) => {
     const f = useFloating({
@@ -231,7 +234,7 @@ const SortButton = observer(({ s }: { s: ProjectsSvc }) => {
         <>
             <button ref={f.refs.setReference} className="pgsort" title={`the list is in ${orderWords(s)}: pick a sort`}
                 {...getReferenceProps({ onClick: () => s.toggleSortMenu() })}>
-                <Icon d={ICON.sort} /><span className="pgsortl">{orderWords(s)}</span>
+                <Icon d={ICON.sort} /><span className="pgsortl">sort</span>
             </button>
             {s.sortMenuOpen ? (
                 <FloatingPortal>

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

@@ -277,6 +277,16 @@ export class ProjectsSvc {
     }
 
 
+    /** the repo above (-1) or below (+1) the selected one, round the ends;
+     *  with none selected, down starts at the top and up at the bottom */
+    step(by: -1 | 1): void {
+        const n = this.list.length
+        if (n === 0) return
+        const at = this.list.findIndex((p) => this.isCurrent(p))
+        const next = at === -1 ? (by === 1 ? 0 : n - 1) : (at + by + n) % n
+        this.select(this.list[next]!.name)
+    }
+
     /** a click selects once it is sure no second click follows */
     click(name: string): void {
         this.select(name)

package/src/serve/hub-app/repo-sections.ts

@@ -1,8 +1,11 @@
 // A repo page's sections: the pages reached for most, the top rows of the
 // left pane's tree (tree-row.tsx draws them the way the project list draws its
 // lines: an icon, a label, a count where it says something, its ⌥ shortcut at
-// the end, keys.ts, the current one lit). A page this repo does not have is
-// not a row. The counts read the severity filter, like everything under them,
+// the end, keys.ts, the current one lit). Every repo draws the same rows, so
+// the list reads the same from repo to repo: a section this repo has nothing
+// in is a greyed row, and only opens a page that can say it is empty (the
+// processes page). Plan, git and admin come from the machine, so a hub of its
+// own has none of the three. The counts read the severity filter, like everything under them,
 // and come from what the page already holds (the kept screen on a reload), so
 // none arrives late and moves the tree.
 import { RUNS_ID } from '../../collections/collection-types.ts'
@@ -18,6 +21,10 @@ export type RepoSection = {
     title: string
     /** null when a number would say nothing */
     count: number | null
+    /** this repo has nothing there: the row is greyed */
+    empty: boolean
+    /** its click opens a page: false for an empty section with no empty page */
+    opens: boolean
     tone: 'red' | 'warn' | null
     on: boolean
     go: () => void
@@ -83,35 +90,42 @@ export function openSection(app: RepoSt, id: SectionId): void {
     }
 }
 
+/** the sections whose page says it is empty, so an empty row still opens it */
+const EMPTY_PAGES = new Set<SectionId>(['processes'])
+
 export function repoSections(app: RepoSt): RepoSection[] {
     const has = (col: string): boolean => app.cols.colMeta.some((c) => c.id === col)
     const cur = sectionOfRepo(app)
     const res = app.cols.resources.filter((r) => passesFilter(r, app.filter))
     const reds = (col: string): number => res.filter((r) => r.collection === col && r.state === 'red').length
     const none = { count: null, tone: null }
-    const line = (id: SectionId, title: string, count: Pick<RepoSection, 'count' | 'tone'>): RepoSection => ({ id, label: sectionLabel(id), title, ...count, on: cur === id, go: () => openSection(app, id) })
+    const line = (id: SectionId, title: string, count: Pick<RepoSection, 'count' | 'tone'>, empty: string | null = null): RepoSection => {
+        const opens = empty == null || EMPTY_PAGES.has(id)
+        return { id, label: sectionLabel(id), title: empty ?? title, ...(empty == null ? count : none), empty: empty != null, opens, on: opens && cur === id, go: opens ? () => openSection(app, id) : () => {} }
+    }
     const out: RepoSection[] = [line('readme', 'the README, what the repo is', none)]
     const ownReds = (from: CheckOwner): number => res.filter((r) => r.check?.from === from && r.state === 'red').length
-    if (has('contracts')) out.push(line('contracts', 'what a release venue asks of this repo, and what it still lacks', counted(reds('contracts'), 'red')))
-    if (has('checks')) out.push(line('shipkit', 'the checks shipkit ships to every repo, one page each', counted(ownReds('shipkit'), 'red')))
-    if (has('checks')) out.push(line('repo', 'the checks this repo declares itself, one page each', counted(ownReds('repo'), 'red')))
-    if (has('creds')) out.push(line('secrets', 'the credentials this repo needs, present or missing', counted(reds('creds'), 'red')))
-    if (has('checks')) out.push(line('when', 'what runs when: every check on every context (commit, ci, full, release, health, save, clock), with the legend', none))
+    const unless = (on: boolean, why: string): string | null => (on ? null : why)
+    out.push(line('contracts', 'what a release venue asks of this repo, and what it still lacks', counted(reds('contracts'), 'red'), unless(has('contracts'), 'no contract: no release venue applies to this repo')))
+    const noChecks = unless(has('checks'), 'no checks yet: its hub has not answered')
+    out.push(line('shipkit', 'the checks shipkit ships to every repo, one page each', counted(ownReds('shipkit'), 'red'), noChecks))
+    out.push(line('repo', 'the checks this repo declares itself, one page each', counted(ownReds('repo'), 'red'), noChecks))
+    out.push(line('secrets', 'the credentials this repo needs, present or missing', counted(reds('creds'), 'red'), unless(has('creds'), 'no secrets: this repo needs no credential')))
+    out.push(line('when', 'what runs when: every check on every context (commit, ci, full, release, health, save, clock), with the legend', none, noChecks))
     // a page, never a resource: every hub keeps a run record
     out.push(line('runs', 'every run on record, the slowest checks and the longest runs', none))
     // the plan and git come from the machine, so a hub of its own has neither
     if (app.home.machine != null) out.push(line('plan', 'what the machine runs here on its own time, and when', none))
     const procs = app.globalProcesses
-    if (procs.length > 0) out.push(line('processes', 'the processes this repo declares: start, stop, open, their description and their log', counted(procs.filter((r) => r.dot === 'crashed').length, 'red')))
+    out.push(line('processes', 'the processes this repo declares: start, stop, open, their description and their log', counted(procs.filter((r) => r.dot === 'crashed').length, 'red'),
+        unless(procs.length > 0, 'no process: this repo declares no global process (a <id>.shipkit.ts file with globalProcess adds one)')))
     if (app.home.machine != null) out.push(line('git', 'the branch, its upstream, what is not committed, the last commits', none))
-    if (has('asks')) {
-        const open = res.filter((r) => r.collection === 'asks' && r.type === 'ask' && r.slot !== 'done').length
-        out.push(line('asks', 'what waits on a human', counted(open, 'warn')))
-    }
-    if (has('reflections')) out.push(line('reflections', 'friction this repo logged against the wiki, waiting to be folded in', counted(res.filter((r) => r.type === 'reflection').length, 'warn')))
-    if (has('tests')) out.push(line('tests', 'every test file, slowest first, then each test check', counted(reds('tests'), 'red')))
-    if ((app.media.assets[0]?.cat ?? app.cols.cachedCat) != null) out.push(line('media', 'the assets, in the atelier', none))
-    if (has(WIKIS)) out.push(line('wikis', 'every wiki this repo mounts, as a link graph', none))
+    const open = res.filter((r) => r.collection === 'asks' && r.type === 'ask' && r.slot !== 'done').length
+    out.push(line('asks', 'what waits on a human', counted(open, 'warn'), unless(has('asks'), 'no asks: nothing has ever waited on a human here')))
+    out.push(line('reflections', 'friction this repo logged against the wiki, waiting to be folded in', counted(res.filter((r) => r.type === 'reflection').length, 'warn'), unless(has('reflections'), 'no reflections: this repo logged no friction')))
+    out.push(line('tests', 'every test file, slowest first, then each test check', counted(reds('tests'), 'red'), unless(has('tests'), 'no tests: this repo has no test file')))
+    out.push(line('media', 'the assets, in the atelier', none, unless((app.media.assets[0]?.cat ?? app.cols.cachedCat) != null, 'no media: this repo has no asset kit')))
+    out.push(line('wikis', 'every wiki this repo mounts, as a link graph', none, unless(has(WIKIS), 'no wiki: this repo mounts none')))
     if (app.home.machine != null) out.push(line('admin', 'reload the hub, keep the repo active, archive it', none))
     return out
 }

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

@@ -227,9 +227,9 @@ export class RepoSt {
             out.push({ id: `asset:${a.id}`, label: a.label, section: a.cat, run: () => this.selectAsset(a.id) })
         // the section lines, with their keys: the same list the left pane draws
         const secs = repoSections(this)
-        for (const s of secs) out.push({ id: `section:${s.id}`, label: s.label, section: 'section', key: sectionKeyLabel(s.id), run: s.go })
+        for (const s of secs.filter((x) => x.opens)) out.push({ id: `section:${s.id}`, label: s.label, section: 'section', key: sectionKeyLabel(s.id), run: s.go })
         for (const col of this.cols.sidebarCols) {
-            if (!secs.some((s) => s.id === col.id)) out.push({ id: `col:${col.id}`, label: col.title, section: 'section', run: () => this.showCol(col.id) })
+            if (!secs.some((s) => s.id === col.id && s.opens)) out.push({ id: `col:${col.id}`, label: col.title, section: 'section', run: () => this.showCol(col.id) })
             for (const i of col.instances)
                 out.push({ id: `item:${i.id}`, label: i.text, section: col.title, run: () => this.cols.select(col.id, i.id) })
         }
@@ -256,10 +256,27 @@ export class RepoSt {
         void this.tests.load(check)
     }
 
+    /** a walk with the tree's arrows is under way, and whether the current
+     *  history entry is its own: a held arrow opens ~30 pages a second, and
+     *  the browser throws past 100 pushState calls per 10 seconds */
+    private walking = false
+    private walked = false
+    /** open pages as one walk: the first step is a history entry, every next
+     *  one rewrites it, so back returns to where the walk started */
+    walk(open: () => void): void {
+        this.walking = true
+        try {
+            open()
+        } finally {
+            this.walking = false
+        }
+    }
+
     /** the ONE place a selection is written, so the url always describes what
      *  is on screen. A new page is a history entry, so back returns to the
-     *  page before it. The same address is never pushed twice: applyHash
-     *  lands here too, with the hash already naming this selection */
+     *  page before it, except inside a walk (walk). The same address is never
+     *  pushed twice: applyHash lands here too, with the hash already naming
+     *  this selection */
     setSel(sel: Sel): void {
         this.sel = sel
         const h = hashFor(sel)
@@ -269,7 +286,9 @@ export class RepoSt {
         // the tool set rides after the asset id (media-svc syncHash), so an
         // address is the same page whatever tools it carries
         if (cur.kind === next.kind && cur.col === next.col && cur.id === next.id) return
-        history.pushState(null, '', `#${h}`)
+        if (this.walking && this.walked) history.replaceState(null, '', `#${h}`)
+        else history.pushState(null, '', `#${h}`)
+        this.walked = this.walking
     }
     /** one tree row, opened: an asset goes to the atelier, everything else to
      *  its own item card. A gate check has a page of its own now, so nothing

package/src/serve/hub-app/sidebar.tsx

@@ -3,7 +3,7 @@
 // whose rows under them are every resource of the repo. Only the tree
 // scrolls, so the filter stays in reach. The row itself is tree-row.tsx.
 import { observer } from 'mobx-react-lite'
-import { SEARCH_KEY } from './keys.ts'
+import { isTreeWalk, SEARCH_KEY } from './keys.ts'
 import type { RepoSt } from './repo-st.ts'
 import { TreeRowView } from './tree-row.tsx'
 
@@ -11,9 +11,9 @@ const Tree = observer(({ app }: { app: RepoSt }) => {
     const t = app.tree
     const empty = app.cols.loaded && app.filter !== 'all' && app.query.trim() === '' && t.visible.length === 0
     return (
-        // roving focus: the arrows belong to the tree only while it HAS the
-        // focus, so the atelier keeps its own keys
-        <div className="tree" tabIndex={0} onKeyDown={(e) => { if (t.key(e.key)) e.preventDefault() }}>
+        // the page's key handler drives it (hub-app.tsx), so the arrows need
+        // no focus here; the atelier consumes its own keys before that
+        <div className="tree">
             {t.rows.map((r) => <TreeRowView key={r.key} app={app} row={r} />)}
             {!app.cols.loaded && !app.cols.cached ? <div className="tempty twait"><span className="spin" />reading the repo…</div> : null}
             {empty ? <div className="tempty">{app.filter === 'red' ? 'no reds — nothing is blocked ✨' : 'nothing needs you ✨'}</div> : null}
@@ -46,7 +46,7 @@ export const Sidebar = observer(({ app }: { app: RepoSt }) => (
             <span className="sfield">
                 <input ref={(el) => { app.searchEl = el }} placeholder="filter" aria-label="filter the tree by name or path" value={app.query}
                     onChange={(e) => app.setQuery(e.target.value)}
-                    onKeyDown={(e) => { if (e.key === 'Escape') app.setQuery('') }} />
+                    onKeyDown={(e) => { if (e.key === 'Escape') app.setQuery(''); else if (isTreeWalk(e.key) && app.tree.key(e.key)) e.preventDefault() }} />
                 <kbd className="skey">{SEARCH_KEY}</kbd>
             </span>
             <SegFilter app={app} />

package/src/serve/hub-app/tree-build.ts

@@ -171,6 +171,7 @@ const groupOf = (r: Resource): Seg[] => {
     if (r.test != null) return []
     if (r.check != null || r.type === 'contract' || r.type === 'secret') return []
     if (r.type === 'ask') return isDone(r) ? [{ key: 'type:ask:done', label: 'done', kind: 'done', page: null }] : []
+    if (r.type === 'asset' && r.group != null) return [{ key: `cat:${r.group}`, label: r.group, kind: 'category', page: { t: 'cat', cat: r.group } }]
     if (r.type === 'wiki' || r.type === 'asset' || r.type === 'test' || r.type === 'process' || r.type === 'reflection') return []
     return [{ key: `type:${r.type}`, label: r.type, kind: r.type, page: { t: 'col', id: r.collection } }]
 }
@@ -381,6 +382,7 @@ export const TYPE_MARK: Record<string, TypeMark> = {
     ask: { glyph: '\u25c9', hue: 'k2', word: 'an ask: something only a human can do' },
     secret: { glyph: '\u25c8', hue: 'k4', word: 'a secret this repo needs, present or missing' },
     asset: { glyph: '\u25c6', hue: 'k1', word: 'an asset of the kit, with its rolls and its pick' },
+    category: { glyph: '\u25a6', hue: 'k1', word: 'a category of the kit: its page shows every asset in it' },
     post: { glyph: '\u25a4', hue: 'k2', word: 'a post waiting in the social queue' },
     workflow: { glyph: '\u29c9', hue: 'k6', word: 'a comfy workflow module' },
     wiki: { glyph: '\u2b21', hue: 'k3', word: 'a markdown wiki, opened as its link graph' },

package/src/serve/hub-app/tree-row.tsx

@@ -6,12 +6,21 @@
 // No row carries prose: the words (the duration too) are the tooltips and
 // the page it opens. A click opens, only the chevron folds.
 import { observer } from 'mobx-react-lite'
-import type { CSSProperties } from 'react'
+import { useEffect, useRef, type CSSProperties, type RefObject } from 'react'
 import { Icon, ICON } from './icons.tsx'
 import { sectionKeyLabel } from './keys.ts'
 import type { RepoSt } from './repo-st.ts'
 import { GLYPH, markOf, rowName, rowSlots, type TreeRow } from './tree-build.ts'
 
+/** the row under the cursor stays in sight while the arrows move it */
+const useInSight = (on: boolean): RefObject<HTMLDivElement | null> => {
+    const el = useRef<HTMLDivElement | null>(null)
+    useEffect(() => {
+        if (on) el.current?.scrollIntoView({ block: 'nearest' })
+    }, [on])
+    return el
+}
+
 /** the fold marker: a chevron, right when the branch is shut and down when
  *  it is open. The 9px triangle it replaces read as a dot with an opinion */
 export const Caret = ({ open }: { open: boolean }): React.ReactElement => (
@@ -34,8 +43,9 @@ export const SectionRowView = observer(({ app, row }: { app: RepoSt; row: TreeRo
     const id = row.section!
     const s = t.sections.find((x) => x.id === id)
     const key = s == null ? null : sectionKeyLabel(id)
+    const el = useInSight(t.cursor === row.key)
     return (
-        <div className={`tsec${s?.on === true ? ' cur' : ''}${t.cursor === row.key ? ' on' : ''}`} aria-current={s?.on === true ? 'page' : undefined}
+        <div ref={el} className={`tsec${s?.empty === true ? ' empty' : ''}${s?.opens === false ? ' noop' : ''}${s?.on === true ? ' cur' : ''}${t.cursor === row.key ? ' on' : ''}`} aria-current={s?.on === true ? 'page' : undefined}
             title={s == null ? row.label : `${s.title} (${key})`} onClick={() => t.click(row)}>
             <Fold app={app} row={row} />
             <Icon d={ICON[id]} />
@@ -46,16 +56,19 @@ export const SectionRowView = observer(({ app, row }: { app: RepoSt; row: TreeRo
     )
 })
 
-export const TreeRowView = observer(({ app, row }: { app: RepoSt; row: TreeRow }) => {
-    if (row.section != null) return <SectionRowView app={app} row={row} />
+export const TreeRowView = ({ app, row }: { app: RepoSt; row: TreeRow }): React.ReactElement =>
+    row.section != null ? <SectionRowView app={app} row={row} /> : <LeafRowView app={app} row={row} />
+
+const LeafRowView = observer(({ app, row }: { app: RepoSt; row: TreeRow }) => {
     const t = app.tree
     const u = app.checks
     const running = row.checks.some((id) => u.isRunning(id))
     const s = rowSlots(row, running)
     const mark = markOf(row.res, row.kind)
     const name = rowName(row)
+    const el = useInSight(t.cursor === row.key)
     return (
-        <div className={`trow${t.cursor === row.key ? ' on' : ''}`} style={{ '--d': row.depth } as CSSProperties}
+        <div ref={el} className={`trow${t.cursor === row.key ? ' on' : ''}`} style={{ '--d': row.depth } as CSSProperties}
             title={s.hint} onClick={() => t.click(row)}>
             <span className="tw" onClick={row.dir ? (e) => { e.stopPropagation(); t.fold(row) } : undefined}>
                 {row.dir ? <Caret open={t.isOpen(row.key)} /> : null}

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

@@ -150,12 +150,35 @@ export class TreeSvc {
         if (row.dir) this.toggle(row.key)
     }
 
+    /** where the arrows start: the cursor, else the section of the page shown */
+    private get from(): number {
+        const rows = this.rows
+        const i = rows.findIndex((r) => r.key === this.cursor)
+        if (i !== -1) return i
+        const on = this.sections.find((s) => s.on)?.id
+        return on == null ? -1 : rows.findIndex((r) => r.section === on)
+    }
+
+    /** an arrow lands on a row and opens its page at once. A branch with
+     *  nothing to open only takes the cursor: a fold is the chevron's job */
+    private land(row: TreeRow): void {
+        this.cursor = row.key
+        if (row.section != null || row.page != null || row.res != null) this.st.walk(() => this.activate(row))
+    }
+
+    /** a greyed section with no page: the arrows step over it */
+    private inert(row: TreeRow): boolean {
+        return row.section != null && this.sections.find((s) => s.id === row.section)?.opens === false
+    }
+
     move(d: number): void {
         const rows = this.rows
         if (rows.length === 0) return
-        const i = rows.findIndex((r) => r.key === this.cursor)
-        const next = i === -1 ? (d > 0 ? 0 : rows.length - 1) : Math.min(rows.length - 1, Math.max(0, i + d))
-        this.cursor = rows[next]!.key
+        const i = this.from
+        let next = i === -1 ? (d > 0 ? 0 : rows.length - 1) : i + d
+        while (next >= 0 && next < rows.length && this.inert(rows[next]!)) next += d
+        if (next < 0 || next >= rows.length || next === i) return
+        this.land(rows[next]!)
     }
     /** right descends: a folded row unfolds, anything else steps down */
     right(): void {
@@ -171,10 +194,7 @@ export class TreeSvc {
         const rows = this.rows
         const i = rows.findIndex((x) => x.key === r.key)
         for (let n = i - 1; n >= 0; n--) {
-            if (rows[n]!.depth < r.depth) {
-                this.cursor = rows[n]!.key
-                return
-            }
+            if (rows[n]!.depth < r.depth) return this.land(rows[n]!)
         }
     }
     enter(): void {

package/src/serve/hub-runtime.ts

@@ -202,7 +202,9 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
     // ONE way a run executes. In process for a hub of its own; as a detached
     // job in the daemon, which follows it: its lines and verdicts reach the
     // same taps, and a reload of the daemon leaves it running
-    const exec = async (kind: 'ci' | 'check', opts: Record<string, unknown>, tap: CheckTap, background: boolean): Promise<number> => {
+    const exec = async (kind: 'ci' | 'check', sent: Record<string, unknown>, tap: CheckTap, background: boolean): Promise<number> => {
+        // the switches a terminal set ride beside the options, into the job's env
+        const { env, ...opts } = sent as { env?: Record<string, string> }
         if (jobs == null) {
             const turn = background ? await takeSlot(autoGatePool(), { repo: c.name, check: 'auto gate' }, { pollMs: 250 }) : null
             try {
@@ -214,7 +216,7 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
         }
         // a job still running here, started before this image or by a terminal's --detach
         while (liveJobs(root).length > 0) await Bun.sleep(jobs.pollMs ?? 250)
-        const j = startJob(root, { cli: jobs.cli, kind, args: [], job: { opts, oneLib: true, turn: background } })
+        const j = startJob(root, { cli: jobs.cli, kind, args: [], job: { opts, oneLib: true, turn: background, ...(env == null ? {} : { env }) } })
         tap.job?.(j.id)
         return (await followJob(root, j.id, tap, { pollMs: jobs.pollMs })) ?? 1
     }

package/src/serve/project-gutter-route.ts

@@ -4,7 +4,8 @@
 // and the uncommitted count ask git only when a stat says a commit, a tag or
 // the index moved, a few repos per poll, and a repo's run record is opened
 // only when it moved, so a steady poll spawns ps and lsof and nothing else. The icon route
-// serves only the icon files a discovered repo carries, and POST
+// serves only the icon files a discovered repo carries, the app-icon route
+// draws the app icon (core/app-icon.ts) for the admin page's preview, and POST
 // /api/projects/open opens a discovered repo in VS Code, POST
 // /api/projects/fork in Fork: a request names a repo, never a path. The rail ORDER is one text file for the whole machine
 // (ORDER_FILE), so every hub shows the same order and a hand edit is seen
@@ -21,11 +22,14 @@ import {
 import { readLastStatusReadonly } from '../ledger/run-log.ts'
 import { identityOfText, identityProblem, type Identity } from '../core/identity-color.ts'
 import { writeIdentity } from '../core/identity.ts'
+import { appIconOf, appIconPngs, identityOfRoot } from '../core/app-icon.ts'
 import { writeArchived } from '../core/archived.ts'
 
 export type { Gate }
 
 export const POLL_MS = 5_000
+/** the app icon preview: sharp on a 2x screen at the admin page's 128px */
+const PREVIEW_PX = 256
 /** how long a release answer holds for a checkout whose `.git` is not a
  *  folder, since no stat can say when it moved */
 export const RELEASE_TTL_MS = 60_000
@@ -377,6 +381,23 @@ export function projectGutter(d: GutterDeps) {
                 headers: { 'content-type': ICON_TYPES[r.icon.split('.').pop()!] ?? 'application/octet-stream', 'cache-control': 'max-age=86400' },
             })
         }
+        if (path.startsWith('/api/projects/app-icon/')) {
+            if (repos.length === 0) await answer()
+            const r = findAny(decodeURIComponent(path.slice('/api/projects/app-icon/'.length)))
+            if (r == null) return new Response('not a house repo', { status: 404 })
+            const icon = appIconOf(r.path)
+            if (icon == null) return new Response('no png mark: the app wears the default icon', { status: 404 })
+            // the colours a picker is on right now, before they are saved; else the config's
+            const q = new URL(req.url).searchParams
+            const asked = { colorLight: q.get('light') ?? '', colorDark: q.get('dark') ?? '' }
+            const id = identityProblem(asked) == null ? asked : identityOfRoot(r.path)
+            try {
+                const [png] = await appIconPngs(await readFile(icon), id, [PREVIEW_PX])
+                return new Response(new Uint8Array(png!), { headers: { 'content-type': 'image/png', 'cache-control': 'max-age=60' } })
+            } catch (e) {
+                return new Response(`could not draw the icon from ${icon}: ${(e as Error).message}`, { status: 422 })
+            }
+        }
         if (path === '/api/projects/identity' && req.method === 'POST') {
             if (repos.length === 0) await answer()
             const b = (await req.json().catch(() => ({}))) as { name?: unknown; colorLight?: unknown; colorDark?: unknown }

package/src/suite/judge-suites.ts

@@ -294,6 +294,10 @@ export function aloneRunsNeeded(suspects: Timed[], parallelCpu: Record<string, P
     return { rerun, cleared }
 }
 
+/** the recap bun prints after the last file, "3 tests failed:", repeats
+ *  every (fail) line under no header of its own: it closes the last file */
+export const BUN_RECAP = /^\s*\d+ tests? failed:\s*$/
+
 /** the suites with a failing test, read off bun's report: a file that failed
  *  prints its path as a header line, then its `(fail)` lines under it. A
  *  passing file prints nothing at all in a piped run, which is why this reads
@@ -304,6 +308,7 @@ export function failedSuites(output: string): string[] {
     for (const line of output.split('\n')) {
         const head = line.match(/^(\S+\.(?:test|spec)\.[cm]?[jt]sx?):$/)
         if (head != null) { cur = normSuitePath(head[1]!); continue }
+        if (BUN_RECAP.test(line)) { cur = null; continue }
         // a file that cannot load prints no `(fail)` line, only this banner
         if (cur != null && (/^\(fail\) /.test(line) || line.startsWith('# Unhandled error between tests'))) out.add(cur)
     }
@@ -322,6 +327,7 @@ export function failLines(output: string): Map<string, string> {
         const line = raw.trimEnd()
         const head = line.match(/^(\S+\.(?:test|spec)\.[cm]?[jt]sx?):$/)
         if (head != null) { cur = normSuitePath(head[1]!); err = null; continue }
+        if (BUN_RECAP.test(line)) { cur = null; continue }
         if (cur == null || out.has(cur)) continue
         if (err == null && /^\s*error: /.test(line)) err = line.trim()
         const fail = line.match(/^\(fail\) (.*?)(?: \[[\d.]+m?s\])?$/)