Skip to content

Short vertical cut-paper explainer reels, made by your coding agent. Nine Agent Skills plus a Remotion library. Works with Claude Code, OpenCode, Codex, Gemini CLI, Cursor, Copilot and more.

58.8 KB
Raw Blame

Papercut kit catalog (generated by tools/catalog.py; do not edit)

The kit is synced into each project at src/lib/ (papercut/sync_kit.sh). Scenes import it as ../lib/<file>. Read this file instead of the kit source. Open a source file only when you need a detail that isn't here. If a scene needs something the kit lacks, build it in your scene file. The lead promotes reusable pieces into the kit after the episode (HARVEST.md).

cast/Critter.tsx (import from '../lib/cast/Critter')

The one base creature for the whole cast: a boxy paper critter with eyes only and stubby limbs. Cast members differ by colour, accessory and name pill. (x, y) is the ground point under the body.

  • type Expr = 'idle' | 'sleep' | 'shock' | 'happy' | 'worried' | 'blink' | 'squint';
  • type Acc = 'none' | 'postCap' | 'monocle' | 'headphones' | 'visor' | 'cap' | 'hardhat' | 'beret' | 'glasses' | 'headset' | 'bowtie';
  • <Critter x: number; y: number; size?: number; color?: string; shade?: string; expr?: Expr; acc?: Acc; tag?: string; tagColor?: string; armR?: number; armRAngle?: number; armL?: number; armLAngle?: number; // reach 0–1, angle deg (negative = up) lean?: number; lift?: n…>

fonts.ts (import from '../lib/fonts')

Fonts from local files in public/fonts/: the exact woff2 files @remotion/google-fonts used to fetch at render time. Two problems this fixes: 1. Network: every render tab fetched the fonts from fonts.gstatic.com, so a Wi-Fi blip failed the whole render. 2. Banner jitter: TapeBanner sizes its text with fitText(). A tab that measured before the font arrived cached the fallback width, so the banner ju

  • const fontsReady: Promise<void> = Promise.all(
  • const fontsLoaded = () => loaded;

paper/backdrops.tsx (import from '../lib/paper/backdrops')

Backdrops: 24 paper-diorama sets (1080x1920 JPEGs in public/bg/backdrops/) to use instead of , so each scene can sit in its own place. Layout contract for every set: floor line near y 1420 (measured per set in BACKDROPS), calm middle band for props and UI, calm top for the banner, plain bottom for captions, light from the top-left, no people or text baked in. Stand props and critters on BACK

  • const BACKDROPS = {: Every backdrop name with its measured floor line (px y at 1080x1920) and mood (day, night, warm, cool). Props and critters stand on floorY.
  • type BackdropName = keyof typeof BACKDROPS;: Union of the backdrop names, for typing a scene's backdrop prop.
  • <Backdrop name: BackdropName; tint?: string; dim?: number>: Backdrop: full-frame generated set (object-fit cover), a drop-in for . Optional tint multiplies a colour over it, dim (0-1) darkens it toward black.

paper/camera.tsx (import from '../lib/paper/camera')

Camera moves for papercut sets: parallax orbit (OrbitCamera + Depth layers), foreground pass, rack focus, snap zoom, pull-back reveal and freeze frame. A fake camera moving through a paper diorama; all motion from useCurrentFrame(). Moves transform the whole frame, so the banner zone (y < 420) and the caption band (y 1420-1580) move too: keep key props and faces out of both.

  • <OrbitCamera dur: number; yaw?: number; drift?: [number, number]; push?: number; focus?: number; depth?: number; origin?: [number, number]; children: React.ReactNode>: Parallax orbit: the camera arcs yaw degrees (16) around the focal plane while dollying to push, so layers separate. origin = pivot px (near the floor line), depth = layer spacing, drift = pan px.
  • <Depth z: number; cover?: boolean; children: React.ReactNode>: Depth layer in : z 0 = backdrop (auto-oversized to cover), ~0.5 = props and cast, 1 = foreground. Lay each out at normal screen positions; the camera adds the parallax. Outside an OrbitCamera it is a plain fill.
  • <ForegroundPass at: number; dur?: number; kind?: 'leaf' | 'cable' | 'block'; from?: 'left' | 'right'; y?: number; blur?: number; scale?: number; dim?: number>: Blurred paper object (kind leaf | cable | block) sweeps across the lens from the from side over dur frames from at, and a faint shadow dims the set. Put it last in the stack; y moves its anchor.
  • <RackFocus from?: number; to?: number; at?: number; dur?: number; bleed?: boolean; returnAt?: number; holdFrames?: number; children: React.ReactNode>: Blur wrapper: eases blur from to to px over dur frames from at. Wrap the backdrop (set bleed to hide its soft edge) or a hero prop; use opposite pairs on two planes to pull focus between them. returnAt / holdFrames make it a …
  • <SnapZoom at: number; x?: number; y?: number; to?: number; settle?: number; shake?: number; roll?: number; blur?: boolean; children: React.ReactNode>: Punch-in to the focal point (x, y): 1 to to (1.25) in 4 frames with radial motion blur, a 3-frame shake and a little roll, then settles at settle. For numbers and joke landings: at = the frame the thing lands.
  • <PullBack dur: number; x: number; y: number; from?: number; at?: number; blur?: boolean; children: React.ReactNode>: Pull-back reveal: starts fromx (2.8) tight on the detail at (x, y), eases out to the whole set over dur frames with motion blur on the first frames. Edges stay covered. Shows scale.
  • <FreezeFrame at: number; label?: string; x?: number; y?: number; rot?: number; size?: number; mark?: 'left' | 'right' | false; children: React.ReactNode>: Meme beat: holds the child on frame at (Freeze), desaturates, darkens the edges, then slaps on a torn paper label (at x, y) with a stamp bounce and a record-scratch mark (left|right). Pair with SFX scratch at at.
  • <DollyZoom dur: number; at?: number; strength?: number; grow?: number; focus?: number; depth?: number; origin?: [number, number]; children: React.ReactNode>: Dolly zoom for the REALISATION beat ("oh no"): the subject layer (z = focus) holds its size, near layers swell and the backdrop shrinks and spreads. Build it from layers. strength 1.5; <1 reverses.
  • const crabFrames = (stops: number[], hold = 14, move = 10) => stops.length * hold + (stops.length - 1) * move;: Total frames a CrabTrack takes: a hold at every stop and a move between stops.
  • <CrabTrack stops: number[]; hold?: number; move?: number; at?: number; parallax?: number; focus?: number; blur?: boolean; children: React.ReactNode>: Crab track (a flat side-on track) for LISTS, lineups and comparisons: slides along a set wider than the frame, easing to each x in stops (world px) and holding hold frames. Put layers in (z 0.45 = items).
  • <Crane dur: number; height: number; mode?: 'rise' | 'drop'; at?: number; pitch?: number; parallax?: number; focus?: number; blur?: boolean; origin?: [number, number]; children: React.ReactNode>: Crane for SCALE reveals and "meanwhile, below": a vertical move through a tall set (layers in , world y = screen y at the top). drop descends height px through dollhouse floors; rise climbs and tilts to a high angle.
  • <PovMask kind?: 'keyhole' | 'lens' | 'binoculars' | 'phone'; x?: number; y?: number; size?: number; reticle?: boolean; at?: number; sway?: number; zoom?: number; children: React.ReactNode>: POV mask for SPY and PRIVACY beats: the child is seen through a paper keyhole, lens, binoculars or phone viewfinder (kind) in a dark surround, with handheld sway and a crosshair reticle. (x, y) = view centre; at = raise frame.
  • <TimeRamp segments: {until: number; rate: number}[]; start?: number; trail?: boolean; push?: number; children: React.ReactNode>: Time ramp (speed ramp / bullet time) for the DRAMATIC beat: remaps the child's clock. segments = [{until (outer frame), rate}]: 0.2 = slow-mo, 0 = frozen, >1 = fast with a trail; 1 after the last. start = inner frame at 0.
  • <DutchTilt deg?: number; at?: number; judder?: number; children: React.ReactNode>: Dutch tilt for "things going wrong": the frame rolls to deg (10) with a back-ease snap from at, then judders on twos. Scaled up so the rotated frame still covers the canvas (a big crop at 1080 x 1920, so keep key props central).
  • <TiltShift focus?: number; band?: number; blur?: number; sat?: number; children: React.ReactNode>: Tilt shift for MINIATURE scale ("a tiny paper world"): blurs the top and bottom bands so the diorama reads as a toy model, and lifts saturation. focus = sharp band centre (0-1), band = its height, blur = px at the edges.
  • <FocusPulse at: number; dur?: number; children: React.ReactNode>: Focus pulse, the hunt alone on a static shot: it goes soft and snaps back over dur frames (18) from at. For REVEALS and emphasis (a number lands, a prop is named) without moving the camera.
  • <FocusHunt at: number; dur?: number; amount?: number; x?: number; y?: number; children: React.ReactNode>: Focus hunt for REVEALS: pushes in on a number or key prop at (x, y) from 1x to 1+amount (1 = 2x) over dur frames (30) with a hard ease, and the lens hunts for focus part-way through (starts at 10/30 of dur, lasts 18/30).
  • <Handheld amount?: number; roll?: number; rate?: number; settleAt?: number; children: React.ReactNode>: ---------- handheld ---------- Handheld camera for lit-by-fire and tense scenes: a slow, deterministic multi-sine drift (x, y, roll) plus a faint breathing scale. amount = px of drift, roll = deg, rate = frames per drift cycle; `sett…

paper/hook.tsx (import from '../lib/paper/hook')

Hook title: the reel's cover title (torn paper tags) on screen from frame 0, so the muted first frame carries the hook and matches the profile-grid cover. It slaps in place over frames 0–10 (frame 0 is already the full title), boils on threes, then lifts away over 7 frames ending at outAt. PapercutVideo holds the taped banner back until outAt. Configure in episode.json "hook" (build_vo.py copi

  • type TornTitleProps = {lines: string[][]; hot?: string[]; size?: number; seed?: string; jitter?: number};
  • <TornTag word: string; hot: boolean; size: number; seed: string; jitter?: number>: One torn paper word tag, the same look as the reel covers.
  • <TornTitle TornTitleProps & {step?: number>: Lines of torn tags, centred.
  • type HookTitleProps = {lines: string[][]; hot?: string[]; outAt: number; top?: number; size?: number};
  • <HookTitle HookTitleProps>

paper/kit.tsx (import from '../lib/paper/kit')

Papercut kit: every prop is paper (grain + rough cut edge + drop shadow), shading is stacked cut pieces, motion is transforms driven by useCurrentFrame(). No CSS animations.

  • const GRAIN = staticFile('bg/grain.png');
  • const PaperDefs: React.FC = () => (: ---------- filters, mounted once at the root ----------
  • <Paper children: React.ReactNode; lift?: number; torn?: boolean; style?: React.CSSProperties>: Paper wrapper for a whole prop: rough edge + drop shadow (light from the top-left).
  • <Slab x: number; y: number; w: number; h: number; color: string; r?: number | string; shade?: string; shadeH?: number; hi?: string; hiH?: number; rot?: number; grain?: number; children?: React.ReactNode; style?: React.CSSProperties;>: One cut piece of paper. (x, y) is the top-left corner. shade adds a darker underside strip, hi a lighter top strip.
  • <Disc x: number; y: number; d: number; color: string; shade?: string; children?: React.ReactNode; style?: React.CSSProperties>: Paper disc (circle). (x, y) is the center.
  • <Pill x: number; y: number; text: string; bg?: string; color?: string; size?: number; rot?: number; center?: boolean>: Pill label: bold sans caps. (x, y) is the center (unless center={false}).
  • <Card x: number; y: number; w: number; h: number; lines?: number; rot?: number; color?: string; children?: React.ReactNode; seed?: string>: Cream paper card with grey "text" bars. (x, y) is the top-left corner, like Slab.
  • <PopIn at: number; seed?: string; children: React.ReactNode; origin?: string; style?: React.CSSProperties>: ---------- motion ----------
  • <SlideIn at: number; dx?: number; dy?: number; dur?: number; children: React.ReactNode>
  • <Boil amp?: number; rot?: number; seed?: string; children: React.ReactNode>: Stop-motion boil for screen-space paper overlays: hold 2 frames, then jump.
  • <CameraPush dur: number; to?: number; origin?: string; drift?: [number, number]; accent?: number; children: React.ReactNode>: Scene camera: smooth push toward a focal point, plus an optional accent push at accent.
  • <Bg src: string; tint?: string>
  • <Blink on: React.ReactNode; off: React.ReactNode; hz?: number; from?: number>
  • <SparkleBurst at: number; x: number; y: number; seed?: string; spread?: number>
  • <RadioWaves x: number; y: number; dir?: number; color?: string; from?: number>
  • <Typewriter text: string; at: number; fpc?: number; caret?: boolean>
  • <DrawOnEllipse at: number; x: number; y: number; w: number; h: number; color?: string; stroke?: number; dur?: number>: Hand-drawn red annotation ellipse, drawn on over ~8 frames.
  • <StampMark at: number; x: number; y: number; text: string; color?: string; size?: number; rot?: number>: Rubber-stamp mark: ink rectangle with a rough double border, lands with a thump.
  • const GrainOverlay: React.FC = () => {
  • const bob = (f: number, period = 36, amp = 3, phase = 0) => Math.sin(((f + phase) / period) * Math.PI * 2) * amp;: Idle helpers
  • const hop = (f: number, at: number, dur = 12, h = 14) => { const u = (f - at) / dur; return u > 0 && u < 1 ? Math.sin(u * Math.PI) * h : 0; };
  • const reach = (f: number, at: number, back?: number) => {

paper/look.tsx (import from '../lib/paper/look')

Film-look layers for papercut reels: gate weave and exposure flicker (FilmWeave), moving felt fibre (FeltFibre), lens dirt, lamp flicker, print halftone and graph paper. Overlays use the textures in public/bg/textures/ (synced by sync_kit.sh). Keep every one of them subtle. Overlays sit above the set and below the banner and captions; FilmWeave wraps the set.

  • <FilmWeave amp?: number; flicker?: number; seed?: string; children: React.ReactNode>: Film gate weave plus exposure flicker, for a photographed, stop-motion feel: the frame drifts about 1.5 px with a hair of rotation, stepped on twos, and brightness wobbles 2.5% (seeded). amp / flicker scale each (1 = default).
  • <FeltFibre opacity?: number; blend?: Blend>: Moving felt-fibre overlay (felt-fibre.mp4, 12 fps on purpose, looped), a living alternative to GrainOverlay. The grey base is crushed to black so only the bright fibres show, then screened on at opacity 0.3.
  • <LensDirt opacity?: number; at?: number; x?: number; y?: number; r?: number; blend?: Blend>: Lens dirt (smudges, dust) for lit dioramas and FocusHunt moments: screened on, so it lifts the darks; (x, y, r) confines it to a lamp or flash. at = fade-in frame. Subtle at best; color-dodge hits only highlights but washes cream paper.
  • const flickerAt = (f: number, seed = 'lamp', depth = 0.4, every = 42) => {: The brightness multiplier (about 0.3-1.03) of a flickering light at frame f: a gentle shimmer plus an occasional organic dip and recovery. Seeded, so a render never changes. depth = how far a dip goes, every = frames per chance of one.
  • <LampFlicker seed?: string; depth?: number; every?: number; children: React.ReactNode>: Wraps a light source's glow (a Glow, a lit lamp shade) so it flickers: occasional organic dips that recover, seeded per lamp. Use flickerAt for your own maths. Differ the seed between lamps.
  • <Halftone opacity?: number; tone?: number; at?: number; blend?: Blend; children?: React.ReactNode>: Print texture for "newspaper", "report" and "leak document" beats: a scanned print grain multiplied over the frame. With children it also washes the colour toward newsprint (tone 0-1 desaturation). opacity 0.4.
  • <GraphPaper x?: number; y?: number; w?: number; h?: number; rot?: number; tint?: string; dim?: number; children?: React.ReactNode>: Graph paper for plan, sketch and maths beats. With no box it is a full-frame backdrop (tint multiplies a colour, dim darkens); with (x, y, w, h) it is a paper card surface with the usual rough edge and shadow, tilted by rot.

paper/motion.ts (import from '../lib/paper/motion')

Small keyframe helpers every hand-animated scene reuses (so scene files do not each carry a copy). keyed = piecewise eased value through [frame, value] keys; swing = decaying follow-through; onN = stepped "on twos"; clamp01 and lcg are the usual 0-1 clamp and a seeded random.

  • const keyed = (f: number, keys: [number, number][], ease: (t: number) => number = Easing.out(Easing.cubic)) => {
  • const swing = (f: number, at: number, amp: number, tau = 9, period = 14) =>
  • const onN = (f: number, n = 2) => f - (f % n);
  • const clamp01 = (v: number) => Math.min(1, Math.max(0, v));
  • const lcg = (seed: number) => { let s = seed; return () => { s = (s * 1664525 + 1013904223) % 4294967296; return s / 4294967296; }; };

paper/overlays.tsx (import from '../lib/paper/overlays')

Screen-space overlays: taped headline banner (boils on twos) and word-pop torn caption tags.

  • <TapeBanner text: string; seed: string>
  • const pageWords = (caps: Caption[], max = 3): Page[] => {
  • <WordTagCaptions captions: Caption[]; bandY: (ms: number) => number>

paper/proof.tsx (import from '../lib/paper/proof')

Proof beat: a real browser capture laid on a paper card (RealShot) with hand-drawn red marker strokes over it (MarkerCircle, MarkerUnderline, MarkerArrow). Use it once per reel, on the proof beat: it is the one place a real page, real logos and real UI appear. Capture the page with lib/tools/capture.mjs. Marker strokes are filled ribbons (varying width, rough ends) revealed by a stroke-dashoffset

  • <RealShot src: string; x: number; y: number; w: number; ratio?: number; rot?: number; tape?: boolean; at?: number; chrome?: string; children?: React.ReactNode>: A real screenshot (public/ PNG from tools/capture.mjs) on a paper card: tape corners, shadow, print grain, pop-in at at. ratio = image h/w (capture.mjs prints it); chrome = URL text for a paper browser bar; children share the tilt.
  • <MarkerCircle x: number; y: number; w: number; h: number; at: number; dur?: number; color?: string; loops?: number; seed?: string; width?: number; bleed?: boolean>: Hand-drawn red marker ellipse around the centre (x, y), w x h, drawn on over dur frames from at (default 10). Overshoots its start (loops 1.15). bleed (on) = felt-tip ink: ragged edge, pooling at start and end. width = pen px.
  • <MarkerUnderline x: number; y: number; w: number; at: number; dur?: number; color?: string; double?: boolean; seed?: string; width?: number; bleed?: boolean>: Hand-drawn red marker underline from (x, y) across w px, left to right, with a slight slope and wobble; double adds a second pass back underneath.
  • <MarkerArrow x: number; y: number; tx: number; ty: number; at: number; dur?: number; color?: string; bend?: number; seed?: string; width?: number; bleed?: boolean>: Hand-drawn red marker arrow from (x, y) to the tip (tx, ty): a slightly bowed shaft, then two barbs. bend = how much the shaft bows (0.14 of its length).

paper/sets.tsx (import from '../lib/paper/sets')

Set building blocks: a room per set (tinted paper wall + floor band), generated decor props, and the whip-pan into the CTA. Light from the top-left everywhere.

  • <Room color: RoomColor | string; floorY?: number; floor?: 'wood' | 'dark' | 'none'; skirting?: boolean>: Room: flat wall colour × mottled paper wall texture (multiply) + vignette, then a floor band. floorY is the floor line (characters stand on it). Captions sit on the floor band (y ≈ 1430–1560); keep faces above y 1400.
  • <Plant x: number; y: number; s?: number>: Decor props, cut from paper in code. (x, y) is the top-left; s scales the whole prop.
  • <Lamp x: number; y: number; s?: number; on?: boolean>
  • <Corkboard x: number; y: number; w: number; h: number>
  • <Window x: number; y: number; w?: number; h?: number; night?: boolean>
  • <Shelf x: number; y: number; w: number; books?: number>: Wall shelf with a few book spines.
  • <Sticky x: number; y: number; s?: number; color?: string; rot?: number>: Sticky note on a wall.
  • <WhipIn dur?: number; from?: number; children: React.ReactNode>: Whip-pan into a set: the frame arrives from the right with a horizontal motion smear (~7 frames).

paper/tape.tsx (import from '../lib/paper/tape')

Tape corners: two strips of paper tape across the top corners of a card, so a wall-hung prop is never loose. (x, y, w, h) = the card's box and rot its own tilt (about its centre, like NumberCard / PRCard).

  • <TapeCorners x: number; y: number; w: number; h?: number; rot?: number; len?: number>

paper/transitions.tsx (import from '../lib/paper/transitions')

Paper transitions between scenes: whip, zoomThrough, pageTurn (curl), tearAway, tapePull (a kraft tape strip), stampCut, infiniteZoom (Droste), popUpBook (+ PopUpOpen) and keyhole. Use in place of in PapercutVideo: cuts={{S05: {kind: 'pageTurn'}}}, keyed by the INCOMING scene, no entry = hard cut. Scene start frames stay on plan.json. Needs .

  • type CutKind = 'whip' | 'zoomThrough' | 'pageTurn' | 'tearAway' | 'tapePull' | 'stampCut' | 'infiniteZoom' | 'popUpBook' | 'keyhole' | 'burnAway';: Story beats: whip topic switch, zoomThrough go inside, pageTurn next step, tearAway something breaks, tapePull the default cut, stampCut verdict, infiniteZoom recursion joke, popUpBook chapter or opener, keyhole sneaking in / spying / a he…
  • const CUT_DEFAULTS: Record<CutKind, {frames: number; sfx: string}> = {: Default frames and suggested SFX per kind: whip 7 'whip', zoomThrough 8 'zoom', pageTurn 12 'page-flip', tearAway 10 'rip', tapePull 10 'tape-peel', stampCut 12 'stamp' (+3 frames, on the thump), infiniteZoom 24 'zoom', popUpBook 20 'pop3'…
  • const whip = (o: {blur?: number; overlap?: number} = {}) => pres(Whip, o);: whip, 7 frames, SFX whip: the outgoing scene shoots off left, the incoming arrives from the right, both with a strong horizontal motion smear. For a fast topic switch or a "meanwhile". blur = peak smear in px (46).
  • const zoomThrough = (o: {x?: number; y?: number; scale?: number; trails?: number} = {}) => pres(ZoomThrough, o);: zoomThrough, 8 frames, SFX zoom: pushes hard into the focal point (x, y px) of the outgoing scene until it fills the frame and blurs; the incoming scene scales 1.15 -> 1 and unblurs. For going inside a screen, door or mirror.
  • const pageTurn = (o: {style?: 'curl' | 'fold'; angle?: number; from?: 'bottom' | 'top'; back?: string} = {}) => pres(PageTurn, o);: pageTurn, 12 frames, SFX page-flip: the outgoing scene is a sheet of paper whose corner curls over like a book page (cylindrical highlight, paper back, cast shadow). For "next step", "turn the page", a new chapter. style 'fold' = flat fold…
  • const tearAway = (o: {x?: number; jag?: number; seed?: string} = {}) => pres(TearAway, o);: tearAway, 10 frames, SFX rip: the outgoing scene rips in two along a jagged vertical tear (x px, default 540) with white fibrous edges; the halves fall away. For a broken promise, a leak, "ripped off", cancelling something. jag = roughness.
  • const tapePull = (o: {y?: number; label?: string} = {}) => pres(TapePull, o);: tapePull, 10 frames, SFX tape-peel: a kraft strip (plain, or printed with label) slaps across the top of the outgoing sheet (y px, 175) and is yanked up, dragging the sheet off with a tilt and a flap. A good default cut.
  • const stampCut = (o: {x?: number; y?: number; ink?: string} = {}) => pres(StampCut, o);: stampCut, 12 frames, SFX stamp: a 3/4-view paper rubber stamp slams into the middle (x, y px), squashes, shakes the sheet and springs out the top, leaving an inked impression with the incoming scene inside it, which grows to fill the frame…
  • const infiniteZoom = (o: {levels?: number; x?: number; y?: number; w?: number; bezel?: string} = {}) => pres(Droste, o);: infiniteZoom, 24 frames, SFX zoom: Droste. A paper screen (x, y, w px) appears in the outgoing scene showing a smaller copy of it; the camera dives through levels nested copies (2) and lands in the incoming scene. For recursion jokes: ca…
  • const popUpBook = (o: {style?: 'dim' | 'kraft'} = {}) => pres(PopUpBook, o);: popUpBook, 20 frames, SFX pop3: the previous scene dims, an open book slides up, and the incoming set rises out of its gutter as three pop-up cards (backdrop, props, foreground) with fold shadows. For a chapter change or "let me show you".…
  • const keyhole = (o: KeyholeOpts = {}) => pres(Keyhole, o);: keyhole, 14 frames, SFX click: a heist iris. A near-black paper card closes over the outgoing scene leaving a keyhole window (middle at x, y px) that shrinks until shut, holds ~2 frames on black, then the window re-opens on the incoming sc…
  • const burnAway = (o: BurnOpts = {}) => pres(Burn, o);: burnAway, 14 frames, SFX burn-away: the outgoing scene is paper that catches light. A glowing orange-red scorched edge eats outward from the ignition point (x, y px, default bottom-centre 540, 1500) along an irregular noise-driven front; t…
  • <PopUpOpen dur?: number; from?: number; table?: string; children: React.ReactNode>: PopUpOpen: the popUpBook as an opener, with no outgoing scene. Wrap the first scene's set: the book is already open on frame 0 (from = starting progress, 0.15) and the set pops up over dur frames (20). table = what the book lies on (kraf…
  • type CutSpec = CutBase & (({kind: 'whip'} & WhipOpts) | ({kind: 'zoomThrough'} & ZoomOpts) | ({kind: 'pageTurn'} & PageOpts) | ({kind: 'tearAway'} & TearOpts) …: One cut: kind + options (whip blur; zoomThrough x, y, scale; pageTurn style, angle, from; tearAway x, jag; tapePull y, label; stampCut x, y, ink; infiniteZoom levels, x, y, w; popUpBook style; keyhole x, y, x2, y2, ink; burnAway x, y, seed…
  • type CutScene = {id: string; component: React.ComponentType; durationInFrames: number};: One scene of a CutSeries: its id (plan.json), component and plan duration in frames.
  • <CutSeries scenes: CutScene[]; cuts?: Record<string, CutSpec>>: CutSeries: drop-in for (scenes = {id, component, durationInFrames} from plan.json). cuts = {INCOMING_SCENE_ID: spec}, no entry = hard cut. Every scene's frame 0 stays on its plan.json frame and the total is unchanged: the outgoing…

props/aura.tsx (import from '../lib/props/aura')

Power-up aura: a flame aura in cut paper. Flames CLIMB from the feet (the aura layers are revealed bottom to top with a flame-toothed front), close over the head and burst into the full fitted aura (spring, overshoot), and the whole fire changes colour through a list of stages (red -> orange -> gold -> blue-white by default; the last stage flips through a near-white hot point) with paper lightning

  • type AuraPal = {
  • const AURA_STAGES: AuraPal[] = [
  • const mixPal = <T,>(a: T, b: T, t: number): T => {
  • const flipPal = (a: AuraPal, b: AuraPal, t: number): AuraPal => {
  • const auraPal = (f: number, stageAt: number[], stages: AuraPal[] = AURA_STAGES, flipLast = true): AuraPal => {
  • <PowerUpAura f: number; x?: number; y?: number; size?: number; children?: React.ReactNode; stageAt?: number[]; burstAt?: number; holdAt?: number; climb?: [number, number][]; stages?: AuraPal[]; pal?: AuraPal; bolts?: boolean; embers?: boolean; cracks?: number;>

props/cable.tsx (import from '../lib/props/cable')

Plugging in: a fat ribbed paper cable (a cubic curve between two points), a plug head that rides its end, and a socket plate to plug into. cablePath builds the d for from a start point S and an end point E, with a slack amount Cable the ribbed cable along any SVG path d (full frame; coordinates are frame pixels) PlugHead two-prong plug with a ribbed boot; place it on the

  • type Pt = {x: number; y: number};: A point in frame pixels (1080 x 1920).
  • const cablePath = (S: Pt, E: Pt, slack: number, sagS = 300, back = 150) => {: Path for from S to E: hangs from S, enters E from the left; slack 1 = lazy floor loop, 0 = near taut. Returns {d, c2}; aim a PlugHead along E - c2.
  • <Cable d: string; color?: string; lo?: string; hi?: string; width?: number>: A fat ribbed paper cable drawn along the SVG path d (frame pixels, use cablePath or your own); width = thickness px, color/lo/hi = body, rib/shadow and highlight.
  • <PlugHead x: number; y: number; rot?: number; s?: number; boot?: string; bootLo?: string; bootHi?: string>: Two-prong plug, about 140 px long at s = 1. (x, y) = middle of the connector body; it points right and rot (deg) turns it about that middle, s scales it. boot/bootLo/bootHi = the ribbed boot's colours.
  • <SocketPlate x: number; y: number; lit?: number; led?: string>: Port block bolted to a prop's side, 44 x 90 px. (x, y) = its top-left; lit 0-1 turns the LED on (glows led, default green) once above 0.1.

props/council.tsx (import from '../lib/props/council')

Council props: the idea (a paper lightbulb), a flattering AI ("yes-bot"), a four-agent council, agent .md files, verdict cards, speech bubbles, a campfire and a skewer. Light from the top-left; everything is paper.

  • type RoleId = 'skeptic' | 'customer' | 'competitor' | 'investor';: ---------- cast ---------- Every council member is the same clay critter; the role reads from accessory + name-pill colour + held prop. Each role gets one colour (red / green / orange / yellow); the pill, the accessory and the file's `colo…
  • const ROLE: Record<RoleId, {tag: string; acc: Acc; color: string; lo: string; file: string; job: string}> = {
  • const ROLES: RoleId[] = ['skeptic', 'customer', 'competitor', 'investor'];
  • <Agent role: RoleId; x: number; y: number; size?: number; expr?: Expr; tag?: boolean; armR?: number; armRAngle?: number; armL?: number; armLAngle?: number; lean?: number; lift?: number; face?: 1 | -1; phase?: number; holdR?: React.ReactNode>: A council member: Critter with the role's accessory, accessory colour and name pill.
  • <You React.ComponentProps<typeof Critter>>: "You": the viewer stand-in, clay with the blue cap.
  • const YESBOT = {color: '#9A86C2', lo: '#7563A0'};: The flattering AI ("yes-bot"): a lilac critter in a headset with an "AI" pill. Always eager to agree.
  • <YesBot React.ComponentProps<typeof Critter>>
  • <Idea x: number; y: number; s?: number; lit?: number; crack?: number; patch?: boolean; rot?: number; seed?: string>: ---------- the idea: a paper lightbulb ---------- (x, y) = centre of the glass. lit 0–1 (glow + warm glass), crack 0–1 (a jagged crack draws down the glass), patch: a strip of tape over the crack (the improved idea). Rays wiggle while lit.
  • <Bubble x: number; y: number; w: number; h: number; text?: string; size?: number; tail?: 'bl' | 'br' | 'none'; color?: string; ink?: string; rot?: number; children?: React.ReactNode>: ---------- paper speech bubble ---------- (x, y) = top-left. tail: which corner the tail points from ('bl' | 'br' | 'none').
  • <AgentFile x: number; y: number; w?: number; role: RoleId; rot?: number; lines?: number; scale?: number>: ---------- agent file (.md with YAML frontmatter) ---------- (x, y) = top-left, w ≈ 300–420. Shows the filename tab, ---, name / description / color, ---, then body bars.
  • <Verdict x: number; y: number; w?: number; role: RoleId; text: string; stampAt: number; rot?: number>: ---------- verdict card: a cream card with a rubber-stamped verdict ---------- stampAt: frame the stamp slams down (relative to the scene). (x, y) = top-left.
  • <Campfire x: number; y: number; s?: number; on?: number>: ---------- campfire + skewer ---------- (x, y) = ground centre of the fire. Flames flicker on twos (stepped, like replacement cels).
  • <Skewer x: number; y: number; len?: number; angle?: number; children?: React.ReactNode>: A long roasting fork; (x, y) = handle end, len in px, angle in degrees (0 = pointing right, negative = up).
  • <NumberCard x: number; y: number; w: number; h: number; big: string; small?: string; color?: string; ink?: string; rot?: number; tape?: boolean>: Small stat card with a big number (numbers are physical props). (x, y) = top-left. tape: two tape strips across the top corners so a wall-hung card is never loose.
  • const armTip = (o: {x: number; y: number; size?: number; reach: number; angle: number; face?: 1 | -1; lift?: number; f?: number; phase?: number; side?: 1 | -1;…: Where a Critter's arm tip is, so a scene can place a held prop that stays upright (Critter's own holdR rotates with the arm). Matches Critter's geometry; ignores lean. side 1 = right arm, -1 = left arm.

props/crowd.tsx (import from '../lib/props/crowd')

A stadium of tiny sleepers, drawn cheaply: ~1100 people in 25 tiers (one SVG per tier, instanced ) so a full-frame crowd renders fast, with a few "hero" real s seated in the rows who can lift, speak up and wake. Pan the stand sideways with pan; back tiers drift less. Crowd the stand: tiers, seat boards, floating z tags, and every hero that is still asleep or seated AwakeHer

  • type HeroSpot = {k: number; x: number};: A hero's seat: front-tier index k (0 = front row, up to about 8 stay big enough to read) and its screen x at heroPan.
  • type PlacedHero = {k: number; slot: number; x: number};: A hero placed on a seat: slot is the seat in its tier, x the feet position when pan is 0 (add tierShift via heroScreenX for any pan).
  • const CROWD_HEROES: HeroSpot[] = [: Ten hero seats in front tiers 2-6, clustered mid-screen (the default for Crowd and AwakeHeroes); x is the screen x when heroPan is 130.
  • const placeHeroes = (spots: HeroSpot[] = CROWD_HEROES, heroPan = 130): PlacedHero[] => spots.map((h) => {: Snap hero spots onto real seats so no sleeper overlaps a hero: pass the same spots and heroPan you give Crowd and AwakeHeroes.
  • const heroScreenX = (h: PlacedHero, pan: number) => h.x + tierShift(tierOf(h.k), pan);: Screen x of a placed hero's feet at a given pan; the feet y is that tier's baseline (about 1320 at k 2, 1128 at k 6).
  • type HeroState = {lift?: number; expr?: Expr; armUp?: number; awake?: boolean; wave?: number};: What a hero is doing this frame: lift (px up off the seat), expression, arms up 0-1, wave (deg), awake (true = AwakeHeroes draws it, Crowd skips it).
  • <Crowd pan?: number; seat?: string; hero?: (i: number) => HeroState; zz?: boolean; heroes?: HeroSpot[]; heroPan?: number; haze?: string; dusk?: string; heroAcc?: Acc>: The sleeping stadium, full frame. pan = px to scroll (-270..270); hero(i) = state of hero i (index into heroes); zz = floating z tags; seat = seat-board colour; haze/dusk = depth fog and mood tint.
  • <AwakeHeroes hero: (i: number) => HeroState; pan?: number; seat?: string; heroes?: HeroSpot[]; heroPan?: number; haze?: string; dusk?: string; heroAcc?: Acc>: The awake heroes (hero(i).awake), drawn above everything with a brightness lift; use the same pan, seat, heroes, heroPan, haze, dusk and heroAcc as Crowd.

props/everyday.tsx (import from '../lib/props/everyday')

Everyday paper props that suit any episode. All paper (Slab / Disc / Pill inside ), motion only from useCurrentFrame(). Desk small table with two legs and a rail, sits on a floor line WallCalendar hanging wall calendar whose month pages flip away to a big final date (+ optional pill) BirthdayCake two-tier cake on a stand with flickering candles HomeSign house-shaped enamel p

  • <Desk x: number; y: number; w: number; floor: number; top?: string; topLo?: string; topHi?: string; legs?: string; legsLo?: string>: Small paper desk. (x, y) = top-left of the table top (w wide, 34 tall); the legs run down to the y of the floor line. top/topLo/topHi and legs/legsLo set the wood colours.
  • type CalendarPage = {month: string; marks?: number[]};: One month page that flips away: its month word and the day-cell indexes (0-34) to mark in red.
  • <WallCalendar x: number; y: number; flipAt: number; w?: number; h?: number; flipEvery?: number; rot?: number; bump?: number; pages?: CalendarPage[]; final?: {month: string; day: string; label?: string}; head?: string; headLo?: string; labelBg?: string>: Hanging wall calendar, w x h at (x, y) = top-left of the sheet (nail and string reach 58 px above). pages flip up and away one every flipEvery frames from flipAt, first page first, then the final page shows a huge day and an option…
  • <BirthdayCake x: number; y: number; s?: number; candles?: number; lit?: boolean; color?: string; colorLo?: string; topColor?: string; topLo?: string>: Two-tier cake on a stand, about 330 px wide and 320 tall at s = 1. (x, y) = the floor point under the stand; candles (up to about 12) are spaced across the top tier; lit = flames on. color/colorLo = pink tier, topColor/topLo = cream tier.
  • <HomeSign x: number; y: number; s?: number; text?: string; color?: string; colorLo?: string; colorHi?: string; textColor?: string>: House-shaped enamel plaque, 168 x 140 px at s = 1. (x, y) = its middle; text is the word on it (4-5 capitals fit at 40 px), color/colorLo/colorHi the enamel.
  • <Clipboard size: number; counterRot?: number; board?: string; boardLo?: string>: Clipboard held at a hand: drawn around (0, 0) = the hand, so pass it as a Critter's holdR; size = the critter's size, counterRot = minus the arm angle so it stays upright; board/boardLo = the wood.
  • <ThumbsUp size: number; counterRot?: number; color?: string; shade?: string; show?: number>: Thumbs-up fist held at a hand: drawn around (0, 0) = the hand, so pass it as a Critter's holdR; size = about 1.45x the critter's size, counterRot = minus the arm angle keeps the thumb up, show 0-1 pops it in (scale).

props/gpu.tsx (import from '../lib/props/gpu')

Hardware props: GamingPC (tower, glass panel, RGB fans; open = motherboard with GPU and RAM slots), GpuCard (graphics card; suitcase mode has a lid, zipper and luggage tag; GpuCase is the closed one), RamStick, ServerRack, Whale (the "125B" model), WhaleTail, PaperCloud, SpeedGauge. All cut paper (Slab/Disc/Card/Pill inside Paper, stacked shade pieces, no outlines). Light from the top-left. RGB li

  • <GamingPC x: number; y: number; s?: number; rot?: number; on?: boolean | number; glow?: string; open?: boolean | number; gpuIn?: number; ramIn?: number; spinAt?: number>: Desktop tower, seen from the glass side. (x, y) = the floor point under the middle of the case; the case is 300×560 at s = 1 (about 575 tall with feet). on: boolean or 0–1 (lights, glow and fan spin); glow: fixed RGB colour such as '#3DDC8…
  • <GpuCard x: number; y: number; s?: number; rot?: number; rgb?: number; spinAt?: number; fanAngle?: number; label?: string; glow?: string; suitcase?: boolean; open?: number; zip?: number; strain?: number; lining?: string; tag?: string; tagSide?: 'left' | 'right'; tagSw…>: A graphics card, side on: dark shroud, two fans that spin, bracket, backplate edge, gold fingers, an RGB edge strip and a "12 GB" plate. No brand marks. (x, y) = the middle of the card's front face. Plain card is 460×160 at s = 1. rgb 0–1 …
  • <GpuCase x: number; y: number; s?: number; rot?: number; tag?: string; tagSide?: 'left' | 'right'; tagSwing?: number; tagFlash?: number; zip?: number; tail?: number; rgb?: number; children?: React.ReactNode>: A closed, zipped GpuCard suitcase with a whale tail peeking out of the end of the zipper. (x, y) = the middle of the front face; tag = luggage tag text; zip 0–1 (default 1 = zipped as far as the tail allows); tail = wag amplitude 0–1 (0 = …
  • <RamStick x: number; y: number; s?: number; rot?: number; label?: string>: A memory module: green board, six chips, a cream label, gold fingers with the key notch, eject clips at both ends. (x, y) = the middle of the board; 360×84 at s = 1. label = text on the label ('16 GB'); rot turns it (90 = standing up).
  • <ServerRack x: number; y: number; s?: number; w?: number; h?: number; seed?: string; fanSpeed?: number; cascadeAt?: number>: A tall dark rack of 1U units with vents, drive bays, blinking LEDs (stepped, seeded) and the odd fan. (x, y) = the floor point under the middle; w wide, h tall (before s). seed varies the blink pattern; fanSpeed 0 = fans still, 1 = steady,…
  • <WhaleTail x: number; y: number; s?: number; rot?: number; wag?: number>: A whale tail on its own (peeking out of a case, or from behind a wall). (x, y) = where the stalk starts; rot 0 = pointing straight up, positive turns it clockwise; wag 0–1 sways it; s scales (1 = about 240 px long).
  • <Whale x: number; y: number; len?: number; rot?: number; face?: 1 | -1; squash?: number; tailWag?: number; tailUp?: number; expr?: 'happy' | 'strain' | 'sleepy'; tag?: string; tagScale?: number; bob?: number; spout?: number>: A big friendly cut-paper whale facing right (face = -1 flips it), with a stitched tag on its flank. (x, y) = the middle of the whale; len = tip of tail to nose in px (300–800 works), default 700. squash 0–1 squeezes it (shorter and taller,…
  • const whalePoint = (o: {x: number; y: number; len?: number; rot?: number; face?: 1 | -1; squash?: number}, bx: number, by: number) => {: Where a point of the whale's body lands in the scene, so a scene can aim arms, badges or sparkles at it. (bx, by) are in the whale's body box: tail root (26, 164), eye (538, 122), nose (588, 138), tag middle (338, 118), belly bottom (300, …
  • <PaperCloud x: number; y: number; w?: number; rot?: number; sad?: number; deflate?: number; socket?: boolean; float?: number>: A puffy paper cloud with a cable socket on its underside. (x, y) = the middle of the cloud; w wide (height about 0.6 w). sad 0–1 fades in a worried face with a falling tear (0 = a plain cloud); deflate 0–1 squashes it flat; socket = draw t…
  • const cloudSocket = (o: {x: number; y: number; w?: number}) => ({x: o.x, y: o.y + 109 * ((o.w ?? 380) / 380)});
  • <SpeedGauge x: number; y: number; d?: number; value: number; max?: number; label?: string; rot?: number>: A paper speed dial: ticks, a green top band, a red needle that swings to value/max, and a pill label under the hub. (x, y) = the middle of the dial; d = outer diameter (default 360). value / max set the needle (it sweeps -125° to +125°; an…

props/leak.tsx (import from '../lib/props/leak')

Code-hosting and data-leak props: paper screenshot cards, a public/private visibility pill, a repo page with a file list, and a pull-request card with an image attachment slot. Rough papercut rebuilds of generic code-hosting UI: no logos, plain text names only.

  • <VisPill x: number; y: number; vis: 'public' | 'private'; size?: number; alarm?: boolean; rot?: number>: ---------- visibility pill ---------- "Public" (globe, amber-red when alarm) or "Private" (padlock, green). (x, y) = top-left. size = font px.
  • type ShotKind = 'dashboard' | 'billing' | 'design' | 'chat' | 'code';: ---------- screenshot card ---------- A paper screenshot (window chrome + simplified content). (x, y) = top-left, w = width (height = 0.68 w). kind picks the content; redact draws black bars over the sensitive bits; tape adds two tape corn…
  • <Screenshot x: number; y: number; w?: number; kind: ShotKind; rot?: number; tape?: boolean; label?: string; redact?: boolean; seed?: string; lift?: number>
  • <RepoPage x: number; y: number; w?: number; owner: string; repo: string; vis: 'public' | 'private'; files: string[]; filesAt?: number; every?: number; alarm?: boolean; rot?: number; rows?: number>: ---------- repo page ---------- A code-hosting repo page: owner / repo, a visibility pill, and a file list whose rows pop in one by one from filesAt. (x, y) = top-left. The image files get a small picture glyph. alarm turns the Public pill…
  • <PRCard x: number; y: number; w?: number; title: string; num: number; attach?: 'none' | 'dashed' | 'image'; shakeAt?: number; rot?: number; children?: React.ReactNode>: ---------- pull request card ---------- A PR page: an Open pill, title, #number, and a description box. attach = what sits in the image slot: 'none' (empty), 'dashed' (a dashed "drop image here" box that shakes from shakeAt, i.e. the age…
  • <PaperCamera x: number; y: number; s?: number; rot?: number; flashAt?: number>: ---------- paper camera ---------- A small paper camera (body, lens, flash window). (x, y) = centre, s = width. flashAt fires a soft white flash (radial glow is allowed for light sources) that fades over ~6 frames.

props/stage.tsx (import from '../lib/props/stage')

Stage props: an APPLAUSE sign that can be dark or lit, a paper phone whose comment field takes typed text and posts it as a new comment row (scene-driven, unlike the self-timed PhoneComment in ui), a studio phone tripod, and a DM notification bubble. All cut paper (Slab / Disc inside Paper).

  • <ApplauseSign x: number; y: number; w?: number; h?: number; rot?: number; lit?: boolean; chase?: number; flicker?: number; text?: string; fontSize?: number; color?: string>
  • <SendDisc x: number; y: number; d: number; press?: number>
  • <CommentPhone x: number; y: number; w?: number; h?: number; typed?: string; caret?: boolean; posted?: number; press?: number; rot?: number; postedText?: string>
  • <PhoneTripod x: number; top: number; floor: number>
  • <DmBubble x: number; y: number; w?: number; h?: number; text: string; rot?: number; dot?: number>

props/usage.tsx (import from '../lib/props/usage')

Usage props: the LIMIT gauge (a paper fuel gauge, E to F, with crack and stamp) and the long paper chat scroll that conveys along a path. All cut paper (Slab / Disc inside Paper); motion comes from the props the scene passes in.

  • type PathPt = [number, number];
  • <LimitGauge x: number; y: number; r?: number; level: number; crack?: number; stamp?: number; stampText?: string; squashY?: number; flash?: number; smoke?: boolean; label?: string>
  • type PathT = {L: number; at: (s: number) => {x: number; y: number; ang: number}};
  • const makePath = (ctrl: PathPt[], per = 14): PathT => {
  • <ScrollFeed path: PathT; shift?: number; width?: number; seg?: number; seed?: string; lift?: number; win?: [number, number]>

scenes/CtaPhoneDM.tsx (import from '../lib/scenes/CtaPhoneDM')

Scene template: the comment-keyword CTA, the last set of an episode. It whip-pans in, a paper phone types KEYWORD and posts it, and a paper DM envelope opens on "send" and fans out the deliverable cards (any count). There's a sparkle, then a calm hold. A whole CTA scene is ~10 lines: const cue = cueOf(ID); <CtaPhoneDM dur={durOf(ID)} keyword="GUIDE" typeAt={cue('Comment')} postAt={cue('and') + 2}

  • <CtaPhoneDM dur: number; keyword: string; typeAt: number; postAt?: number; sendAt: number; landAt: number; sparkleAt: number; // scene-relative frames (use cue words) items: React.ReactNode[]; itemW: number; itemH: number; // deliverable cards, each drawn with its top-le…>

tokens.ts (import from '../lib/tokens')

Shared papercut palette by role: neutrals, props, cast, captions, signals, room walls, fonts, timings. Episode themes extend this in their own src/theme.ts (e.g. role or category colours); never edit the synced copy.

  • const C = {
  • const ROOM = {: Room wall colours: rotate one per set so every cut reads as a new idea.
  • type RoomColor = keyof typeof ROOM;
  • const FONT = {banner: 'Archivo Black', caption: 'Fraunces', label: 'Inter', mono: 'JetBrains Mono'};
  • const T = {pop: 8, wordPop: 4, slide: 10, press: 6, blinkHz: 4};
  • const W = 1080;
  • const H = 1920;

ui/ui.tsx (import from '../lib/ui/ui')

Rough papercut rebuilds of real UI: paper bezels around a near-black app panel, few big elements, one accent colour, fake interactions (typing, cursor clicks, counters).

  • <Monitor x: number; y: number; w: number; h: number; stand?: boolean; screen?: string; children?: React.ReactNode>: ---------- frames ---------- Desktop monitor: dark bezel → screen panel → content → reflection sliver; stand below.
  • <Laptop x: number; y: number; w: number; h: number; children?: React.ReactNode>: Laptop: screen lid + keyboard deck seen front-on.
  • <AppWindow w: number; h: number; title: string; children?: React.ReactNode; bg?: string>: App window chrome (inside a Monitor/Laptop or free-standing): title bar with three dots + title.
  • type TermLine = {at: number; text: string; kind?: 'you' | 'out' | 'ok' | 'dim' | 'warn'};: ---------- terminal session ---------- Lines appear at their frame; 'you' lines type in (2 frames per character), others pop in whole.
  • <Terminal w: number; h: number; lines: TermLine[]; title?: string; size?: number; fpc?: number>
  • const fmt = (n: number) => Math.round(n).toLocaleString('en-US');: ---------- numbers as props ----------
  • const useCount = (at: number, dur: number, to: number, from = 0) => {: Count from from to to between frames [at, at+dur] (ease-out), formatted with commas.
  • <CountUp at: number; dur: number; to: number; from?: number; prefix?: string; suffix?: string>
  • <RepoCard x: number; y: number; w?: number; owner: string; repo: string; desc: string; starsAt: number; stars: number; starsFrom?: number; forks?: number; starDur?: number; rot?: number>: Repo card pinned in the set: at frame starsAt the Star button is pressed and its count runs from starsFrom (default 0) up to stars; forks count up beside it.
  • type PointerKey = {f: number; x: number; y: number; click?: boolean};: ---------- pointer ---------- A mouse pointer that glides between keyframes; a click (k.click) squashes it and drops a ripple ring.
  • <Pointer keys: PointerKey[]; size?: number>
  • <Button x: number; y: number; w: number; h?: number; text: string; color?: string; pressAt?: number; size?: number>: ---------- small UI pieces ---------- Primary button in the accent colour; pressAt dips it.
  • <Progress x: number; y: number; w: number; at: number; dur: number; color?: string; to?: number>: Progress bar that fills between [at, at+dur].
  • <ToolCard x: number; y: number; name: string; color: string; glyph?: string; w?: number; rot?: number>: A tool card for "works in 17 tools": cream card with a coloured glyph block and the tool's name (no logos).
  • <PhoneComment x: number; y: number; keyword: string; typeAt: number; fpc?: number; postAt?: number; scale?: number>

Backdrops (24 generated sets, <Backdrop name="..." /> from '../lib/paper/backdrops')

Full-frame 1080x1920 paper-diorama rooms and outdoor sets: use one in place of <Room>. Each follows the layout contract: floor line near y 1420, calm middle band for props, calm top for the banner, plain bottom for captions. Stand props and critters on that backdrop's floorY. Optional tint (multiply colour) and dim (0-1 darkening) shift a set's mood. No people or text are baked in.

name floorY mood desc bestFor
gamer-bedroom 1379 night Dim gamer bedroom in charcoal-plum with purple and teal RGB strips along the ceiling and wall base, a black gaming desk with PC tower at the left edge, a blank abstract poster and a teal bean bag at the right. gaming, PC builds, GPU and local-model topics, streaming and dev-at-night beats
server-room 1435 cool Dark blue-green data centre: tall black server racks with cool teal LED dots frame both edges, smaller dim racks recede in the centre, raised grey floor tiles. servers, cloud, hosting, databases, self-hosting, infrastructure and uptime beats
home-office-day 1432 day Bright sunny home office in butter yellow: window with daylight and clouds at the left, house plants in terracotta pots, light honey-wood floor, plain sunny wall. work-from-home, solo dev, productivity, daytime setup and calm explainer beats
cafe 1481 warm Warm terracotta coffee shop: wooden counter at the left with espresso machine, cups and cake dome, pendant lamps with glowing bulbs, a blank green chalkboard menu, tan wood floor. freelance and work-anywhere beats, coffee-break asides, meeting and chat scenes, casual hooks
startup-office 1289 day Open-plan startup office in soft grey-blue: tall glass wall with daylight and city hint at the right, pale desks with monitors and chairs, plants and a beanbag at the edges, plain pale carpet. The wall/floor line sits high, carpet below is open floor. teams, hiring, product launches, company and startup beats, management and workflow topics
rooftop-day 1501 day Sunny city rooftop: blue sky with paper clouds, layered blue-grey and dusty-pink skyline behind a low ledge, wooden water tank at the left, vent pipe and plant at the right, warm grey concrete floor. big-picture or outlook beats, launches, 'above the noise' moments, open-air hooks and endings
city-street-night 1430 night Night street in dark teal-slate: brick shop fronts with glowing blank amber windows and striped awnings at both edges, iron streetlamp at the right, mailbox at the left, wet pavement with warm reflections. going out into the world, late-night stories, security and surveillance beats, shipping and delivery beats
garage-workshop 1452 warm Cosy garage workshop: big light-brown pegboard with hanging hand tools at its edges, workbench with vice and toolbox at the right, warm hanging bulb, cardboard boxes at the left, grey concrete floor. DIY, hacking and tinkering, hardware builds, prototypes, repair and open-source maker beats
library 1414 warm Warm library in burgundy: tall wooden bookshelves full of blank spines at both edges, arched wall panel in the centre, brass reading lamp with a warm glow and side table at the right, armchair at the left, dark wood floor. docs, reading, research, learning, knowledge bases, RAG and memory topics
classroom 1519 day Daylight classroom in cream: large blank green chalkboard with wooden frame, tall windows at the right, plants on shelves at the left, wooden student desks at the bottom corners, light wood floor. The floor line sits low. teaching, tutorials, how-it-works explainers, courses, quizzes and step-by-step beats
lab 1469 cool Clean mint-and-white science lab: mint tile wall, benches with drawers at both edges holding flasks, beakers, test tubes and a microscope, wall shelves of jars, pale tile floor. experiments, benchmarks, evals, research results, science and testing beats
stage-spotlight 1438 warm Empty theatre stage: burgundy velvet curtains with a swagged valance at the edges, dark plum back wall, soft warm spotlight cone and light pool on wooden plank floor. big reveals, announcements, 'meet X' intros, awards and finale beats
kitchen 1530 day Cheerful home kitchen in pale sage and cream: tiled backsplash, sage lower cabinets with butcher-block counter, pots, kettle and utensils at the left, plant and bread bin at the right, morning window light, terracotta floor. recipes and cooking metaphors, ingredients and steps, morning routine, 'cooking up' build beats
park-day 1419 day Sunny park: pale blue sky, layered green hills, big round-canopy paper trees at both edges, sandy path across the floor line, green bench at the right, grass below. outdoor and breather beats, walks, nature or growth metaphors, calm intros and outros
art-gallery 1420 day Bright contemporary art gallery in warm off-white paper: pale skylight band with mullions across the top, a row of small brass picture lamps along the upper wall, honey-wood plank floor getting darker toward the bottom. Clean plain wall and floor (no hooks, no stanchions: draw VelvetRope and frames in the scene). Code-drawn papercut (made without imagegen). galleries, exhibitions, public display and show-and-tell beats, 'on show' or museum metaphors, openings, tours
gallery-lobby 1420 cool Museum lobby in pale grey-green paper marble: tall plain wall in the middle band under a crown cornice, a tall dark wooden door with brass lever handle and kick plate at the right edge (x 716-1096, top y 444), a small reception desk with brass bell at the left edge, a potted fig tree at x 500, speckled terrazzo floor. Code-drawn papercut (made without imagegen). entrances, reception and lobby beats, private-wing or locked-door metaphors, institutional and museum beats
courtroom 1450 warm Sage striped wall over oak panelling; tall light-oak judge's bench with a tilted gavel at the left edge (x 0-300), spindle-railed witness stand at the right edge (x 810-1080), blank gold seal disc high in the middle (y ~520), honey plank floor. Code-drawn papercut. rules, judgments, trials, bans, appeals, legal and policy disputes
bank-vault 1450 cool Steel plate wall; huge round vault door with brass spoked wheel at the left edge (x 0-380), safe-deposit box grid at the right edge (x 780-1080), brass-post velvet rope low at the left, polished grey-green tiled floor with a faint reflection. Code-drawn papercut. security, money, secrets, access control, leaks, protecting data
warehouse 1450 warm Beige wall; orange steel shelving with kraft boxes at both edges (x 0-260, x 820-1080), pallet stack of cartons at the right (x 780-1030), closed roll-up shutter mid-wall (x 290-790), yellow floor stripe at y ~1490, concrete floor, hanging industrial lamp top-left (x 85-270, y < 400). Code-drawn papercut. shipping, supply, stock, logistics, storage, bulk and scale
mission-control 1440 night Navy panelled wall; console desk with 3 glowing screens, keys and LED dots at left (x 0-330, y 970-1440); wall of 12 teal/blue monitors at right (x 800-1080, y 440-1440); big dark blank central screen on a bracket (x 296-776, y 520-920); dark carpet floor. Code-drawn papercut. AI agents, monitoring, dashboards, outages, launches, ops/control rooms, tracking many things at once
airport-gate 1440 day Grey-blue wall; big window with pale sky, clouds and a plane tail outside at left (x 0-610, y 470-1320); 3 grey seats at left edge (x 0-300); blank departures-board frame top-right (x 744-1080, y 460-710); gate desk with monitor at right (x 800-1080, y 1000-1440); carpet with pale stripe at y 1478. The window is wide: a mascot in the middle band overlaps plain sky and mullions. Code-drawn papercut. travel, waiting, boarding, delays, transitions, departures, queues, leaving or arriving
subway-platform 1440 night Teal brick-bond tile wall with a darker band (y 1040-1210); bench at left edge (x 0-290, y 1190-1440); glowing arched tunnel mouth at right (x 750-1080, y 780-1440); two blank sign frames (left y 500, right y 470); yellow safety line at y 1468-1492; concrete floor. Code-drawn papercut. commuting, waiting for something to arrive, loops, routes, late-night, going under the radar, trains/transit metaphors
diner 1440 warm Mint wall with a long pale window band across y 470-660 (full width), cream wainscot with a red rail below, red-and-cream chequered perspective floor. Counter with two red stools and a glass pie dome at the left (x 0-290); tall red booth with a seat at the right (x 800-1080); blank pink neon arrow at x 830-1010, y 800-900. Code-drawn papercut. food, cafe or late-night talk, small-town and retro beats, orders, breakfast, comfort topics
bedroom-day 1450 day Lilac wall and light wood floor. Peach bed with a patchwork quilt (x 0-220) and bedside table with a lamp (x 215-315) at the left, blank framed print above at x 80-270, y 720-970; window with peach curtains at the right (x 790-1080, y 615-1190, cropped by the edge); round lilac and peach rug at y 1560-1810. Code-drawn papercut. mornings, sleep, wake-up and routine beats, cozy or personal topics, home life, gentle explainers