rvlib-shipkit 2.1.1 → 2.3.0

package/src/suite/judge-suites.ts

@@ -335,6 +335,18 @@ export function aloneRunsNeeded(suspects: Timed[], parallelCpu: Record<string, n
  *  every (fail) line under no header of its own: it closes the last file */
 export const BUN_RECAP = /^\s*\d+ tests? failed:\s*$/
 
+/** the banner bun prints under a file header for an error thrown outside
+ *  any test (a top level throw, a throw inside a describe callback), then a
+ *  rule, the code frame, the error, the stack and a closing rule */
+export const BETWEEN_TESTS = '# Unhandled error between tests'
+export const BUN_RULE = /^-{20,}$/
+/** the line that carries an error's message: bun's own `error:` and a named
+ *  error class (`ReferenceError: x is not defined`) */
+const ERROR_LINE = /^\s*(?:error|[A-Z]\w*(?:Error|Exception)): /
+const BETWEEN_WORDS = 'an unhandled error between tests'
+/** the line that opens a file in bun's report: its path and a colon */
+const HEADER = /^(\S+\.(?:test|spec)\.[cm]?[jt]sx?):$/
+
 /** 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
@@ -343,39 +355,73 @@ export function failedSuites(output: string): string[] {
     const out = new Set<string>()
     let cur: string | null = null
     for (const line of output.split('\n')) {
-        const head = line.match(/^(\S+\.(?:test|spec)\.[cm]?[jt]sx?):$/)
+        const head = line.match(HEADER)
         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)
+        if (cur != null && (/^\(fail\) /.test(line) || line.startsWith(BETWEEN_TESTS))) out.add(cur)
     }
     return [...out]
 }
 
+/** the error line inside the banner block that starts at `from`, before its closing rule */
+function blockError(lines: string[], from: number): string | null {
+    let rules = 0
+    for (let j = from; j < lines.length && rules < 2; j++) {
+        const line = lines[j]!.trim()
+        if (BUN_RULE.test(line)) { rules++; continue }
+        if (HEADER.test(line)) return null
+        if (ERROR_LINE.test(line)) return line
+    }
+    return null
+}
+
 /** the FIRST failure of each failing suite, read off the same report as
- *  failedSuites: its `(fail)` line, timing dropped, with the first `error:`
- *  line bun printed before it in that file. What the record keeps so a page
- *  can say why a file is red without a rerun */
+ *  failedSuites: its `(fail)` line, timing dropped, with the first error line
+ *  bun printed before it in that file, or the error inside the banner of one
+ *  that threw outside any test. What the record keeps so a page can say why a
+ *  file is red without a rerun */
 export function failLines(output: string): Map<string, string> {
     const out = new Map<string, string>()
+    const lines = output.split('\n')
     let cur: string | null = null
     let err: string | null = null
-    for (const raw of output.split('\n')) {
-        const line = raw.trimEnd()
-        const head = line.match(/^(\S+\.(?:test|spec)\.[cm]?[jt]sx?):$/)
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i]!.trimEnd()
+        const head = line.match(HEADER)
         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()
+        if (err == null && ERROR_LINE.test(line)) err = line.trim()
         const fail = line.match(/^\(fail\) (.*?)(?: \[[\d.]+m?s\])?$/)
         if (fail != null) out.set(cur, clip(err == null ? fail[1]! : `${fail[1]!}: ${err}`))
-        else if (line.startsWith('# Unhandled error between tests')) out.set(cur, clip(err == null ? 'an unhandled error between tests' : `an unhandled error between tests: ${err}`))
+        else if (line.startsWith(BETWEEN_TESTS)) {
+            const thrown = blockError(lines, i + 1) ?? err
+            out.set(cur, clip(thrown == null ? BETWEEN_WORDS : `${BETWEEN_WORDS}: ${thrown}`))
+        }
     }
     return out
 }
 
 const clip = (s: string): string => (s.length > 300 ? `${s.slice(0, 299)}…` : s)
 
+/** the FAIL headline of a run bun ended red with no kill, read off bun's own
+ *  summary (`N fail`, `N error`) and the report in `out`. bun can count an
+ *  error thrown outside any test as `0 fail`, so the errors lead, each with
+ *  the file that threw */
+export function redWords(o: { failedTests: number; errors: number; ran: number; slowest: string; out: string }): string {
+    const thrown = [...failLines(o.out)].filter(([, w]) => w.startsWith(BETWEEN_WORDS))
+    const parts: string[] = []
+    if (o.errors > 0 || thrown.length > 0) {
+        const named = thrown.slice(0, 3).map(([file, w]) => `${file} threw ${w.slice(BETWEEN_WORDS.length + 2) || 'with no message'}`)
+        const more = thrown.length > 3 ? `; ${thrown.length - 3} more` : ''
+        parts.push(`${Math.max(o.errors, thrown.length)} error(s) outside any test ${named.length > 0 ? `(${named.join('; ')}${more})` : '(bun named no file)'}`)
+    }
+    if (o.failedTests > 0) parts.push(`${o.failedTests} test(s) failed`)
+    if (parts.length === 0) parts.push('bun test exited red with no failed test and no error counted')
+    return `${parts.join(', ')}, Ran ${o.ran} tests${o.slowest}`
+}
+
 /** the clause the headline carries for the gate line: the command phase one
  *  ran, and the flags the runner added to the script's own. Per file ignores
  *  stay out, the slow and serial counts already say what they leave out */

package/src/suite/select.ts

@@ -31,7 +31,7 @@ import { blobOid, listingHash } from '../core/read-set.ts'
 import { shipkitRoot } from '../ledger/db.ts'
 import { extractSpecs, resolveSpec } from '../ts/source-graph.ts'
 import { type RvtConfig } from '../ts/config.ts'
-import { inDotDir } from './judge-suites.ts'
+import { BETWEEN_TESTS, BUN_RULE, inDotDir } from './judge-suites.ts'
 
 export const SELECT_VERSION = 5
 
@@ -403,9 +403,6 @@ export function selectSuites(o: {
     return { all: false, run, why: reasons, changed: o.changed.size }
 }
 
-const BETWEEN_TESTS = '# Unhandled error between tests'
-const RULE = /^-{20,}$/
-
 /** the repo modules named in the frames of every error bun printed between
  *  tests (a module whose top level threw), repo-relative to `top` */
 export function loadErrorModules(out: string, top: string): string[] {
@@ -419,7 +416,7 @@ export function loadErrorModules(out: string, top: string): string[] {
         let rules = 0
         for (let j = i + 1; j < lines.length && rules < 2; j++) {
             const line = lines[j]!
-            if (RULE.test(line.trim())) { rules++; continue }
+            if (BUN_RULE.test(line.trim())) { rules++; continue }
             const m = /^\s+at .*?\(?((?:\/|[A-Za-z]:\\)[^():]+):\d+(?::\d+)?\)?\s*$/.exec(line)
             if (m == null) continue
             const base = roots.find((r) => m[1]!.startsWith(`${r}/`))

package/src/suite/suite-cli.ts

@@ -20,7 +20,7 @@ import { SUITE_READS_ENV, SUITE_ROOT_ENV, SUITE_SELECT_ENV } from './reads-env.t
 import { changedKeys, dropStaticEdges, extras, isBunSuite, envFilesOf, foldReads, loadErrorModules, loadState, preloadsOf, saveState, selectStatePath, selectSuites, snapshot, suiteFiles, taintedSuites, walkGraph, type GraphEntry, type Selection, type SelectState } from './select.ts'
 import { gitRoot } from '../core/git-root.ts'
 import { loadConfig } from '../ts/config.ts'
-import { aloneRunsNeeded, bunfigTest, type BunfigTest, readPhaseCpu, SUITE_CPU_ENV, type AloneRun, type Confirmed, confirmOver, crashedWorkers, interruptedSuites, overWords, ranAs, retryAlone, smallerRun, stallWords, DEFAULT_BUDGET_MS, FULL_CEILING_MS, failedSuites, failLines, judgeSuites, normSuitePath, parseSuiteFlags, planPhases, QUICK_CEILING_MS, poolWorkers } from './judge-suites.ts'
+import { aloneRunsNeeded, bunfigTest, type BunfigTest, readPhaseCpu, SUITE_CPU_ENV, type AloneRun, type Confirmed, confirmOver, crashedWorkers, interruptedSuites, overWords, ranAs, retryAlone, smallerRun, stallWords, DEFAULT_BUDGET_MS, FULL_CEILING_MS, failedSuites, failLines, judgeSuites, normSuitePath, parseSuiteFlags, planPhases, QUICK_CEILING_MS, poolWorkers, redWords } from './judge-suites.ts'
 
 type Phase = { code: number; signal: string | null; stalled: boolean; out: string; timings: Record<string, number>; cpuMs: number | null }
 
@@ -196,6 +196,7 @@ async function runSuites(argv: string[], ctx: SelectCtx): Promise<number> {
         const phases = [p1, ...(p2 != null ? [p2] : [])]
         const ran = phases.reduce((n, p) => n + lastCount(p.out, /Ran (\d+) tests?/g), 0)
         const failedTests = phases.reduce((n, p) => n + lastCount(p.out, /^\s*(\d+) fail$/gm), 0)
+        const errors = phases.reduce((n, p) => n + lastCount(p.out, /^\s*(\d+) errors?$/gm), 0)
         const timings = Object.assign({}, ...phases.map((p) => p.timings)) as Record<string, number>
         const crashed = crashedWorkers(p1.out)
         const red = new Set([...phases.flatMap((p) => failedSuites(p.out)), ...crashed.map((c) => c.file)])
@@ -290,7 +291,7 @@ async function runSuites(argv: string[], ctx: SelectCtx): Promise<number> {
             ...killed.map((k) => `FAIL: ${k}`),
             ...(vacuous ? ['FAIL: ran 0 tests: a suite with no test in it proves nothing, write a real one'] : []),
             ...(!vacuous && (failedTests > 0 || (phases.some((p) => p.code !== 0 && p.signal == null) && killed.length === 0))
-                ? [`FAIL: ${failedTests} test(s) failed, Ran ${ran} tests${slowest}`] : []),
+                ? [`FAIL: ${redWords({ failedTests, errors, ran, slowest, out: phases.map((p) => p.out).join('\n') })}`] : []),
             ...(over.length > 0
                 ? [`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`]
                 : []),

package/src/trailer/adapter.ts

@@ -0,0 +1,78 @@
+// what a repo adds to the trailer core, all optional (wiki build/trailer.md, The trailer unit). Filming is never here:
+// a film line calls the project CLI's film rows (vocab.ts). A `trailer({...})` unit in any `<name>.shipkit.ts`
+// resolves the sounds that are not files, names the paths a take's world is, checks the content the language cannot
+// know, refines one film line's take, and turns on the guards that read the repo's own words. Discovered like every
+// unit file (load-unit.ts)
+import type { TakeLength } from './grammar.ts'
+
+export interface TrailerSounds {
+    /** a music id to an audio file of at least `seconds`, cached by the repo */
+    music?(id: string, o: { take?: string; seconds: number }): Promise<string>
+    /** an sfx id to an audio file */
+    sfx?(id: string): Promise<string>
+    /** a voice line, found by its text, to an audio file */
+    voice?(text: string): Promise<string>
+}
+
+/** a film line of the project CLI as the unit sees it: its words as written, the text of each `@<file>` word */
+export interface TrailerFilmLine {
+    line: number
+    /** the shot or footage block it films */
+    shot: string
+    argv: string[]
+    output: 'still' | 'clip'
+    files: Record<string, string>
+}
+
+/** what `check` reads: the cut's film lines and the sounds it names by id */
+export interface TrailerCheckInput {
+    file: string
+    dir: string
+    size: [number, number]
+    fps: number
+    films: TrailerFilmLine[]
+    /** each music cue that names an id; `opening`: the header's, the one the cut starts on */
+    music: { line: number; id: string; take?: string; from: number; opening: boolean }[]
+    sfx: { line: number; id: string }[]
+    voices: { line: number; text: string }[]
+}
+
+/** an error at its line; `warn`: said, never blocking */
+export interface TrailerFinding {
+    line: number
+    message: string
+    warn?: true
+}
+
+/** one film line's take over its row's defaults: its version, how long it films, a fixed world, what its key reads */
+export interface TakeAnswer {
+    version?: number | string
+    length?: TakeLength
+    /** the take's world for good (`rev:<commit>`): never stale */
+    world?: string
+    /** what the key reads instead of the words */
+    recipe?: unknown
+}
+
+export interface TrailerDef {
+    sound?: TrailerSounds
+    /** the paths a take's world is (`['src', 'public']`); default the whole tree, trailer/ and .shipkit/ left out */
+    stamp?: string[]
+    /** in process, before filming, in a few ms: the content the language cannot know */
+    check?(c: TrailerCheckInput): TrailerFinding[] | Promise<TrailerFinding[]>
+    /** one film line's take, when its words change what its row says */
+    take?(f: TrailerFilmLine & { version: number | string | null; length: TakeLength }): TakeAnswer | undefined
+    /** the `states` a film prints: parts a cut may land on (`ignore`), parts a shot never opens or ends on (`underWay`) */
+    states?: { ignore?: string[]; underWay?: string[] }
+    /** a clip take that drops its picture for a few frames is filmed again once, then refused (holes.ts) */
+    holes?: boolean
+}
+
+export type TrailerUnit = TrailerDef & { kind: 'trailer' }
+
+export function trailer(d: TrailerDef): TrailerUnit {
+    for (const [k, f] of Object.entries(d.sound ?? {})) if (typeof f !== 'function') throw new Error(`trailer: sound.${k} is a function returning an audio file`)
+    for (const k of ['check', 'take'] as const) if (d[k] !== undefined && typeof d[k] !== 'function') throw new Error(`trailer: ${k} is a function`)
+    if (d.stamp !== undefined && (!Array.isArray(d.stamp) || d.stamp.some((p) => typeof p !== 'string' || p === '' || p.startsWith('/')))) throw new Error('trailer: stamp is a list of repo relative paths')
+    return { ...d, kind: 'trailer' }
+}