rvlib-shipkit 1.3.0 → 1.5.0

package/src/suite/judge-suites.ts

@@ -18,7 +18,7 @@ export type SerialSuite = {
     why: string
 }
 export type TestsConfig = {
-    /** per suite time in the quick tier (default 2000). A suite whose wall time goes over it under the parallel run is run again alone, and fails when that run burns more CPU than this, or waits more than twice this while the machine is idle. A suite whose CPU inside the parallel run, children included, plus all its worker burned before it stays under it skips that run, unless it may wait on an idle machine or ended with a child not yet reaped. The full tier fails nothing on time */
+    /** per suite time in the quick tier (default 2000). A suite whose wall time goes over it under the parallel run is run again alone, and fails when the smaller of its CPU and its wall passes this, grown with the load share by up to half, or when its wall passes twice this, an allowance that grows with the square of the load share and has no end on a saturated machine. A suite whose CPU inside the parallel run, children included, plus all its worker burned before it stays under it skips that run, unless its wall is past that allowance or it ended with a child not yet reaped. The full tier fails nothing on time */
     budgetMs?: number
     /** suites that break the budget on purpose: the full tier runs them, the quick tier does not */
     slow?: SlowSuite[]
@@ -190,32 +190,58 @@ export const WAIT_FACTOR = 2
 /** how much more CPU the same suite burns on a saturated machine. CPU time is
  *  not load free: measured on 8 cores, one suite went from 1.0s of CPU idle to
  *  1.35 to 1.5s with the cores saturated (load 7 to 19), and did not grow past
- *  that. So a loaded machine fails a suite past the budget times this */
+ *  that. So the CPU allowance grows with the load share up to this factor */
 export const LOADED_CPU_FACTOR = 1.5
+
+/** how much of the machine the other processes took, 0 idle to 1 saturated:
+ *  the one load measure every verdict here reads, so no verdict has a step */
+export const loadShare = (load: MachineLoad): number => (load.cores > 0 ? Math.min(1, Math.max(0, load.load1 / load.cores)) : 0)
+/** the CPU a suite may burn at this load: the budget, plus the measured
+ *  inflation in proportion to how saturated the machine is */
+export const cpuAllowance = (budgetMs: number, load: MachineLoad): number => budgetMs * (1 + (LOADED_CPU_FACTOR - 1) * loadShare(load))
+/** the wall a suite may take before it reads as a WAIT: WAIT_FACTOR times
+ *  the budget on an idle machine, grown with the square of the load share,
+ *  and without end once the machine is saturated. A wall on a busy machine
+ *  is the machine's (measured: 11 to 19s for suites burning 1s of CPU at
+ *  load 20.5 on 8 cores, far past any fair share), so only a quiet machine
+ *  can show a suite that sleeps; the ramp keeps the verdict continuous */
+export const waitAllowance = (budgetMs: number, load: MachineLoad): number => {
+    const free = 1 - loadShare(load) ** 2
+    return free <= 0 ? Infinity : (budgetMs * WAIT_FACTOR) / free
+}
 /** `ms` is the time the verdict used: cpu, or wall for a wait or when no cpu figure exists */
 export type Confirmed = { file: string; ms: number; wallMs: number; cpuMs: number | null; over: 'cpu' | 'wait' | 'wall' | null }
 
-/** the verdict on each suspect once it ran alone. A wall time carries the load
- *  of every other process on the machine, and another gate can triple it, so
- *  the budget judges CPU: what the suite itself burned, which load moves by
- *  a bounded factor only (LOADED_CPU_FACTOR). Wall time still fails a suite
- *  far over the budget while the machine was idle, because only then is the
- *  wait the suite's own */
+/** the verdict on each suspect once it ran alone, continuous in the load.
+ *  A wall time carries the load of every other process on the machine, so
+ *  the budget judges CPU, against an allowance that grows with the load share
+ *  (cpuAllowance). A suite is charged the SMALLER of its CPU and its wall:
+ *  JS runs on one thread, so CPU above the wall is bun's GC and JIT threads
+ *  or children running side by side, time nobody waits on. A wall past its
+ *  wait allowance fails as a wait (waitAllowance), never on a busy machine */
 export function confirmOver(suspects: Timed[], alone: Record<string, AloneRun>, budgetMs: number, load: MachineLoad): { over: Confirmed[]; cleared: Confirmed[] } {
     const byFile = new Map(Object.entries(alone).map(([f, run]) => [normSuitePath(f), run]))
-    const idle = load.load1 < load.cores
     const judged = suspects.map((t): Confirmed => {
         const run = byFile.get(t.file)
         const wallMs = run?.wallMs ?? t.ms
         const cpuMs = run?.cpuMs ?? null
         if (cpuMs == null) return { file: t.file, ms: wallMs, wallMs, cpuMs, over: wallMs > budgetMs ? 'wall' : null }
-        if (cpuMs > budgetMs * (idle ? 1 : LOADED_CPU_FACTOR)) return { file: t.file, ms: cpuMs, wallMs, cpuMs, over: 'cpu' }
-        if (idle && wallMs > budgetMs * WAIT_FACTOR) return { file: t.file, ms: wallMs, wallMs, cpuMs, over: 'wait' }
-        return { file: t.file, ms: cpuMs, wallMs, cpuMs, over: null }
+        const charged = Math.min(cpuMs, wallMs)
+        if (charged > cpuAllowance(budgetMs, load)) return { file: t.file, ms: charged, wallMs, cpuMs, over: 'cpu' }
+        if (wallMs > waitAllowance(budgetMs, load)) return { file: t.file, ms: wallMs, wallMs, cpuMs, over: 'wait' }
+        return { file: t.file, ms: charged, wallMs, cpuMs, over: null }
     })
     return { over: judged.filter((c) => c.over != null), cleared: judged.filter((c) => c.over == null) }
 }
 
+const secs = (ms: number): string => `${(ms / 1000).toFixed(1)}s`
+
+/** the line a confirmed suite fails with */
+export const overWords = (c: Confirmed, load: MachineLoad, budgetMs: number = DEFAULT_BUDGET_MS): string =>
+    c.over === 'cpu' ? `${c.file} ${secs(c.cpuMs ?? c.ms)} of CPU (${secs(c.wallMs)} wall)`
+        : c.over === 'wait' ? `${c.file} ${secs(c.wallMs)} wall at load ${load.load1.toFixed(1)} on ${load.cores} cores, past its ${secs(waitAllowance(budgetMs, load))} wait allowance, with ${secs(c.cpuMs ?? 0)} of CPU: it waits (a timer, a sleep, a poll)`
+            : `${c.file} ${secs(c.wallMs)} wall (no CPU figure)`
+
 /** how the parallel phase's workers hand the runner the CPU of each suite
  *  (suite-cpu-preload.ts writes it, readPhaseCpu reads it) */
 export const SUITE_CPU_ENV = 'SHIPKIT_SUITE_CPU'
@@ -253,16 +279,15 @@ export function readPhaseCpu(text: string, cwd: string): { ran: string[]; cpu: R
  *  what the worker computed by the suite's end, its whole CPU before the
  *  suite (priorMs) plus what the suite burned, and sharing the machine only
  *  raises CPU, so a suspect whose sum is inside the budget is inside it alone
- *  too. A suspect with no figure (a child not yet reaped) runs alone. Only the alone run can see a WAIT, so a
- *  suite past WAIT_FACTOR times the budget in wall time still gets it while
- *  the machine is idle */
+ *  too. A suspect with no figure (a child not yet reaped) runs alone. Only the
+ *  alone run can see a WAIT, so a suite whose wall is past its wait
+ *  allowance still gets it */
 export function aloneRunsNeeded(suspects: Timed[], parallelCpu: Record<string, PhaseCpu>, budgetMs: number, load: MachineLoad): { rerun: Timed[]; cleared: Confirmed[] } {
-    const idle = load.load1 < load.cores
     const rerun: Timed[] = []
     const cleared: Confirmed[] = []
     for (const t of suspects) {
         const f = parallelCpu[t.file]
-        const mayWait = idle && t.ms > budgetMs * WAIT_FACTOR
+        const mayWait = t.ms > waitAllowance(budgetMs, load)
         if (f != null && f.cpuMs + f.priorMs <= budgetMs && !mayWait) cleared.push({ file: t.file, ms: f.cpuMs, wallMs: t.ms, cpuMs: f.cpuMs, over: null })
         else rerun.push(t)
     }

package/src/suite/suite-cli.ts

@@ -16,7 +16,7 @@ import { killTree } from '../core/spawn-timeout.ts'
 import { parallelCap } from '../core/parallel.ts'
 import { poolDir, poolOccupancy } from '../core/slots.ts'
 import { keepTimings, seedTimings, timingsHome } from './kept-timings.ts'
-import { aloneRunsNeeded, bunfigTest, readPhaseCpu, SUITE_CPU_ENV, type AloneRun, type Confirmed, confirmOver, crashedWorkers, WAIT_FACTOR, DEFAULT_BUDGET_MS, FULL_CEILING_MS, failedSuites, failLines, judgeSuites, normSuitePath, parseSuiteFlags, planPhases, QUICK_CEILING_MS, poolWorkers } from './judge-suites.ts'
+import { aloneRunsNeeded, bunfigTest, readPhaseCpu, SUITE_CPU_ENV, type AloneRun, type Confirmed, confirmOver, crashedWorkers, overWords, DEFAULT_BUDGET_MS, FULL_CEILING_MS, failedSuites, failLines, judgeSuites, normSuitePath, parseSuiteFlags, planPhases, QUICK_CEILING_MS, poolWorkers } from './judge-suites.ts'
 
 type Phase = { code: number; signal: string | null; stalled: boolean; out: string; timings: Record<string, number>; cpuMs: number | null }
 
@@ -63,11 +63,6 @@ const CPU_PRELOAD = join(import.meta.dir, 'suite-cpu-preload.ts')
 
 const secs = (ms: number): string => `${(ms / 1000).toFixed(1)}s`
 
-const overWords = (c: Confirmed): string =>
-    c.over === 'cpu' ? `${c.file} ${secs(c.ms)} of CPU (${secs(c.wallMs)} wall)`
-        : c.over === 'wait' ? `${c.file} ${secs(c.wallMs)} wall on an idle machine, more than ${WAIT_FACTOR}x the budget, with ${secs(c.cpuMs ?? 0)} of CPU: it waits (a timer, a sleep, a poll)`
-            : `${c.file} ${secs(c.wallMs)} wall (no CPU figure)`
-
 /** the suite FILES a phase names: a flag is not a file, and the repo's own
  *  `bun test` arguments are not files this runner put there */
 const phaseFiles = (phase: string[], rawArgs: string[]): string[] => phase.filter((a) => !a.startsWith('-') && !rawArgs.includes(a))
@@ -117,6 +112,9 @@ export async function suiteCli(argv: string[]): Promise<number> {
         const kept = timed && parallel ? timingsHome(process.cwd(), unit) : null
         if (kept != null) seedTimings(kept, join(dir, 'parallel.json'))
         const cpuFile = timed && parallel ? join(dir, 'cpu.tsv') : null
+        // the load BEFORE this run: read after it, the one minute average
+        // carries this run's own parallel phase, which is no other process
+        const load = machineLoad()
         const p1At = Date.now()
         const p1 = await runPhase(plan.parallel, timed ? join(dir, 'parallel.json') : null, ceilingMs, tmp, true, cpuFile)
         const p1Ms = Date.now() - p1At
@@ -148,7 +146,6 @@ export async function suiteCli(argv: string[]): Promise<number> {
         // before it can fail the task. One at a time: four alone runs side by
         // side each burned about 40% more CPU than one alone (8 cores)
         const aloneRuns: Record<string, AloneRun> = {}
-        const load = machineLoad()
         const parallelCpu = phaseCpu.cpu
         const { rerun, cleared: clearedInPhase } = aloneRunsNeeded(judged.over, parallelCpu, budget, load)
         const aloneAt = Date.now()
@@ -224,7 +221,7 @@ export async function suiteCli(argv: string[]): Promise<number> {
             ...(!vacuous && (failedTests > 0 || (phases.some((p) => p.code !== 0 && p.signal == null) && killed.length === 0))
                 ? [`FAIL: ${failedTests} test(s) failed, Ran ${ran} tests${slowest}`] : []),
             ...(over.length > 0
-                ? [`FAIL: ${over.length} suite(s) over the ${budget}ms budget: ${over.map(overWords).join(', ')} (run alone, load ${load.load1.toFixed(1)} on ${load.cores} cores). Make each fast, or declare it in ${declaredIn}.slow with what it catches and why it cannot be fast`]
+                ? [`FAIL: ${over.length} suite(s) over the ${budget}ms budget: ${over.map((c) => overWords(c, load, budget)).join(', ')} (run alone, load ${load.load1.toFixed(1)} on ${load.cores} cores before the run). Make each fast, or declare it in ${declaredIn}.slow with what it catches and why it cannot be fast`]
                 : []),
         ]
         // the most actionable failure prints LAST, where the gate reads its headline

package/src/wiki/lint-md.ts

@@ -6,6 +6,7 @@ import { scanMd, type MdDanglingRef, type ScanMdConfig } from 'rvlib-shipkit/src
 export type MdLintReport = {
     index: string | null // resolved entrypoint (null = neither index.md nor README.md found)
     files: number
+    pages: string[] // every scanned .md file, scan-root relative
     orphans: string[] // .md files with no path from the entrypoint
     dangling: MdDanglingRef[] // refs whose target does not exist in the scan
     ok: boolean
@@ -17,6 +18,7 @@ export function lintMd(cfg: ScanMdConfig): MdLintReport {
     return {
         index: scan.index,
         files: scan.graph.nodes.length,
+        pages: scan.graph.nodes.map((n) => n.id),
         orphans,
         dangling: scan.dangling,
         ok: scan.index != null && orphans.length === 0 && scan.dangling.length === 0,

package/src/wiki/scan-md.ts

@@ -4,10 +4,14 @@
 //   → path.md          lazy  — resolved from the scan root, then file-relative
 //   [text](path.md)    lazy  — file-relative
 //   `path.md`          lazy  — file-relative, then from the scan root
+//   [text](dir/)       lazy  — a folder: an edge to every page under it
+//   `dir/`             lazy  — the same, from a backtick mention
+// A ref that leaves the scan root but stays under `boundary` is checked on
+// disk: no edge, and dangling only when the target is really missing.
 // Depth = 0-1 BFS from the index (eager edge keeps depth, lazy adds 1);
 // unreachable files stay in the graph with no depth (lint-md.ts turns those,
 // plus dangling refs, into failures — the graph itself is a viewer).
-import { readdirSync, readFileSync, statSync } from 'fs'
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { basename, dirname, join, relative, resolve } from 'path'
 import type { MdEdge, MdGraph, MdNode } from 'rvlib-shipkit/src/wiki/md-graph.ts'
 
@@ -15,6 +19,7 @@ export type ScanMdConfig = {
     root: string // absolute dir to scan
     index?: string // root-relative entry the BFS starts from (default: index.md AND README.md, both)
     skipDirs?: string[] // dir names to skip on top of node_modules/.git/dist/tmp
+    boundary?: string // absolute dir enclosing root (a repo): refs leaving root but staying here resolve on disk
 }
 
 export type MdDanglingRef = { from: string; token: string } // an @/→/[](…) ref whose target is not in the scan
@@ -46,13 +51,33 @@ export function scanMd(cfg: ScanMdConfig): MdScan {
     // writers inside a scanned dir often name paths from the REPO root
     // ("agent/architecture.md" while scanning agent/) — accept that form too
     const rootBase = `${basename(cfg.root)}/`
-    const resolveRef = (fromRel: string, token: string): string | null => {
-        const cands = [resolve(join(cfg.root, dirname(fromRel)), token), resolve(cfg.root, token)]
-        if (token.startsWith(rootBase)) cands.push(resolve(cfg.root, token.slice(rootBase.length)))
-        for (const cand of cands) {
+    const cands = (fromRel: string, token: string): string[] => {
+        const out = [resolve(join(cfg.root, dirname(fromRel)), token), resolve(cfg.root, token)]
+        if (token.startsWith(rootBase)) out.push(resolve(cfg.root, token.slice(rootBase.length)))
+        return out
+    }
+    // pages a ref reaches: one file, every page under a folder (never the
+    // root itself), or none. `onDisk` = the target exists in the boundary
+    // outside the scan, which is resolved but carries no edge.
+    type Hit = { to: string[]; onDisk: boolean }
+    const resolveRef = (fromRel: string, token: string): Hit | null => {
+        const folder = token.endsWith('/')
+        for (const cand of cands(fromRel, token)) {
             const rel = relative(cfg.root, cand)
-            if (!rel.startsWith('..') && inGraph.has(rel)) return rel
+            if (rel.startsWith('..')) continue
+            if (!folder && inGraph.has(rel)) return { to: [rel], onDisk: false }
+            if (folder && rel === '') return { to: [], onDisk: false }
+            if (folder) {
+                const under = files.filter((f) => f.startsWith(`${rel}/`))
+                if (under.length > 0) return { to: under, onDisk: false }
+                if (existsSync(cand)) return { to: [], onDisk: true }
+            }
         }
+        if (cfg.boundary == null) return null
+        const cand = resolve(join(cfg.root, dirname(fromRel)), token)
+        const inRoot = !relative(cfg.root, cand).startsWith('..')
+        const inBoundary = !relative(cfg.boundary, cand).startsWith('..')
+        if (!inRoot && inBoundary && existsSync(cand)) return { to: [], onDisk: true }
         return null
     }
     const edgesOf = (rel: string): MdEdge[] => {
@@ -64,14 +89,16 @@ export function scanMd(cfg: ScanMdConfig): MdScan {
         // strict: @/→/[](…) are deliberate wiki refs — a miss is a dangling ref.
         // Backtick spans mention paths casually (other repos, deleted examples) — resolve or ignore, never fail.
         const push = (token: string, eager: boolean, strict: boolean) => {
-            const to = resolveRef(rel, token)
-            if (to != null && to !== rel) out.push({ from: rel, to, eager })
-            else if (to == null && strict) dangling.push({ from: rel, token })
+            const hit = resolveRef(rel, token)
+            if (hit == null) { if (strict) dangling.push({ from: rel, token }); return }
+            for (const to of hit.to) if (to !== rel) out.push({ from: rel, to, eager })
         }
-        for (const m of prose.matchAll(/(?:^|[\s(])@([\w][\w./-]*\.md)/gm)) push(m[1]!, true, true)
+        for (const m of prose.matchAll(/(?:^|[\s(])@((?:\.{1,2}\/)*[\w][\w./-]*\.md)/gm)) push(m[1]!, true, true)
         for (const m of prose.matchAll(/→\s*([\w][\w./-]*\.md)\b/g)) push(m[1]!, false, true)
         for (const m of prose.matchAll(/\]\(([^)\s:]+\.md)\)/g)) push(m[1]!, false, true)
+        for (const m of prose.matchAll(/\]\(([^)\s:]*\/)\)/g)) push(m[1]!, false, true)
         for (const s of spans) for (const m of s.matchAll(/[\w][\w./-]*\.md/g)) push(m[0], false, false)
+        for (const s of spans) for (const m of s.matchAll(/(?:^|\s)([\w.][\w./-]*\/)(?=$|[\s<*])/g)) push(m[1]!, false, false)
         return out
     }
     const dangling: MdDanglingRef[] = []

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>
-))

package/src/serve/repo-processes.ts

@@ -1,89 +0,0 @@
-// the long running processes a repo declares in `serve.processes` (a dev
-// server, a watcher), supervised by its hub with the same supervisor the home
-// uses for resources. Each runs detached with a pid record in the machine db
-// (named by its path under .shipkit/tmp, where an older copy kept a pid file),
-// so a hub restart in place adopts it, and only a real stop of the hub stops it.
-import { join, resolve } from 'path'
-import { Proc, realDeps, tailLines, type ProcView, type SuperviseDeps } from '../home/supervise.ts'
-import type { ProcessDecl } from '../repo-config.ts'
-import { LAYOUT } from '../core/layout.ts'
-
-export type ProcessView = ProcView & { url: string | null; auto: boolean; cmd: string; tail: string[] }
-
-export const processDir = (root: string): string => join(root, LAYOUT.tmp, 'processes')
-
-const probeUrl = async (url: string): Promise<boolean> => {
-    try {
-        // any answer means it serves: a dev server may 404 its root
-        await fetch(url, { signal: AbortSignal.timeout(1_500) })
-        return true
-    } catch {
-        return false
-    }
-}
-
-export class RepoProcesses {
-    private procs: { decl: ProcessDecl; proc: Proc }[]
-
-    constructor(root: string, decls: ProcessDecl[], o: { deps?: SuperviseDeps; probe?: (url: string) => Promise<boolean> } = {}) {
-        const dir = processDir(root)
-        this.procs = decls.map((decl) => ({
-            decl,
-            proc: new Proc({
-                id: decl.id,
-                cmd: decl.cmd,
-                cwd: resolve(root, decl.cwd ?? '.'),
-                log: join(dir, `${decl.id}.log`),
-                pidKey: join(dir, `${decl.id}.pid`),
-                probe: decl.url == null ? undefined : () => (o.probe ?? probeUrl)(decl.url!),
-            }, o.deps ?? realDeps),
-        }))
-    }
-
-    /** the auto ones start with the hub; an adopted one is left as it runs */
-    async startAuto(): Promise<void> {
-        await Promise.all(this.procs.filter((p) => p.decl.auto === true && p.proc.pid == null).map((p) => p.proc.ensure()))
-    }
-
-    act(id: string, act: 'start' | 'stop' | 'restart'): ProcessView | null {
-        const p = this.procs.find((x) => x.decl.id === id)
-        if (p == null) return null
-        if (act === 'stop' || act === 'restart') p.proc.stop()
-        if (act === 'start') void p.proc.ensure()
-        if (act === 'restart') this.restartWhenGone(p.proc)
-        return this.view(p)
-    }
-
-    private restartWhenGone(proc: Proc): void {
-        const wait = async (): Promise<void> => {
-            for (let i = 0; i < 40 && proc.status === 'stopping'; i++) {
-                await Bun.sleep(250)
-                await proc.tick()
-            }
-            proc.start()
-        }
-        void wait()
-    }
-
-    async tick(): Promise<void> {
-        await Promise.all(this.procs.map((p) => p.proc.tick()))
-    }
-
-    /** a real stop of the hub: every process it started stops with it */
-    stopAll(): void {
-        for (const p of this.procs) if (p.proc.pid != null) p.proc.stop()
-    }
-
-    private view(p: { decl: ProcessDecl; proc: Proc }): ProcessView {
-        const v = p.proc.view()
-        return { ...v, url: p.decl.url ?? null, auto: p.decl.auto === true, cmd: p.decl.cmd.join(' '), tail: v.status === 'up' ? [] : tailLines(p.proc.spec.log, 20) }
-    }
-
-    views(): ProcessView[] {
-        return this.procs.map((p) => this.view(p))
-    }
-
-    get size(): number {
-        return this.procs.length
-    }
-}