@olegkoval/agent-skills 1.60.0 → 1.62.0

package/adapters/cursor/olko-creative/skills/shorts-animator/scripts/edge/sound.ts

@@ -0,0 +1,46 @@
+// The soundtrack: every take at its moment on one voice track, the score, and the ducked mix.
+import path from "node:path";
+import { PRESETS, renderSoundtrack } from "../audio/soundtrack.ts";
+import type { Short, Take, Timeline } from "../domain/types.ts";
+import { mix, mkdir, pcm, SR, wav } from "./media.ts";
+
+export const MOODS = ["tender", "hopeful", "night", "wonder", "playful"];
+const LEAD_IN = 0.05;
+
+type Placed = { readonly at: number; readonly data: Float32Array };
+
+const place = (tl: Timeline) => (t: Take, i: number): readonly Placed[] => {
+  if (!t.file) return [];
+  const at = tl.voiceAt[i] ?? 0;
+  return t.slice
+    ? [{ at: Math.round((at - LEAD_IN) * SR), data: pcm(t.file, Math.max(0, (t.from ?? 0) - LEAD_IN), t.dur + 0.15) }]
+    : [{ at: Math.round(at * SR), data: pcm(t.file) }];
+};
+
+/** Sums the takes into one buffer; a take that runs past the end is cut there. */
+function voiceTrack(tl: Timeline, takes: readonly Placed[]): Float32Array {
+  const track = new Float32Array(Math.ceil((tl.duration + 0.5) * SR));
+  takes.forEach(({ at, data }) => data.subarray(0, Math.max(0, track.length - at)).forEach((x, j) => { track[at + j] = (track[at + j] ?? 0) + x; }));
+  return track;
+}
+
+/** Returns the mixed WAV the encoder muxes in. */
+export function soundtrack(dir: string, s: Short, tl: Timeline, takes: readonly Take[]): string {
+  const a = mkdir(dir, "build", "audio");
+  const placed = takes.flatMap(place(tl));
+  const voice = path.join(a, "voice.wav");
+  wav(voice, voiceTrack(tl, placed));
+  const m = s.music;
+  const own = !MOODS.includes(m.mood) && !(m.mood in PRESETS);
+  const music = m.mood === "none" ? null : path.join(a, "music.wav");
+  if (music) {
+    renderSoundtrack(
+      { duration: tl.duration, preset: own ? "tender" : m.mood, music: own ? path.resolve(dir, m.mood) : "auto", cues: [], outroAt: tl.duration - 1.5, musicStart: m.start },
+      music,
+      { seed: m.seed ?? 11 },
+    );
+  }
+  const hasVoice = placed.length > 0;
+  const volume = m.volume ?? (hasVoice ? 0.42 : 0.9);
+  return mix({ voice, music, hasVoice, volume, duration: tl.duration }, path.join(a, "mix.wav"));
+}

package/adapters/cursor/olko-creative/skills/shorts-animator/scripts/edge/voice.ts

@@ -0,0 +1,183 @@
+// The narrator: Kokoro-82M in a private Python, or the person's own recording, timed by transcript.
+// Everything is pinned and the model files are checked by sha256, so a setup is the same setup.
+import { spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { words } from "../domain/captions.ts";
+import { isMap } from "../domain/schema.ts";
+import type { Json, Short, Take } from "../domain/types.ts";
+import { duration, mkdir, run } from "./media.ts";
+
+const HOME = path.join(os.homedir(), ".cache", "shorts-animator");
+const VENV = path.join(HOME, "venv");
+const PY = path.join(VENV, process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
+const TTS = path.join(import.meta.dirname, "..", "tts.py");
+const PACKAGES = ["kokoro-onnx==0.6.1", "soundfile==0.14.0"];
+export const HYPERFRAMES = "hyperframes@0.8.150";
+const NPX = process.platform === "win32" ? "npx.cmd" : "npx";
+const RELEASE = "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0";
+const MODEL = {
+  "kokoro-v1.0.onnx": "7d5df8ecf7d4b1878015a32686053fd0eebe2bc377234608764cc0ef3636a6c5",
+  "voices-v1.0.bin": "bca610b8308e8d99f32e6fe4197e7ec01679264efed0cac9140fe9c29f1fbf7d",
+};
+type ModelFile = keyof typeof MODEL;
+
+export const hash = (...xs: readonly Json[]): string =>
+  crypto.createHash("sha1").update(xs.map((x) => JSON.stringify(x)).join("|")).digest("hex").slice(0, 10);
+
+const sha256 = (f: string): string => crypto.createHash("sha256").update(fs.readFileSync(f)).digest("hex");
+
+/** HyperFrames' cache first (it ships the same files), then ours. */
+const modelFiles = (): readonly [string, string] | undefined => {
+  const hf = path.join(os.homedir(), ".cache", "hyperframes", "tts");
+  const pairs: readonly (readonly [string, string])[] = [
+    [path.join(hf, "models", "kokoro-v1.0.onnx"), path.join(hf, "voices", "voices-v1.0.bin")],
+    [path.join(HOME, "kokoro", "kokoro-v1.0.onnx"), path.join(HOME, "kokoro", "voices-v1.0.bin")],
+  ];
+  return pairs.find(([m, v]) => fs.existsSync(m) && fs.existsSync(v));
+};
+
+const pythonReady = (): boolean => fs.existsSync(PY) && spawnSync(PY, ["-I", "-c", "import kokoro_onnx, soundfile"]).status === 0;
+export const narratorReady = (): boolean => pythonReady() && modelFiles() !== undefined;
+
+const PYTHONS = ["python3.13", "python3.12", "python3.11", "python3.10", "python3", "python", "py"];
+const modernPython = (): string | undefined =>
+  PYTHONS.find((b) => spawnSync(b, ["-c", "import sys; print(sys.version_info >= (3, 10) and sys.version_info < (3, 14))"], { encoding: "utf8" }).stdout?.trim() === "True");
+
+function installPython(log: (m: string) => void): string | undefined {
+  mkdir(HOME);
+  if (spawnSync("uv", ["--version"]).status === 0) {
+    log("· setting up the narrator's Python (uv)...");
+    spawnSync("uv", ["venv", "-q", "--allow-existing", "-p", "3.12", VENV], { stdio: "inherit" });
+    spawnSync("uv", ["pip", "install", "-q", "-p", PY, ...PACKAGES], { stdio: "inherit" });
+  } else {
+    const py = modernPython();
+    if (!py) return 'the narrator needs Python 3.10 to 3.13, or uv (https://docs.astral.sh/uv/). Or set voice to "none", or use your own recording';
+    log(`· setting up the narrator's Python (${py})...`);
+    spawnSync(py, ["-m", "venv", VENV], { stdio: "inherit" });
+    spawnSync(PY, ["-m", "pip", "install", "-q", ...PACKAGES], { stdio: "inherit" });
+  }
+  return pythonReady() ? undefined : `couldn't install ${PACKAGES.join(" ")} into ${VENV}`;
+}
+
+async function download(dir: string, f: ModelFile, log: (m: string) => void): Promise<string | undefined> {
+  log(`· downloading the voice model: ${f}...`);
+  const res = await fetch(`${RELEASE}/${f}`);
+  if (!res.ok) return `couldn't download ${f} (${res.status})`;
+  const part = path.join(dir, f + ".part");
+  fs.writeFileSync(part, Buffer.from(await res.arrayBuffer()));
+  if (sha256(part) !== MODEL[f]) {
+    fs.rmSync(part);
+    return `${f} failed its checksum; nothing was installed`;
+  }
+  fs.renameSync(part, path.join(dir, f));
+  return undefined;
+}
+
+/** Sets the narrator up. Returns undefined when ready, or what is missing. */
+export async function setupNarrator(log: (m: string) => void = console.log): Promise<string | undefined> {
+  const py = pythonReady() ? undefined : installPython(log);
+  if (py || modelFiles()) return py;
+  const dir = mkdir(HOME, "kokoro");
+  const files: readonly ModelFile[] = ["voices-v1.0.bin", "kokoro-v1.0.onnx"];
+  return files.reduce<Promise<string | undefined>>(async (prev, f) => (await prev) ?? download(dir, f, log), Promise.resolve(undefined));
+}
+
+/* ------------------------------------------------------------------ takes */
+
+const silent = (s: Short): readonly Take[] => s.lines.map((l) => ({ file: null, dur: Math.max(1.3, words(l.say).length * 0.36) }));
+
+type Job = { readonly text: string; readonly file: string };
+
+const kokoroJobs = (s: Short, vdir: string, id: string, speed: number): readonly (Job & { readonly fresh: boolean })[] =>
+  s.lines.map((l, i) => {
+    const text = (l.speak ?? l.say).replace(/\*|\|/g, "");
+    const n = String(i + 1).padStart(2, "0");
+    const file = path.join(vdir, `${n}-${hash(text, id, speed)}.wav`);
+    return { text, file, fresh: fs.existsSync(file) };
+  });
+
+/** A line's text changed: its old take goes, so the folder never holds two takes of one line. */
+const dropStale = (vdir: string, file: string): void => {
+  const prefix = path.basename(file).slice(0, 3);
+  fs.readdirSync(vdir).filter((f) => f.startsWith(prefix) && f !== path.basename(file)).forEach((f) => fs.rmSync(path.join(vdir, f)));
+};
+
+async function kokoro(s: Short, vdir: string, id: string, speed: number, quiet: boolean): Promise<readonly Take[]> {
+  const jobs = kokoroJobs(s, vdir, id, speed);
+  const todo = jobs.filter((j) => !j.fresh);
+  if (todo.length) {
+    const why = narratorReady() ? undefined : await setupNarrator();
+    const files = modelFiles();
+    if (why || !files) throw new Error(why ?? "no voice model");
+    todo.forEach((j) => dropStale(vdir, j.file));
+    if (!quiet) console.log(`· narrating ${todo.length} line${todo.length > 1 ? "s" : ""} with ${id} (Kokoro, on this computer)...`);
+    run(PY, ["-I", TTS, ...files, id, String(speed)], { input: JSON.stringify(todo.map((j) => [j.text, j.file])) });
+  }
+  return jobs.map((j) => ({ file: j.file, dur: duration(j.file) }));
+}
+
+type Word = { readonly start: number; readonly end: number };
+
+/** Every {word|text, start, end} in a transcript, wherever the tool nested it. */
+const pickWords = (o: Json | undefined): readonly Word[] => {
+  if (Array.isArray(o)) return o.flatMap(pickWords);
+  if (!isMap(o)) return [];
+  const { start, end } = o;
+  if ((o.word || o.text) && typeof start === "number" && typeof end === "number" && !o.words) return [{ start, end }];
+  return Object.values(o).flatMap(pickWords);
+};
+
+const parseTranscript = (raw: string): Json | undefined => {
+  try {
+    const v: unknown = JSON.parse(raw.slice(raw.indexOf("{")));
+    return isMap(v) ? v : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+function transcriptWords(src: string, vdir: string, quiet: boolean): readonly Word[] {
+  const tj = path.join(vdir, `transcript-${hash(fs.statSync(src).mtimeMs, src)}.json`);
+  if (!fs.existsSync(tj)) {
+    if (!quiet) console.log("· transcribing your recording for the timing...");
+    fs.writeFileSync(tj, run(NPX, ["--yes", HYPERFRAMES, "transcribe", src, "--json", "-d", vdir], { cwd: vdir }));
+  }
+  const direct = pickWords(parseTranscript(fs.readFileSync(tj, "utf8")));
+  const side = fs.readdirSync(vdir).find((f) => f.endsWith("transcript.json") && !f.startsWith("transcript-"));
+  const ws = direct.length || !side ? direct : pickWords(parseTranscript(fs.readFileSync(path.join(vdir, side), "utf8")));
+  return ws.toSorted((a, b) => a.start - b.start);
+}
+
+/** Their own recording: each line takes the next run of words, in order. */
+function ownRecording(s: Short, dir: string, vdir: string, file: string, quiet: boolean): readonly Take[] {
+  const src = path.resolve(dir, file);
+  if (!fs.existsSync(src)) throw new Error(`voice.file ${file} not found`);
+  const ws = transcriptWords(src, vdir, quiet);
+  if (!ws.length) throw new Error("couldn't read word timings from the transcript");
+  const word = (i: number): Word => ws[Math.min(i, ws.length - 1)] ?? { start: 0, end: 0 };
+  const firsts = s.lines.map((_, i) => s.lines.slice(0, i).reduce((n, l) => n + words(l.say).length, 0));
+  return s.lines.map((l, i) => {
+    const a = word(firsts[i] ?? 0);
+    const b = word((firsts[i] ?? 0) + words(l.say).length - 1);
+    return { file: src, from: a.start, dur: Math.max(0.6, b.end - a.start), slice: true };
+  });
+}
+
+export async function narrate(dir: string, s: Short, quiet = false): Promise<readonly Take[]> {
+  const vdir = mkdir(dir, "voice");
+  const v = s.voice;
+  if (v.kind === "none") return silent(s);
+  if (v.kind === "file") return ownRecording(s, dir, vdir, v.file, quiet);
+  return kokoro(s, vdir, v.id, v.speed, quiet);
+}
+
+/** Timing without narrating: cached Kokoro takes when every line has one, word-count estimates otherwise. */
+export function cachedTakes(dir: string, s: Short): readonly Take[] {
+  const v = s.voice;
+  if (v.kind !== "kokoro") return silent(s);
+  const jobs = kokoroJobs(s, path.join(dir, "voice"), v.id, v.speed);
+  return jobs.every((j) => j.fresh) ? jobs.map((j) => ({ file: j.file, dur: duration(j.file) })) : silent(s);
+}

package/adapters/cursor/olko-creative/skills/shorts-animator/scripts/looks/gouache.json

@@ -0,0 +1,7 @@
+{
+  "about": "Gouache storybook: flat matte shapes, crisp edges, a little brush texture and paper. Calm and graphic.",
+  "mode": "strokes", "brush": 6, "length": 2.2, "layers": 2, "swirl": 0.2, "flow": 300, "curve": 0.3,
+  "bristle": 0.35, "impasto": 0.1, "hueJitter": 0.05, "valueJitter": 0.07, "satJitter": 0.1, "respect": 1,
+  "boil": 0.3, "paper": 0.8, "grain": 0.35, "saturation": 1.02, "contrast": 1.02, "warmth": 0.1, "vignette": 0.15, "bloom": 0.05,
+  "captions": { "style": "box", "size": 44 }
+}

package/adapters/cursor/olko-creative/skills/shorts-animator/scripts/looks/ink.json

@@ -0,0 +1,6 @@
+{
+  "about": "Ink and wash, like a graphic novel: wobbly hand-inked outlines that boil, flat washes of colour, paper.",
+  "mode": "wash", "wash": 0.5, "bleed": 0.3, "outline": 0.95, "ink": "#1b1712", "paper": 0.7, "paperColor": "#f4efe3",
+  "grain": 0.3, "boil": 1, "posterize": 0, "saturation": 0.85, "contrast": 1.05, "warmth": 0.1, "vignette": 0.1, "bloom": 0,
+  "captions": { "style": "box", "size": 44, "box": "rgba(27,23,18,0.8)" }
+}

package/adapters/cursor/olko-creative/skills/shorts-animator/scripts/looks/oil.json

@@ -0,0 +1,7 @@
+{
+  "about": "Oil paint on canvas: swirling strokes, deep saturated colour, a slow shimmer. The painted-shorts look.",
+  "mode": "strokes", "brush": 11, "length": 2.8, "layers": 3, "swirl": 0.7, "flow": 160, "curve": 0.9,
+  "bristle": 0.75, "impasto": 0.6, "hueJitter": 0.2, "valueJitter": 0.22, "satJitter": 0.35, "respect": 0.85,
+  "boil": 0.5, "paper": 0.6, "grain": 0.5, "saturation": 1.18, "contrast": 1.06, "warmth": 0.2, "vignette": 0.35, "bloom": 0.3,
+  "captions": { "style": "box", "size": 44, "y": 0.775 }
+}

package/adapters/cursor/olko-creative/skills/shorts-animator/scripts/looks/pastel.json

@@ -0,0 +1,7 @@
+{
+  "about": "Soft pastel / crayon on toned paper: straight chalky hatching, paper tooth everywhere, pale gentle colour.",
+  "mode": "strokes", "brush": 6, "length": 4.6, "layers": 3, "swirl": 0.05, "flow": 600, "curve": 0,
+  "bristle": 1, "impasto": 0, "hueJitter": 0.1, "valueJitter": 0.3, "satJitter": 0.2, "respect": 0.5,
+  "boil": 0.8, "paper": 1.6, "grain": 0.8, "saturation": 0.82, "contrast": 0.9, "warmth": 0.35, "vignette": 0.2, "bloom": 0.1,
+  "captions": { "style": "box", "size": 44 }
+}

package/adapters/cursor/olko-creative/skills/shorts-animator/scripts/looks/watercolor.json

@@ -0,0 +1,6 @@
+{
+  "about": "Watercolour on cold-press paper: soft bleeding washes, pigment pooled at the edges, granulation, light and airy.",
+  "mode": "wash", "wash": 0.9, "bleed": 0.8, "paper": 0.9, "paperColor": "#f6f1e6", "grain": 0.25, "boil": 0.4,
+  "outline": 0, "saturation": 0.92, "contrast": 0.96, "warmth": 0.1, "vignette": 0.12, "bloom": 0.1,
+  "captions": { "style": "box", "size": 44, "box": "rgba(34,38,58,0.58)" }
+}

package/adapters/cursor/olko-creative/skills/shorts-animator/scripts/package.json

@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "module"
+}

package/adapters/cursor/olko-creative/skills/shorts-animator/scripts/runtime/globals.d.ts

@@ -0,0 +1,199 @@
+/*
+ * Ambient types shared by kit.ts, paint.ts and stage.ts. This file is a script
+ * (no import/export), so everything here is global. It is never shipped: the
+ * three runtime scripts are type-stripped and loaded as classic <script> tags.
+ */
+
+type Pt = [number, number];
+type Seed = number | string;
+type Palette = Record<string, string>;
+type Rng = () => number;
+
+/* ---------- the timeline the CLI builds (window.SHORT) ---------- */
+
+interface PaintLook {
+  mode?: string;
+  brush?: number; length?: number; layers?: number; swirl?: number; flow?: number; curve?: number;
+  bristle?: number; impasto?: number; hueJitter?: number; valueJitter?: number; satJitter?: number;
+  respect?: number; boil?: number; paper?: number; grain?: number; wash?: number; bleed?: number;
+  outline?: number; ink?: string; paperColor?: string; posterize?: number; saturation?: number;
+  contrast?: number; warmth?: number; vignette?: number; bloom?: number;
+}
+
+type PaintSettings = Required<PaintLook>;
+
+type PaintNumberKey =
+  | "brush" | "length" | "layers" | "swirl" | "flow" | "curve" | "bristle" | "impasto"
+  | "hueJitter" | "valueJitter" | "satJitter" | "respect" | "boil" | "paper" | "grain"
+  | "wash" | "bleed" | "outline" | "posterize" | "saturation" | "contrast" | "warmth"
+  | "vignette" | "bloom";
+
+interface Captions {
+  style?: string; size?: number; weight?: number | string; font?: string; case?: string;
+  width?: number; y?: number; box?: string; color?: string;
+}
+
+interface Look extends PaintLook {
+  palette?: Palette;
+  captions?: Captions;
+}
+
+interface Beat {
+  line: number; scene: string; start: number; dur: number;
+  move?: string; moveAmount?: number; seed?: Seed; transition?: string; fadeDur?: number;
+  say?: string; caption?: string;
+}
+
+interface CaptionChunk { at: number; end: number; text: string }
+
+interface Short {
+  W: number; H: number; fps: number; twos: number; duration: number;
+  beats: Beat[]; track?: CaptionChunk[]; voiceAt?: number[];
+  look: Look; captions?: Captions;
+}
+
+/* ---------- options each kit helper takes (all optional unless marked) ---------- */
+
+type SkyStop = string | [number, string];
+
+interface SkyOpts { stops?: SkyStop[]; y0?: number; y1?: number }
+interface CloudsOpts {
+  y?: number; band?: number; n?: number; color?: string; shade?: string | null; size?: number;
+  drift?: number; seed?: Seed; opacity?: number; perspective?: boolean;
+}
+interface SunOpts { x?: number; y?: number; r?: number; color?: string; glow?: string; glowSize?: number; glowAlpha?: number }
+interface GlowOpts { x: number; y: number; r?: number; color?: string; a?: number }
+interface StarsOpts { n?: number; y1?: number; color?: string; size?: number; seed?: Seed }
+interface RaysOpts {
+  x?: number; y?: number; angle?: number; spread?: number; n?: number; length?: number;
+  color?: string; a?: number; width?: number;
+}
+interface RainOpts { n?: number; color?: string; a?: number; slant?: number; length?: number; speed?: number; seed?: Seed }
+interface MotesOpts { n?: number; y0?: number; y1?: number; color?: string; r?: number; seed?: Seed }
+interface HazeOpts { y?: number; h?: number; color?: string; a?: number }
+interface RidgeOpts {
+  y?: number; amp?: number; freq?: number; color?: string; shape?: string; seed?: Seed;
+  to?: number; x0?: number; x1?: number; top?: string | null;
+}
+interface GroundOpts {
+  y?: number; color?: string; far?: string | null; stripes?: number; stripe?: string | null;
+  flowers?: number; flower?: string; seed?: Seed;
+}
+interface PathOpts { x?: number; y?: number; near?: number; far?: number; color?: string; to?: number; bend?: number }
+interface WaterOpts {
+  y0?: number; y1?: number; color?: string; deep?: string; glint?: string; glints?: number;
+  seed?: Seed; speed?: number;
+}
+interface WaterfallOpts { x?: number; w?: number; y0?: number; y1?: number; color?: string; shade?: string; speed?: number }
+interface TreeOpts {
+  x?: number; y?: number; h?: number; kind?: string; crown?: string; trunk?: string;
+  fruit?: string | null; seed?: Seed;
+}
+interface TreesOpts {
+  n?: number; y?: number; h?: number; x0?: number; x1?: number; kind?: string; crown?: string;
+  trunk?: string; jitter?: number; seed?: Seed;
+}
+interface FoliageOpts {
+  side?: string; x?: number | null; y0?: number; y1?: number; depth?: number;
+  color?: string; light?: string; seed?: Seed;
+}
+interface TrunksOpts {
+  n?: number; color?: string; light?: string; y1?: number; seed?: Seed; x0?: number; x1?: number; width?: number;
+}
+interface HouseOpts {
+  x?: number; y?: number; w?: number; h?: number; wall?: string; roof?: string; window?: string;
+  lit?: boolean; litColor?: string; floors?: number; aFrame?: boolean;
+}
+interface CityOpts {
+  y?: number; h?: number; color?: string; lit?: boolean; litColor?: string; density?: number;
+  n?: number; seed?: Seed; x0?: number; x1?: number;
+}
+interface PagodaOpts { x?: number; y?: number; h?: number; color?: string; tiers?: number }
+interface PoleOpts { x?: number; y?: number; h?: number; color?: string; wires?: number }
+interface BlockOpts { x0: number; y0: number; x1: number; y1: number; color?: string; edge?: string | null; edgeWidth?: number }
+interface LampOpts { x?: number; y?: number; h?: number; color?: string; light?: string; pool?: boolean }
+interface ShapeOpts { pts: Pt[]; color?: string; smooth?: boolean }
+interface HeartOpts { x?: number; y?: number; s?: number; color?: string }
+interface PersonOpts {
+  x?: number; y?: number; h?: number; pose?: string; facing?: string; hair?: string;
+  skin?: string; hairColor?: string; top?: string; bottom?: string; shoes?: string;
+  robe?: boolean; rim?: string | null; silhouette?: string | null; walk?: number; dx?: number;
+  scale?: number; flip?: boolean; build?: number;
+}
+
+/* ---------- the kit a scene receives: (k) => { ... } ---------- */
+
+interface Kit {
+  g: CanvasRenderingContext2D;
+  W: number; H: number; u: number; t: number; p: number;
+  r: Rng;
+  pal: Palette;
+  beat: Beat;
+  mix: (a: string, b: string, t: number) => string;
+  alpha: (c: string, a: number) => string;
+  rng: (seed: number) => Rng;
+  noise1: (seed: number) => (x: number) => number;
+  X: (x: number) => number;
+  Y: (y: number) => number;
+  sky: (o?: SkyOpts) => void;
+  clouds: (o?: CloudsOpts) => void;
+  sun: (o?: SunOpts) => void;
+  glow: (o: GlowOpts) => void;
+  stars: (o?: StarsOpts) => void;
+  rays: (o?: RaysOpts) => void;
+  rain: (o?: RainOpts) => void;
+  motes: (o?: MotesOpts) => void;
+  haze: (o?: HazeOpts) => void;
+  ridge: (o?: RidgeOpts) => void;
+  ground: (o?: GroundOpts) => void;
+  path: (o?: PathOpts) => void;
+  water: (o?: WaterOpts) => void;
+  waterfall: (o?: WaterfallOpts) => void;
+  tree: (o?: TreeOpts) => void;
+  trees: (o?: TreesOpts) => void;
+  foliage: (o?: FoliageOpts) => void;
+  trunks: (o?: TrunksOpts) => void;
+  house: (o?: HouseOpts) => void;
+  city: (o?: CityOpts) => void;
+  pagoda: (o?: PagodaOpts) => void;
+  pole: (o?: PoleOpts) => void;
+  block: (o: BlockOpts) => void;
+  lamp: (o?: LampOpts) => void;
+  shape: (o: ShapeOpts) => void;
+  heart: (o?: HeartOpts) => void;
+  person: (o?: PersonOpts) => void;
+  people: (list: PersonOpts[]) => void;
+}
+
+type SceneFn = (k: Kit) => void;
+
+interface ShortsKitApi {
+  make: (
+    g: CanvasRenderingContext2D, W: number, H: number, t: number, p: number,
+    seed: number, pal: Palette | undefined, beat: Beat,
+  ) => Kit;
+  rng: (seed: number) => Rng;
+  hashStr: (s: Seed) => number;
+  mix: (a: string, b: string, t: number) => string;
+  alpha: (c: string, a: number) => string;
+}
+
+interface Painter {
+  paint: (flat: HTMLCanvasElement, look: PaintLook, tick: number) => void;
+}
+
+interface ShortsPaintApi {
+  Painter: (canvas: HTMLCanvasElement) => Painter;
+  DEFAULTS: PaintSettings;
+}
+
+interface Window {
+  SHORT: Short;
+  IMAGES: Record<string, HTMLImageElement>;
+  SCENES: Record<string, SceneFn | undefined>;
+  ShortsKit: ShortsKitApi;
+  ShortsPaint: ShortsPaintApi;
+  drawing: (d: number) => string;
+  still: (i: number, at: number) => string;
+  ready: boolean;
+}