calvyn-code 0.14.0

package/skills/creative/manim-video/references/scene-planning.md

@@ -0,0 +1,118 @@
+# Scene Planning Reference
+
+## Narrative Arc Structures
+
+### Discovery Arc (most common)
+1. Hook -- pose a question or surprising result
+2. Intuition -- build visual understanding
+3. Formalize -- introduce the equation/algorithm
+4. Reveal -- the "aha moment"
+5. Extend -- implications or generalizations
+
+### Problem-Solution Arc
+1. Problem -- what's broken
+2. Failed attempt -- obvious approach fails
+3. Key insight -- the idea that works
+4. Solution -- implement it
+5. Result -- show improvement
+
+### Comparison Arc
+1. Setup -- introduce two approaches
+2. Approach A -- how it works
+3. Approach B -- how it works
+4. Contrast -- differences
+5. Verdict -- which is better
+
+### Build-Up Arc (architecture/systems)
+1. Component A -- first piece
+2. Component B -- second piece
+3. Connection -- how they interact
+4. Scale -- add more pieces
+5. Full picture -- zoom out
+
+## Scene Transitions
+
+### Clean Break (default)
+```python
+self.play(FadeOut(Group(*self.mobjects)), run_time=0.5)
+self.wait(0.3)
+```
+
+### Carry-Forward
+Keep one element, fade the rest. Next scene starts with it still on screen.
+
+### Transform Bridge
+End scene with a shape, start next scene by transforming it.
+
+## Cross-Scene Consistency
+
+```python
+# Shared constants at file top
+BG = "#1C1C1C"
+PRIMARY = "#58C4DD"
+SECONDARY = "#83C167"
+ACCENT = "#FFFF00"
+TITLE_SIZE = 48
+BODY_SIZE = 30
+LABEL_SIZE = 24
+FAST = 0.8; NORMAL = 1.5; SLOW = 2.5
+```
+
+## Scene Checklist
+
+- [ ] Background color set
+- [ ] Subcaptions on every animation
+- [ ] `self.wait()` after every reveal
+- [ ] Text buff >= 0.5 for edge positioning
+- [ ] No text overlap
+- [ ] Color constants used (not hardcoded)
+- [ ] Opacity layering applied
+- [ ] Clean exit at scene end
+- [ ] No more than 5-6 elements visible at once
+
+## Duration Estimation
+
+| Content | Duration |
+|---------|----------|
+| Title card | 3-5s |
+| Concept introduction | 10-20s |
+| Equation reveal | 15-25s |
+| Algorithm step | 5-10s |
+| Data comparison | 10-15s |
+| "Aha moment" | 15-30s |
+| Conclusion | 5-10s |
+
+## Planning Template
+
+```markdown
+# [Video Title]
+
+## Overview
+- **Topic**: [Core concept]
+- **Hook**: [Opening question]
+- **Aha moment**: [Key insight]
+- **Target audience**: [Prerequisites]
+- **Length**: [seconds/minutes]
+- **Resolution**: 480p (draft) / 1080p (final)
+
+## Color Palette
+- Background: #1C1C1C
+- Primary: #58C4DD -- [purpose]
+- Secondary: #83C167 -- [purpose]
+- Accent: #FFFF00 -- [purpose]
+
+## Arc: [Discovery / Problem-Solution / Comparison / Build-Up]
+
+## Scene 1: [Name] (~Ns)
+**Purpose**: [one sentence]
+**Layout**: [FULL_CENTER / LEFT_RIGHT / GRID / PROGRESSIVE]
+
+### Visual elements
+- [Mobject: type, position, color]
+
+### Animation sequence
+1. [Animation] -- [what it reveals] (~Ns)
+
+### Subtitle
+"[text]"
+```

package/skills/creative/manim-video/references/troubleshooting.md

@@ -0,0 +1,135 @@
+# Troubleshooting
+
+## LaTeX Errors
+
+**Missing raw string** (the #1 error):
+```python
+# WRONG: MathTex("\\frac{1}{2}")  -- \\f is form-feed
+# RIGHT: MathTex(r"\frac{1}{2}")
+```
+
+**Unbalanced braces**: `MathTex(r"\frac{1}{2")` -- missing closing brace.
+
+**LaTeX not installed**: `which pdflatex` -- install texlive-full or mactex.
+
+**Missing package**: Add to preamble:
+```python
+tex_template = TexTemplate()
+tex_template.add_to_preamble(r"\usepackage{mathrsfs}")
+MathTex(r"\mathscr{L}", tex_template=tex_template)
+```
+
+## VGroup TypeError
+
+**Error:** `TypeError: Only values of type VMobject can be added as submobjects of VGroup`
+
+**Cause:** `Text()` objects are `Mobject`, not `VMobject`. Mixing `Text` with shapes in a `VGroup` fails on Manim CE v0.20+.
+
+```python
+# WRONG: Text is not a VMobject
+group = VGroup(circle, Text("Label"))
+
+# RIGHT: use Group for mixed types
+group = Group(circle, Text("Label"))
+
+# RIGHT: VGroup is fine for shapes-only
+shapes = VGroup(circle, square, arrow)
+
+# RIGHT: MathTex IS a VMobject — VGroup works
+equations = VGroup(MathTex(r"a"), MathTex(r"b"))
+```
+
+**Rule:** If the group contains any `Text()`, use `Group`. If it's all shapes or all `MathTex`, `VGroup` is fine.
+
+**FadeOut everything:** Always use `Group(*self.mobjects)`, not `VGroup(*self.mobjects)`:
+```python
+self.play(FadeOut(Group(*self.mobjects)))  # safe for mixed types
+```
+
+## Group save_state() / restore() Not Supported
+
+**Error:** `NotImplementedError: Please override in a child class.`
+
+**Cause:** `Group.save_state()` and `Group.restore()` are not implemented in Manim CE v0.20+. Only `VGroup` and individual `Mobject` subclasses support save/restore.
+
+```python
+# WRONG: Group doesn't support save_state
+group = Group(circle, Text("label"))
+group.save_state()  # NotImplementedError!
+
+# RIGHT: use FadeIn with shift/scale instead of save_state/restore
+self.play(FadeIn(group, shift=UP * 0.3, scale=0.8))
+
+# RIGHT: or save/restore on individual VMobjects
+circle.save_state()
+self.play(circle.animate.shift(RIGHT))
+self.play(Restore(circle))
+```
+
+## letter_spacing Is Not a Valid Parameter
+
+**Error:** `TypeError: Mobject.__init__() got an unexpected keyword argument 'letter_spacing'`
+
+**Cause:** `Text()` does not accept `letter_spacing`. Manim uses Pango for text rendering and does not expose kerning controls on `Text()`.
+
+```python
+# WRONG
+Text("HERMES", letter_spacing=6)
+
+# RIGHT: use MarkupText with Pango attributes for spacing control
+MarkupText('<span letter_spacing="6000">HERMES</span>', font_size=18)
+# Note: Pango letter_spacing is in 1/1024 of a point
+```
+
+## Animation Errors
+
+**Invisible animation** -- mobject never added:
+```python
+# WRONG: circle = Circle(); self.play(circle.animate.set_color(RED))
+# RIGHT: self.play(Create(circle)); self.play(circle.animate.set_color(RED))
+```
+
+**Transform confusion** -- after Transform(A, B), A is on screen, B is not. Use ReplacementTransform if you want B.
+
+**Duplicate animation** -- same mobject twice in one play():
+```python
+# WRONG: self.play(c.animate.shift(RIGHT), c.animate.set_color(RED))
+# RIGHT: self.play(c.animate.shift(RIGHT).set_color(RED))
+```
+
+**Updater fights animation**:
+```python
+mob.suspend_updating()
+self.play(mob.animate.shift(RIGHT))
+mob.resume_updating()
+```
+
+## Rendering Issues
+
+**Blurry output**: Using -ql (480p). Switch to -qm/-qh for final.
+
+**Slow render**: Use -ql during development. Reduce Surface resolution. Shorter self.wait().
+
+**Stale output**: `manim -ql --disable_caching script.py Scene`
+
+**ffmpeg concat fails**: All clips must match resolution/FPS/codec.
+
+## Common Mistakes
+
+**Text clips at edge**: `buff >= 0.5` for `.to_edge()`
+
+**Overlapping text**: Use `ReplacementTransform(old, new)`, not `Write(new)` on top.
+
+**Too crowded**: Max 5-6 elements visible. Split into scenes or use opacity layering.
+
+**No breathing room**: `self.wait(1.5)` minimum after reveals, `self.wait(2.0)` for key moments.
+
+**Missing background color**: Set `self.camera.background_color = BG` in every scene.
+
+## Debugging Strategy
+
+1. Render a still: `manim -ql -s script.py Scene` -- instant layout check
+2. Isolate the broken scene -- render only that one
+3. Replace `self.play()` with `self.add()` to see final state instantly
+4. Print positions: `print(mob.get_center())`
+5. Clear cache: delete `media/` directory

package/skills/creative/manim-video/references/updaters-and-trackers.md

@@ -0,0 +1,260 @@
+# Updaters and Value Trackers
+
+## The problem updaters solve
+
+Normal animations are discrete: `self.play()` goes from state A to state B. But what if you need continuous relationships — a label that always hovers above a moving dot, or a line that always connects two points?
+
+Without updaters, you'd manually reposition every dependent object before every `self.play()`. Five animations that move a dot means five manual repositioning calls for the label. Miss one and it freezes in the wrong spot.
+
+Updaters let you declare a relationship ONCE. Manim calls the updater function EVERY FRAME (15-60 fps depending on quality) to enforce that relationship, no matter what else is happening.
+
+## ValueTracker: an invisible steering wheel
+
+A ValueTracker is an invisible Mobject that holds a single float. It never appears on screen. It exists so you can ANIMATE it while other objects REACT to its value.
+
+Think of it as a slider: drag the slider from 0 to 5, and every object wired to it responds in real time.
+
+```python
+tracker = ValueTracker(0)        # invisible, stores 0.0
+tracker.get_value()              # read: 0.0
+tracker.set_value(5)             # write: jump to 5.0 instantly
+tracker.animate.set_value(5)     # animate: smoothly interpolate to 5.0
+```
+
+### The three-step pattern
+
+Every ValueTracker usage follows this:
+
+1. **Create the tracker** (the invisible slider)
+2. **Create visible objects that READ the tracker** via updaters
+3. **Animate the tracker** — all dependents update automatically
+
+```python
+# Step 1: Create tracker
+x_tracker = ValueTracker(1)
+
+# Step 2: Create dependent objects
+dot = always_redraw(lambda: Dot(axes.c2p(x_tracker.get_value(), 0), color=YELLOW))
+v_line = always_redraw(lambda: axes.get_vertical_line(
+    axes.c2p(x_tracker.get_value(), func(x_tracker.get_value())), color=BLUE
+))
+label = always_redraw(lambda: DecimalNumber(x_tracker.get_value(), font_size=24)
+    .next_to(dot, UP))
+
+self.add(dot, v_line, label)
+
+# Step 3: Animate the tracker — everything follows
+self.play(x_tracker.animate.set_value(5), run_time=3)
+```
+
+## Types of updaters
+
+### Lambda updater (most common)
+
+Runs a function every frame, passing the mobject itself:
+
+```python
+# Label always stays above the dot
+label.add_updater(lambda m: m.next_to(dot, UP, buff=0.2))
+
+# Line always connects two points
+line.add_updater(lambda m: m.put_start_and_end_on(
+    point_a.get_center(), point_b.get_center()
+))
+```
+
+### Time-based updater (with dt)
+
+The second argument `dt` is the time since the last frame (~0.017s at 60fps):
+
+```python
+# Continuous rotation
+square.add_updater(lambda m, dt: m.rotate(0.5 * dt))
+
+# Continuous rightward drift
+dot.add_updater(lambda m, dt: m.shift(RIGHT * 0.3 * dt))
+
+# Oscillation
+dot.add_updater(lambda m, dt: m.move_to(
+    axes.c2p(m.get_center()[0], np.sin(self.time))
+))
+```
+
+Use `dt` updaters for physics simulations, continuous motion, and time-dependent effects.
+
+### always_redraw: full rebuild every frame
+
+Creates a new mobject from scratch each frame. More expensive than `add_updater` but handles cases where the mobject's structure changes (not just position/color):
+
+```python
+# Brace that follows a resizing square
+brace = always_redraw(Brace, square, UP)
+
+# Area under curve that updates as function changes
+area = always_redraw(lambda: axes.get_area(
+    graph, x_range=[0, x_tracker.get_value()], color=BLUE, opacity=0.3
+))
+
+# Label that reconstructs its text
+counter = always_redraw(lambda: Text(
+    f"n = {int(x_tracker.get_value())}", font_size=24, font="Menlo"
+).to_corner(UR))
+```
+
+**When to use which:**
+- `add_updater` — position, color, opacity changes (cheap, preferred)
+- `always_redraw` — when the shape/structure itself changes (expensive, use sparingly)
+
+## DecimalNumber: showing live values
+
+```python
+# Counter that tracks a ValueTracker
+tracker = ValueTracker(0)
+number = DecimalNumber(0, font_size=48, num_decimal_places=1, color=PRIMARY)
+number.add_updater(lambda m: m.set_value(tracker.get_value()))
+number.add_updater(lambda m: m.next_to(dot, RIGHT, buff=0.3))
+
+self.add(number)
+self.play(tracker.animate.set_value(100), run_time=3)
+```
+
+### Variable: the labeled version
+
+```python
+var = Variable(0, Text("x", font_size=24, font="Menlo"), num_decimal_places=2)
+self.add(var)
+self.play(var.tracker.animate.set_value(PI), run_time=2)
+# Displays: x = 3.14
+```
+
+## Removing updaters
+
+```python
+# Remove all updaters
+mobject.clear_updaters()
+
+# Suspend temporarily (during an animation that would fight the updater)
+mobject.suspend_updating()
+self.play(mobject.animate.shift(RIGHT))
+mobject.resume_updating()
+
+# Remove specific updater (if you stored a reference)
+def my_updater(m):
+    m.next_to(dot, UP)
+label.add_updater(my_updater)
+# ... later ...
+label.remove_updater(my_updater)
+```
+
+## Animation-based updaters
+
+### UpdateFromFunc / UpdateFromAlphaFunc
+
+These are ANIMATIONS (passed to `self.play`), not persistent updaters:
+
+```python
+# Call a function on each frame of the animation
+self.play(UpdateFromFunc(mobject, lambda m: m.next_to(moving_target, UP)), run_time=3)
+
+# With alpha (0 to 1) — useful for custom interpolation
+self.play(UpdateFromAlphaFunc(circle, lambda m, a: m.set_fill(opacity=a)), run_time=2)
+```
+
+### turn_animation_into_updater
+
+Convert a one-shot animation into a continuous updater:
+
+```python
+from manim import turn_animation_into_updater
+
+# This would normally play once — now it loops forever
+turn_animation_into_updater(Rotating(gear, rate=PI/4))
+self.add(gear)
+self.wait(5)  # gear rotates for 5 seconds
+```
+
+## Practical patterns
+
+### Pattern 1: Dot tracing a function
+
+```python
+tracker = ValueTracker(0)
+graph = axes.plot(np.sin, x_range=[0, 2*PI], color=PRIMARY)
+dot = always_redraw(lambda: Dot(
+    axes.c2p(tracker.get_value(), np.sin(tracker.get_value())),
+    color=YELLOW
+))
+tangent = always_redraw(lambda: axes.get_secant_slope_group(
+    x=tracker.get_value(), graph=graph, dx=0.01,
+    secant_line_color=HIGHLIGHT, secant_line_length=3
+))
+
+self.add(graph, dot, tangent)
+self.play(tracker.animate.set_value(2*PI), run_time=6, rate_func=linear)
+```
+
+### Pattern 2: Live area under curve
+
+```python
+tracker = ValueTracker(0.5)
+area = always_redraw(lambda: axes.get_area(
+    graph, x_range=[0, tracker.get_value()],
+    color=PRIMARY, opacity=0.3
+))
+area_label = always_redraw(lambda: DecimalNumber(
+    # Numerical integration
+    sum(func(x) * 0.01 for x in np.arange(0, tracker.get_value(), 0.01)),
+    font_size=24
+).next_to(axes, RIGHT))
+
+self.add(area, area_label)
+self.play(tracker.animate.set_value(4), run_time=5)
+```
+
+### Pattern 3: Connected diagram
+
+```python
+# Nodes that can be moved, with edges that auto-follow
+node_a = Dot(LEFT * 2, color=PRIMARY)
+node_b = Dot(RIGHT * 2, color=SECONDARY)
+edge = Line().add_updater(lambda m: m.put_start_and_end_on(
+    node_a.get_center(), node_b.get_center()
+))
+label = Text("edge", font_size=18, font="Menlo").add_updater(
+    lambda m: m.move_to(edge.get_center() + UP * 0.3)
+)
+
+self.add(node_a, node_b, edge, label)
+self.play(node_a.animate.shift(UP * 2), run_time=2)
+self.play(node_b.animate.shift(DOWN + RIGHT), run_time=2)
+# Edge and label follow automatically
+```
+
+### Pattern 4: Parameter exploration
+
+```python
+# Explore how a parameter changes a curve
+a_tracker = ValueTracker(1)
+curve = always_redraw(lambda: axes.plot(
+    lambda x: a_tracker.get_value() * np.sin(x),
+    x_range=[0, 2*PI], color=PRIMARY
+))
+param_label = always_redraw(lambda: Text(
+    f"a = {a_tracker.get_value():.1f}", font_size=24, font="Menlo"
+).to_corner(UR))
+
+self.add(curve, param_label)
+self.play(a_tracker.animate.set_value(3), run_time=3)
+self.play(a_tracker.animate.set_value(0.5), run_time=2)
+self.play(a_tracker.animate.set_value(1), run_time=1)
+```
+
+## Common mistakes
+
+1. **Updater fights animation:** If a mobject has an updater that sets its position, and you try to animate it elsewhere, the updater wins every frame. Suspend updating first.
+
+2. **always_redraw for simple moves:** If you only need to reposition, use `add_updater`. `always_redraw` reconstructs the entire mobject every frame — expensive and unnecessary for position tracking.
+
+3. **Forgetting to add to scene:** Updaters only run on mobjects that are in the scene. `always_redraw` creates the mobject but you still need `self.add()`.
+
+4. **Updater creates new mobjects without cleanup:** If your updater creates Text objects every frame, they accumulate. Use `always_redraw` (which handles cleanup) or update properties in-place.

package/skills/creative/manim-video/references/visual-design.md

@@ -0,0 +1,124 @@
+# Visual Design Principles
+
+## 12 Core Principles
+
+1. **Geometry Before Algebra** — Show the shape first, the equation second.
+2. **Opacity Layering** — PRIMARY=1.0, CONTEXT=0.4, GRID=0.15. Direct attention through brightness.
+3. **One New Idea Per Scene** — Each scene introduces exactly one concept.
+4. **Spatial Consistency** — Same concept occupies the same screen region throughout.
+5. **Color = Meaning** — Assign colors to concepts, not mobjects. If velocity is blue, it stays blue.
+6. **Progressive Disclosure** — Show simplest version first, add complexity incrementally.
+7. **Transform, Don't Replace** — Use Transform/ReplacementTransform to show connections.
+8. **Breathing Room** — `self.wait(1.5)` minimum after showing something new.
+9. **Visual Weight Balance** — Don't cluster everything on one side.
+10. **Consistent Motion Vocabulary** — Pick a small set of animation types and reuse them.
+11. **Dark Background, Light Content** — #1C1C1C to #2D2B55 backgrounds maximize contrast.
+12. **Intentional Empty Space** — Leave at least 15% of the frame empty.
+
+## Layout Templates
+
+### FULL_CENTER
+One main element centered, title above, note below.
+Best for: single equations, single diagrams, title cards.
+
+### LEFT_RIGHT
+Two elements side by side at x=-3.5 and x=3.5.
+Best for: equation + visual, before/after, comparison.
+
+### TOP_BOTTOM
+Main element at y=1.5, supporting content at y=-1.5.
+Best for: concept + examples, theorem + cases.
+
+### GRID
+Multiple elements via `arrange_in_grid()`.
+Best for: comparison matrices, multi-step processes.
+
+### PROGRESSIVE
+Elements appear one at a time, arranged DOWN with aligned_edge=LEFT.
+Best for: algorithms, proofs, step-by-step processes.
+
+### ANNOTATED_DIAGRAM
+Central diagram with floating labels connected by arrows.
+Best for: architecture diagrams, annotated figures.
+
+## Color Palettes
+
+### Classic 3B1B
+```python
+BG="#1C1C1C"; PRIMARY=BLUE; SECONDARY=GREEN; ACCENT=YELLOW; HIGHLIGHT=RED
+```
+
+### Warm Academic
+```python
+BG="#2D2B55"; PRIMARY="#FF6B6B"; SECONDARY="#FFD93D"; ACCENT="#6BCB77"
+```
+
+### Neon Tech
+```python
+BG="#0A0A0A"; PRIMARY="#00F5FF"; SECONDARY="#FF00FF"; ACCENT="#39FF14"
+```
+
+## Font Selection
+
+**Use monospace fonts for all text.** Manim's Pango text renderer produces broken kerning with proportional fonts (Helvetica, Inter, SF Pro, Arial) at all sizes and resolutions. Characters overlap and spacing is inconsistent. This is a fundamental Pango limitation, not a Manim bug.
+
+Monospace fonts have fixed character widths — zero kerning issues by design.
+
+### Recommended Fonts
+
+| Use case | Font | Fallback |
+|----------|------|----------|
+| **All text (default)** | `"Menlo"` | `"Courier New"`, `"DejaVu Sans Mono"` |
+| Code, labels | `"JetBrains Mono"`, `"SF Mono"` | `"Menlo"` |
+| Math | Use `MathTex` (renders via LaTeX, not Pango) | — |
+
+```python
+MONO = "Menlo"  # define once at top of file
+
+title = Text("Fourier Series", font_size=48, color=PRIMARY, weight=BOLD, font=MONO)
+label = Text("n=1: (4/pi) sin(x)", font_size=20, color=BLUE, font=MONO)
+note = Text("Convergence at discontinuities", font_size=18, color=DIM, font=MONO)
+
+# Math — always use MathTex, not Text
+equation = MathTex(r"\nabla L = \frac{\partial L}{\partial w}")
+```
+
+### When Proportional Fonts Are Acceptable
+
+Large title text (font_size >= 48) with short strings (1-3 words) can use proportional fonts without visible kerning issues. For anything else — labels, descriptions, multi-word text, small sizes — use monospace.
+
+### Font Availability
+
+- **macOS**: Menlo (pre-installed), SF Mono
+- **Linux**: DejaVu Sans Mono (pre-installed), Liberation Mono
+- **Cross-platform**: JetBrains Mono (install from jetbrains.com)
+
+`"Menlo"` is the safest default — pre-installed on macOS, and Linux systems fall back to DejaVu Sans Mono.
+
+### Fine-Grained Text Control
+
+`Text()` does not support `letter_spacing` or kerning parameters. For fine control, use `MarkupText` with Pango attributes:
+
+```python
+# Letter spacing (Pango units: 1/1024 of a point)
+MarkupText('<span letter_spacing="6000">HERMES</span>', font_size=18, font="Menlo")
+
+# Bold specific words
+MarkupText('This is <b>important</b>', font_size=24, font="Menlo")
+
+# Color specific words
+MarkupText('Red <span foreground="#FF6B6B">warning</span>', font_size=24, font="Menlo")
+```
+
+### Minimum Font Size
+
+`font_size=18` is the minimum for readable text at any resolution. Below 18, characters become blurry at `-ql` and barely readable even at `-qh`.
+
+## Visual Hierarchy Checklist
+
+For every frame:
+1. What is the ONE thing to look at? (brightest/largest)
+2. What is context? (dimmed to 0.3-0.4)
+3. What is structural? (dimmed to 0.15)
+4. Enough empty space? (>15%)
+5. All text readable at phone size?

package/skills/creative/manim-video/scripts/setup.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -euo pipefail
+G="\033[0;32m"; R="\033[0;31m"; N="\033[0m"
+ok() { echo -e "  ${G}+${N} $1"; }
+fail() { echo -e "  ${R}x${N} $1"; }
+echo ""; echo "Manim Video Skill — Setup Check"; echo ""
+errors=0
+command -v python3 &>/dev/null && ok "Python $(python3 --version 2>&1 | awk '{print $2}')" || { fail "Python 3 not found"; errors=$((errors+1)); }
+python3 -c "import manim" 2>/dev/null && ok "Manim $(manim --version 2>&1 | head -1)" || { fail "Manim not installed: pip install manim"; errors=$((errors+1)); }
+command -v pdflatex &>/dev/null && ok "LaTeX (pdflatex)" || { fail "LaTeX not found (macOS: brew install --cask mactex-no-gui)"; errors=$((errors+1)); }
+command -v ffmpeg &>/dev/null && ok "ffmpeg" || { fail "ffmpeg not found"; errors=$((errors+1)); }
+echo ""
+[ $errors -eq 0 ] && echo -e "${G}All prerequisites satisfied.${N}" || echo -e "${R}$errors prerequisite(s) missing.${N}"
+echo ""