rvlib-shipkit 1.4.0 → 1.6.0

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

@@ -1,17 +1,16 @@
-// The resource tree, as state: which tab, what is expanded, where the
-// keyboard cursor sits. The trie itself is pure (tree-build.ts) and cached
-// here as computeds. Everything hand tuned persists to localStorage as
-// newline separated paths, text encodable and hand editable, and comes back
-// on reopen.
+// The left pane's tree, as state: what is unfolded and where the keyboard
+// cursor sits. The trie itself is pure (tree-build.ts) and cached here as
+// computeds, its top rows the sections repo-sections.tsx draws. The folds
+// persist to localStorage as newline separated keys, text encodable and hand
+// editable, and come back on reopen. A live filter unfolds what matches
+// without touching them, so clearing it restores them.
 import { makeAutoObservable } from 'mobx'
 import type { RepoSt } from './repo-st.ts'
 import type { Resource } from './hub-types.ts'
-import { buildPathTree, buildTypeTree, dirKeys, flattenTree, whenCounts, type TreeNode, type TreeRow } from './tree-build.ts'
-
-export type TreeTab = 'path' | 'type'
+import { repoSections, type RepoSection } from './repo-sections.ts'
+import { buildTree, dirKeys, flattenTree, matchesQuery, passesFilter, processResources, whenCounts, type TreeNode, type TreeRow } from './tree-build.ts'
 
 const EXPANDED_KEY = 'shipkit.tree.expanded'
-const TAB_KEY = 'shipkit.tree.tab'
 
 // every access is guarded: a private window, blocked site data or a stale
 // origin throws on read AND on write, and a tree that cannot remember is
@@ -32,44 +31,68 @@ const writeStore = (k: string, v: string): void => {
 }
 
 export class TreeSvc {
-    tab: TreeTab = 'path'
     expanded = new Set<string>()
     /** the row key under the keyboard cursor */
     cursor: string | null = null
 
     constructor(private st: RepoSt) {
-        this.tab = readStore(TAB_KEY) === 'type' ? 'type' : 'path'
         for (const p of readStore(EXPANDED_KEY).split('\n')) if (p !== '') this.expanded.add(p)
         makeAutoObservable<this, 'st'>(this, { st: false })
     }
 
-    /** the filter and the search apply BEFORE the grouping, so a filtered
-     *  tree prunes to the branches that still hold something */
+    private get q(): string {
+        return this.st.query.trim().toLowerCase()
+    }
+
+    /** what the tree holds, filtered BEFORE the grouping so it prunes to the
+     *  branches that still hold something. A search names a thing to find,
+     *  so it reads every row: the severity group applies only while it is empty */
+    /** every row the tree can show: the hub's resources, then the repo's
+     *  global processes, which pm reports and the hub never lists */
+    private get all(): Resource[] {
+        return [...this.st.cols.resources, ...processResources(this.st.globalProcesses)]
+    }
+
     get visible(): Resource[] {
+        const all = this.all
+        if (this.q !== '') return all.filter((r) => matchesQuery(r, this.q))
         const f = this.st.filter
-        const q = this.st.query.trim().toLowerCase()
-        return this.st.cols.resources.filter((r) => {
-            // the filter reads the COLOUR, so what `red` shows is what reads
-            // red on the tree. An ask is proactive work, so it is in needs
-            // and never in red (collection-types stateOf owns that rule)
-            if (f === 'red' && r.state !== 'red') return false
-            if (f === 'needs' && r.severity == null) return false
-            if (q !== '' && !r.title.toLowerCase().includes(q) && !r.path.toLowerCase().includes(q)) return false
-            return true
-        })
+        return all.filter((r) => passesFilter(r, f))
+    }
+
+    /** rows the severity group keeps out of the tree, said under it so a
+     *  pruned tree never reads as a broken one */
+    get hidden(): number {
+        return this.q !== '' ? 0 : this.all.length - this.visible.length
+    }
+
+    /** the sections the pane draws, with their counts, keys and pages */
+    get sections(): RepoSection[] {
+        return repoSections(this.st)
     }
 
     get nodes(): TreeNode[] {
-        return this.tab === 'type' ? buildTypeTree(this.visible) : buildPathTree(this.visible)
+        const all = buildTree(this.sections.map((s) => s.id), this.visible)
+        // a search hides every section with nothing matching, unless its own
+        // name is what was typed
+        if (this.q === '') return all
+        return all.filter((n) => n.children.length > 0 || n.label.includes(this.q))
+    }
+
+    /** what is unfolded right now: a live search must SHOW its matches, so
+     *  the folds yield while it runs, and they are back once it is cleared */
+    get open(): Set<string> {
+        return this.q === '' ? this.expanded : new Set(dirKeys(this.nodes, false))
+    }
+    isOpen(key: string): boolean {
+        return this.open.has(key)
     }
 
     get rows(): TreeRow[] {
-        // a live search must SHOW its matches: folds yield while it runs
-        if (this.st.query.trim() !== '') return flattenTree(this.nodes, new Set(dirKeys(this.nodes, false)))
-        return flattenTree(this.nodes, this.expanded)
+        return flattenTree(this.nodes, this.open)
     }
 
-    /** the one line above the tree: what runs always and what does not */
+    /** the line at the top of the checks page: what runs always and what does not */
     get whenLine(): string {
         const c = whenCounts(this.st.cols.resources)
         const total = c.always + c.release + c.health + c.off
@@ -83,14 +106,8 @@ export class TreeSvc {
 
     private save(): void {
         writeStore(EXPANDED_KEY, [...this.expanded].join('\n'))
-        writeStore(TAB_KEY, this.tab)
     }
 
-    setTab(t: TreeTab): void {
-        this.tab = t
-        this.cursor = null
-        this.save()
-    }
     toggle(key: string): void {
         this.expanded.has(key) ? this.expanded.delete(key) : this.expanded.add(key)
         this.save()
@@ -111,14 +128,21 @@ export class TreeSvc {
         return this.rowAt(this.cursor)
     }
 
+    /** what a row opens: a section its page, a group with a page that page,
+     *  a leaf its own page. Only a row with nothing to open folds */
+    private activate(row: TreeRow): void {
+        const sec = row.section == null ? null : this.sections.find((s) => s.id === row.section)
+        if (sec != null) sec.go()
+        else if (row.page != null) this.st.go(row.page)
+        else if (row.res != null) this.st.openResource(row.res)
+        else if (row.dir) this.toggle(row.key)
+    }
+
     /** a row click is both a cursor move and the open: one click, one result.
-     *  A folder with a page of its own opens the page, and only its chevron
-     *  folds (fold): the one convention for a row that is both */
+     *  Only the chevron folds a row that opens something (fold) */
     click(row: TreeRow): void {
         this.cursor = row.key
-        if (row.page != null) this.st.go(row.page)
-        else if (row.dir) this.toggle(row.key)
-        else if (row.res != null) this.st.openResource(row.res)
+        this.activate(row)
     }
     /** the chevron: fold or unfold, never open */
     fold(row: TreeRow): void {
@@ -126,39 +150,56 @@ 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 collapsed directory opens, anything else steps down */
+    /** right descends: a folded row unfolds, anything else steps down */
     right(): void {
         const r = this.cur
-        if (r != null && r.dir && !this.expanded.has(r.key)) this.toggle(r.key)
+        if (r != null && r.dir && !this.isOpen(r.key)) this.toggle(r.key)
         else this.move(1)
     }
-    /** left ascends: an open directory closes, anything else climbs to its parent */
+    /** left ascends: an unfolded row folds, anything else climbs to its parent */
     left(): void {
         const r = this.cur
         if (r == null) return this.move(-1)
-        if (r.dir && this.expanded.has(r.key)) return this.toggle(r.key)
+        if (r.dir && this.isOpen(r.key)) return this.toggle(r.key)
         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]!)
         }
     }
-    open(): void {
+    enter(): void {
         const r = this.cur
-        if (r == null) return
-        if (r.page != null) this.st.go(r.page)
-        else if (r.dir) this.toggle(r.key)
-        else if (r.res != null) this.st.openResource(r.res)
+        if (r != null) this.activate(r)
     }
 
     /** true = the key was ours, so the page must not also scroll */
@@ -167,7 +208,7 @@ export class TreeSvc {
         else if (k === 'ArrowUp') this.move(-1)
         else if (k === 'ArrowRight') this.right()
         else if (k === 'ArrowLeft') this.left()
-        else if (k === 'Enter' || k === ' ') this.open()
+        else if (k === 'Enter' || k === ' ') this.enter()
         else return false
         return true
     }

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

@@ -0,0 +1,89 @@
+// A repo's when page: what runs when. The legend first (every context, every
+// value, what it means), then one row per check with its value on each axis,
+// read from the facts every check row already carries (core/runs-matrix.ts),
+// so the page reads nothing of its own and never disagrees with `shipkit when`.
+import { observer } from 'mobx-react-lite'
+import { useState } from 'react'
+import { MATRIX_AXES, RUNS_LEGEND, inColumn, type MatrixAxis } from '../../core/runs-matrix.ts'
+import type { RunsCells } from './hub-types.ts'
+import type { RepoSt } from './repo-st.ts'
+
+type Row = { id: string; title: string; cells: RunsCells; blocking: boolean | null; build: boolean }
+
+const shortOf = (k: MatrixAxis): string => RUNS_LEGEND.find((a) => a.axis === k)!.short
+
+const Legend = () => (
+    <table className="whlegend">
+        <tbody>
+            {RUNS_LEGEND.map((a) => (
+                <tr key={a.axis}>
+                    <td className="whaxis">{a.axis}</td>
+                    <td>
+                        <div>{a.context}</div>
+                        {a.values.map((v) => <div key={v.value} className="whval"><code>{v.value}</code> <span className="dim">{v.means}</span></div>)}
+                    </td>
+                </tr>
+            ))}
+        </tbody>
+    </table>
+)
+
+const Cell = ({ r, k }: { r: Row; k: MatrixAxis }) => {
+    const c = r.cells.cells[k]
+    return (
+        <td className={`whc${c.on ? ' on' : ''}`} title={`${k}: ${c.text} · from ${c.source}${r.cells.derivedWhy != null ? ` (${r.cells.derivedWhy})` : ''}`}>
+            {c.text}
+        </td>
+    )
+}
+
+export const WhenPage = observer(({ app }: { app: RepoSt }) => {
+    const [only, setOnly] = useState<MatrixAxis | null>(null)
+    const all: Row[] = app.cols.resources
+        .filter((r) => r.collection === 'checks' && r.check != null)
+        .map((r) => ({ id: r.check!.checkId, title: r.text, cells: r.check!.runs, blocking: r.check!.blocking, build: r.check!.build }))
+    const live = all.filter((r) => r.cells.off == null)
+    const off = all.filter((r) => r.cells.off != null)
+    const shown = only == null ? live : live.filter((r) => inColumn(r.cells, only))
+    return (
+        <div className="colcard checkcard whpage">
+            <div className="chead">
+                <span className="tid">when</span>
+                <h3 className="ctitle">what runs when</h3>
+            </div>
+            <div className="usays">every check declares every context, with no default. Click a column to see only what that context runs. `shipkit when` prints the same</div>
+            <section className="csec"><div className="cstitle">the legend</div><Legend /></section>
+            <section className="csec">
+                <div className="cstitle">{only == null ? `${live.length} checks` : `${shown.length} of ${live.length} checks run on ${only}`}{only != null ? <> · <a href="#" onClick={(e) => { e.preventDefault(); setOnly(null) }}>show all</a></> : null}</div>
+                <table className="whtable">
+                    <thead>
+                        <tr>
+                            <th>check</th>
+                            {MATRIX_AXES.map((k) => (
+                                <th key={k} className={only === k ? 'on' : ''} title={`${k}: ${RUNS_LEGEND.find((a) => a.axis === k)!.context}. Click: only what it runs (${live.filter((r) => inColumn(r.cells, k)).length})`} onClick={() => setOnly(only === k ? null : k)}>
+                                    {shortOf(k)} <span className="dim">{live.filter((r) => inColumn(r.cells, k)).length}</span>
+                                </th>
+                            ))}
+                            <th>cache</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {shown.map((r) => (
+                            <tr key={r.id}>
+                                <td className="whid"><a href="#" title={r.title} onClick={(e) => { e.preventDefault(); app.timeline.openCheck(r.id) }}>{r.id}</a>{r.build ? <span className="dim"> build</span> : r.blocking === false ? <span className="dim"> warns</span> : null}</td>
+                                {MATRIX_AXES.map((k) => <Cell key={k} r={r} k={k} />)}
+                                <td className="whcache dim" title={r.cells.cache}>{r.cells.cache}</td>
+                            </tr>
+                        ))}
+                    </tbody>
+                </table>
+            </section>
+            {off.length > 0 ? (
+                <section className="csec">
+                    <div className="cstitle">off in this repo ({off.length}): repo.config.ts `off`, or the check does not apply here</div>
+                    {off.map((r) => <div key={r.id} className="whoff"><span className="whid">{r.id}</span> <span className="dim">{r.cells.off}</span></div>)}
+                </section>
+            ) : null}
+        </div>
+    )
+})

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

@@ -0,0 +1,17 @@
+/* the when page (when-view.tsx): the legend, then the matrix. A cell that
+   runs is washed with the accent, a cell the repo moved carries a star, and
+   nothing here picks a colour of its own. */
+.whpage{font-size:13px}
+.whlegend{border-collapse:collapse;margin-bottom:var(--s2)}
+.whlegend td{vertical-align:top;padding:var(--s1) var(--s2);border-bottom:1px solid var(--line)}
+.whaxis{font-family:ui-monospace,monospace;color:var(--accent);white-space:nowrap}
+.whval{padding-left:var(--s3)}
+.whtable{border-collapse:collapse;width:100%}
+.whtable th{position:sticky;top:0;background:var(--panel);text-align:left;font-weight:500;padding:var(--s1) var(--s2);cursor:pointer;white-space:nowrap;border-bottom:1px solid var(--line)}
+.whtable th.on{color:var(--accent);border-bottom-color:var(--accent)}
+.whtable td{padding:var(--s0) var(--s2);border-bottom:1px solid var(--line);white-space:nowrap}
+.whc{color:var(--dim);font-family:ui-monospace,monospace}
+.whc.on{color:var(--ink);background:var(--wash2)}
+.whid{font-family:ui-monospace,monospace}
+.whcache{max-width:320px;overflow:hidden;text-overflow:ellipsis}
+.whoff{padding:var(--s0) var(--s2)}

package/src/serve/hub-runtime.ts

@@ -44,7 +44,6 @@ import { RUN_JOB } from '../home/home-words.ts'
 import { OtherRepos } from './other-repos.ts'
 import { HouseRuns } from './house-runs.ts'
 import { recordStamp } from './project-gutter.ts'
-import { RepoProcesses } from './repo-processes.ts'
 import { shapeTimeline } from '../ledger/run-timeline.ts'
 import { readSuiteRuns, readSuites } from '../ledger/suite-log.ts'
 import { shapeTestCheck, shapeTestsRoot } from '../collections/test-time.ts'
@@ -203,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 {
@@ -215,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
     }
@@ -333,7 +334,6 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
         root,
         name: c.name,
         uses: c.serve?.uses ?? [],
-        processes: new RepoProcesses(root, c.serve?.processes ?? []),
         port,
         graphs,
         studio,
@@ -443,10 +443,8 @@ export type HubRuntime = {
     ping: () => Promise<void>
     /** a run is in flight: a reload now would kill it */
     busy: () => boolean
-    /** everything this runtime started stops, and it leaves the plan. `procs`
-     *  also stops the repo's declared processes: a real stop of the hub,
-     *  never a process restart */
-    stop: (o?: { procs?: boolean }) => void
+    /** everything this runtime started stops, and it leaves the plan */
+    stop: () => void
 }
 
 export type LoadHubOpts = {
@@ -489,7 +487,6 @@ export async function loadHub(root: string, io: ServeIo, o: LoadHubOpts): Promis
         return ok
     }
     const handler = hubHandler(deps, { base: o.base, projects: o.projects })
-    const procs = deps.processes
     // tick failures are LOUD (the hub's own lines), never swallowed
     const ping = async (): Promise<void> => {
         if (deps.pingTick == null) return
@@ -519,13 +516,6 @@ export async function loadHub(root: string, io: ServeIo, o: LoadHubOpts): Promis
         // the answers a page waits on, computed now, one hub at a time
         // across the process, so a first visit reads them from memory
         warming = warming.then(() => handler.warm())
-        // the repo's own processes: the auto ones start, a restart adopts the
-        // ones still running from their pid records
-        void procs?.startAuto()
-        if (procs != null && procs.size > 0) {
-            const t = setInterval(() => void procs.tick(), 2_000)
-            live.push({ stop: () => clearInterval(t) })
-        }
         if (o.ownTimers) {
             // one tick now (the state file guarantees a restart never re-fires), then every minute
             void ping()
@@ -541,9 +531,8 @@ export async function loadHub(root: string, io: ServeIo, o: LoadHubOpts): Promis
         start,
         ping,
         busy: () => deps.busy?.() === true,
-        stop: (s) => {
+        stop: () => {
             for (const l of live.splice(0)) l.stop()
-            if (s?.procs === true) procs?.stopAll()
             handler.stop()
         },
     }

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/serve/run-serve.ts

@@ -142,7 +142,7 @@ export async function runServe(root: string, io: ServeIo, o?: { port?: number })
             stale.stop()
             clearInterval(planClock)
             plan.stop()
-            rt.stop({ procs: true })
+            rt.stop()
             hub.stop()
             process.exit(0)
         })

package/src/serve/serve-hub.ts

@@ -28,7 +28,6 @@ import type { HubProblems } from './hub-problems.ts'
 import hubIndex from './hub-app/index.html'
 import { homePort, homeUp } from '../home/home-paths.ts'
 import { RUN_EXIT } from '../home/home-words.ts'
-import type { RepoProcesses } from './repo-processes.ts'
 import { projectGutter } from './project-gutter-route.ts'
 import { sameOrigin } from './same-origin.ts'
 import { LAYOUT } from '../core/layout.ts'
@@ -54,8 +53,6 @@ export type HubDeps = {
     name: string
     /** the machine resources the repo declares in serve.uses */
     uses?: string[]
-    /** the long running processes the repo declares in serve.processes */
-    processes?: RepoProcesses
     /** a terminal's `shipkit ci` or `check`, run in this process; resolves to its exit code */
     runCli?: (kind: 'ci' | 'check', opts: Record<string, unknown>, print: (l: string) => void) => Promise<number>
     /** 0 = random (tests); real launches pass repo.config/default */
@@ -235,13 +232,6 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
                 })
                 return new Response(stream, { headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' } })
             }
-            if (path === '/api/processes.json') return Response.json({ processes: d.processes?.views() ?? [] })
-            if (path === '/api/processes/act' && req.method === 'POST') {
-                const b = (await req.json().catch(() => ({}))) as { id?: string; act?: string }
-                if (b.act !== 'start' && b.act !== 'stop' && b.act !== 'restart') return new Response('act must be start, stop or restart', { status: 400 })
-                const v = d.processes?.act(b.id ?? '', b.act)
-                return v == null ? new Response(`no process '${b.id ?? ''}' in serve.processes`, { status: 404 }) : Response.json(v)
-            }
             // the three surfaces built on the config read the config on disk
             if (path === '/api/needs.json' || path === '/api/resources.json' || path === '/api/checks.json' || path === '/api/collections.json') await d.refresh?.()
             if (path === '/api/needs.json') {
@@ -249,9 +239,9 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
                 return Response.json({ needs })
             }
             if (path === '/api/resources.json') {
-                // ONE flat list for the whole repo: the page groups it by
-                // path and by type, and a second endpoint would be a second
-                // answer to drift from this one
+                // ONE flat list for the whole repo: the page groups it
+                // under its sections, and a second endpoint would be a
+                // second answer to drift from this one
                 const r = await rows.get({ fresh: fresh(req) })
                 return Response.json({
                     collections: r.collections,
@@ -377,7 +367,7 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
                 if (req.method === 'POST') {
                     try {
                         const body = (await req.json()) as GateEdit & { expect?: string }
-                        const b = await writeGateBlock(d.root, { when: body.when, slow: body.slow, slowRemove: body.slowRemove, words: body.words }, { expect: body.expect })
+                        const b = await writeGateBlock(d.root, { off: body.off, slow: body.slow, slowRemove: body.slowRemove, words: body.words }, { expect: body.expect })
                         await d.refresh?.()
                         return Response.json({ ...b, dirty: configDirty(d.root) })
                     } catch (e) {

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\])?$/)