rvlib-shipkit 2.1.1 → 2.2.0

package/src/trailer/footage.ts

@@ -0,0 +1,104 @@
+// the takes on disk: each film line that writes its own take (a project CLI film row, a `film run`, a `film url`) filmed once into
+// `.shipkit/cache/trailer/footage/<key>.<ext>`, a stamp beside it naming the world it was filmed on. A take of an older
+// world is reported, and filmed again only on --refilm. Written aside then renamed, two at once
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { duration } from './ffmpeg.ts'
+import type { Trailer } from './grammar.ts'
+import { cliArgv, isTake, runCommand, type Stamp, type Take, type TakeFilm, takeIsStill, takeName, takeSeconds } from './plan.ts'
+
+export const trailerCache = (root: string, part: 'footage' | 'pieces' | 'titles' | 'sound'): string => join(root, '.shipkit', 'cache', 'trailer', part)
+
+/** every shot's take, with its stamp when it was filmed */
+export function takesOf(t: Trailer, root: string): Take[] {
+    const dir = trailerCache(root, 'footage')
+    return t.shots.flatMap((shot) => {
+        const film = shot.film
+        if (!isTake(film)) return []
+        const file = join(dir, takeName(shot, film, t))
+        const stampFile = `${file}.json`
+        const stamp = existsSync(file) && existsSync(stampFile) ? (JSON.parse(readFileSync(stampFile, 'utf8')) as Stamp) : null
+        return [{ shot, film, file, stamp }]
+    })
+}
+
+const git = (root: string, ...args: string[]): string | null => {
+    const r = spawnSync('git', args, { cwd: root, encoding: 'utf8' })
+    return r.status === 0 ? r.stdout : null
+}
+
+/** the world the takes show: the repo's committed tree and what the working tree changes, trailer folders and the
+ *  shipkit cache left out; a repo with no git: `no-git` */
+export function worldStamp(root: string): string {
+    const tree = git(root, 'rev-parse', 'HEAD^{tree}')
+    if (tree === null) return 'no-git'
+    const h = new Bun.CryptoHasher('sha1').update(tree)
+    const dirty = (git(root, 'status', '--porcelain=v1', '-z', '--untracked-files=all', '--', '.', ':(exclude)trailer', ':(exclude).shipkit') ?? '')
+        .split('\0')
+        .filter(Boolean)
+        .map((l) => l.slice(3))
+        .sort()
+    for (const f of dirty) {
+        h.update(f)
+        const abs = join(root, f)
+        try {
+            h.update(readFileSync(abs))
+        } catch {}
+    }
+    return h.digest('hex').slice(0, 12)
+}
+
+export interface FilmContext {
+    root: string
+    t: Pick<Trailer, 'size' | 'fps' | 'base'>
+    world: string
+    /** the project CLI's argv, null when the repo has none */
+    cli: readonly string[] | null
+    say: (line: string) => void
+}
+
+/** film one take; a failure throws with the shot, its line and what the command said */
+export async function filmTake(tk: Take, c: FilmContext): Promise<Take> {
+    mkdirSync(trailerCache(c.root, 'footage'), { recursive: true })
+    const part = tk.file.replace(/(\.\w+)$/, '.part$1')
+    rmSync(part, { force: true })
+    const t0 = performance.now()
+    const seconds = takeSeconds(tk.shot, tk.film)
+    const f = tk.film
+    const said = f.kind === 'url' ? await urlTake(tk, f, part, seconds, c) : await commandTake(tk, f, part, seconds, c)
+    renameSync(part, tk.file)
+    const still = takeIsStill(f)
+    const stamp: Stamp = { world: c.world, filmedAt: new Date().toISOString(), seconds: still ? 0 : duration(tk.file), note: said.split('\n')[0]?.slice(0, 200) ?? '' }
+    writeFileSync(`${tk.file}.json`, JSON.stringify(stamp, null, 2))
+    c.say(`  filmed ${tk.shot.name}: ${still ? 'a still' : `${stamp.seconds.toFixed(2)} s`} in ${((performance.now() - t0) / 1000).toFixed(1)} s`)
+    return { ...tk, stamp }
+}
+
+/** a take a command writes at `part` (a `film run`, a project CLI row); what it said, or a throw with its last lines */
+async function commandTake(tk: Take, f: Exclude<TakeFilm, { kind: 'url' }>, part: string, seconds: number | null, c: FilmContext): Promise<string> {
+    if (f.kind === 'cli' && c.cli === null) throw new Error(`shot ${tk.shot.name} (line ${f.line}): film ${f.argv.join(' ')} needs the project CLI (the cli script of package.json)`)
+    const argv = f.kind === 'run' ? ['sh', '-c', runCommand(f, { out: part, seconds, size: c.t.size, fps: c.t.fps })] : cliArgv(c.cli!, f, part, seconds)
+    const p = Bun.spawn(argv, { cwd: c.root, stdout: 'pipe', stderr: 'pipe' })
+    const [out, err, code] = await Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text(), p.exited])
+    const said = `${out}${err}`.trim()
+    if (code !== 0 || !existsSync(part)) {
+        rmSync(part, { force: true })
+        const shown = f.kind === 'run' ? f.cmd : [...(c.cli ?? []), ...f.argv].join(' ')
+        throw new Error(`shot ${tk.shot.name} (line ${f.line}): ${shown} ${code !== 0 ? `exited ${code}` : `wrote no file at its --out`}${said ? `\n${said.split('\n').slice(-8).join('\n')}` : ''}`)
+    }
+    return said
+}
+
+/** a `film url` take through the house shot service; a throw names the shot, its line and the service's reason */
+async function urlTake(tk: Take, f: Extract<TakeFilm, { kind: 'url' }>, part: string, seconds: number | null, c: FilmContext): Promise<string> {
+    const { filmUrl } = await import('./url.ts')
+    try {
+        const note = await filmUrl(f, { root: c.root, base: c.t.base, size: c.t.size, fps: c.t.fps, seconds, out: part, say: c.say })
+        if (!existsSync(part)) throw new Error('the shot service wrote no file')
+        return note
+    } catch (e) {
+        rmSync(part, { force: true })
+        throw new Error(`shot ${tk.shot.name} (line ${f.line}): film url ${f.route}: ${(e as Error).message}`)
+    }
+}