gitreel 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mohammed S. Yaseen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# gitreel 🎬
+
+**Turn your pull requests into movie trailers.**
+
+gitreel makes narrated, fast-paced, Fireship-style review videos out of GitHub PRs: animated
+architecture diagrams, syntax-highlighted diff morphs, spotlit code close-ups, a local TTS
+narrator with opinions, and a verdict card at the end. Your coding agent writes the screenplay;
+gitreel renders the movie.
+
+<!-- DEMO-VIDEO: drag-drop out/zod-5898.mp4 here in the GitHub editor so it gets a hosted player URL -->
+> 🎥 demo: gitreel reviewing [zod#5898](https://github.com/colinhacks/zod/pull/5898) — a prototype-pollution fix ([video](assets/demo/zod-5898.mp4))
+
+## How it works
+
+gitreel is two pieces:
+
+1. **The `gitreel` CLI** (this package) — the render engine. Remotion-based scene primitives,
+   Kokoro-82M local TTS, synthesized music/SFX, and a workspace where episodes live. No cloud,
+   no API keys: narration, rendering, everything runs on your machine.
+2. **The `gitreel` agent skill** — instructions that teach any coding agent (Claude Code, Cursor,
+   Codex, opencode, …) to read a PR, write the screenplay (narration + scene composition), and
+   drive the CLI. The agent is the writer-director; the CLI is the camera crew.
+
+## Install
+
+```sh
+# 1. the engine
+npm i -g gitreel
+gitreel doctor          # checks node ≥ 20, gh auth, render browser
+
+# 2. the skill (via skills.sh, into your agent's skills)
+npx skills add mohasarc/gitreel
+```
+
+Then, in your agent of choice, from any repo:
+
+```
+/gitreel 5898                       # short video for PR #5898
+/gitreel 5898 long                  # full walkthrough
+/gitreel 5898 --review review.md    # weave your review's findings into the video
+```
+
+The agent checks for the engine and installs it if missing — so honestly, step 2 alone works.
+
+## CLI
+
+The skill drives these, but they're yours too:
+
+```sh
+gitreel new <id>                # scaffold an episode (episode.tsx + narration.json)
+gitreel narrate <id>            # local TTS → per-scene WAVs + duration manifest
+gitreel still <id> --frame 120  # render one frame (cheap visual check)
+gitreel render <id> [--draft]   # render the MP4
+gitreel preview <id>            # open Remotion Studio for live editing
+gitreel where                   # print the workspace (default ~/gitreel, GITREEL_HOME to move)
+gitreel doctor                  # environment checks
+```
+
+Episodes are plain TSX files in your workspace that import scene primitives from
+`gitreel/engine` — `TitleCard`, `DiagramScene`, `DiffMorph`, `CodeScene`, `TerminalScene`,
+`FileTreeScene`, `VerdictCard`, and friends. The narration manifest drives scene durations, so
+audio and visuals never drift. Keep your workspace under git; episodes are re-renderable forever.
+
+A complete real episode lives in [`examples/zod-5898/`](examples/zod-5898/) — the screenplay
+behind the demo video above. To re-render it:
+`cp -r examples/zod-5898 "$(gitreel where)/episodes/" && gitreel narrate zod-5898 && gitreel render zod-5898`.
+
+## Licensing notes
+
+- **gitreel is MIT.**
+- **Remotion** (the render engine underneath) is source-available, **not** MIT: free for
+  individuals and companies of up to 3 people; larger companies need a
+  [Remotion company license](https://www.remotion.dev/license) to render. You render locally,
+  so you are the licensee — check your situation.
+- **Kokoro-82M** (the narrator) is Apache-2.0; the ~90MB model downloads from Hugging Face on
+  first `gitreel narrate`.
+- Music and SFX are synthesized by scripts in this repo — no licensed assets anywhere.
+- Requires **Node ≥ 20** and the **`gh` CLI** (authenticated) for PR fetching.

package/dist/cli/bundling.d.ts

@@ -0,0 +1,3 @@
+export declare function writeEntry(workspace: string, id: string): string;
+export declare function gitreelWebpackOverride(config: Record<string, unknown>): Record<string, unknown>;
+export declare function bundleEpisode(workspace: string, id: string): Promise<string>;

package/dist/cli/bundling.js

@@ -0,0 +1,76 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { bundle } from "@remotion/bundler";
+import { manifestPath, packageRoot, requireEpisode } from "./workspace.js";
+const require = createRequire(import.meta.url);
+export function writeEntry(workspace, id) {
+    const episodeFile = requireEpisode(workspace, id);
+    const manifest = manifestPath(workspace, id);
+    if (!existsSync(manifest)) {
+        throw new Error(`no narration manifest for "${id}" — run \`gitreel narrate ${id}\` first`);
+    }
+    const entry = `import React from "react";
+import { Composition, registerRoot } from "remotion";
+import { FPS, Timeline, totalDurationInFrames } from "gitreel/engine";
+import episode from ${JSON.stringify(episodeFile)};
+import manifest from ${JSON.stringify(manifest)};
+
+const Root = () => (
+  <Composition
+    id={episode.id}
+    component={() => (
+      <Timeline
+        episodeId={episode.id}
+        scenes={episode.scenes}
+        manifest={manifest}
+        music={episode.music}
+        musicVolume={episode.musicVolume}
+      />
+    )}
+    durationInFrames={totalDurationInFrames(episode.scenes, manifest)}
+    fps={FPS}
+    width={1920}
+    height={1080}
+  />
+);
+
+registerRoot(Root);
+`;
+    const entryFile = path.join(workspace, ".cache", `entry-${id}.tsx`);
+    writeFileSync(entryFile, entry);
+    return entryFile;
+}
+const packageDir = (name) => path.dirname(require.resolve(`${name}/package.json`));
+export function gitreelWebpackOverride(config) {
+    const resolve = (config.resolve ?? {});
+    const module = (config.module ?? {});
+    const rules = (module.rules ?? []);
+    return {
+        ...config,
+        resolve: {
+            ...resolve,
+            alias: {
+                ...(resolve.alias ?? {}),
+                "gitreel/engine": path.join(packageRoot, "dist", "engine", "index.js"),
+                react: packageDir("react"),
+                "react-dom": packageDir("react-dom"),
+                remotion: packageDir("remotion"),
+            },
+            modules: [path.join(packageRoot, "node_modules"), "node_modules"],
+        },
+        module: {
+            ...module,
+            rules: [...rules, { test: /\.js$/, resolve: { fullySpecified: false } }],
+        },
+    };
+}
+export async function bundleEpisode(workspace, id) {
+    const entryFile = writeEntry(workspace, id);
+    return bundle({
+        entryPoint: entryFile,
+        publicDir: path.join(workspace, "public"),
+        outDir: path.join(workspace, ".cache", `bundle-${id}`),
+        webpackOverride: gitreelWebpackOverride,
+    });
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import { execFileSync, spawn } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { Command } from "commander";
+import { bundleEpisode, writeEntry } from "./bundling.js";
+import { narrateEpisode } from "./narrate.js";
+import { ensureWorkspace, episodeDir, packageRoot } from "./workspace.js";
+const require = createRequire(import.meta.url);
+const program = new Command();
+const version = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8"))
+    .version;
+program.name("gitreel").description("Turn your pull requests into movie trailers.").version(version);
+program
+    .command("where")
+    .description("print the gitreel workspace path")
+    .action(() => {
+    console.log(ensureWorkspace());
+});
+program
+    .command("new <id>")
+    .description("scaffold a new episode (episode.tsx + narration.json)")
+    .action((id) => {
+    const workspace = ensureWorkspace();
+    const target = episodeDir(workspace, id);
+    if (existsSync(path.join(target, "episode.tsx"))) {
+        console.error(`episode "${id}" already exists at ${target}`);
+        process.exit(1);
+    }
+    mkdirSync(target, { recursive: true });
+    cpSync(path.join(packageRoot, "templates", "episode"), target, { recursive: true });
+    const episodeFile = path.join(target, "episode.tsx");
+    const stamped = readFileSync(episodeFile, "utf8").replace(/EPISODE_ID/g, id);
+    writeFileSync(episodeFile, stamped);
+    console.log(`scaffolded ${target}`);
+    console.log(`next: edit episode.tsx + narration.json, then \`gitreel narrate ${id}\``);
+});
+program
+    .command("narrate <id>")
+    .description("generate narration audio + duration manifest (Kokoro TTS, local)")
+    .option("--force", "regenerate all scenes, ignore cache", false)
+    .action(async (id, options) => {
+    const workspace = ensureWorkspace();
+    await narrateEpisode(workspace, id, options.force);
+});
+program
+    .command("still <id>")
+    .description("render a single frame as PNG (cheap visual verification)")
+    .requiredOption("--frame <n>", "frame number")
+    .option("--out <path>", "output path")
+    .action(async (id, options) => {
+    const workspace = ensureWorkspace();
+    const { renderStill, selectComposition } = await import("@remotion/renderer");
+    const serveUrl = await bundleEpisode(workspace, id);
+    const composition = await selectComposition({ serveUrl, id, inputProps: {} });
+    const frame = Number(options.frame);
+    const output = options.out ?? path.join(workspace, "out", `${id}-f${frame}.png`);
+    await renderStill({ composition, serveUrl, frame, output });
+    console.log(output);
+});
+program
+    .command("render <id>")
+    .description("render the episode to MP4")
+    .option("--out <path>", "output path")
+    .option("--draft", "fast low-quality render for iteration", false)
+    .action(async (id, options) => {
+    const workspace = ensureWorkspace();
+    const { renderMedia, selectComposition } = await import("@remotion/renderer");
+    const serveUrl = await bundleEpisode(workspace, id);
+    const composition = await selectComposition({ serveUrl, id, inputProps: {} });
+    const outputLocation = options.out ?? path.join(workspace, "out", `${id}.mp4`);
+    let lastShown = -1;
+    await renderMedia({
+        composition,
+        serveUrl,
+        codec: "h264",
+        outputLocation,
+        scale: options.draft ? 0.5 : 1,
+        jpegQuality: options.draft ? 60 : 80,
+        onProgress: ({ progress }) => {
+            const percent = Math.floor(progress * 10) * 10;
+            if (percent > lastShown) {
+                lastShown = percent;
+                console.log(`render ${percent}%`);
+            }
+        },
+    });
+    console.log(outputLocation);
+});
+program
+    .command("preview <id>")
+    .description("open Remotion Studio for live-editing the episode")
+    .action((id) => {
+    const workspace = ensureWorkspace();
+    const entryFile = writeEntry(workspace, id);
+    const remotionBin = path.join(path.dirname(require.resolve("@remotion/cli/package.json")), "remotion-cli.js");
+    const child = spawn(process.execPath, [remotionBin, "studio", entryFile, "--public-dir", path.join(workspace, "public")], { cwd: packageRoot, stdio: "inherit" });
+    child.on("exit", (code) => process.exit(code ?? 0));
+});
+program
+    .command("doctor")
+    .description("check the environment: node, gh, browser, workspace")
+    .action(async () => {
+    const checks = [
+        ["node", () => {
+                const major = Number(process.versions.node.split(".")[0]);
+                if (major < 20)
+                    throw new Error(`node ${process.versions.node} — gitreel needs >= 20`);
+                return process.versions.node;
+            }],
+        ["gh CLI", () => {
+                execFileSync("gh", ["auth", "status"], { stdio: "pipe" });
+                return "installed + authenticated";
+            }],
+        ["workspace", () => ensureWorkspace()],
+        ["engine", () => {
+                const engine = path.join(packageRoot, "dist", "engine", "index.js");
+                if (!existsSync(engine))
+                    throw new Error("engine build missing — reinstall gitreel");
+                return engine;
+            }],
+        ["browser", async () => {
+                const { ensureBrowser } = await import("@remotion/renderer");
+                await ensureBrowser();
+                return "headless shell ready";
+            }],
+    ];
+    let failed = false;
+    for (const [label, check] of checks) {
+        try {
+            const detail = await check();
+            console.log(`  ok    ${label}: ${detail}`);
+        }
+        catch (error) {
+            failed = true;
+            console.log(`  FAIL  ${label}: ${error.message}`);
+        }
+    }
+    process.exit(failed ? 1 : 0);
+});
+program.parseAsync().catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+});

package/dist/cli/narrate.d.ts

@@ -0,0 +1 @@
+export declare function narrateEpisode(workspace: string, id: string, force: boolean): Promise<void>;

package/dist/cli/narrate.js

@@ -0,0 +1,41 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { episodeDir, manifestPath } from "./workspace.js";
+export async function narrateEpisode(workspace, id, force) {
+    const scriptFile = path.join(episodeDir(workspace, id), "narration.json");
+    if (!existsSync(scriptFile)) {
+        throw new Error(`no narration script at ${scriptFile} — run \`gitreel new ${id}\` first`);
+    }
+    const script = JSON.parse(readFileSync(scriptFile, "utf8"));
+    const voice = script.voice ?? "am_michael";
+    const speed = script.speed ?? 1.1;
+    const outDir = path.join(workspace, "public", "audio", id);
+    mkdirSync(outDir, { recursive: true });
+    const manifestFile = manifestPath(workspace, id);
+    const previous = existsSync(manifestFile)
+        ? JSON.parse(readFileSync(manifestFile, "utf8"))
+        : null;
+    const manifest = { voice, scenes: {} };
+    console.log("loading Kokoro-82M (first run downloads the model, ~90MB)...");
+    const { KokoroTTS } = await import("kokoro-js");
+    const tts = await KokoroTTS.from_pretrained("onnx-community/Kokoro-82M-v1.0-ONNX", {
+        dtype: "q8",
+        device: "cpu",
+    });
+    for (const scene of script.scenes) {
+        const wavPath = path.join(outDir, `${scene.id}.wav`);
+        const cached = previous?.scenes[scene.id];
+        if (!force && cached && cached.text === scene.text && previous?.voice === voice && existsSync(wavPath)) {
+            manifest.scenes[scene.id] = cached;
+            console.log(`  ${scene.id}: cached (${cached.seconds.toFixed(2)}s)`);
+            continue;
+        }
+        const audio = await tts.generate(scene.text, { voice: voice, speed });
+        await audio.save(wavPath);
+        const seconds = audio.audio.length / audio.sampling_rate;
+        manifest.scenes[scene.id] = { seconds, text: scene.text };
+        console.log(`  ${scene.id}: ${seconds.toFixed(2)}s`);
+    }
+    writeFileSync(manifestFile, JSON.stringify(manifest, null, 2));
+    console.log(`wrote ${manifestFile}`);
+}

package/dist/cli/workspace.d.ts

@@ -0,0 +1,7 @@
+export declare const packageRoot: string;
+export declare function configFilePath(): string;
+export declare function resolveWorkspace(): string;
+export declare function ensureWorkspace(): string;
+export declare function episodeDir(workspace: string, id: string): string;
+export declare function manifestPath(workspace: string, id: string): string;
+export declare function requireEpisode(workspace: string, id: string): string;

package/dist/cli/workspace.js

@@ -0,0 +1,56 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+export function configFilePath() {
+    return path.join(homedir(), ".config", "gitreel", "config.json");
+}
+export function resolveWorkspace() {
+    const fromEnv = process.env.GITREEL_HOME;
+    if (fromEnv)
+        return path.resolve(fromEnv);
+    const configFile = configFilePath();
+    if (existsSync(configFile)) {
+        const config = JSON.parse(readFileSync(configFile, "utf8"));
+        if (config.workspace)
+            return config.workspace;
+    }
+    return path.join(homedir(), "gitreel");
+}
+export function ensureWorkspace() {
+    const workspace = resolveWorkspace();
+    for (const dir of ["episodes", "out", ".cache", "public/audio", "public/music", "public/sfx"]) {
+        mkdirSync(path.join(workspace, dir), { recursive: true });
+    }
+    seedAssets(workspace);
+    const configFile = configFilePath();
+    if (!existsSync(configFile)) {
+        mkdirSync(path.dirname(configFile), { recursive: true });
+        writeFileSync(configFile, JSON.stringify({ workspace }, null, 2));
+    }
+    return workspace;
+}
+function seedAssets(workspace) {
+    const assetsDir = path.join(packageRoot, "assets");
+    for (const kind of ["music", "sfx"]) {
+        const target = path.join(workspace, "public", kind);
+        const source = path.join(assetsDir, kind);
+        if (!existsSync(source))
+            continue;
+        cpSync(source, target, { recursive: true, force: false, errorOnExist: false });
+    }
+}
+export function episodeDir(workspace, id) {
+    return path.join(workspace, "episodes", id);
+}
+export function manifestPath(workspace, id) {
+    return path.join(workspace, "public", "audio", id, "manifest.json");
+}
+export function requireEpisode(workspace, id) {
+    const file = path.join(episodeDir(workspace, id), "episode.tsx");
+    if (!existsSync(file)) {
+        throw new Error(`episode "${id}" not found at ${file} — run \`gitreel new ${id}\` first`);
+    }
+    return file;
+}

package/dist/engine/code/CodeBlock.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { type CodeLang, type TokenLine } from "./highlight";
+export type LineRange = readonly [number, number];
+export declare const CodeBlock: React.FC<{
+    code: string;
+    lang?: CodeLang;
+    fontSize?: number;
+    startLineNumber?: number;
+    showLineNumbers?: boolean;
+    spotlight?: readonly LineRange[];
+    revealAtSecond?: number;
+    highlightColor?: string;
+}>;
+export declare const CodeLine: React.FC<{
+    tokens: TokenLine;
+}>;

package/dist/engine/code/CodeBlock.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { interpolate, useCurrentFrame } from "remotion";
+import { FPS, theme } from "../theme";
+import { useTokenLines } from "./highlight";
+const lineInRanges = (lineNumber, ranges) => ranges.some(([start, end]) => lineNumber >= start && lineNumber <= end);
+export const CodeBlock = ({ code, lang = "typescript", fontSize = 30, startLineNumber = 1, showLineNumbers = true, spotlight = [], revealAtSecond = 0, highlightColor = theme.accent, }) => {
+    const frame = useCurrentFrame();
+    const lines = useTokenLines(code.replace(/\n$/, ""), lang);
+    if (!lines)
+        return null;
+    const lineHeight = fontSize * 1.55;
+    const hasSpotlight = spotlight.length > 0;
+    return (_jsx("div", { style: { fontFamily: theme.fontMono, fontSize, lineHeight: `${lineHeight}px` }, children: lines.map((tokens, i) => {
+            const lineNumber = startLineNumber + i;
+            const revealFrame = revealAtSecond * FPS + i * 1.2;
+            const appear = interpolate(frame, [revealFrame, revealFrame + 6], [0, 1], {
+                extrapolateLeft: "clamp",
+                extrapolateRight: "clamp",
+            });
+            const lit = !hasSpotlight || lineInRanges(lineNumber, spotlight);
+            const opacity = appear * (lit ? 1 : 0.22);
+            return (_jsxs("div", { style: {
+                    display: "flex",
+                    opacity,
+                    transform: `translateX(${(1 - appear) * 24}px)`,
+                    backgroundColor: lit && hasSpotlight ? `${highlightColor}1f` : "transparent",
+                    borderLeft: lit && hasSpotlight ? `4px solid ${highlightColor}` : "4px solid transparent",
+                    paddingLeft: 14,
+                    borderRadius: 4,
+                }, children: [showLineNumbers && (_jsx("span", { style: {
+                            width: fontSize * 1.8,
+                            flexShrink: 0,
+                            textAlign: "right",
+                            marginRight: fontSize * 0.9,
+                            color: theme.textDim,
+                            opacity: 0.55,
+                            userSelect: "none",
+                        }, children: lineNumber })), _jsx(CodeLine, { tokens: tokens })] }, i));
+        }) }));
+};
+export const CodeLine = ({ tokens }) => (_jsx("span", { style: { whiteSpace: "pre" }, children: tokens.length === 0 ? " " : tokens.map((token, i) => (_jsx("span", { style: { color: token.color ?? theme.text }, children: token.content }, i))) }));

package/dist/engine/code/highlight.d.ts

@@ -0,0 +1,6 @@
+import { type ThemedToken } from "shiki";
+declare const LANGS: readonly ["typescript", "tsx", "json", "bash", "diff", "markdown", "text"];
+export type CodeLang = (typeof LANGS)[number];
+export type TokenLine = ThemedToken[];
+export declare function useTokenLines(code: string, lang: CodeLang): TokenLine[] | null;
+export {};

package/dist/engine/code/highlight.js

@@ -0,0 +1,30 @@
+import { useEffect, useState } from "react";
+import { continueRender, delayRender } from "remotion";
+import { createHighlighter } from "shiki";
+const LANGS = ["typescript", "tsx", "json", "bash", "diff", "markdown", "text"];
+let highlighterPromise = null;
+function getHighlighter() {
+    highlighterPromise ??= createHighlighter({
+        themes: ["one-dark-pro"],
+        langs: [...LANGS],
+    });
+    return highlighterPromise;
+}
+export function useTokenLines(code, lang) {
+    const [lines, setLines] = useState(null);
+    const [handle] = useState(() => delayRender(`shiki:${lang}`));
+    useEffect(() => {
+        let cancelled = false;
+        getHighlighter().then((highlighter) => {
+            if (cancelled)
+                return;
+            const tokens = highlighter.codeToTokensBase(code, { lang, theme: "one-dark-pro" });
+            setLines(tokens);
+            continueRender(handle);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [code, lang, handle]);
+    return lines;
+}

package/dist/engine/episode-definition.d.ts

@@ -0,0 +1,8 @@
+import type { SceneSpec } from "./timeline";
+export type EpisodeDefinition = {
+    readonly id: string;
+    readonly title?: string;
+    readonly music?: string;
+    readonly musicVolume?: number;
+    readonly scenes: readonly SceneSpec[];
+};

package/dist/engine/episode-definition.js

@@ -0,0 +1 @@
+export {};

package/dist/engine/index.d.ts

@@ -0,0 +1,16 @@
+export { FPS, theme, severityColor, severityLabel, type Severity } from "./theme";
+export { Timeline, sceneDurationInFrames, totalDurationInFrames, type SceneSpec, type NarrationManifest, } from "./timeline";
+export type { EpisodeDefinition } from "./episode-definition";
+export { CodeBlock, CodeLine, type LineRange } from "./code/CodeBlock";
+export { useTokenLines, type CodeLang, type TokenLine } from "./code/highlight";
+export { SceneShell, Panel, FileChip, ContextTag } from "./scenes/SceneShell";
+export { TitleCard, Pop } from "./scenes/TitleCard";
+export { BigText } from "./scenes/BigText";
+export { CodeScene, type SpotlightBeat, type TreeLine } from "./scenes/CodeScene";
+export { CalloutOverlay, type Finding } from "./scenes/CalloutOverlay";
+export { DiffMorph } from "./scenes/DiffMorph";
+export { DiagramScene, type DiagramNode, type DiagramArrow, type ArrowSide, } from "./scenes/DiagramScene";
+export { FileTreeScene, type FileGroup, type FileEntry, type GroupSpotlight } from "./scenes/FileTreeScene";
+export { MontageBeat, type MontageItem } from "./scenes/MontageBeat";
+export { TerminalScene } from "./scenes/TerminalScene";
+export { VerdictCard, type VerdictCount } from "./scenes/VerdictCard";

package/dist/engine/index.js

@@ -0,0 +1,15 @@
+export { FPS, theme, severityColor, severityLabel } from "./theme";
+export { Timeline, sceneDurationInFrames, totalDurationInFrames, } from "./timeline";
+export { CodeBlock, CodeLine } from "./code/CodeBlock";
+export { useTokenLines } from "./code/highlight";
+export { SceneShell, Panel, FileChip, ContextTag } from "./scenes/SceneShell";
+export { TitleCard, Pop } from "./scenes/TitleCard";
+export { BigText } from "./scenes/BigText";
+export { CodeScene } from "./scenes/CodeScene";
+export { CalloutOverlay } from "./scenes/CalloutOverlay";
+export { DiffMorph } from "./scenes/DiffMorph";
+export { DiagramScene, } from "./scenes/DiagramScene";
+export { FileTreeScene } from "./scenes/FileTreeScene";
+export { MontageBeat } from "./scenes/MontageBeat";
+export { TerminalScene } from "./scenes/TerminalScene";
+export { VerdictCard } from "./scenes/VerdictCard";

package/dist/engine/scenes/BigText.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export declare const BigText: React.FC<{
+    emoji?: string;
+    text: string;
+    sub?: string;
+    color?: string;
+}>;

package/dist/engine/scenes/BigText.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { spring, useCurrentFrame, useVideoConfig } from "remotion";
+import { theme } from "../theme";
+import { SceneShell } from "./SceneShell";
+export const BigText = ({ emoji, text, sub, color = theme.text }) => {
+    const frame = useCurrentFrame();
+    const { fps } = useVideoConfig();
+    const pop = spring({ frame, fps, config: { damping: 12, stiffness: 180, mass: 0.7 } });
+    const subPop = spring({ frame: frame - 12, fps, config: { damping: 15, stiffness: 150, mass: 0.6 } });
+    return (_jsxs(SceneShell, { center: true, children: [_jsxs("div", { style: { textAlign: "center", transform: `scale(${pop}) rotate(${(1 - pop) * -3}deg)` }, children: [emoji && _jsx("div", { style: { fontSize: 170, marginBottom: 24 }, children: emoji }), _jsx("div", { style: { fontFamily: theme.fontDisplay, fontWeight: 900, fontSize: 96, color, maxWidth: 1500 }, children: text })] }), sub && (_jsx("div", { style: {
+                    fontFamily: theme.fontMono,
+                    fontSize: 36,
+                    color: theme.textDim,
+                    marginTop: 44,
+                    opacity: subPop,
+                    transform: `translateY(${(1 - subPop) * 30}px)`,
+                }, children: sub }))] }));
+};

package/dist/engine/scenes/CalloutOverlay.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { type Severity } from "../theme";
+export type Finding = {
+    readonly severity: Severity;
+    readonly title: string;
+    readonly detail?: string;
+    readonly atSecond: number;
+};
+export declare const CalloutOverlay: React.FC<{
+    finding: Finding;
+}>;