@waits/cadence 0.2.0

package/src/content/panels.beats.ts

@@ -0,0 +1,40 @@
+import type { ChangelogInput } from "../schema/beats";
+
+/** Showcase fixture: one beat per panel kind, used to eyeball the registry. */
+const video: ChangelogInput = {
+  format: "16x9",
+  beats: [
+    {
+      id: "upload",
+      durationInFrames: 150,
+      background: { src: "mountains.jpg" },
+      eyebrow: "new in sdk 6.0",
+      headline: "Pause and resume backfills.",
+      code: { filename: "backfill.ts", lang: "ts", source: `const ctrl = new UploadControl();\n\nawait sl.datasets.export("sbtc", file, {\n  control: ctrl,\n});` },
+      panel: { kind: "upload-progress", file: "datasets/sbtc.parquet", sizeMB: 210, parts: 14 },
+    },
+    {
+      id: "query",
+      durationInFrames: 150,
+      background: { src: "mountains.jpg" },
+      headline: "Query any dataset.",
+      code: { filename: "query.ts", lang: "ts", source: `const { rows } = await sl.datasets.query("sbtc", {\n  where: { event: "transfer" },\n  limit: 4,\n});` },
+      panel: { kind: "data-table", title: "sbtc · transfers", columns: ["block", "amount", "to"], rows: [["951475", "1,200.00", "SP2J6…"], ["951474", "48.50", "SP3K9…"], ["951472", "9,000.00", "SPF8M…"], ["951470", "150.00", "SP1Y4…"]] },
+    },
+    {
+      id: "status",
+      durationInFrames: 150,
+      background: { src: "mountains.jpg" },
+      headline: "Watch every service.",
+      panel: { kind: "status", title: "status", services: [{ name: "api", state: "ok" }, { name: "indexer", state: "ok", detail: "block 951475" }, { name: "l2-decoder", state: "syncing", detail: "−2 blocks" }, { name: "database", state: "ok" }] },
+    },
+    {
+      id: "pipeline",
+      durationInFrames: 150,
+      background: { src: "mountains.jpg" },
+      headline: "Decoded once. Query forever.",
+      panel: { kind: "diagram", nodes: [{ id: "node", label: "Stacks node", type: "default" }, { id: "idx", label: "Indexer", type: "data" }, { id: "api", label: "Index API", type: "api" }], edges: [{ from: "node", to: "idx", label: "events" }, { from: "idx", to: "api", label: "decoded" }], note: "decoded once — query forever" },
+    },
+  ],
+};
+export default video;

package/src/content/sdk-6.5-mempool.beats.ts

@@ -0,0 +1,67 @@
+import type { ChangelogInput } from "../schema/beats";
+
+/**
+ * T0.1 brain-spike output. Sourced entirely by reading the Secondlayer repo
+ * GENERICALLY (no baked-in knowledge):
+ *   - latest release: git tag `@secondlayer/sdk@6.5.0`
+ *   - what changed: commits 6.4.0..6.5.0 → the Index mempool feature (+contractId filter)
+ *   - honest API: packages/sdk/src/index-api/client.ts types + packages/sdk/README.md
+ * Honesty ladder caught: the real class is `SecondLayer` (capital L), and the
+ * real call is `sl.index.mempool.list({ contractId, limit })` returning `{ mempool }`.
+ */
+const BG = "backgrounds/mount-bonnell.png";
+
+const video: ChangelogInput = {
+  format: "16x9",
+  beats: [
+    {
+      id: "opener",
+      durationInFrames: 150,
+      background: { src: BG },
+      eyebrow: "new in sdk 6.5",
+      headline: "The mempool, indexed.",
+    },
+    {
+      id: "pending",
+      durationInFrames: 235,
+      background: { src: BG },
+      eyebrow: "index.mempool",
+      headline: "Query the pending set.",
+      code: {
+        filename: "mempool.ts",
+        lang: "ts",
+        source: `import { SecondLayer } from "@secondlayer/sdk";
+
+const sl = new SecondLayer();
+
+const { mempool } = await sl.index.mempool.list({
+  contractId: "SP….amm-pool-v2",
+  limit: 50,
+});`,
+      },
+      panel: {
+        kind: "data-table",
+        title: "index.mempool",
+        columns: ["tx_id", "function", "sender"],
+        rows: [
+          ["0x8f2a…", "swap-x-for-y", "SP2J6…WVEF"],
+          ["0x3c91…", "add-liquidity", "SP3K9…X1A0"],
+          ["0x7e0d…", "swap-x-for-y", "SPF8M…7QQC"],
+          ["0x1a44…", "transfer", "SP1Y4…NZ2D"],
+        ],
+      },
+    },
+    {
+      id: "cta",
+      durationInFrames: 160,
+      background: { src: BG },
+      headline: "Start building.",
+      layout: "center",
+      code: { filename: "terminal", lang: "bash", source: `bun add @secondlayer/sdk` },
+      badge: "v6.5",
+      caption: "index · streams · datasets · subgraphs",
+    },
+  ],
+};
+
+export default video;

package/src/content/streams-launch.beats.ts

@@ -0,0 +1,143 @@
+import type { ChangelogInput } from "../schema/beats";
+
+/**
+ * Streams showcase — the Stacks event firehose. Subscribe → provable → resumable
+ * → reorg-safe → install. New panel kinds (proof / cursor-resume / reorg) designed
+ * with the design skills; real @secondlayer/sdk/streams API.
+ */
+const BG = "backgrounds/congress.png";
+
+const video: ChangelogInput = {
+  format: "16x9",
+  beats: [
+    {
+      id: "opener",
+      durationInFrames: 150,
+      background: { src: BG },
+      eyebrow: "new in streams",
+      headline: "The Stacks event firehose.",
+    },
+    {
+      id: "subscribe",
+      durationInFrames: 235,
+      background: { src: BG },
+      eyebrow: "real-time",
+      headline: "Subscribe to every block.",
+      code: {
+        filename: "stream.ts",
+        lang: "ts",
+        source: `import { createStreamsClient } from "@secondlayer/sdk/streams";
+
+const streams = createStreamsClient();
+
+for await (const event of streams.events.consume({
+  types: ["ft_transfer"],
+  mode: "tail",
+})) {
+  ledger.append(event);
+}`,
+      },
+      panel: {
+        kind: "feed",
+        title: "streams.consume",
+        subtitle: "tail",
+        rows: [
+          { badge: "sBTC", label: "SP2J6…WVEF", value: "1,200.00" },
+          { badge: "USDA", label: "SP3K9…X1A0", value: "48.50" },
+          { badge: "ALEX", label: "SPF8M…7QQC", value: "9,000.00" },
+          { badge: "sBTC", label: "SP1Y4…NZ2D", value: "150.00" },
+        ],
+      },
+    },
+    {
+      id: "proof",
+      durationInFrames: 235,
+      background: { src: BG },
+      eyebrow: "signed",
+      headline: "Every event, provable.",
+      code: {
+        filename: "verify.ts",
+        lang: "ts",
+        source: `const streams = createStreamsClient({
+  verify: true,
+});
+
+// every response carries an ed25519 signature,
+// checked against the server's public key.`,
+      },
+      panel: {
+        kind: "proof",
+        eventLine: "ft_transfer · 1,200 sBTC",
+        cursor: "951475:3",
+        signature: "3a9f8c217b14e0d5f29a4c6b8e1d70a3c8a17b142e9d",
+        keyId: "f3a9…2b1c",
+      },
+    },
+    {
+      id: "resume",
+      durationInFrames: 235,
+      background: { src: BG },
+      eyebrow: "resumable",
+      headline: "Resume from anywhere.",
+      code: {
+        filename: "resume.ts",
+        lang: "ts",
+        source: `for await (const event of streams.events.consume({
+  fromCursor: "951475:3",
+  mode: "tail",
+})) {
+  process(event);
+}`,
+      },
+      panel: {
+        kind: "stream-resume",
+        fromCursor: "951475:3",
+        rows: [
+          { cursor: "951475:4", label: "print · swap-x-for-y" },
+          { cursor: "951476:0", label: "ft_transfer" },
+          { cursor: "951476:1", label: "nft_transfer" },
+          { cursor: "951477:0", label: "print · mint" },
+        ],
+      },
+    },
+    {
+      id: "reorg",
+      durationInFrames: 235,
+      background: { src: BG },
+      eyebrow: "reorg-safe",
+      headline: "Forks, handled.",
+      code: {
+        filename: "reorg.ts",
+        lang: "ts",
+        source: `streams.events.replay({
+  from: "genesis",
+  onReorg: (reorg, { cursor }) => {
+    rewind(cursor);
+  },
+});`,
+      },
+      panel: {
+        kind: "fork",
+        blocks: [
+          { height: 951472, hash: "a3f9", state: "canonical" },
+          { height: 951473, hash: "b1c4", state: "canonical" },
+          { height: 951474, hash: "7e2d", state: "orphaned" },
+          { height: 951474, hash: "c8a1", state: "new" },
+        ],
+        rewindTo: "951472:0",
+      },
+    },
+    {
+      id: "cta",
+      durationInFrames: 160,
+      background: { src: BG },
+      headline: "Stream it now.",
+      layout: "center",
+      code: { filename: "terminal", lang: "bash", source: `bun add @secondlayer/sdk` },
+      badge: "streams",
+      caption: "subscribe · verify · resume · reorg-safe",
+    },
+  ],
+};
+
+export default video;

package/src/content/streams.beats.ts

@@ -0,0 +1,46 @@
+import type { ChangelogInput } from "../schema/beats";
+
+/**
+ * The Sprint-0 reference scene, re-expressed as pure data. Renders identically
+ * through the changelog engine — `bun run render src/content/streams.beats.ts`.
+ */
+const video: ChangelogInput = {
+  format: "16x9",
+  beats: [
+    {
+      id: "stream",
+      durationInFrames: 210,
+      background: { src: "mountains.jpg" },
+      eyebrow: "new in sdk 5.5",
+      headline: "Stream every Stacks event.",
+      code: {
+        filename: "stream.ts",
+        lang: "ts",
+        source: `import { Secondlayer } from "@secondlayer/sdk";
+
+const sl = new Secondlayer({
+  apiKey: process.env.SL_API_KEY,
+});
+
+const { events } = await sl.index.events({
+  eventType: "ft_transfer",
+  limit: 50,
+});`,
+      },
+      panel: {
+        kind: "feed",
+        title: "index.events",
+        subtitle: "ft_transfer",
+        rows: [
+          { badge: "sBTC", label: "SP2J6…WVEF", value: "1,200.00" },
+          { badge: "USDA", label: "SP3K9…X1A0", value: "48.50" },
+          { badge: "ALEX", label: "SPF8M…7QQC", value: "9,000.00" },
+          { badge: "sBTC", label: "SP1Y4…NZ2D", value: "150.00" },
+          { badge: "WELSH", label: "SPGR2…0KME", value: "73.25" },
+        ],
+      },
+    },
+  ],
+};
+
+export default video;

package/src/index.ts

@@ -0,0 +1,4 @@
+import { registerRoot } from "remotion";
+import { RemotionRoot } from "./Root";
+
+registerRoot(RemotionRoot);

package/src/motion/names.ts

@@ -0,0 +1,29 @@
+/**
+ * Frozen vocabulary of motion preset names. Single source of truth shared by
+ * the presets implementation (Sprint A), the beats schema (Sprint B), and
+ * MOTION.md. Adding a transition means adding it here first.
+ */
+export const ENTER_PRESETS = [
+  "rise", // translateY up + fade — headlines, cards
+  "settle", // scale 1.03→1 + fade — windows/panels arriving
+  "bloom", // fade + de-blur — backgrounds
+  "type", // character-by-character typewriter — code/terminal
+  "stagger", // sequential rise of children — list rows
+  "draw", // SVG stroke reveal — diagrams, the NEW badge circle
+  "count", // numeric tween 0→value — metrics
+] as const;
+
+export const EXIT_PRESETS = [
+  "sink", // translateY up + fade out
+  "dissolve", // fade out
+  "lift", // scale 1→1.02 + fade out
+  "cut", // instant
+] as const;
+
+export type EnterPreset = (typeof ENTER_PRESETS)[number];
+export type ExitPreset = (typeof EXIT_PRESETS)[number];
+
+export const isEnterPreset = (s: string): s is EnterPreset =>
+  (ENTER_PRESETS as readonly string[]).includes(s);
+export const isExitPreset = (s: string): s is ExitPreset =>
+  (EXIT_PRESETS as readonly string[]).includes(s);

package/src/motion/presets.ts

@@ -0,0 +1,67 @@
+import type { EnterPreset, ExitPreset } from "./names";
+
+/**
+ * Pure preset functions: given a normalized progress `p` (0→1, already eased by
+ * the caller) they return a style fragment. Keeping them pure (no hooks) makes
+ * the vocabulary testable and lets `useMotion` own all timing/easing.
+ *
+ * Entrances use the caller's `smooth` easing (pure ease-out). `type`/`draw`/
+ * `count` carry their value internally (typewriter chars, stroke offset, tween)
+ * so as container presets they only gate visibility — see the helpers below.
+ */
+export type StyleFrag = { opacity: number; transform: string; filter?: string };
+
+export function enterStyle(
+  name: EnterPreset,
+  p: number,
+  opts: { distance?: number; reduced?: boolean } = {}
+): StyleFrag {
+  const reduced = opts.reduced ?? false;
+  const d = opts.distance ?? 24;
+  switch (name) {
+    case "rise":
+      return { opacity: p, transform: reduced ? "none" : `translateY(${(1 - p) * d}px)` };
+    case "settle":
+      return { opacity: p, transform: reduced ? "none" : `scale(${(1.03 - 0.03 * p).toFixed(4)})` };
+    case "bloom":
+      return { opacity: p, transform: "none", filter: reduced ? undefined : `blur(${((1 - p) * 8).toFixed(2)}px)` };
+    case "stagger":
+      return { opacity: p, transform: reduced ? "none" : `translateY(${(1 - p) * 16}px)` };
+    case "type":
+    case "draw":
+    case "count":
+      return { opacity: p > 0 ? 1 : 0, transform: "none" };
+  }
+}
+
+export function exitStyle(
+  name: ExitPreset,
+  p: number,
+  opts: { reduced?: boolean } = {}
+): StyleFrag {
+  const reduced = opts.reduced ?? false;
+  switch (name) {
+    case "sink":
+      return { opacity: 1 - p, transform: reduced ? "none" : `translateY(${-16 * p}px)` };
+    case "lift":
+      return { opacity: 1 - p, transform: reduced ? "none" : `scale(${(1 + 0.02 * p).toFixed(4)})` };
+    case "dissolve":
+      return { opacity: 1 - p, transform: "none" };
+    case "cut":
+      return { opacity: p < 1 ? 1 : 0, transform: "none" };
+  }
+}
+
+// ─── Helpers for the value-carrying presets ──────────────────────────────────
+
+/** `type`: how many characters of `total` are revealed at eased progress `p`. */
+export const typewriterChars = (p: number, total: number) => Math.round(p * total);
+
+/** `draw`: stroke-dashoffset for an SVG path of length `len` at progress `p`. */
+export const drawDashoffset = (p: number, len: number) => (1 - p) * len;
+
+/** `count`: tween a metric from `from`→`to` at eased progress `p`. */
+export const countValue = (p: number, to: number, from = 0) => from + (to - from) * p;
+
+/** `stagger`: per-child delay (in frames) for index `i`. */
+export const staggerDelay = (i: number, step = 4) => i * step;

package/src/motion/useMotion.ts

@@ -0,0 +1,63 @@
+import { interpolate, useCurrentFrame, useVideoConfig } from "remotion";
+import type { CSSProperties } from "react";
+import { EASE } from "../brand/tokens";
+import type { EnterPreset, ExitPreset } from "./names";
+import { enterStyle, exitStyle } from "./presets";
+
+/** Declarative motion for one element. Mirrored as zod in `src/schema/beats.ts`. */
+export type MotionSpec = {
+  enter?: EnterPreset;
+  exit?: ExitPreset;
+  easing?: "smooth" | "snappy";
+  /** frames to wait before entering */
+  delay?: number;
+  /** frames the entrance takes (default ~0.55s) */
+  durationInFrames?: number;
+  /** px travel for rise (default 24) */
+  distance?: number;
+};
+
+/**
+ * Resolves a MotionSpec to a style for the current frame, composing the entrance
+ * (from `delay`) with an exit ramp in the sequence's final ~0.4s. `smooth` is the
+ * default entrance easing; `snappy` (slight settle) is opt-in for state pops.
+ */
+export const useMotion = (spec: MotionSpec = {}, opts: { reduced?: boolean } = {}): CSSProperties => {
+  const frame = useCurrentFrame();
+  const { fps, durationInFrames } = useVideoConfig();
+  const reduced = opts.reduced ?? false;
+
+  const easing = EASE[spec.easing ?? "smooth"];
+  const delay = spec.delay ?? 0;
+  const enterDur = spec.durationInFrames ?? Math.round(fps * 0.55);
+
+  const ep = interpolate(frame, [delay, delay + enterDur], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp",
+    easing,
+  });
+  const enterFrag = enterStyle(spec.enter ?? "rise", ep, { distance: spec.distance, reduced });
+
+  let opacity = enterFrag.opacity;
+  const transforms: string[] = [];
+  if (enterFrag.transform !== "none") transforms.push(enterFrag.transform);
+
+  if (spec.exit) {
+    const exitDur = Math.round(fps * 0.4);
+    const xStart = durationInFrames - exitDur;
+    const xp = interpolate(frame, [xStart, durationInFrames], [0, 1], {
+      extrapolateLeft: "clamp",
+      extrapolateRight: "clamp",
+      easing: EASE.smooth,
+    });
+    const exitFrag = exitStyle(spec.exit, xp, { reduced });
+    opacity *= exitFrag.opacity;
+    if (exitFrag.transform !== "none") transforms.push(exitFrag.transform);
+  }
+
+  return {
+    opacity,
+    transform: transforms.length ? transforms.join(" ") : undefined,
+    filter: enterFrag.filter,
+  };
+};

package/src/prepare.ts

@@ -0,0 +1,33 @@
+import { changelogSchema, DIMENSIONS, type ChangelogVideo } from "./schema/beats";
+import { tokenize } from "./code/highlight";
+import { waitForFonts } from "./brand/fonts";
+
+/**
+ * Pre-render preparation, shared by Root's `calculateMetadata` and the render
+ * script: validate against the schema, pre-tokenize code via shiki (off the hot
+ * path), compute duration + dimensions from the format, and load fonts.
+ */
+export async function prepareChangelog(raw: unknown): Promise<{
+  durationInFrames: number;
+  width: number;
+  height: number;
+  props: ChangelogVideo;
+}> {
+  const video = changelogSchema.parse(raw);
+
+  const beats = await Promise.all(
+    video.beats.map(async (beat) => {
+      if (beat.code && !beat.code.tokens) {
+        const tokens = await tokenize(beat.code.source, beat.code.lang);
+        return { ...beat, code: { ...beat.code, tokens } };
+      }
+      return beat;
+    })
+  );
+
+  const durationInFrames = beats.reduce((n, b) => n + b.durationInFrames, 0);
+  const { width, height } = DIMENSIONS[video.format];
+  await waitForFonts();
+
+  return { durationInFrames, width, height, props: { ...video, beats } };
+}

package/src/schema/beats.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+import { ENTER_PRESETS, EXIT_PRESETS } from "../motion/names";
+
+/**
+ * The data contract for a changelog video. Authored as a `.ts` module (for types
+ * + comments) but **100% JSON-serializable** — every motion/panel/background is a
+ * string key resolved at render time via registries. `scripts/render.ts` parses
+ * a beats module with this schema, serializes to JSON, and feeds it as Remotion
+ * input props.
+ */
+
+const enterEnum = z.enum(ENTER_PRESETS);
+const exitEnum = z.enum(EXIT_PRESETS);
+
+export const motionSchema = z
+  .object({
+    enter: enterEnum.optional(),
+    exit: exitEnum.optional(),
+    easing: z.enum(["smooth", "snappy"]).optional(),
+    delay: z.number().optional(),
+    durationInFrames: z.number().optional(),
+    distance: z.number().optional(),
+  })
+  .strict();
+
+export const formatSchema = z.enum(["16x9", "1x1", "9x16"]);
+
+const codeTokenSchema = z.object({ content: z.string(), color: z.string() });
+
+export const codeSchema = z
+  .object({
+    filename: z.string(),
+    lang: z.enum(["ts", "tsx", "bash", "json"]),
+    source: z.string(),
+    theme: z.literal("light").default("light"),
+    motion: motionSchema.optional(),
+    /** Filled by calculateMetadata via shiki — do not author by hand. */
+    tokens: z.array(z.array(codeTokenSchema)).optional(),
+  })
+  .strict();
+
+export const panelSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("feed"),
+    title: z.string().default("feed"),
+    subtitle: z.string().optional(),
+    status: z.string().default("live…"),
+    rows: z.array(z.object({ badge: z.string(), label: z.string(), value: z.string() })),
+    motion: motionSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("upload-progress"),
+    file: z.string(),
+    sizeMB: z.number(),
+    parts: z.number(),
+    motion: motionSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("data-table"),
+    title: z.string().optional(),
+    columns: z.array(z.string()),
+    rows: z.array(z.array(z.string())),
+    motion: motionSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("status"),
+    title: z.string().default("status"),
+    services: z.array(z.object({ name: z.string(), state: z.enum(["ok", "syncing", "error", "idle"]), detail: z.string().optional() })),
+    motion: motionSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("proof"),
+    eventLine: z.string(),
+    cursor: z.string(),
+    signature: z.string(),
+    keyId: z.string(),
+    motion: motionSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("stream-resume"),
+    fromCursor: z.string(),
+    rows: z.array(z.object({ cursor: z.string(), label: z.string() })),
+    motion: motionSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("fork"),
+    blocks: z.array(z.object({ height: z.number(), hash: z.string(), state: z.enum(["canonical", "orphaned", "new"]) })),
+    rewindTo: z.string(),
+    motion: motionSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("stat"),
+    value: z.string(),
+    label: z.string(),
+    sub: z.string().optional(),
+    motion: motionSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("diagram"),
+    nodes: z.array(z.object({ id: z.string(), label: z.string(), type: z.enum(["default", "data", "api"]).default("default") })),
+    edges: z.array(z.object({ from: z.string(), to: z.string(), label: z.string().optional() })),
+    note: z.string().optional(),
+    motion: motionSchema.optional(),
+  }),
+]);
+
+export const beatSchema = z
+  .object({
+    id: z.string(),
+    durationInFrames: z.number().int().positive(),
+    /** Omit for the default procedural, theme-colored backdrop (the "shapes" pack). */
+    background: z
+      .object({
+        /** A painting/image in public/ (the optional painterly style pack). */
+        src: z.string().optional(),
+        treatment: z.enum(["kenburns", "static"]).default("kenburns"),
+        /** AI-free packs: a [from, to] gradient or a solid color. */
+        gradient: z.tuple([z.string(), z.string()]).optional(),
+        angle: z.number().default(160),
+        solid: z.string().optional(),
+        /** Procedural theme-colored backdrop (no asset, no API key) — the default. */
+        shapes: z.boolean().optional(),
+      })
+      .refine((b) => b.src || b.gradient || b.solid || b.shapes, "background needs src, gradient, solid, or shapes")
+      .optional(),
+    eyebrow: z.string().optional(),
+    headline: z.string(),
+    headlineMotion: motionSchema.optional(),
+    /** Optional sub-line pinned bottom-center — e.g. an install closer's tagline. */
+    caption: z.string().optional(),
+    /** Optional gold version pill shown with the caption — e.g. "v1.0". */
+    badge: z.string().optional(),
+    layout: z.enum(["split", "center"]).default("split"),
+    code: codeSchema.optional(),
+    panel: panelSchema.optional(),
+  })
+  .strict();
+
+export const changelogSchema = z
+  .object({
+    format: formatSchema.default("16x9"),
+    beats: z.array(beatSchema).min(1),
+    /** Reserved — silent render for now. */
+    audio: z.object({ music: z.string().optional(), vo: z.string().optional() }).optional(),
+  })
+  .strict();
+
+export type MotionSpecData = z.infer<typeof motionSchema>;
+export type Format = z.infer<typeof formatSchema>;
+export type CodeSpec = z.infer<typeof codeSchema>;
+export type PanelSpec = z.infer<typeof panelSchema>;
+export type Beat = z.infer<typeof beatSchema>;
+export type ChangelogVideo = z.infer<typeof changelogSchema>;
+/** Authoring type (defaults optional) — used by `content/*.beats.ts`. */
+export type ChangelogInput = z.input<typeof changelogSchema>;
+
+export const DIMENSIONS: Record<Format, { width: number; height: number }> = {
+  "16x9": { width: 1920, height: 1080 },
+  "1x1": { width: 1080, height: 1080 },
+  "9x16": { width: 1080, height: 1920 },
+};