rvlib-shipkit 2.2.0 → 2.3.0

package/src/trailer/footage.ts

@@ -1,52 +1,96 @@
 // 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 { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { isAbsolute, join } from 'node:path'
+import type { TrailerFilmLine, TrailerUnit } from './adapter.ts'
 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'
+import type { Shot, Trailer } from './grammar.ts'
+import { cliArgv, isTake, recipeText, recipeWords, runCommand, type Stamp, specOf, type Take, type TakeFilm, type TakeSpec, takeIsStill, takeName, takeSeconds } from './plan.ts'
+import { statesOf } from './states.ts'
 
-export const trailerCache = (root: string, part: 'footage' | 'pieces' | 'titles' | 'sound'): string => join(root, '.shipkit', 'cache', 'trailer', part)
+export const trailerCache = (root: string, part: 'footage' | 'pieces' | 'titles' | 'sound' | 'score'): 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[] {
+/** a recipe file a `@<file>` word names: its repo relative path, its text */
+export interface Recipe {
+    path: string
+    text: string
+}
+
+/** what a take reads past its line: the recipe files, the repo's trailer unit */
+export interface TakeContext {
+    recipes: ReadonlyMap<string, Recipe>
+    unit: TrailerUnit | null
+}
+
+/** a film line as the unit sees it */
+export function filmLineOf(shot: Shot, f: Extract<TakeFilm, { kind: 'cli' }>, c: Pick<TakeContext, 'recipes'>): TrailerFilmLine {
+    const files = Object.fromEntries(recipeWords(f.argv).flatMap((w) => (c.recipes.has(w) ? [[w, c.recipes.get(w)!.text]] : [])))
+    return { line: f.line, shot: shot.name, argv: f.argv, output: f.output, files }
+}
+
+/** a take's spec and the words it runs: its row's defaults, the unit's `take` over them, each `@<file>` resolved */
+export function specFor(shot: Shot, f: TakeFilm, c: TakeContext): { spec: TakeSpec; argv?: string[] } {
+    // a run keys the files it says it reads, by their content
+    if (f.kind === 'run') return { spec: specOf(f, Object.fromEntries((f.reads ?? []).map((p) => [`reads:${p}`, c.recipes.get(`reads:${p}`)?.text ?? '']))) }
+    if (f.kind !== 'cli') return { spec: specOf(f) }
+    const line = filmLineOf(shot, f, c)
+    // a declared file word keys its content, and reaches the row as its repo relative path
+    const declared = Object.fromEntries((f.files ?? []).flatMap((i) => (c.recipes.has(`file:${f.argv[i]}`) ? [[`file:${f.argv[i]}`, c.recipes.get(`file:${f.argv[i]}`)!.text]] : [])))
+    const base = specOf(f, { ...Object.fromEntries(Object.entries(line.files).map(([w, text]) => [w, recipeText(text)])), ...declared })
+    const got = c.unit?.take?.({ ...line, version: base.version, length: base.length })
+    const spec: TakeSpec = got
+        ? { ...base, version: got.version ?? base.version, length: got.length ?? base.length, world: got.world ?? null, recipe: got.recipe === undefined ? base.recipe : { recipe: got.recipe, files: (base.recipe as { files?: unknown }).files ?? null } }
+        : base
+    const files = new Set(f.files ?? [])
+    return { spec, argv: f.argv.map((w, i) => (files.has(i) ? (c.recipes.get(`file:${w}`)?.path ?? w) : c.recipes.has(w) ? `@${c.recipes.get(w)!.path}` : w)) }
+}
+
+/** every shot's and footage block's take, with its stamp when it was filmed */
+export function takesOf(t: Trailer, root: string, c: TakeContext = { recipes: new Map(), unit: null }): Take[] {
     const dir = trailerCache(root, 'footage')
-    return t.shots.flatMap((shot) => {
+    return [...t.shots, ...t.footage].flatMap((shot) => {
         const film = shot.film
-        if (!isTake(film)) return []
-        const file = join(dir, takeName(shot, film, t))
+        if (!isTake(film) || shot.broken) return []
+        const { spec, argv } = specFor(shot, film, c)
+        const file = join(dir, takeName(shot, film, t, spec))
         const stampFile = `${file}.json`
         const stamp = existsSync(file) && existsSync(stampFile) ? (JSON.parse(readFileSync(stampFile, 'utf8')) as Stamp) : null
-        return [{ shot, film, file, stamp }]
+        return [{ shot, film, file, stamp, spec, ...(argv ? { argv } : {}) }]
     })
 }
 
-const git = (root: string, ...args: string[]): string | null => {
-    const r = spawnSync('git', args, { cwd: root, encoding: 'utf8' })
-    return r.status === 0 ? r.stdout : null
+/** a git run's output, null when it fails; no size limit: a big repo lists many files */
+const git = (root: string, args: string[], env?: Record<string, string>): string | null => {
+    const r = Bun.spawnSync(['git', ...args], { cwd: root, stdout: 'pipe', stderr: 'pipe', ...(env ? { env: { ...process.env, ...env } } : {}) })
+    return r.exitCode === 0 ? r.stdout.toString() : 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 {}
+/**
+ * the world the takes show: every file of the repo as it stands, by its content (`trailer/` and `.shipkit/` left out),
+ * or only the `paths` the trailer unit's `stamp` names; a repo with no git: `no-git`. Content addressed: the working
+ * tree is staged into a throwaway copy of the index and the staged entries hashed, so the same content dirty or
+ * committed is one world, and an edit of the cut alone moves nothing
+ */
+export function worldStamp(root: string, paths?: readonly string[]): string {
+    const real = git(root, ['rev-parse', '--git-path', 'index'])
+    if (real === null) return 'no-git'
+    const spec = paths ? ['--', ...paths] : ['--', '.', ':(exclude)trailer', ':(exclude).shipkit']
+    if (paths) for (const p of paths) if (!existsSync(join(root, p))) throw new Error(`the trailer unit's stamp names a path the repo does not hold: ${p}`)
+    const index = join(tmpdir(), `sk-world-${process.pid}-${Math.random().toString(36).slice(2)}`)
+    try {
+        // a copy of the real index keeps git's stat cache: only the files that changed are read again
+        const from = isAbsolute(real.trim()) ? real.trim() : join(root, real.trim())
+        if (existsSync(from)) copyFileSync(from, index)
+        const env = { GIT_INDEX_FILE: index }
+        if (git(root, ['add', '-A', ...spec], env) === null) throw new Error('git add into the world\'s throwaway index failed')
+        const staged = git(root, ['ls-files', '-s', ...spec], env)
+        if (staged === null) throw new Error('git ls-files of the world\'s throwaway index failed')
+        return new Bun.CryptoHasher('sha1').update(staged).digest('hex').slice(0, 12)
+    } finally {
+        rmSync(index, { force: true })
     }
-    return h.digest('hex').slice(0, 12)
 }
 
 export interface FilmContext {
@@ -55,6 +99,8 @@ export interface FilmContext {
     world: string
     /** the project CLI's argv, null when the repo has none */
     cli: readonly string[] | null
+    /** a clip take that drops its picture is filmed again once, then refused (the unit's `holes`) */
+    holes?: boolean
     say: (line: string) => void
 }
 
@@ -64,12 +110,33 @@ export async function filmTake(tk: Take, c: FilmContext): Promise<Take> {
     const part = tk.file.replace(/(\.\w+)$/, '.part$1')
     rmSync(part, { force: true })
     const t0 = performance.now()
-    const seconds = takeSeconds(tk.shot, tk.film)
+    const seconds = takeSeconds(tk.shot, tk.film, tk.spec.length)
     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) ?? '' }
+    let said = ''
+    for (let attempt = 1; ; attempt++) {
+        said = f.kind === 'url' ? await urlTake(tk, f, part, seconds, c) : await commandTake(tk, f, part, seconds, c)
+        if (still || !c.holes) break
+        const holes = await (await import('./holes.ts')).takeHoles(part)
+        if (holes.length === 0) break
+        const where = `the picture drops out on frames ${holes[0]} to ${holes.at(-1)}`
+        if (attempt >= 2) {
+            rmSync(part, { force: true })
+            throw new Error(`shot ${tk.shot.name} (line ${f.line}): ${where}, twice`)
+        }
+        c.say(`  ${tk.shot.name}: ${where}, filmed again`)
+    }
+    renameSync(part, tk.file)
+    const states = statesOf(said)
+    const first = (said.split('\n')[0] ?? '').replace(/\s·\sstates \S+/, '').replace(part, '').trim()
+    const stamp: Stamp = {
+        world: tk.spec.world ?? c.world,
+        filmedAt: new Date().toISOString(),
+        seconds: still ? 0 : duration(tk.file),
+        note: first.slice(0, 200),
+        ...(states ? { states } : {}),
+        ...(tk.spec.world ? { fixed: true as const } : {}),
+    }
     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 }
@@ -78,13 +145,15 @@ export async function filmTake(tk: Take, c: FilmContext): Promise<Take> {
 /** 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 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, tk.argv)
+    // the cut's frame and rate: a row that films at the cut's size reads them
+    const env = { ...process.env, SK_TRAILER_SIZE: `${c.t.size[0]}x${c.t.size[1]}`, SK_TRAILER_FPS: String(c.t.fps) }
+    const p = Bun.spawn(argv, { cwd: c.root, stdout: 'pipe', stderr: 'pipe', env })
     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(' ')
+        const shown = f.kind === 'run' ? f.cmd : [...(c.cli ?? []), ...(tk.argv ?? 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