demobite 0.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,58 @@
+# demobite
+
+**You prompt, it records.** The agentic recorder films a real browser from a
+storyboard — real cursor physics, a measured clock, cinematic camera moves —
+and delivers the take into [DemoBites](https://demobites.com), where it becomes
+a fully editable demo: AI narration, zooms, cursor rendering, intro and outro,
+localization, all tweakable in the studio.
+
+```bash
+npx demobite@latest
+```
+
+That one command checks your setup, installs the recorder skill for
+[Claude Code](https://claude.com/claude-code), and connects your machine to
+DemoBites through your own browser — no passwords in the terminal, ever.
+Then you just ask your agent:
+
+> "Record a demo of how search works on our app, and upload it to DemoBites."
+
+The agent storyboards the flow, films it in a real Chrome, and stages the take
+for your approval inside DemoBites. You approve in the product; the platform
+does the rest.
+
+## What's in this repository
+
+| Directory | What it is |
+|---|---|
+| `launcher/` | The `npx demobite` entry — environment checks, skill install, login |
+| `skill/` | The DemoBites recorder skill for Claude Code (staging, preview, approval flow) |
+| `recorder/` | The open recorder — same filming engine, no account, ends at a polished `demo.mp4` |
+| `scripts/` | The shared engine: filming, clock calibration, cutting |
+
+## Just want the recorder, no DemoBites?
+
+The `recorder/` directory is a standalone skill: the same real-browser filming,
+hover-anchor clock calibration and camera work, delivering a finished, styled
+`demo.mp4` on your disk — no account, no upload. Point Claude Code at it and
+film. When you want narration, zooms, an editable timeline and hosting, the
+sibling skill in `skill/` is one login away.
+
+## How updates reach you
+
+Run with `@latest` and every invocation resolves the newest published version —
+the skill you install always matches the DemoBites platform it talks to.
+Releases are published from GitHub Actions with npm provenance: every version
+is cryptographically tied to a public commit in this repository.
+
+## Requirements
+
+- Node 18+
+- [Claude Code](https://claude.com/claude-code) — the recorder is agent-driven
+- Google Chrome (recommended; films with the real browser) — otherwise
+  Chromium is downloaded on first take
+- ffmpeg (`brew install ffmpeg` on macOS)
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/launcher/index.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+// demobite — the DemoBites agentic recorder, one command away.
+//
+//   npx demobite@latest            install/update the skill + check your setup
+//   npx demobite@latest login      connect this machine to DemoBites
+//   npx demobite@latest logout     disconnect (revokes the key server-side)
+//
+// This launcher is deliberately boring: it verifies the environment, installs
+// the recorder skill into your agent's skills directory, and hands off. The
+// recorder itself is driven by your coding agent (Claude Code): once set up,
+// you just ask it — "record a demo of how search works on our app".
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileSync, spawnSync } from "node:child_process";
+
+const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf8"));
+const arg = process.argv[2] ?? "";
+
+const ok = (m) => console.log(`  ✓ ${m}`);
+const warn = (m) => console.log(`  ! ${m}`);
+
+console.log(`\ndemobite v${pkg.version} — the DemoBites agentic recorder\n`);
+
+// ── 1. Environment checks ──────────────────────────────────────────────────
+const nodeMajor = Number(process.versions.node.split(".")[0]);
+if (nodeMajor >= 18) ok(`Node ${process.versions.node}`);
+else { warn(`Node ${process.versions.node} — 18+ required`); process.exit(1); }
+
+const hasBin = (bin) => {
+  try { execFileSync(process.platform === "win32" ? "where" : "which", [bin], { stdio: "ignore" }); return true; }
+  catch { return false; }
+};
+const chromePaths = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "C:/Program Files/Google/Chrome/Application/chrome.exe",
+  "/usr/bin/google-chrome",
+];
+if (chromePaths.some((p) => fs.existsSync(p)) || hasBin("google-chrome")) ok("Google Chrome (films with the real browser)");
+else warn("Google Chrome not found — the recorder will download Chromium on first take");
+if (hasBin("ffmpeg")) ok("ffmpeg");
+else warn("ffmpeg not found — install it (macOS: brew install ffmpeg) before recording");
+if (hasBin("claude")) ok("Claude Code (the agent that drives the recorder)");
+else warn("Claude Code not found — install it from https://claude.com/claude-code, the recorder is agent-driven");
+
+// ── 2. Install / update the skill ──────────────────────────────────────────
+const skillsDir = path.join(os.homedir(), ".claude", "skills");
+const dest = path.join(skillsDir, "agentic-recorder");
+fs.mkdirSync(dest, { recursive: true });
+fs.mkdirSync(path.join(dest, "scripts"), { recursive: true });
+const copy = (from, to) => fs.copyFileSync(path.join(pkgRoot, from), path.join(dest, to));
+copy("skill/SKILL.md", "SKILL.md");
+for (const f of fs.readdirSync(path.join(pkgRoot, "skill/scripts"))) copy(`skill/scripts/${f}`, `scripts/${f}`);
+for (const f of fs.readdirSync(path.join(pkgRoot, "scripts"))) copy(`scripts/${f}`, `scripts/${f}`);
+ok(`Skill installed → ${dest}`);
+
+// Playwright lives with the skill so takes can film.
+if (!fs.existsSync(path.join(dest, "node_modules", "playwright"))) {
+  console.log("\n  Installing Playwright (one-time)…");
+  const r = spawnSync("npm", ["install", "--prefix", dest, "--silent", "playwright"], { stdio: "inherit" });
+  if (r.status === 0) ok("Playwright ready");
+  else warn("Playwright install failed — run: npm install --prefix ~/.claude/skills/agentic-recorder playwright");
+}
+
+// ── 3. Subcommands ─────────────────────────────────────────────────────────
+if (arg === "login" || arg === "logout") {
+  const r = spawnSync("node", [path.join(dest, "scripts", "login.mjs"), ...(arg === "logout" ? ["--logout"] : [])], {
+    stdio: "inherit",
+    cwd: process.cwd(),
+  });
+  process.exit(r.status ?? 0);
+}
+
+// ── 4. Handoff ─────────────────────────────────────────────────────────────
+console.log(`
+Ready. The recorder is agent-driven — open Claude Code in your project and ask:
+
+    "Record a demo of <your flow> and upload it to DemoBites"
+
+It signs in via your browser on first use (or run: npx demobite login).
+Only the recorder, no DemoBites? See the open recorder in this package's repo.
+`);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "demobite",
+  "version": "0.0.1",
+  "description": "The DemoBites agentic recorder — you prompt, it films a real browser, and DemoBites turns the take into an editable demo bite.",
+  "bin": {
+    "demobite": "launcher/index.mjs"
+  },
+  "files": [
+    "launcher",
+    "skill",
+    "recorder",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "demo",
+    "screen-recording",
+    "playwright",
+    "claude-code",
+    "skill",
+    "demobites",
+    "agentic"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/demobites/demobite.git"
+  },
+  "homepage": "https://github.com/demobites/demobite#readme",
+  "bugs": {
+    "url": "https://github.com/demobites/demobite/issues"
+  },
+  "license": "MIT",
+  "type": "module"
+}

package/recorder/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: open-recorder
+description: Film a polished product demo by driving a real browser from a storyboard, delivering a finished styled demo.mp4 — no account required. The open sibling of the DemoBites agentic recorder.
+---
+
+# The Open Recorder
+
+The same filming engine as the DemoBites agentic recorder — storyboard-driven
+Playwright capture in a real Chrome, hover-anchor clock calibration, human-pace
+cursor motion — ending at a finished, styled `demo.mp4` on your disk.
+
+Phases (shared engine lives in `../scripts/`):
+
+1. **Storyboard** — write the shot list as JSON (see the schema in
+   `../skill/SKILL.md`, identical here), show it to the human, get approval.
+2. **Dry run** — resolve every selector headless before filming.
+3. **The take** — `node ../scripts/record.mjs <takeDir> <storyboard.json>`
+4. **Trim + calibrate** — `node ../scripts/trim.mjs <takeDir>` then
+   `node ../scripts/calibrate.mjs <takeDir>`
+5. **Deliver** — the standalone finishing tools in `scripts/`:
+   `frame.mjs` (rounded corners + shadow), `post.sh` (backdrop + trim to
+   `demo.mp4`), optional `tts.mjs`/`mux.mjs` voiceover with your own
+   ElevenLabs key, optional SRT captions.
+
+The full standalone-ending reference, preserved verbatim from the original
+skill, is in `STANDALONE-ENDING.md`.
+
+Want narration written for you, cinematic zooms, a rendered cursor, an
+editable timeline, hosting and analytics? That is the DemoBites ending — the
+sibling skill in `../skill/`, one login away: `npx demobite login`.

package/recorder/STANDALONE-ENDING.md

@@ -0,0 +1,34 @@
+# PARKED: the standalone ending (future community skill)
+
+This skill is the COMMERCIAL DemoBites recorder — it does not offer a
+standalone MP4. The content below is preserved verbatim for the planned
+open-source community skill and is NOT part of this skill's flow.
+Do not ask the human which ending they want; there is one ending.
+
+### Ending A: STANDALONE
+
+Deliver a finished, styled demo.mp4.
+
+```bash
+node scripts/frame.mjs <takeDir>            # look overlays: shadow + alpha mask (radius 28)
+scripts/post.sh <takeDir> <backdropHexNo#>  # raw.webm -> demo.mp4, backdrop + corners + shadow + trim
+```
+
+Look laws inside: TRUE alpha mask rounded corners (alphamerge, radius 28, never painted on), shadow strength derived from backdrop luminance, `shortest=1` so the still overlays never extend the cut.
+
+Optional voiceover, only with the customer's OWN ElevenLabs key (env `ELEVENLABS_API_KEY` or `.recorder/elevenlabs.key`, never ask the human to paste it into chat):
+
+```bash
+node scripts/tts.mjs <takeDir>              # narration lines -> measured mp3 segments
+node scripts/mux.mjs <takeDir>              # demo.mp4 -> demo-voiced.mp4, anchored to real step timings
+```
+
+Optional captions:
+
+```bash
+node scripts/manifest.mjs <takeDir> --srt   # writes captions.srt from the narration timeline
+ffmpeg -i <takeDir>/demo-voiced.mp4 -vf "subtitles=<takeDir>/captions.srt" -c:a copy <takeDir>/demo-captioned.mp4
+```
+
+Deliverables: `demo.mp4` (or `demo-voiced.mp4` / `demo-captioned.mp4`) plus `manifest.json`.
+

package/recorder/scripts/frame.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// Standalone ending only — generate the look overlays for post.sh:
+// a shadow ring PNG and a TRUE rounded-alpha mask PNG.
+//
+// LAW (true alpha corners): rounded corners must be a real alpha mask fed to
+// ffmpeg alphamerge — never painted-on corner squares. Radius 28.
+// LAW (shadow from luminance): shadow strength derives from the backdrop's
+// luminance — light backdrops get a soft ink shadow, dark backdrops a deep one.
+//
+// Usage: node frame.mjs <takeDir> [backdropHex]
+// Backdrop resolution order: CLI arg, .recorder/config.json look.backdrop, #0f1420.
+import { chromium } from "playwright";
+import fs from "node:fs";
+import path from "node:path";
+
+const [, , outDir, argBackdrop] = process.argv;
+if (!outDir) {
+  console.error("Usage: node frame.mjs <takeDir> [backdropHex]");
+  process.exit(2);
+}
+let backdrop = argBackdrop;
+if (!backdrop) {
+  try {
+    backdrop = JSON.parse(fs.readFileSync(path.resolve(".recorder", "config.json"), "utf8")).look?.backdrop;
+  } catch {}
+}
+backdrop = backdrop || "#0f1420";
+if (!/^#?[0-9a-fA-F]{6}$/.test(backdrop)) {
+  console.error(`Backdrop must be a 6 digit hex color, got "${backdrop}"`);
+  process.exit(2);
+}
+if (!backdrop.startsWith("#")) backdrop = "#" + backdrop;
+fs.mkdirSync(path.resolve(outDir), { recursive: true });
+
+const hx = backdrop.slice(1);
+const light =
+  parseInt(hx.slice(0, 2), 16) * 0.299 +
+  parseInt(hx.slice(2, 4), 16) * 0.587 +
+  parseInt(hx.slice(4, 6), 16) * 0.114 > 128;
+const W = 1920, H = 1080, VW = 1728, VH = 972, R = 28;
+const X = (W - VW) / 2, Y = (H - VH) / 2;
+
+const b = await chromium.launch();
+const p = await b.newPage();
+await p.setViewportSize({ width: W, height: H });
+// Shadow ring: transparent page, rounded rect with only its box-shadow visible.
+const shadow = light
+  ? "0 14px 60px rgba(20,22,28,.16), 0 3px 14px rgba(20,22,28,.08)"
+  : "0 18px 80px rgba(0,0,0,.5), 0 4px 20px rgba(0,0,0,.3)";
+await p.setContent(`<body style="margin:0;background:transparent"><div style="position:absolute;left:${X}px;top:${Y}px;width:${VW}px;height:${VH}px;border-radius:${R}px;background:transparent;box-shadow:${shadow}"></div></body>`);
+await p.screenshot({ path: path.join(outDir, "shadow.png"), omitBackground: true });
+// Alpha mask: black canvas, white rounded rect — post.sh alphamerges this
+// grayscale source onto the scaled video.
+await p.setViewportSize({ width: VW, height: VH });
+await p.setContent(`<body style="margin:0;background:#000"><div style="position:absolute;inset:0;border-radius:${R}px;background:#fff"></div></body>`);
+await p.screenshot({ path: path.join(outDir, "mask.png") });
+await b.close();
+console.log("overlays ready (radius", R + "px,", light ? "light" : "dark", "shadow,", "backdrop", backdrop + ")");

package/recorder/scripts/mux.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+// Standalone ending only — mux the measured TTS segments onto the composited
+// cut (demo.mp4), anchored to the manifest's REAL step timings. The script is
+// the metronome: each line starts when its step starts, minus the trim.
+//
+// Founder-proven anchor tweaks (kept, commented):
+//   * the OPENING line gets a +0.3s beat after the hold starts, so the voice
+//     never fires on the very first frame
+//   * a line attached to a SCROLL step starts 1.5s early — it describes the
+//     page that just revealed, so it lands as the page settles, before the
+//     scroll moves
+//
+// Usage: node mux.mjs <takeDir>
+// Reads <takeDir>/demo.mp4 + <takeDir>/manifest.json + <takeDir>/tts/tts.json.
+// Writes <takeDir>/demo-voiced.mp4.
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+const dir = process.argv[2];
+if (!dir) {
+  console.error("Usage: node mux.mjs <takeDir>");
+  process.exit(2);
+}
+const requireTool = (tool) => {
+  try { execFileSync(tool, ["-version"], { stdio: "ignore" }); }
+  catch {
+    console.error(`${tool} is required on PATH. Install it (macOS: brew install ffmpeg) and rerun.`);
+    process.exit(1);
+  }
+};
+requireTool("ffmpeg");
+requireTool("ffprobe");
+
+const demoPath = path.join(dir, "demo.mp4");
+const manPath = path.join(dir, "manifest.json");
+const ttsPath = path.join(dir, "tts", "tts.json");
+if (!fs.existsSync(demoPath)) { console.error(`${demoPath} not found. Run frame.mjs + post.sh first.`); process.exit(1); }
+if (!fs.existsSync(manPath)) { console.error(`${manPath} not found. Run record.mjs first.`); process.exit(1); }
+if (!fs.existsSync(ttsPath)) { console.error(`${ttsPath} not found. Run tts.mjs first.`); process.exit(1); }
+
+const man = JSON.parse(fs.readFileSync(manPath, "utf8"));
+const tts = JSON.parse(fs.readFileSync(ttsPath, "utf8"));
+const r0 = man.record_from ?? 0;
+
+// Anchor each narrated step to its real start time, normalized to the cut.
+const narrated = (man.steps ?? []).filter((s) => s.narration?.text);
+const anchors = new Map();
+let first = true;
+for (const s of narrated) {
+  let at = (s.t_start ?? 0) - r0;
+  if (first) { at += 0.3; first = false; } // opening line, small beat after the hold starts
+  if (s.action === "scroll") at -= 1.5;    // page reveal line starts as the page settles, before the scroll
+  anchors.set(s.n, Math.max(0.05, Math.round(at * 100) / 100));
+}
+console.log("narration anchors (s):", JSON.stringify(Object.fromEntries(anchors)));
+
+const inputArgs = [];
+for (const seg of tts) inputArgs.push("-i", path.join(dir, "tts", seg.file));
+const delays = tts
+  .map((seg, i) => {
+    const ms = Math.round((anchors.get(seg.n) ?? 0) * 1000);
+    return `[${i + 1}:a]adelay=${ms}|${ms}[a${i}]`;
+  })
+  .join(";");
+const mix = tts.map((_, i) => `[a${i}]`).join("") + `amix=inputs=${tts.length}:normalize=0[aout]`;
+
+const outPath = path.join(dir, "demo-voiced.mp4");
+execFileSync("ffmpeg", [
+  "-y", "-loglevel", "error",
+  "-i", demoPath,
+  ...inputArgs,
+  "-filter_complex", `${delays};${mix}`,
+  "-map", "0:v", "-map", "[aout]",
+  "-c:v", "copy", "-c:a", "aac", "-b:a", "160k",
+  outPath,
+], { stdio: "inherit" });
+const dur = execFileSync("ffprobe", [
+  "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", outPath,
+]).toString().trim();
+console.log(`demo-voiced.mp4 ready, ${parseFloat(dur).toFixed(2)}s`);

package/recorder/scripts/post.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Standalone ending only — raw.webm -> demo.mp4.
+# Composites the look: backdrop color, TRUE rounded-alpha corners (mask via
+# alphamerge, generated by frame.mjs), shadow ring, and the record_from trim.
+#
+# LAW (shortest=1): the still PNG overlays are infinite inputs — shortest=1 on
+# the final overlay keeps the cut exactly as long as the video, never longer.
+# LAW (first-frame trim): trim=start=record_from so the published cut opens on
+# the fully loaded page that record.mjs stamped.
+#
+# Usage: post.sh <takeDir> [backdrop-hex-no-#]   (default backdrop 0f1420)
+set -euo pipefail
+command -v ffmpeg >/dev/null 2>&1 || { echo "ffmpeg is required on PATH. Install it (macOS: brew install ffmpeg) and rerun." >&2; exit 1; }
+command -v node >/dev/null 2>&1 || { echo "node is required on PATH." >&2; exit 1; }
+D=${1:?Usage: post.sh <takeDir> [backdrop-hex-no-#]}
+# Backdrop resolution mirrors frame.mjs exactly: CLI arg, then the remembered
+# .recorder/config.json look.backdrop, then #0f1420 — the two MUST agree or
+# the corner mask color and the composited backdrop drift apart.
+BG=${2:-$(node -p "try{(JSON.parse(require('fs').readFileSync('.recorder/config.json','utf8')).look||{}).backdrop?.replace('#','')||'0f1420'}catch{'0f1420'}")}
+[ -f "$D/raw.webm" ] || { echo "$D/raw.webm not found. Run record.mjs first." >&2; exit 1; }
+[ -f "$D/shadow.png" ] && [ -f "$D/mask.png" ] || { echo "Overlays missing. Run: node frame.mjs $D" >&2; exit 1; }
+TRIM=$(node -p "JSON.parse(require('fs').readFileSync('$D/manifest.json','utf8')).record_from||0")
+ffmpeg -y -loglevel error -i "$D/raw.webm" -i "$D/shadow.png" -i "$D/mask.png" -filter_complex \
+"color=c=0x${BG}:s=1920x1080:r=30[bg];[0:v]trim=start=${TRIM},setpts=PTS-STARTPTS,scale=1728:972:flags=lanczos[v];[2:v]format=gray[m];[v][m]alphamerge[va];[bg][1:v]overlay=0:0[b1];[b1][va]overlay=96:54:shortest=1,fps=30,format=yuv420p[out]" \
+-map "[out]" -c:v libx264 -preset medium -crf 19 -movflags +faststart "$D/demo.mp4"
+echo "demo.mp4 duration: $(ffprobe -v error -show_entries format=duration -of csv=p=0 "$D/demo.mp4")s"

package/recorder/scripts/tts.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// Standalone ending only — voice the storyboard with the customer's OWN
+// ElevenLabs key. Reads the narration lines from the take's manifest,
+// synthesizes one mp3 per line, measures each with ffprobe, and writes
+// <takeDir>/tts/tts.json so mux.mjs (and manifest.mjs) use MEASURED
+// durations instead of estimates.
+//
+// Key resolution (never stored in config.json): ELEVENLABS_API_KEY env var,
+// else the file .recorder/elevenlabs.key. The key never leaves this machine
+// except to the ElevenLabs API.
+//
+// Usage: node tts.mjs <takeDir>
+// Voice: .recorder/config.json tts.voice_id, else Alice (premade, free tier OK).
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+const dir = process.argv[2];
+if (!dir) {
+  console.error("Usage: node tts.mjs <takeDir>");
+  process.exit(2);
+}
+const requireTool = (tool) => {
+  try { execFileSync(tool, ["-version"], { stdio: "ignore" }); }
+  catch {
+    console.error(`${tool} is required on PATH. Install it (macOS: brew install ffmpeg) and rerun.`);
+    process.exit(1);
+  }
+};
+requireTool("ffprobe");
+
+let KEY = process.env.ELEVENLABS_API_KEY || "";
+if (!KEY) {
+  try { KEY = fs.readFileSync(path.resolve(".recorder", "elevenlabs.key"), "utf8").trim(); } catch {}
+}
+if (!KEY) {
+  console.error("No ElevenLabs key. Set ELEVENLABS_API_KEY or put the key in .recorder/elevenlabs.key");
+  process.exit(1);
+}
+
+let cfg = {};
+try { cfg = JSON.parse(fs.readFileSync(path.resolve(".recorder", "config.json"), "utf8")); } catch {}
+const VOICE = cfg.tts?.voice_id || "Xb7hH8MSUJpSbSDYk0k2"; // Alice, clear engaging educator
+
+const manPath = path.join(dir, "manifest.json");
+if (!fs.existsSync(manPath)) { console.error(`${manPath} not found. Run record.mjs first.`); process.exit(1); }
+const man = JSON.parse(fs.readFileSync(manPath, "utf8"));
+const narrated = (man.steps ?? []).filter((s) => s.narration?.text);
+if (narrated.length === 0) { console.error("No narration lines in the manifest."); process.exit(1); }
+
+const outDir = path.join(dir, "tts");
+fs.mkdirSync(outDir, { recursive: true });
+const out = [];
+for (const step of narrated) {
+  const res = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${VOICE}?output_format=mp3_44100_128`, {
+    method: "POST",
+    headers: { "xi-api-key": KEY, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      text: step.narration.text,
+      model_id: "eleven_multilingual_v2",
+      voice_settings: { stability: 0.5, similarity_boost: 0.7 },
+    }),
+  });
+  if (!res.ok) {
+    console.error("TTS failed for step", step.n, res.status, await res.text());
+    process.exit(1);
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  const file = `seg${step.n}.mp3`;
+  fs.writeFileSync(path.join(outDir, file), buf);
+  const dur = parseFloat(execFileSync("ffprobe", [
+    "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", path.join(outDir, file),
+  ]).toString());
+  out.push({ n: step.n, text: step.narration.text, file, duration: Math.round(dur * 100) / 100 });
+  console.log(`step ${step.n}: ${dur.toFixed(2)}s  "${step.narration.text}"`);
+}
+fs.writeFileSync(path.join(outDir, "tts.json"), JSON.stringify(out, null, 2));
+console.log(`tts.json written (${out.length} segments) in ${outDir}`);