rvlib-shipkit 0.38.0 → 1.0.0

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

@@ -1,20 +1,26 @@
 // HubSt — the ONE root store (build/app-state-tree: one central tree,
 // instantiated once at boot, services with backrefs, exposed as
 // window.app). Owns cross-service state: selection, the severity filter
-// (an ADDRESS: /?f=needs · /?f=red), hash deep-links (#<asset-id> ·
-// #cat-<Category>).
+// (an ADDRESS: /?f=needs · /?f=red), and the hash router: every page and
+// every tab is a selection, every selection has an address (hash-route.ts),
+// and setSel is the one place both move together.
+import { RUNS_ID } from '../../collections/collection-types.ts'
 import { makeAutoObservable } from 'mobx'
+import { ClockSvc } from './clock-svc.ts'
 import { ColsSvc } from './cols-svc.ts'
+import { canonicalSel, currentHash, hashFor, parseHash, selOf, type HashSel } from './hash-route.ts'
+import { ComfySvc } from './comfy-svc.ts'
 import { HealthSvc } from './health-svc.ts'
+import { LiveSvc } from './live-svc.ts'
 import { MediaSvc } from './media-svc.ts'
+import { TimelineSvc } from './timeline-svc.ts'
+import { TreeSvc } from './tree-svc.ts'
+import { ChecksSvc } from './checks-svc.ts'
+import { ProjectsSvc } from './projects-svc.ts'
+import { TestsSvc } from './tests-svc.ts'
+import type { Resource } from './hub-types.ts'
 
-export type Sel =
-    | { t: 'asset'; id: string }
-    | { t: 'cat'; cat: string }
-    | { t: 'col'; id: string }
-    | { t: 'item'; col: string; id: string }
-    | { t: 'status' }
-    | null
+export type Sel = HashSel | null
 
 /** one cmd+j target — run() fires the SAME action clicking would */
 export type Jump = { id: string; label: string; section: string; run: () => void }
@@ -28,9 +34,23 @@ const parseFilter = (search: string): Filter => {
 
 export class HubSt {
     name = ''
+    /** where this repo sits on disk, from /hub.json: what makes a source
+     *  path on a page a link that opens his editor */
+    root = ''
+    /** the one second tick every age on the page reads (clock-svc.ts) */
+    clock = new ClockSvc()
     media = new MediaSvc(this)
     cols = new ColsSvc(this)
+    tree = new TreeSvc(this)
     health = new HealthSvc(this)
+    checks = new ChecksSvc(this)
+    comfy = new ComfySvc(this)
+    timeline = new TimelineSvc(this)
+    /** the runs in flight, whoever started them (live-svc.ts) */
+    live = new LiveSvc(this)
+    projects = new ProjectsSvc(this)
+    /** the pages behind the test groups of the tree (tests-svc.ts) */
+    tests = new TestsSvc(this)
     sel: Sel = null
     filter: Filter = parseFilter(location.search)
     /** sidebar search — live substring filter over asset + collection rows */
@@ -41,21 +61,30 @@ export class HubSt {
     private booted = false
 
     constructor() {
-        makeAutoObservable<this, 'booted'>(this, { media: false, cols: false, health: false, booted: false })
+        makeAutoObservable<this, 'booted'>(this, { media: false, cols: false, tree: false, health: false, checks: false, comfy: false, timeline: false, live: false, projects: false, tests: false, booted: false })
     }
 
     boot(): void {
         void fetch('/hub.json')
-            .then((r) => r.json() as Promise<{ name: string }>)
-            .then((h) => { this.setName(h.name) })
+            .then((r) => r.json() as Promise<{ name: string; root?: string }>)
+            .then((h) => { this.setHub(h.name, h.root ?? '') })
             .catch(() => {})
+        this.clock.start()
         this.media.start()
         this.cols.start()
+        this.live.start()
+        void this.checks.loadGate()
         void this.health.load()
+        // back, forward, a pasted link and a hand edited hash all arrive
+        // here; applyHash is idempotent, so the two events firing together
+        // for one move cost nothing
         window.addEventListener('hashchange', () => this.applyHash())
+        window.addEventListener('popstate', () => this.applyHash())
+        this.applyHash()
     }
-    private setName(n: string): void {
+    private setHub(n: string, root: string): void {
         this.name = n
+        this.root = root
         document.title = `${n} · hub`
     }
 
@@ -102,6 +131,8 @@ export class HubSt {
             out.push({ id: `cat:${cat}`, label: cat, section: 'media', run: () => this.showCat(cat) })
         for (const a of this.media.assets)
             out.push({ id: `asset:${a.id}`, label: a.label, section: a.cat, run: () => this.selectAsset(a.id) })
+        // the runs page is a page, not a resource, so no collection lists it
+        out.push({ id: 'page:runs', label: 'runs', section: 'page', run: () => this.cols.select('runs', RUNS_ID) })
         for (const col of this.cols.sidebarCols) {
             const health = col.id === 'health'
             out.push({ id: `col:${col.id}`, label: col.title, section: 'section', run: () => (health ? this.showStatus() : this.showCol(col.id)) })
@@ -125,49 +156,91 @@ export class HubSt {
     }
 
     // ── selection + hash deep-links ───────────────────────────────────────
-    selectAsset(id: string, writeHash = true): void {
-        this.sel = { t: 'asset', id }
-        if (writeHash) this.setHash(id)
+    selectAsset(id: string): void {
+        this.setSel({ t: 'asset', id })
         void this.media.select(id)
     }
-    showCat(cat: string, writeHash = true): void {
-        this.sel = { t: 'cat', cat }
+    showCat(cat: string): void {
+        this.setSel({ t: 'cat', cat })
         this.media.openCats.add(cat)
-        if (writeHash) this.setHash(`cat-${cat}`)
         void this.media.fillCat()
     }
     showStatus(): void {
-        this.sel = { t: 'status' }
+        this.setSel({ t: 'status' })
         void this.health.load()
     }
+    /** where the test checks' time goes: the `tests` group (null) or one test
+     *  check's group. Fetched as the page opens, never on the poll */
+    showTests(check: string | null): void {
+        this.setSel({ t: 'tests', check })
+        void this.tests.load(check)
+    }
+
+    /** the ONE place a selection is written, so the url always describes what
+     *  is on screen. A new page is a history entry, so back returns to the
+     *  page before it. The same address is never pushed twice: applyHash
+     *  lands here too, with the hash already naming this selection */
+    setSel(sel: Sel): void {
+        this.sel = sel
+        const h = hashFor(sel)
+        if (h == null) return
+        const cur = parseHash(currentHash())
+        const next = parseHash(h)
+        // the tool set rides after the asset id (media-svc syncHash), so an
+        // address is the same page whatever tools it carries
+        if (cur.kind === next.kind && cur.col === next.col && cur.id === next.id) return
+        history.pushState(null, '', `#${h}`)
+    }
+    /** one tree row, opened: an asset goes to the atelier, everything else to
+     *  its own item card. A gate check has a page of its own now, so nothing
+     *  lands on the raw wall of text unless it is asked for by name */
+    openResource(r: Resource): void {
+        const assetId = r.id.replace(/^media:/, '')
+        if (r.collection === 'media' && this.media.assets.some((a) => a.id === assetId)) {
+            this.selectAsset(assetId)
+            return
+        }
+        this.cols.select(r.collection, r.id)
+    }
+
     /** collection view — one card per instance (health has StatusCard instead) */
     showCol(id: string): void {
-        this.sel = { t: 'col', id }
-    }
-    private setHash(h: string): void {
-        if (location.hash.slice(1) !== h) location.hash = h
+        this.setSel({ t: 'col', id })
+    }
+    /** open whatever a selection names, through the same calls a click makes */
+    go(sel: HashSel): void {
+        switch (sel.t) {
+            case 'asset': return this.selectAsset(sel.id)
+            case 'cat': return this.showCat(sel.cat)
+            case 'col': return this.showCol(sel.id)
+            case 'item': return this.cols.select(sel.col, sel.id)
+            case 'status': return this.showStatus()
+            case 'tests': return this.showTests(sel.check)
+        }
     }
+    /** the url decides the page: a reload, back, forward and a pasted link
+     *  all land here, and only a hash naming something else moves the view */
     applyHash(): void {
-        const raw = decodeURIComponent(location.hash.slice(1))
-        if (raw === '') return
-        // #<assetId>?tools=a,b — the query half is the media tool state
-        const qi = raw.indexOf('?')
-        const h = qi === -1 ? raw : raw.slice(0, qi)
-        if (h.startsWith('cat-')) {
-            const c = h.slice(4)
-            if (this.media.assets.some((a) => a.cat === c) && this.media.catMode !== c) this.showCat(c, false)
-            return
-        }
-        const tools = qi === -1 ? null : new URLSearchParams(raw.slice(qi + 1)).get('tools')
-        const list = tools == null ? null : tools === '' ? [] : tools.split(',')
-        if (this.media.assets.some((a) => a.id === h) && this.media.curId !== h) {
-            this.media.pendingTools = list
-            this.selectAsset(h, false)
-        } else if (this.media.curId === h && list != null) {
-            // same asset, new tool set (a pasted share link) — apply NOW; a
+        const p = parseHash(currentHash())
+        const named = selOf(p)
+        if (named == null) return
+        // an address naming what this build opens under another address is
+        // rewritten in place: a replace, so back never lands on the stale one
+        const sel = canonicalSel(named)
+        if (sel !== named) history.replaceState(null, '', `#${hashFor(sel)}`)
+        // media addresses resolve only once the first heartbeat listed the
+        // assets (afterFirstBeat calls back)
+        if (sel.t === 'asset' && !this.media.assets.some((a) => a.id === sel.id)) return
+        if (sel.t === 'cat' && !this.media.assets.some((a) => a.cat === sel.cat)) return
+        if (sel.t === 'asset' && this.media.curId === sel.id) {
+            // same asset, new tool set (a pasted share link): apply NOW, a
             // parked pendingTools would hijack the next selection instead
-            this.media.applyTab(list)
+            if (p.tools != null) this.media.applyTab(p.tools)
+            return
         }
+        if (hashFor(sel) === hashFor(this.sel)) return
+        if (sel.t === 'asset') this.media.pendingTools = p.tools
+        this.go(sel)
     }
     /** first heartbeat has the asset list — only then can a hash resolve */
     afterFirstBeat(): void {

package/src/serve/hub-app/hub-types.ts

@@ -1,6 +1,7 @@
 // Wire types the hub app reads — mirrors of the server shapes
 // (studio-server.ts, collection-types.ts). Kept structural on purpose: the
 // page renders what the API sends, the file is the truth.
+import type { ResourceType, SuiteFacts, TestFacts, TestRun } from '../../collections/collection-types.ts'
 
 export type SideAsset = {
     id: string
@@ -57,9 +58,118 @@ export type QueueState = {
 
 export type Candidate = { id: string; label: string; hint?: string }
 export type Artifact = { copy?: string; url?: string; steps?: string[] }
-export type ColInstance = {
+/** the resource kind, never the collection: one folder holds several kinds.
+ *  The list lives where the providers that emit it live, so a kind can never
+ *  be known on one side of the wire only. Type only, so nothing server side
+ *  reaches the bundle */
+export type { ResourceType, SuiteFacts, TestFacts, TestRun }
+
+export type CheckStatus = 'pass' | 'warn' | 'fail' | 'skip'
+
+/** one outcome of one check, as the page draws it */
+export type RecentRun = { at: number; ms: number; status: CheckStatus; replayed: boolean }
+
+// the page reads the SERVER's words for these, type-only so nothing of the
+// engine reaches the bundle: two declarations of one vocabulary is how a
+// switch ends up writing a word the other half does not know
+import type { WhenAt, WhenSource } from '../../core/when.ts'
+import type { CheckFrom } from '../../check.ts'
+export type { CheckFrom, WhenAt, WhenSource }
+
+/** a gate check's declaration and its numbers (collections/collection-types.ts
+ *  CheckFacts is the source; this is the wire mirror the page reads) */
+export type CheckFacts = {
+    checkId: string
+    /** the check's one line description (the shape: check.ts
+     *  descriptionProblem). Every inventory row carries one */
+    description: string
+    /** the wire lines of its last run, rendered as inline markdown */
+    lastLines: string[]
+    gate: boolean
+    /** a build step: the gate runs it, the health pass does not */
+    build: boolean
+    blocking: boolean | null
+    advisory: boolean
+    optIn: boolean
+    when: WhenAt
+    whenReason: string | null
+    whenSource: WhenSource
+    file: string | null
+    doc: string | null
+    cmd: string[] | null
+    script?: { name: string; body: string } | null
+    deps: string[] | null
+    from: CheckFrom
+    group: string | null
+    inputs?: string[]
+    ttl?: string
+    never?: string
+    timeoutMs: number
+    status: CheckStatus | null
+    replayed: boolean
+    lastMs: number | null
+    lastAt: number | null
+    avgMs: number | null
+    samples: number
+    slowestMs: number | null
+    failures: number
+    /** when it was last measured rather than replayed, and what that said */
+    measuredAt?: number | null
+    measuredStatus?: CheckStatus | null
+    /** a world probe only: when its remembered answer runs out */
+    keepsUntil?: number | null
+    recent?: RecentRun[]
+}
+
+/** the hub's daily health pass timer, as the resources feed sends it
+ *  (serve/health-schedule.ts). null = this hub runs no timer */
+export type Schedule = { everyMs: number; lastPassAt: number | null; nextAt: number; running: boolean }
+
+/** one declared slow suite, with the case test-speed doctrine demands */
+export type SlowSuite = { file: string; catches: string; whyNotFast: string }
+
+/** the managed block in repo.config.ts, as the page sees it. `hash` is what
+ *  the next write hands back, so a write can never land on top of an edit the
+ *  page never saw. `dirty` is the file waiting for a commit */
+export type GateBlock = {
+    path: string
+    hash: string
+    state: 'missing-file' | 'missing-block' | 'stale' | 'current'
+    when: Record<string, string>
+    tests: { budgetMs?: number; slow?: SlowSuite[]; serial?: { file: string; why: string }[] }
+    declaredOutside: boolean
+    dirty: boolean
+    /** the prose words block inside `prose: {` (core/when-block.ts) */
+    wordsState?: 'missing-file' | 'missing-block' | 'stale' | 'current' | 'no-prose'
+}
+
+/** one check finishing, as the run stream sends it */
+export type CheckEvent = {
+    id: string
+    name: string
+    status: CheckStatus
+    ms: number
+    replayed: boolean
+    blocking: boolean | null
+    advisory: boolean
+    lines: { kind: string; text: string }[]
+}
+/** the colour of the tree label: red broken · warn taste pending · ok
+ *  passing on a check that ran · idle the neutral default · quiet archived or out of play */
+export type ResourceState = 'red' | 'warn' | 'ok' | 'idle' | 'quiet'
+export type Resource = {
     id: string
+    collection: string
+    type: ResourceType
+    /** a slash path: the truth file, or a virtual root named for the type */
+    path: string
+    virtual?: boolean
+    title: string
+    state: ResourceState
     text: string
+    /** the ONE short fact the tree shows in its note slot (an ask its kind, a
+     *  secret present or missing, a post its venue, an asset its roll count) */
+    slot?: string
     severity?: 'red' | 'yellow'
     href?: string
     artifact?: Artifact
@@ -70,5 +180,10 @@ export type ColInstance = {
     /** the truth file's markdown BODY (frontmatter stripped) — clamped card
      *  in the grid, full in the item view */
     md?: string
+    /** gate checks only: what it is, and what it last cost */
+    check?: CheckFacts
+    /** test files only: where it runs and what it last cost */
+    test?: TestFacts
 }
-export type Col = { id: string; title: string; media: string; instances: ColInstance[] }
+export type ColMeta = { id: string; title: string; media: string }
+export type Col = ColMeta & { instances: Resource[] }