rvlib-shipkit 2.4.0 → 2.5.0

package/src/serve/run-serve.ts

@@ -5,7 +5,11 @@
 import { basename } from 'path'
 import { reclaimPreviousImage } from '../core/instance.ts'
 import { isLinkedWorktree } from '../core/git-root.ts'
+import { heldNow, heldText, OWN_LIB, setHeld } from '../core/last-good.ts'
 import { diskLibVersion, LIB_VERSION } from '../core/lib-version.ts'
+import { bootEntries, probeLoad, TreeProbe } from '../core/load-probe.ts'
+import { LibWatch } from '../home/lib-watch.ts'
+import type { LoadVerdict } from './stale-restart.ts'
 import { reexecBlocker, reexecSelf } from '../core/reexec.ts'
 import { attachToHome } from '../home/attach.ts'
 import { daemonUp, WORKER_ENV } from '../home/home-paths.ts'
@@ -21,6 +25,14 @@ export type { ServeIo }
 /** how often a hub of its own looks at its plan */
 export const PLAN_TICK_MS = 2_000
 
+/** does the lib this hub would restart onto load: probed again after every
+ *  write to its tree, not only when the version moves */
+export function serveProbe(lib: string): { loads: () => LoadVerdict; stop: () => void } {
+    const w = new LibWatch(lib)
+    const p = new TreeProbe(() => probeLoad(lib, bootEntries(lib, 'serve')), () => `${w.seq}|${diskLibVersion()}`)
+    return { loads: () => p.loads(), stop: () => w.close() }
+}
+
 /** what a `shipkit serve` does with its hub. On a machine with a home, no
  *  hub runs outside it: a home that answers takes it, and an installed one
  *  that does not is started first. `serve` only inside the home, a linked
@@ -104,6 +116,7 @@ export async function runServe(root: string, io: ServeIo, o?: { port?: number })
     // a file table the watch restarts leaked: it re-executes itself in
     // place (same pid, argv, port) once no run is in flight. Only a
     // restart that throws is said, in the hub's own status
+    const probe = serveProbe(OWN_LIB)
     const stale = new StaleRestart({
         boot: LIB_VERSION,
         disk: diskLibVersion,
@@ -114,6 +127,7 @@ export async function runServe(root: string, io: ServeIo, o?: { port?: number })
             if (blocked != null) throw new Error(blocked)
             io.print(`ok: ${why}: restarting in place`)
             stale.stop()
+            probe.stop()
             clearInterval(planClock)
             rt.stop()
             hub.stop()
@@ -126,6 +140,16 @@ export async function runServe(root: string, io: ServeIo, o?: { port?: number })
             }
         },
         say: (text) => deps.hubProblems?.set('stale', text == null ? null : { text, severity: 'red' }),
+        // a version move restarts only onto code that loads; the held line is the hub's (serve-hub.ts)
+        loads: () => probe.loads(),
+        hold: (v) => {
+            if (v == null) return setHeld(null)
+            const was = heldNow()
+            if (was?.file === v.file && was.error === v.error) return
+            const h = { since: was?.since ?? Date.now(), file: v.file, error: v.error, from: OWN_LIB, copyAt: null }
+            io.printErr(`WARN ${heldText(h)}`)
+            setHeld(h)
+        },
     })
     stale.start()
     // a watch restart that leaked sheds it before the first run spawns anything
@@ -140,6 +164,7 @@ export async function runServe(root: string, io: ServeIo, o?: { port?: number })
     for (const sig of ['SIGINT', 'SIGTERM'] as const)
         process.on(sig, () => {
             stale.stop()
+            probe.stop()
             clearInterval(planClock)
             plan.stop()
             rt.stop()

package/src/serve/serve-hub.ts

@@ -31,6 +31,7 @@ import { RUN_EXIT } from '../home/home-words.ts'
 import { projectGutter } from './project-gutter-route.ts'
 import { sameOrigin } from './same-origin.ts'
 import { LAYOUT } from '../core/layout.ts'
+import { heldNow, heldText } from '../core/last-good.ts'
 import { WarmCell } from './warm-cell.ts'
 import { readmeRoutes } from './readme-route.ts'
 import { reviewRoutes } from '../review/routes.ts'
@@ -246,7 +247,7 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
                     collections: r.collections,
                     resources: r.resources,
                     planned: d.planned?.() ?? null,
-                    hub: d.hubProblems?.list() ?? [],
+                    hub: [...(d.hubProblems?.list() ?? []), ...heldProblem()],
                 })
             }
             // the previous address, answered while pages opened before the
@@ -427,6 +428,12 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
     }
 }
 
+/** the machine runs older code than its tree: every hub's header says so */
+const heldProblem = (): { id: string; text: string; severity: 'yellow' }[] => {
+    const h = heldNow()
+    return h == null ? [] : [{ id: 'last-good', text: heldText(h), severity: 'yellow' }]
+}
+
 export function serveHub(d: HubDeps, h: HubHandler = hubHandler(d)): Hub {
     const server: Server = Bun.serve({
         hostname: '127.0.0.1',

package/src/serve/stale-restart.ts

@@ -7,10 +7,14 @@
 // watch fds, and a full table fails every spawn with EBADF. Either way it
 // re-executes in place (core/reexec.ts) once no run is in flight, which is a
 // clean table too. Only a restart that throws reaches a human, once, through
-// `say`.
+// `say`. With `loads`, it restarts only onto code that loads: while the tree
+// fails, it keeps the running image and tells `hold` why.
 import { assertLeakHealable, FD_HEALED_ENV, fdTableLeak } from '../core/fd-table.ts'
 
-export type StaleTick = 'fresh' | 'busy' | 'restarted' | 'impossible'
+export type StaleTick = 'fresh' | 'busy' | 'probing' | 'held' | 'restarted' | 'impossible'
+
+/** does the code a restart would run load: `pending` while a probe runs */
+export type LoadVerdict = 'ok' | 'pending' | { file: string; error: string }
 
 export type StaleRestartOpts = {
     /** the version this process booted with */
@@ -30,6 +34,10 @@ export type StaleRestartOpts = {
     /** the hub's status line: a text when the restart is impossible, null
      *  once there is nothing to say */
     say: (text: string | null) => void
+    /** asked once a restart is due, never before (core/load-probe.ts) */
+    loads?: () => LoadVerdict
+    /** why the due restart waits: a file of the tree fails to load. Null once it loads */
+    hold?: (why: { file: string; error: string } | null) => void
     everyMs?: number
 }
 
@@ -47,6 +55,15 @@ export class StaleRestart {
         }
         if (this.failed != null) return 'impossible'
         if (this.o.busy()) return 'busy'
+        if (this.o.loads != null) {
+            const v = this.o.loads()
+            if (v === 'pending') return 'probing'
+            if (v !== 'ok') {
+                this.o.hold?.(v)
+                return 'held'
+            }
+            this.o.hold?.(null)
+        }
         try {
             if (stale.leak) {
                 assertLeakHealable()

package/src/trailer/build.ts

@@ -504,7 +504,7 @@ export async function scoreFile(l: Loaded, seconds: number, say: Say): Promise<s
 /** everything the stitch reads but its output: sources, titles, sounds, the look */
 async function stitchInput(l: Loaded, takes: readonly Take[], shots: readonly Shot[], silent: boolean, say: Say = () => undefined) {
     const { gridMask, splitMasks } = await import('./stitch.ts')
-    const [{ cardPng, titlePng }, { lookOf }, { duration }, { trailerCache }, { loadBrand, identityLogo }] = await Promise.all([
+    const [{ cardPng, titlePng }, { lookOf }, { durationOf }, { trailerCache }, { loadBrand, identityLogo }] = await Promise.all([
         import('./titles.ts'),
         import('./look.ts'),
         import('./ffmpeg.ts'),
@@ -534,7 +534,7 @@ async function stitchInput(l: Loaded, takes: readonly Take[], shots: readonly Sh
         if (f.kind === 'image') return { image: fileOf(f.path, l)! }
         if (f.kind === 'clip') {
             const file = fileOf(f.path, l)!
-            return { footage: file, seconds: duration(file) }
+            return { footage: file, seconds: await durationOf(file) }
         }
         const tk = takeOf(s)!
         return tk.stamp!.seconds === 0 ? { image: tk.file } : { footage: tk.file, seconds: tk.stamp!.seconds }
@@ -556,11 +556,11 @@ async function stitchInput(l: Loaded, takes: readonly Take[], shots: readonly Sh
     )
     const sfx = await Promise.all(shots.map((s) => Promise.all(s.sfx.map(async (x) => {
         const file = isFileSound(x.id, x) ? fileOf(x.id, l)! : await resolve(ask('sfx', x.id, x))
-        return { file, seconds: duration(file) }
+        return { file, seconds: await durationOf(file) }
     }))))
     const voices = await Promise.all(shots.map((s) => Promise.all(s.voices.map(async (v) => {
         const file = v.file ? fileOf(v.file, l)! : await resolve(ask('voice', v.text ?? 'run', v))
-        return { file, seconds: duration(file) }
+        return { file, seconds: await durationOf(file) }
     }))))
     return { ...base, sources, titles: drawn, music, sfx, voices }
 }
@@ -655,7 +655,15 @@ export async function build(l: Loaded, o: BuildOptions): Promise<string> {
     const done = await stitch({ ...input, t: l.t, out: cut, cache: trailerCache(l.root, 'pieces'), encoder: o.final ? 'final' : 'draft' })
     const finished = l.t.vertical ? await finishVertical(l, input, done, cut, out, o.final) : null
     const stripFile = join(outDir(l), `${l.t.name}.strip.png`)
-    await strip(done.pieces, stripFile)
+    // the strip is drawn from the pieces' thumbs: the same pieces draw the same strip, so a build that rendered no
+    // section keeps it
+    const stripKey = join(trailerCache(l.root, 'pieces'), `${l.t.name}.strip.key`)
+    const key = done.pieces.map((p) => p.thumbs).join('\n')
+    const drawn = (): string => `${key}\n${statSync(stripFile).mtimeMs}`
+    if (!existsSync(stripFile) || !existsSync(stripKey) || readFileSync(stripKey, 'utf8') !== drawn()) {
+        await strip(done.pieces, stripFile)
+        writeFileSync(stripKey, drawn())
+    }
     writeFileSync(join(outDir(l), `${l.t.name}.montage.md`), montage(l.t, basename(l.file)))
     for (const line of timeline(l, takes, world, o.cwd)) o.say(line)
     o.say(`ok: ${out} (${(finished?.seconds ?? total(l.t)).toFixed(2)} s) in ${((performance.now() - t0) / 1000).toFixed(1)} s: filming ${((tFilm - t0) / 1000).toFixed(1)} s, ${rendered(done)}${finished ? `, ${finished.note}` : ''}`)

package/src/trailer/ffmpeg.ts

@@ -1,7 +1,7 @@
 // the one way the trailer spawns ffmpeg and ffprobe: a run that fails loud with ffmpeg's own words, a probe, the nine
 // frame sheet. The binaries resolve once, with the homebrew path for processes started without it
 import { spawn } from 'node:child_process'
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs'
 import { basename } from 'node:path'
 
 const FFMPEG = Bun.which('ffmpeg') ?? '/opt/homebrew/bin/ffmpeg'
@@ -38,6 +38,26 @@ export function duration(file: string): number {
     return d
 }
 
+const probed = new Map<string, Promise<number>>()
+
+/** a media file's length like `duration`, probed once per file and state in this process, the probes side by side: a
+ *  cut that plays one sfx on many lines asks once */
+export function durationOf(file: string): Promise<number> {
+    const st = statSync(file)
+    const k = `${file}\0${st.size}\0${st.mtimeMs}`
+    const had = probed.get(k)
+    if (had) return had
+    const p = (async () => {
+        const r = Bun.spawn([FFPROBE, '-v', 'error', '-show_entries', 'format=duration', '-of', 'csv=p=0', file], { stdout: 'pipe', stderr: 'pipe' })
+        const [out, err, code] = await Promise.all([new Response(r.stdout).text(), new Response(r.stderr).text(), r.exited])
+        const d = Number(out.trim())
+        if (code !== 0 || !(d > 0)) throw new Error(`ffprobe ${file}: ${err.trim() || 'no length'}`)
+        return d
+    })()
+    probed.set(k, p)
+    return p
+}
+
 /** the media file carries a sound stream */
 export function hasAudio(file: string): boolean {
     const r = Bun.spawnSync([FFPROBE, '-v', 'error', '-select_streams', 'a', '-show_entries', 'stream=index', '-of', 'csv=p=0', file], { stdout: 'pipe', stderr: 'pipe' })