rvlib-shipkit 1.4.0 → 1.5.0

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

@@ -1,9 +1,14 @@
-// ONE ROW of the resource tree: a fixed grid of caret, kind, label, duration,
-// note and state glyph. The indent rides in the first column, the label eats
-// the slack, and the glyph is LAST so the wide duration column never pushes it
-// around. No row carries prose: the words are the tooltip and the page it opens.
+// ONE ROW of the left pane's tree. A section row (the top level) is drawn as
+// the project list draws its lines: caret, icon, label, count, ⌥ key, the
+// current one lit. Every row under it is a fixed grid of caret, kind, label,
+// duration clock, note and state glyph. The indent rides in the first
+// column, the label eats the slack, and the glyph is LAST, on the right edge.
+// 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 { 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'
 
@@ -15,24 +20,49 @@ export const Caret = ({ open }: { open: boolean }): React.ReactElement => (
     </svg>
 )
 
+/** the chevron's own hit target: it folds, and the click never reaches the row */
+const Fold = observer(({ app, row }: { app: RepoSt; row: TreeRow }) => (
+    <span className="tw" onClick={row.dir ? (e) => { e.stopPropagation(); app.tree.fold(row) } : undefined}>
+        {row.dir ? <Caret open={app.tree.isOpen(row.key)} /> : null}
+    </span>
+))
+
+/** a top row: a section of the repo. A section no page backs (a kind whose
+ *  own section this repo does not draw) still gets its row, with no key */
+export const SectionRowView = observer(({ app, row }: { app: RepoSt; row: TreeRow }) => {
+    const t = app.tree
+    const id = row.section!
+    const s = t.sections.find((x) => x.id === id)
+    const key = s == null ? null : sectionKeyLabel(id)
+    return (
+        <div className={`tsec${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]} />
+            <span className="rsecl">{s?.label ?? row.label}</span>
+            {s?.count == null ? null : <b className={`rsecn n${s.tone}`}>{s.count}</b>}
+            {key == null ? null : <kbd className="pjkey">{key}</kbd>}
+        </div>
+    )
+})
+
 export const TreeRowView = observer(({ app, row }: { app: RepoSt; row: TreeRow }) => {
+    if (row.section != null) return <SectionRowView app={app} row={row} />
     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.dir, row.kind)
+    const mark = markOf(row.res, row.kind)
     const name = rowName(row)
     return (
         <div className={`trow${t.cursor === row.key ? ' on' : ''}`} style={{ '--d': row.depth } as CSSProperties}
             title={s.hint} onClick={() => t.click(row)}>
-            {/* the chevron folds, the rest of the row opens: on a folder with a
-                page of its own the two differ, everywhere else both fold */}
             <span className="tw" onClick={row.dir ? (e) => { e.stopPropagation(); t.fold(row) } : undefined}>
-                {row.dir ? <Caret open={t.expanded.has(row.key)} /> : null}
+                {row.dir ? <Caret open={t.isOpen(row.key)} /> : null}
             </span>
             <span className={`ty ${mark.hue}`} title={mark.word}>{mark.glyph}</span>
             <span className={`tl ${row.state}`}>{name.tag == null ? null : <span className="tid">{name.tag}</span>}{name.title}</span>
-            <span className={`tdur ${s.durTone ?? ''}`}>{s.dur}</span>
+            <span className={`tdur ${s.durTone ?? ''}`} title={s.dur === '' ? undefined : s.dur}>{s.dur === '' ? null : <Icon d={ICON.clock} />}</span>
             <span className="tnote">
                 {s.count == null ? s.note : <>{s.count.reds > 0 ? <b>{s.count.reds}</b> : null} {s.count.total}</>}
             </span>

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 {
@@ -133,17 +157,17 @@ export class TreeSvc {
         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
     }
-    /** 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--) {
@@ -153,12 +177,9 @@ export class TreeSvc {
             }
         }
     }
-    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 +188,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'
@@ -333,7 +332,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 +441,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 +485,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 +514,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 +529,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/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/serve/hub-app/processes-svc.ts

@@ -1,63 +0,0 @@
-// the repo's declared processes (serve.processes) as the hub supervises them,
-// polled while its repo is the one shown. A repo that declares none never
-// polls again after the first answer.
-import { makeAutoObservable, observableRef, runInAction } from 'mobx'
-import type { ProcessView } from '../repo-processes.ts'
-import type { RepoSt } from './repo-st.ts'
-
-export const PROCESSES_POLL_MS = 2_000
-
-export class ProcessesSvc {
-    list: ProcessView[] = []
-    error = ''
-    private timer: ReturnType<typeof setTimeout> | null = null
-    /** bumped by stop, so a chain that left before it dies at its next await */
-    private gen = 0
-    private polling = false
-
-    constructor(private st: RepoSt) {
-        makeAutoObservable<this, 'st' | 'timer' | 'gen' | 'polling'>(this, { st: false, timer: false, gen: false, polling: false, list: observableRef })
-    }
-
-    start(): void {
-        if (this.polling) return
-        this.polling = true
-        const gen = ++this.gen
-        const tick = async (): Promise<void> => {
-            await this.load()
-            if (gen === this.gen && this.list.length > 0) this.timer = setTimeout(() => void tick(), PROCESSES_POLL_MS)
-        }
-        void tick()
-    }
-
-    stop(): void {
-        this.polling = false
-        this.gen++
-        if (this.timer != null) clearTimeout(this.timer)
-        this.timer = null
-    }
-
-    async load(): Promise<void> {
-        try {
-            const r = await fetch(this.st.url('/api/processes.json'))
-            if (!r.ok) throw new Error(`${r.status} ${await r.text()}`)
-            const j = (await r.json()) as { processes: ProcessView[] }
-            runInAction(() => {
-                this.list = j.processes
-                this.error = ''
-            })
-        } catch (e) {
-            runInAction(() => { this.error = `processes: ${(e as Error).message}` })
-        }
-    }
-
-    async act(id: string, act: 'start' | 'stop' | 'restart'): Promise<void> {
-        try {
-            const r = await fetch(this.st.url('/api/processes/act'), { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ id, act }) })
-            if (!r.ok) throw new Error(await r.text())
-            await this.load()
-        } catch (e) {
-            runInAction(() => { this.error = `${act} ${id}: ${(e as Error).message}` })
-        }
-    }
-}

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

@@ -1,61 +0,0 @@
-// A repo page's sections: the pages reached for most, one line each at the top
-// of the left pane, over the tree, drawn 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 line. The lines come from what the page already holds (the kept
-// screen on a reload), so none arrives late and moves the tree.
-import { observer } from 'mobx-react-lite'
-import { RUNS_ID } from '../../collections/collection-types.ts'
-import { Icon, ICON } from './icons.tsx'
-import { sectionKeyLabel, type SectionId } from './keys.ts'
-import type { RepoSt } from './repo-st.ts'
-import { openWikis, WIKIS } from './wikis-view.tsx'
-
-export type RepoSection = {
-    id: SectionId
-    label: string
-    title: string
-    /** null when a number would say nothing */
-    count: number | null
-    tone: 'red' | 'warn' | null
-    on: boolean
-    go: () => void
-}
-
-const counted = (n: number, tone: 'red' | 'warn'): Pick<RepoSection, 'count' | 'tone'> => (n === 0 ? { count: null, tone: null } : { count: n, tone })
-
-export function repoSections(app: RepoSt): RepoSection[] {
-    const has = (col: string): boolean => app.cols.colMeta.some((c) => c.id === col)
-    const sel = app.sel
-    const onCol = (col: string): boolean => (sel?.t === 'col' && sel.id === col) || (sel?.t === 'item' && sel.col === col)
-    const res = app.cols.resources
-    const reds = (col: string): number => res.filter((r) => r.collection === col && r.state === 'red').length
-    const none = { count: null, tone: null }
-    const out: RepoSection[] = []
-    if (has('checks')) out.push({ id: 'checks', label: 'checks', title: 'every check the gate and the health pass run, one page each', ...counted(reds('checks'), 'red'), on: onCol('checks'), go: () => app.showCol('checks') })
-    // a page, never a resource: every hub keeps a run record
-    out.push({ id: 'runs', label: 'runs', title: 'every run on record, the slowest checks and the longest runs', ...none, on: onCol('runs'), go: () => app.cols.select('runs', RUNS_ID) })
-    if (has('asks')) {
-        const open = res.filter((r) => r.collection === 'asks' && r.type === 'ask' && r.slot !== 'done').length
-        out.push({ id: 'asks', label: 'asks', title: 'what waits on a human', ...counted(open, 'warn'), on: onCol('asks'), go: () => app.showCol('asks') })
-    }
-    if (has('tests')) out.push({ id: 'tests', label: 'tests', title: 'every test file, slowest first, then each test check', ...counted(reds('tests'), 'red'), on: sel?.t === 'tests' || onCol('tests'), go: () => app.showTests(null) })
-    const firstCat = app.media.assets[0]?.cat ?? app.cols.cachedCat ?? undefined
-    if (firstCat != null) out.push({ id: 'media', label: 'media', title: 'the assets, in the atelier', ...none, on: sel?.t === 'asset' || sel?.t === 'cat', go: () => app.showCat(firstCat) })
-    if (has(WIKIS)) out.push({ id: 'wikis', label: 'wikis', title: 'every wiki this repo mounts, as a link graph', ...none, on: onCol(WIKIS), go: () => openWikis(app) })
-    if (app.home.machine != null) out.push({ id: 'admin', label: 'admin', title: 'reload the hub, keep the repo active, archive it', ...none, on: sel?.t === 'admin', go: () => app.showAdmin() })
-    return out
-}
-
-export const Sections = observer(({ app }: { app: RepoSt }) => (
-    <nav className="rsecs" aria-label="sections">
-        {repoSections(app).map((s) => (
-            <button key={s.id} className={`rsec${s.on ? ' cur' : ''}`} aria-current={s.on ? 'page' : undefined} title={`${s.title} (${sectionKeyLabel(s.id)})`} onClick={s.go}>
-                <Icon d={ICON[s.id]} />
-                <span className="rsecl">{s.label}</span>
-                {s.count == null ? null : <b className={`rsecn n${s.tone}`}>{s.count}</b>}
-                <kbd className="pjkey">{sectionKeyLabel(s.id)}</kbd>
-            </button>
-        ))}
-    </nav>
-))