rvlib-shipkit 2.3.0 → 2.4.0

package/src/trailer/graph.ts

@@ -1,9 +1,10 @@
 // the stitch's ffmpeg arguments, as data: a piece of the cut (its shots cut to their frames, joined by their cuts, the
 // titles laid over) and the mix of the sound. Pure: stitch.ts runs them, keyed on these very arguments
 import type { CutKind, Shot, Trailer } from './grammar.ts'
-import { GROW_S, musicCues, starts, total } from './grammar.ts'
+import { CUTS, GROW_S, musicCues, starts, total } from './grammar.ts'
 import type { TrailerLook } from './look.ts'
 import { frameAt, frameSpans, type Piece } from './plan.ts'
+import { inFrames, KNOCK_S, outFrames, type TitleMotion, titleMotion } from './motion.ts'
 import type { TitleImage } from './titles.ts'
 
 /** a wipe's edge, as xfade draws it: along x or y, starting from the far side (`from`) or the near one */
@@ -14,24 +15,6 @@ const SEAM_EDGE: Partial<Record<CutKind, { axis: 'x' | 'y'; from: boolean }>> =
     'wipe-down': { axis: 'y', from: false },
 }
 
-const XFADE: Record<Exclude<CutKind, 'hard'>, string> = {
-    fade: 'fade',
-    'dip-black': 'fadeblack',
-    'dip-white': 'fadewhite',
-    'slide-left': 'slideleft',
-    'slide-right': 'slideright',
-    'slide-up': 'slideup',
-    'slide-down': 'slidedown',
-    'whip-left': 'smoothleft',
-    'whip-right': 'smoothright',
-    'wipe-left': 'wipeleft',
-    'wipe-right': 'wiperight',
-    'wipe-up': 'wipeup',
-    'wipe-down': 'wipedown',
-    circle: 'circleopen',
-    pixel: 'pixelize',
-}
-
 /** a grid's or a split's cell: a shot's or a footage block's take, from its `from`, cropped by its `frame` */
 export interface GridCell {
     footage: string
@@ -198,9 +181,107 @@ function flashF(s: Shot): string {
         .join('')
 }
 
-/** a knocked title flies out of the frame in this long, turning this many radians */
-const KNOCK_S = 0.4
-const KNOCK_TURN = 1.4
+/** a frame's own pseudo random number, 0 to 1: the same cut draws the same frames */
+const rnd = (...xs: number[]): number => {
+    const v = Math.sin(xs.reduce((n, x, j) => n + x * [12.9898, 78.233, 37.719, 4.581][j % 4]!, 0)) * 43758.5453
+    return v - Math.floor(v)
+}
+
+/** the cuts the core draws, frame by frame over the frames both shots hold: `a` the shot leaving, `b` the one coming,
+ *  `n` frames, the result labelled `out`. A whip pans both shots past at speed, blurred along the way they fly; a
+ *  glitch tears the picture (colours split, bands torn sideways, grain) round a flicker from one shot to the next; a
+ *  leak burns two soft lights of the look across a dissolve */
+export function drawnCut(kind: CutKind, a: string, b: string, out: string, n: number, i: number, [W, H]: readonly [number, number], fps: number, look: Pick<TrailerLook, 'accent' | 'light'>): string[] {
+    const d = n / fps
+    if (kind === 'leak') {
+        const big = `s=${2 * W}x${H}:r=${fps}:d=${n3(d + 0.2)}:type=radial:speed=0`
+        const [y1, y2, r1, r2] = [Math.round(H * 0.4), Math.round(H * 0.85), Math.round(W * 0.45), Math.round(W * 0.3)]
+        return [
+            `[${a}][${b}]xfade=transition=fade:duration=${n3(d)}:offset=0,format=gbrp[lx${i}]`,
+            `gradients=${big}:n=3:c0=0xffdcaa:c1=${ff(look.accent)}:c2=0x000000:x0=${W}:y0=${y1}:x1=${W + r1}:y1=${y1},format=gbrp,crop=w=${W}:h=${H}:x='${W}*(1.1-t/${n3(d)})':y=0[la${i}]`,
+            `gradients=${big}:n=2:c0=0xff5a46:c1=0x000000:x0=${W}:y0=${y2}:x1=${W + r2}:y1=${y2},format=gbrp,crop=w=${W}:h=${H}:x='${W}*(0.25+0.6*t/${n3(d)})':y=0[lb${i}]`,
+            `[la${i}][lb${i}]blend=all_mode=screen,colorchannelmixer=rr=0.8:gg=0.8:bb=0.8,fade=t=in:st=0:d=${n3(d / 2)},fade=t=out:st=${n3(d / 2)}:d=${n3(d / 2)}[ll${i}]`,
+            `[lx${i}][ll${i}]blend=all_mode=screen:shortest=1,format=yuv420p[${out}]`,
+        ]
+    }
+    const ks = Array.from({ length: n }, (_, k) => k)
+    const g = [
+        `[${a}]split=${n}${ks.map((k) => `[ca${i}_${k}x]`).join('')}`,
+        `[${b}]split=${n}${ks.map((k) => `[cb${i}_${k}x]`).join('')}`,
+        ...ks.flatMap((k) => [`[ca${i}_${k}x]trim=start_frame=${k}:end_frame=${k + 1},setpts=PTS-STARTPTS[ca${i}_${k}]`, `[cb${i}_${k}x]trim=start_frame=${k}:end_frame=${k + 1},setpts=PTS-STARTPTS[cb${i}_${k}]`]),
+    ]
+    for (const k of ks) {
+        const [fa, fb, fo] = [`ca${i}_${k}`, `cb${i}_${k}`, `co${i}_${k}`]
+        const p = (k + 0.5) / n
+        if (kind.startsWith('whip-')) {
+            // eased in and out: the speed peaks mid way, and the blur with it (a box as wide as a frame's travel)
+            const u = p < 0.5 ? 4 * p ** 3 : 1 - (-2 * p + 2) ** 3 / 2
+            const across = kind === 'whip-left' || kind === 'whip-right'
+            const span = across ? W : H
+            const sigma = Math.min(600, (12 * Math.min(p, 1 - p) ** 2 * span * 0.35) / n)
+            const forward = kind === 'whip-left' || kind === 'whip-up'
+            const off = Math.round((forward ? u : 1 - u) * span)
+            const pair = forward ? `[${fa}][${fb}]` : `[${fb}][${fa}]`
+            g.push(`${pair}${across ? 'hstack' : 'vstack'}=inputs=2,crop=${W}:${H}:${across ? off : 0}:${across ? 0 : off},gblur=sigma=${n3(across ? sigma : 0)}:sigmaV=${n3(across ? 0 : sigma)}[${fo}]`)
+            continue
+        }
+        // glitch: the picture flickers from one shot to the other round the middle, torn hardest there
+        const env = Math.sin(Math.PI * p) ** 0.7
+        const flick = p > 0.3 && p < 0.7 && rnd(i, k, 9) < 0.45
+        const src = (p < 0.5) !== flick ? fa : fb
+        g.push(`[${src === fa ? fb : fa}]nullsink`)
+        const dx = Math.round(W * 0.016 * env * (0.4 + rnd(i, k, 1)))
+        const bands = 1 + Math.floor(rnd(i, k, 2) * 3)
+        let cur = `[${src}]format=gbrp,rgbashift=rh=${dx}:bh=${-dx}:gv=${Math.round(dx / 3)}:edge=smear`
+        const parts: string[] = []
+        for (let j = 0; j < bands; j++) {
+            const bh = 2 * Math.round((H * (0.03 + 0.1 * rnd(i, k, j, 3))) / 2)
+            const by = Math.round((H - bh) * rnd(i, k, j, 4))
+            const shift = Math.round((rnd(i, k, j, 5) - 0.5) * W * 0.16 * env)
+            parts.push(`${cur},split[gb${i}_${k}_${j}][gs${i}_${k}_${j}]`, `[gs${i}_${k}_${j}]crop=${W}:${bh}:0:${by}[gt${i}_${k}_${j}]`)
+            cur = `[gb${i}_${k}_${j}][gt${i}_${k}_${j}]overlay=x=${shift}:y=${by}`
+        }
+        g.push(...parts, `${cur},noise=alls=${Math.round(28 * env)}:allf=t+u:all_seed=${i * 977 + k},format=yuv420p[${fo}]`)
+    }
+    g.push(`${ks.map((k) => `[co${i}_${k}]`).join('')}concat=n=${n}:v=1:a=0,settb=1/${fps},setpts=N,format=yuv420p[${out}]`)
+    return g
+}
+
+/** each title's span on the cut, shot by shot: its first and last frame (inclusive) and its seconds, a knock's flight
+ *  in them. A progress step ends the frame before the next one starts: two steps never stand on one frame */
+export function titleSpans(t: Pick<Trailer, 'shots' | 'fps'> & Parameters<typeof starts>[0]): { ta: number; te: number; seconds: number }[][] {
+    const st = starts(t)
+    return t.shots.map((s, i) =>
+        s.titles.map((ti) => {
+            const at = st[i]! + ti.at
+            const seconds = Math.min(ti.for ?? s.length - ti.at, ti.knock === undefined ? Infinity : ti.knock - ti.at + KNOCK_S)
+            const handOff = ti.style === 'progress' && ti.step !== undefined && ti.step.i < ti.step.n ? 1 : 0
+            return { ta: frameAt(at, t.fps), te: Math.floor((at + seconds) * t.fps + 1e-6) - handOff, seconds }
+        }),
+    )
+}
+
+/** each title's entrance and exit in frames (motion.ts), shot by shot: what the build draws and the stitch lays */
+export function titleMotions(t: Pick<Trailer, 'shots' | 'fps'> & Parameters<typeof starts>[0]): TitleMotion[][] {
+    const spans = titleSpans(t)
+    return t.shots.map((s, i) =>
+        s.titles.map((ti, j) => {
+            const sp = spans[i]![j]!
+            return titleMotion({
+                style: ti.style,
+                text: ti.text,
+                ...(ti.in ? { in: ti.in } : {}),
+                ...(ti.out ? { out: ti.out } : {}),
+                ...(ti.knock !== undefined ? { knock: ti.knock - ti.at } : {}),
+                ...(ti.step ? { step: ti.step } : {}),
+                seconds: sp.seconds,
+                frames: Math.max(0, sp.te - sp.ta + 1),
+                fps: t.fps,
+                cover: ti.style === 'short' && sp.ta === 0,
+            })
+        }),
+    )
+}
 
 /** the ffmpeg arguments that render a piece's frames, no sound, and the row of its shots' middle frames for the
  *  contact strip (`thumbs`, when a middle falls in it) */
@@ -340,7 +421,9 @@ export function pieceArgs(a: Pick<StitchInput, 't' | 'sources' | 'titles' | 'loo
             const kind = t.shots[i - 1]!.cut.kind as Exclude<CutKind, 'hard'>
             const d = head / fps
             const edge = SEAM_EDGE[kind]
-            if (edge === undefined) graph.push(`[e${i - 1}][h${i}]xfade=transition=${XFADE[kind]}:duration=${n3(d)}:offset=0,format=yuv420p[j${i}]`)
+            const how = CUTS[kind] as string
+            if (how === 'drawn') graph.push(...drawnCut(kind, `e${i - 1}`, `h${i}`, `j${i}`, head, i, [W, H], fps, a.look))
+            else if (edge === undefined) graph.push(`[e${i - 1}][h${i}]xfade=transition=${how}:duration=${n3(d)}:offset=0,format=yuv420p[j${i}]`)
             else {
                 // a wipe's seam rides its edge: a soft shadow of the look's edge, then a line of its light
                 const across = edge.axis === 'x'
@@ -349,7 +432,7 @@ export function pieceArgs(a: Pick<StitchInput, 't' | 'sources' | 'titles' | 'loo
                 const at = (w: number): string => (across ? `x='${pos}-${w / 2}':y=0` : `x=0:y='${pos}-${w / 2}'`)
                 const [sw, lw] = [Math.round(H / 64), Math.max(4, Math.round(H / 300))]
                 graph.push(
-                    `[e${i - 1}][h${i}]xfade=transition=${XFADE[kind]}:duration=${n3(d)}:offset=0[jw${i}]`,
+                    `[e${i - 1}][h${i}]xfade=transition=${how}:duration=${n3(d)}:offset=0[jw${i}]`,
                     bar(`${ff(a.look.edge)}@0.35`, sw, 'ws'),
                     bar(ff(a.look.light), lw, 'wl'),
                     `[jw${i}][ws${i}]overlay=${at(sw)}:eval=frame:shortest=1[jv${i}]`,
@@ -373,43 +456,34 @@ export function pieceArgs(a: Pick<StitchInput, 't' | 'sources' | 'titles' | 'loo
         cur = 'ends'
     }
 
-    // the titles that show in the piece, wherever their shot is: each faded in and out over its own span
+    // the titles that show in the piece, wherever their shot is: each its entrance's frames, its still held, its exit's
+    // frames (titles.ts drew them all in one box), laid at that box
+    const tspans = titleSpans(t)
     t.shots.forEach((s, i) => {
-        s.titles.forEach((ti, j) => {
-            const at = st[i]! + ti.at
-            const dur = Math.min(ti.for ?? s.length - ti.at, ti.knock === undefined ? Infinity : ti.knock - ti.at + KNOCK_S)
-            // a progress step ends the frame before the next one starts: two steps never stand on one frame
-            const handOff = ti.style === 'progress' && ti.step !== undefined && ti.step.i < ti.step.n ? 1 : 0
-            const [ta, te] = [frameAt(at, fps), Math.floor((at + dur) * fps + 1e-6) - handOff]
+        s.titles.forEach((_, j) => {
+            const { ta, te } = tspans[i]![j]!
             if (te < p.from || ta >= p.to || te < ta) return
-            // a tagline and the logo breathe in slowly; the plates pop; a short's words come quick
-            const short = ti.style === 'short' || ti.style === 'progress'
-            const f = Math.min(ti.style === 'line' || ti.style === 'logo' ? 0.7 : short ? 0.15 : 0.25, dur / 3)
-            // the steps of a progress swap on their beat: the first alone fades in, the last alone fades out
-            const step = ti.style === 'progress' ? ti.step : undefined
-            const fadeIn = step === undefined || step.i === 1
-            const fadeOut = step === undefined || step.i === step.n
-            // a short's caption on the cut's first frame is there whole: frame 0 is the cover the platforms take
-            const cover = ti.style === 'short' && ta === 0
             const img = a.titles[i]![j]!
-            const k = input('-i', img.file)
+            const [nIn, nOut] = [img.in ?? 0, img.out ?? 0]
+            const hold = te - ta + 1 - nIn - nOut
             const [from, to] = [Math.max(ta, base), Math.min(te, p.to - 1)]
-            const kn = ti.knock === undefined ? null : ti.knock - ti.at
-            const hyp = kn === null ? 0 : Math.ceil(Math.hypot(img.w, img.h))
-            const tip = kn === null ? '' : `rotate=a='-${KNOCK_TURN}*pow(max(0,t-${n3(kn)})/${KNOCK_S},2)':ow=${hyp}:oh=${hyp}:c=none,`
-            graph.push(
-                `[${k}:v]format=rgba,loop=loop=${to - ta}:size=1:start=0,setpts=N/${fps}/TB,${tip}${cover || !fadeIn ? '' : `fade=t=in:st=0:d=${n3(f)}:alpha=1,`}${fadeOut && kn === null ? `fade=t=out:st=${n3(dur - f)}:d=${n3(f)}:alpha=1,` : ''}` +
-                    `trim=start_frame=${from - ta},settb=1/${fps},setpts=N+${from - base}[t${i}_${j}]`,
-            )
-            // it rises into place over its fade in, eased, by a fortieth of the frame; counted in frames. A short's
-            // caption slides in from the left instead, eased out over 0.15 s
-            const rise = cover || short ? '0' : `${n3(H / 40)}*pow(max(0,1-(n-${n3(at * fps - base)})/${n3(Math.max(f, 0.05) * fps)}),2)`
-            const slide = cover || ti.style !== 'short' ? '' : `-${n3(H / 32)}*pow(max(0,1-(n-${n3(at * fps - base)})/${n3(0.15 * fps)}),3)`
+            const segs: string[] = []
+            const seq = (pattern: string, n: number, tag: string): void => {
+                const k = input('-framerate', String(fps), '-start_number', '0', '-i', pattern)
+                graph.push(`[${k}:v]format=rgba,trim=end_frame=${n},settb=1/${fps},setpts=N[t${i}_${j}${tag}]`)
+                segs.push(`[t${i}_${j}${tag}]`)
+            }
+            if (nIn > 0) seq(inFrames(img.file), nIn, 'i')
+            if (hold > 0) {
+                const k = input('-i', img.file)
+                graph.push(`[${k}:v]format=rgba,loop=loop=${hold - 1}:size=1:start=0,settb=1/${fps},setpts=N[t${i}_${j}h]`)
+                segs.push(`[t${i}_${j}h]`)
+            }
+            if (nOut > 0) seq(outFrames(img.file), nOut, 'o')
+            const join = segs.length > 1 ? `${segs.join('')}concat=n=${segs.length}:v=1:a=0,` : `${segs[0]}`
+            graph.push(`${join}${segs.length > 1 ? '' : 'null,'}trim=start_frame=${from - ta}:end_frame=${to - ta + 1},settb=1/${fps},setpts=N+${from - base}[t${i}_${j}]`)
             const on = `between(t,${n3((ta - base - 0.5) / fps)},${n3((te - base + 0.5) / fps)})`
-            const flown = kn === null ? '' : `pow(max(0,n-${n3((at + kn) * fps - base)})/${n3(KNOCK_S * fps)},2)`
-            const x = kn === null ? `${img.x}${slide}` : `${img.x - (hyp - img.w) / 2}-${n3(W * 1.1)}*${flown}`
-            const y = kn === null ? `${img.y}+${rise}` : `${img.y - (hyp - img.h) / 2}+${rise}-${n3(H * 0.45)}*${flown}`
-            graph.push(`[${cur}][t${i}_${j}]overlay=x='${x}':y='${y}':eof_action=pass:enable='${on}'[v${i}_${j}]`)
+            graph.push(`[${cur}][t${i}_${j}]overlay=x=${img.x}:y=${img.y}:eof_action=pass:enable='${on}'[v${i}_${j}]`)
             cur = `v${i}_${j}`
         })
     })

package/src/trailer/look.ts

@@ -22,6 +22,9 @@ export interface TrailerLookInput {
     short?: { font?: { file?: string; family?: string; weight?: number }; light?: string; edge?: string; accent?: string }
     /** the vertical short's look (a `vertical` cut), each part `false` to leave it out (vertical.ts) */
     vertical?: VerticalLookInput
+    /** text styles by name, each a title line's words (`style big font "Bebas Neue" in letters`): a title's `style`
+     *  names one; one named like a built in style gives that style its defaults (grammar.ts resolveStyles) */
+    styles?: Record<string, string>
 }
 
 /** what a vertical short wears, image paths repo relative; its colours and face are the look's */

package/src/trailer/motion.ts

@@ -0,0 +1,207 @@
+// a title's entrance and exit, frame by frame: what each move does to the whole title or to each of its letters at a
+// point of its run. Pure: the grammar checks the words, titles.ts draws each state, graph.ts lays the frames. An exit
+// is its move played backwards; the knock is the one exit of its own
+
+export const MOVES = ['none', 'fade', 'rise', 'drop', 'slide', 'pop', 'shake', 'blur', 'wipe', 'typewriter', 'letters', 'wave'] as const
+export type MoveKind = (typeof MOVES)[number]
+/** the moves drawn letter by letter: the title is drawn again each frame, the rest move the drawn title */
+export const LETTER_MOVES: ReadonlySet<MoveKind> = new Set(['typewriter', 'letters', 'wave'])
+
+/** a move a title line names: `in pop 0.4s`; no seconds, its own default */
+export interface Move {
+    kind: MoveKind
+    seconds?: number
+}
+
+/** the whole title at a frame: its alpha, its offset in frame pixels, its scale and turn (radians) about its box's
+ *  middle, a blur in frame pixels, and the share of its width a wipe shows (1: all) */
+export interface Whole {
+    a: number
+    dx: number
+    dy: number
+    s: number
+    rot: number
+    blur: number
+    wipe: number
+}
+
+/** one letter at a frame, about its own middle: alpha, offset in frame pixels, scale */
+export interface Glyph {
+    a: number
+    dx: number
+    dy: number
+    s: number
+}
+
+/** what a frame draws: the whole title's state; with a letter move, each letter's and the plates' and bands' alpha */
+export interface TitleFrame {
+    whole: Whole
+    glyph?: (i: number, n: number) => Glyph
+    decor: number
+}
+
+export const STILL: Whole = { a: 1, dx: 0, dy: 0, s: 1, rot: 0, blur: 0, wipe: 1 }
+const AT_REST: TitleFrame = { whole: STILL, decor: 1 }
+
+const clip01 = (x: number): number => Math.max(0, Math.min(1, x))
+const BACK = 1.70158
+/** an ease out that overshoots a little and settles */
+export const backOut = (x: number): number => 1 + (BACK + 1) * (x - 1) ** 3 + BACK * (x - 1) ** 2
+const inOut = (x: number): number => (x < 0.5 ? 4 * x ** 3 : 1 - (-2 * x + 2) ** 3 / 2)
+const smooth = (x: number): number => x * x * (3 - 2 * x)
+
+/** a knocked title tips and flies out over this long */
+export const KNOCK_S = 0.4
+const KNOCK_TURN = 1.4
+
+/** the frame of `kind` at `p`, 0 (before the entrance) to 1 (at rest), on a frame W by H whose letters are `px` tall */
+export function moveFrame(kind: MoveKind, p: number, [W, H]: readonly [number, number], px: number): TitleFrame {
+    void W
+    p = clip01(p)
+    const whole = (w: Partial<Whole>): TitleFrame => ({ whole: { ...STILL, ...w }, decor: 1 })
+    switch (kind) {
+        case 'none':
+            return AT_REST
+        case 'fade':
+            return whole({ a: p })
+        case 'rise':
+            return whole({ a: p, dy: (H / 40) * (1 - p) ** 2 })
+        case 'drop':
+            return whole({ a: p, dy: -(H / 30) * (1 - p) ** 2 })
+        case 'slide':
+            return whole({ a: p, dx: -(H / 32) * (1 - p) ** 3 })
+        case 'pop':
+            return whole({ a: clip01(p * 3), s: 0.55 + 0.45 * backOut(p) })
+        case 'shake': {
+            const amp = (H / 26) * (1 - p) ** 2
+            return whole({ a: clip01(p * 4), dx: (amp * (Math.sin(p * 53) + 0.5 * Math.sin(p * 31 + 1))) / 1.5, dy: (amp * (Math.cos(p * 47) + 0.5 * Math.sin(p * 23 + 2))) / 1.5, rot: (amp / H) * 0.6 * Math.sin(p * 41) })
+        }
+        case 'blur':
+            return whole({ a: clip01(p * 1.6), blur: (H / 40) * (1 - p) ** 2, s: 1 + 0.04 * (1 - p) })
+        case 'wipe':
+            return whole({ wipe: inOut(p) })
+        case 'typewriter':
+            return { whole: STILL, decor: clip01(p * 4), glyph: (i, n) => ({ a: p * n >= i + 1 - 1e-9 ? 1 : 0, dx: 0, dy: 0, s: 1 }) }
+        case 'letters':
+            return {
+                whole: STILL,
+                decor: clip01(p * 3),
+                glyph: (i, n) => {
+                    const span = 0.45
+                    const q = smooth(clip01((p - (n > 1 ? (i / (n - 1)) * (1 - span) : 0)) / span))
+                    return { a: q, dx: 0, dy: px * 0.4 * (1 - q) ** 2, s: 1 }
+                },
+            }
+        case 'wave':
+            return {
+                whole: STILL,
+                decor: clip01(p * 3),
+                glyph: (i, n) => {
+                    const span = 0.5
+                    const q = clip01((p - (n > 1 ? (i / (n - 1)) * (1 - span) : 0)) / span)
+                    return { a: clip01(q * 2.5), dx: 0, dy: px * 0.7 * (1 - backOut(q)), s: 0.7 + 0.3 * backOut(q) }
+                },
+            }
+    }
+}
+
+/** a knocked title at `q`, 0 (still in place) to 1 (gone): it tips and flies off left and up */
+export function knockFrame(q: number, [W, H]: readonly [number, number]): TitleFrame {
+    const k = clip01(q) ** 2
+    return { whole: { ...STILL, rot: -KNOCK_TURN * k, dx: -W * 1.1 * k, dy: -H * 0.45 * k }, decor: 1 }
+}
+
+/** how many letters a title's text draws: every character but spaces, the `*` marks and the `\n` breaks */
+export const letterCount = (text: string): number => [...text.replaceAll('\\n', '').replace(/[*\s]/g, '')].length
+
+/** a move's length when its line names none; the default entrance and exit keep the style's own (`styleFade`) */
+export function moveSeconds(kind: MoveKind, letters: number): number {
+    switch (kind) {
+        case 'none':
+            return 0
+        case 'typewriter':
+            return 0.045 * letters
+        case 'letters':
+            return 0.3 + 0.03 * letters
+        case 'wave':
+            return 0.35 + 0.035 * letters
+        case 'pop':
+            return 0.35
+        case 'shake':
+        case 'blur':
+        case 'wipe':
+            return 0.5
+        default:
+            return 0.4
+    }
+}
+
+/** the style's own fade: a tagline and the logo breathe in slowly, the plates pop, a short's words come quick */
+export const styleFade = (style: string): number => (style === 'line' || style === 'logo' ? 0.7 : style === 'short' || style === 'progress' ? 0.15 : 0.25)
+
+/** what a title's entrance and exit are, their frames counted */
+export interface TitleMotion {
+    in: { kind: MoveKind; frames: number }
+    out: { kind: MoveKind | 'knock'; frames: number }
+}
+
+/** the title's span in seconds and frames, and what it shows: the words of its line, its style, its step */
+export interface MotionInput {
+    style: string
+    text: string
+    in?: Move
+    out?: Move
+    /** seconds from the title's start to its knock */
+    knock?: number
+    step?: { i: number; n: number }
+    /** seconds it stands, a knock's flight included */
+    seconds: number
+    /** frames it stands */
+    frames: number
+    fps: number
+    /** a short's caption on the cut's first frame: there whole, the cover the platforms take */
+    cover: boolean
+}
+
+/** a title's entrance and exit in frames. With no `in`, a title rises in (a short slides, a progress fades) over its
+ *  style's fade; with no `out`, it fades out over it; a default never takes more than a third of the title, a letter
+ *  move more than half. A progress step swaps on its beat: only the first fades in, only the last fades out */
+export function titleMotion(m: MotionInput): TitleMotion {
+    const fade = Math.min(styleFade(m.style), m.seconds / 3)
+    const letters = letterCount(m.text)
+    const own = (mv: Move | undefined, fallback: MoveKind): [MoveKind, number] => {
+        if (!mv) return [fallback, fallback === 'none' ? 0 : fade]
+        if (mv.seconds !== undefined) return [mv.kind, mv.seconds]
+        return [mv.kind, Math.min(moveSeconds(mv.kind, letters), m.seconds * (LETTER_MOVES.has(mv.kind) ? 0.5 : 1 / 3))]
+    }
+    const firstStep = m.step === undefined || m.step.i === 1
+    const lastStep = m.step === undefined || m.step.i === m.step.n
+    const defIn: MoveKind = m.style === 'short' ? 'slide' : m.style === 'progress' ? 'fade' : 'rise'
+    let [inKind, inS] = m.cover || !firstStep ? ['none' as MoveKind, 0] : own(m.in, defIn)
+    let [outKind, outS]: [MoveKind | 'knock', number] = m.knock !== undefined ? ['knock', KNOCK_S] : !lastStep ? ['none', 0] : own(m.out, 'fade')
+    if (inKind === 'none') inS = 0
+    if (outKind === 'none') outS = 0
+    let a = Math.round(inS * m.fps)
+    let b = Math.round(outS * m.fps)
+    // a title shorter than its moves shares its frames between them
+    if (a + b > m.frames) {
+        const k = m.frames / (a + b)
+        a = Math.floor(a * k)
+        b = Math.floor(b * k)
+    }
+    if (a === 0) inKind = 'none'
+    if (b === 0) outKind = 'none'
+    return { in: { kind: inKind, frames: a }, out: { kind: outKind, frames: b } }
+}
+
+/** the frame `k` of an entrance of `n` frames: frame 0 is before it, the frame after the last at rest */
+export const inFrame = (kind: MoveKind, k: number, n: number, size: readonly [number, number], px: number): TitleFrame => moveFrame(kind, k / n, size, px)
+
+/** the frame `k` of an exit of `n` frames: its move played backwards, the last frame gone; a knock leaves from its
+ *  first frame, still in place */
+export const outFrame = (kind: MoveKind | 'knock', k: number, n: number, size: readonly [number, number], px: number): TitleFrame =>
+    kind === 'knock' ? knockFrame(k / n, size) : moveFrame(kind, 1 - (k + 1) / n, size, px)
+
+/** the files of an entrance's or an exit's frames beside a title's PNG, as ffmpeg reads a numbered run */
+export const inFrames = (file: string): string => `${file}.in-%04d.png`
+export const outFrames = (file: string): string => `${file}.out-%04d.png`

package/src/trailer/plan.ts

@@ -12,8 +12,8 @@ export function footageKey(version: unknown, recipe: unknown, size: readonly [nu
 }
 
 /** a film that writes a take of its own: the others are read where they lie (a clip, an image) or drawn (a card) */
-export type TakeFilm = Extract<Film, { kind: 'run' | 'cli' | 'url' }>
-export const isTake = (f: Film | null): f is TakeFilm => f?.kind === 'run' || f?.kind === 'cli' || f?.kind === 'url'
+export type TakeFilm = Extract<Film, { kind: 'run' | 'cli' | 'url' | 'page' }>
+export const isTake = (f: Film | null): f is TakeFilm => f?.kind === 'run' || f?.kind === 'cli' || f?.kind === 'url' || f?.kind === 'page'
 
 /** the take is one picture, held for the shot */
 export const takeIsStill = (f: TakeFilm): boolean => (f.kind === 'cli' ? f.output === 'still' : f.still === true)

package/src/trailer/prune.ts

@@ -28,7 +28,7 @@ export interface Live {
 /** the live set: each cut read, the name of every cache file its build reads, by the build's own key functions */
 export async function liveSet(root: string): Promise<Live> {
     const live: Live = { footage: new Set(), stems: new Set(), sound: new Set(), score: new Set(), titles: new Set(), broken: [] }
-    const [{ takesOfLoaded }, { trailerCache }, { scoreWavFile }, { scoreModuleFile, scoreModule }, titles, { lookOf }, { loadBrand, identityLogo }] = await Promise.all([
+    const [{ fileOf, takesOfLoaded, titleRequest }, { trailerCache }, { scoreWavFile }, { scoreModuleFile, scoreModule }, titles, { lookOf }, { loadBrand, identityLogo }, fonts, { titleMotions }, { resolveStyles }] = await Promise.all([
         import('./build.ts'),
         import('./footage.ts'),
         import('./score/sound.ts'),
@@ -36,6 +36,9 @@ export async function liveSet(root: string): Promise<Live> {
         import('./titles.ts'),
         import('./look.ts'),
         import('../assets/run-assets.ts'),
+        import('./fonts.ts'),
+        import('./graph.ts'),
+        import('./grammar.ts'),
     ])
     const brand = await loadBrand(root)
     const look = typeof brand === 'string' ? null : lookOf(brand, await identityLogo(root))
@@ -55,7 +58,15 @@ export async function liveSet(root: string): Promise<Live> {
             if (look) {
                 const dir = trailerCache(root, 'titles')
                 names.titles.push(basename(titles.cardFile(dir, t.size, look)))
-                for (const s of t.shots) for (const ti of s.titles) names.titles.push(basename(titles.titleFile(dir, root, ti.text, ti.style, t.size, titles.placeOf(ti), look, ti.step)))
+                resolveStyles(t, (typeof brand === 'object' && brand?.trailer?.styles) || {})
+                const motions = titleMotions(t)
+                t.shots.forEach((s, i) =>
+                    s.titles.forEach((ti, j) => {
+                        const f = ti.fx?.font
+                        const font = f === undefined ? null : fonts.isFontFile(f) ? fileOf(f, l) : fonts.googleFile(f, ti.fx?.weight ?? 400)
+                        names.titles.push(basename(titles.titleFile(dir, { ...titleRequest(l, ti, look, motions[i]![j]!), font })))
+                    }),
+                )
             }
             if (t.score && l.score) {
                 names.score.push(basename(scoreModuleFile(scoreModule(t.score, t.sections).text, trailerCache(root, 'score'))))

package/src/trailer/score/compose.ts

@@ -34,8 +34,9 @@ export function transpose(text: string, semis: number): string {
         .map((tok) => {
             const { mods, body } = splitMods(tok)
             const [note = '', len] = body.split('/')
-            const midi = noteToMidi(note)
-            return midi === null ? tok : mods + midiToNote(midi + semis) + (len === undefined ? '' : `/${len}`)
+            const midis = note.split('+').map(noteToMidi)
+            if (midis.some((m) => m === null)) return tok
+            return mods + midis.map((m) => midiToNote(m! + semis)).join('+') + (len === undefined ? '' : `/${len}`)
         })
         .join(' ')
 }
@@ -238,3 +239,18 @@ export function voice(text: string, which: number, floor: number, bar = 16, rest
     }
     return out.join(' ')
 }
+
+/**
+ * each chord of a chart whole, as one chord token (`D4+F4+A4`): every tone placed at or above `floor` (a midi note),
+ * stacked upward, re-struck per segment and every `restrike` rows. For strings, brass, an organ or a stab.
+ */
+export function chords(text: string, floor: number, bar = 16, restrike = 0): string {
+    const out: string[] = []
+    for (const seg of chart(text, bar)) {
+        let m = seg.chord.root
+        while (m < floor) m += 12
+        const tok = seg.chord.tones.map((iv) => midiToNote(m + iv)).join('+')
+        for (let k = 0; k < seg.rows; k++) out.push(k === 0 || (restrike > 0 && k % restrike === 0) ? tok : '.')
+    }
+    return out.join(' ')
+}

package/src/trailer/score/gm-render.ts

@@ -0,0 +1,43 @@
+// a score's General MIDI tracks as stems: each GM instrument's notes written as a .mid, rendered by FluidSynth with
+// its own room off, read back for the synth to mix into the score's bus (its pan, its send to the room, the master)
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { fluidRender, readWav } from '../sound/fluid.ts'
+import { stemMidi } from './midi.ts'
+import type { CompiledScore } from './score.ts'
+
+/** fluidsynth's gain for a stem: a GM instrument at vol 0.8 then sits near a synth one of the palette (measured on one
+ *  arpeggio: GM piano -26.9 dBFS at gain 1, the palette's keys -19.5) */
+const STEM_GAIN = 2.2
+
+export interface Stem {
+    instrument: string
+    left: Float32Array
+    right: Float32Array
+}
+
+/** the score's GM instruments that play a note before `end` */
+export const gmInstruments = (score: CompiledScore, end: number): string[] =>
+    [...new Set(score.notes.filter((n) => n.time < end && score.instruments[n.instrument]?.osc === 'gm').map((n) => n.instrument))]
+
+/** one stem a GM instrument, `rate` samples a second, its notes up to `end` seconds of the render */
+export function gmStems(score: CompiledScore, end: number, rate: number): Stem[] {
+    const names = gmInstruments(score, end)
+    if (names.length === 0) return []
+    const dir = mkdtempSync(join(tmpdir(), 'sk-gm-'))
+    try {
+        return names.map((name, i) => {
+            const v = score.instruments[name]!.gm!
+            const mid = join(dir, `${i}.mid`)
+            const wav = join(dir, `${i}.wav`)
+            writeFileSync(mid, stemMidi(score.notes.filter((n) => n.instrument === name), v, end))
+            fluidRender(mid, wav, { rate, room: false, gain: STEM_GAIN })
+            const w = readWav(wav)
+            if (w.rate !== rate) throw new Error(`fluidsynth rendered ${name} at ${w.rate} Hz, not ${rate}`)
+            return { instrument: name, left: w.left, right: w.right }
+        })
+    } finally {
+        rmSync(dir, { recursive: true, force: true })
+    }
+}