@reelscript/cli 0.1.0

package/dist/resolve-self.d.ts

@@ -0,0 +1,12 @@
+type Resolve = (specifier: string, context: {
+    parentURL?: string;
+}, next: (specifier: string, context: {
+    parentURL?: string;
+}) => Promise<{
+    url: string;
+}>) => Promise<{
+    url: string;
+    shortCircuit?: boolean;
+}>;
+export declare const resolve: Resolve;
+export {};

package/dist/resolve-self.js

@@ -0,0 +1,12 @@
+/**
+ * Module resolution hook registered by the CLI so that user scripts can
+ * `import "@reelscript/cli"` even when the package is not installed next to
+ * the script (global install, the container, or `npx`). The import resolves
+ * to the copy of the library that is running the CLI.
+ */
+const SELF = new URL("./index.js", import.meta.url).href;
+export const resolve = async (specifier, context, next) => {
+    if (specifier === "@reelscript/cli")
+        return { url: SELF, shortCircuit: true };
+    return next(specifier, context);
+};

package/dist/terminal.d.ts

@@ -0,0 +1,38 @@
+/** One chunk of output: when it appeared (ms from command start) and what. */
+export type TermEvent = [atMs: number, text: string];
+export interface TermRecording {
+    version: 1;
+    command: string;
+    cols: number;
+    rows: number;
+    exitCode: number | null;
+    durationMs: number;
+    recordedAt: string;
+    events: TermEvent[];
+}
+export declare const TERMINAL_URL = "https://reelscript.local/terminal";
+/** Stable file name for a command's recording. */
+export declare function slugForCommand(command: string): string;
+export declare function recordingPath(dir: string, command: string): string;
+export declare function loadRecording(dir: string, command: string): TermRecording | null;
+/** Turn declared output into evenly paced line events. */
+export declare function scriptedEvents(output: string, durationMs?: number): TermEvent[];
+/**
+ * Compact a recording's timing for playback: cap long silences, scale by
+ * speed, so a real command that stalled for 20s doesn't stall the demo.
+ */
+export declare function playbackEvents(events: TermEvent[], opts?: {
+    speed?: number;
+    maxGapMs?: number;
+}): TermEvent[];
+export interface RecordOptions {
+    cwd?: string;
+    cols?: number;
+    rows?: number;
+    timeoutMs?: number;
+}
+/** Run a command for real and capture its output with timestamps. */
+export declare function recordCommand(command: string, opts?: RecordOptions): Promise<TermRecording>;
+export declare function saveRecording(dir: string, rec: TermRecording): string;
+/** Self-contained HTML for the terminal page (xterm + font inlined). */
+export declare function terminalPageHtml(fontSize?: number): string;

package/dist/terminal.js

@@ -0,0 +1,164 @@
+/**
+ * Terminal window: an xterm.js page rendered in Chromium with a bundled
+ * monospace font, driven by the timeline. Output is either declared in the
+ * script or replayed from a recording made by `reelscript record`.
+ */
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+export const TERMINAL_URL = "https://reelscript.local/terminal";
+/** Stable file name for a command's recording. */
+export function slugForCommand(command) {
+    const base = command
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+    const hash = createHash("sha1").update(command).digest("hex").slice(0, 6);
+    return `${base || "cmd"}-${hash}`;
+}
+export function recordingPath(dir, command) {
+    return join(dir, `${slugForCommand(command)}.json`);
+}
+export function loadRecording(dir, command) {
+    const file = recordingPath(dir, command);
+    if (!existsSync(file))
+        return null;
+    return JSON.parse(readFileSync(file, "utf8"));
+}
+/** Turn declared output into evenly paced line events. */
+export function scriptedEvents(output, durationMs) {
+    const lines = output.replace(/\r\n/g, "\n").split("\n");
+    const n = lines.length;
+    const total = durationMs ?? Math.min(2500, 150 + 60 * n);
+    const step = n > 1 ? total / (n - 1) : 0;
+    return lines.map((line, i) => [Math.round(80 + i * step), i < n - 1 ? `${line}\n` : line]);
+}
+/**
+ * Compact a recording's timing for playback: cap long silences, scale by
+ * speed, so a real command that stalled for 20s doesn't stall the demo.
+ */
+export function playbackEvents(events, opts = {}) {
+    const speed = opts.speed ?? 1;
+    const maxGap = opts.maxGapMs ?? 700;
+    let prev = 0;
+    let acc = 0;
+    return events.map(([at, text]) => {
+        const gap = Math.min(Math.max(0, at - prev), maxGap) / speed;
+        prev = at;
+        acc += gap;
+        return [Math.round(acc), text];
+    });
+}
+/** Run a command for real and capture its output with timestamps. */
+export function recordCommand(command, opts = {}) {
+    const cols = opts.cols ?? 120;
+    const rows = opts.rows ?? 36;
+    return new Promise((resolve, reject) => {
+        const start = Date.now();
+        const events = [];
+        const child = spawn(command, {
+            shell: true,
+            cwd: opts.cwd,
+            env: { ...process.env, FORCE_COLOR: "1", TERM: "xterm-256color", COLUMNS: String(cols), LINES: String(rows) },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const onData = (chunk) => events.push([Date.now() - start, chunk.toString("utf8")]);
+        child.stdout.on("data", onData);
+        child.stderr.on("data", onData);
+        const timer = setTimeout(() => child.kill(), opts.timeoutMs ?? 120_000);
+        child.on("error", reject);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({
+                version: 1,
+                command,
+                cols,
+                rows,
+                exitCode: code,
+                durationMs: Date.now() - start,
+                recordedAt: new Date().toISOString(),
+                events,
+            });
+        });
+    });
+}
+export function saveRecording(dir, rec) {
+    mkdirSync(dir, { recursive: true });
+    const file = recordingPath(dir, rec.command);
+    writeFileSync(file, JSON.stringify(rec, null, 2) + "\n");
+    return file;
+}
+// ---------------------------------------------------------------- page
+const THEME = {
+    background: "#1c1c1e",
+    foreground: "#e5e5e7",
+    cursor: "#e5e5e7",
+    cursorAccent: "#1c1c1e",
+    selectionBackground: "#3a3a3c",
+    black: "#1c1c1e",
+    red: "#ff6b6b",
+    green: "#5fd27a",
+    yellow: "#f5c451",
+    blue: "#6ea8ff",
+    magenta: "#d38cff",
+    cyan: "#5ed7e0",
+    white: "#e5e5e7",
+    brightBlack: "#6e6e73",
+    brightRed: "#ff8787",
+    brightGreen: "#7ee89b",
+    brightYellow: "#ffd479",
+    brightBlue: "#8fbcff",
+    brightMagenta: "#e0a5ff",
+    brightCyan: "#7fe6ee",
+    brightWhite: "#ffffff",
+};
+let pageCache = new Map();
+/** Self-contained HTML for the terminal page (xterm + font inlined). */
+export function terminalPageHtml(fontSize = 15) {
+    let html = pageCache.get(fontSize);
+    if (html)
+        return html;
+    const require = createRequire(import.meta.url);
+    const xtermJs = readFileSync(require.resolve("@xterm/xterm/lib/xterm.js"), "utf8");
+    const xtermCss = readFileSync(require.resolve("@xterm/xterm/css/xterm.css"), "utf8");
+    const fitJs = readFileSync(require.resolve("@xterm/addon-fit/lib/addon-fit.js"), "utf8");
+    const font = readFileSync(new URL("../assets/fonts/JetBrainsMono-Variable.ttf", import.meta.url)).toString("base64");
+    html = `<!doctype html><html><head><meta charset="utf-8"><style>
+@font-face { font-family: "JetBrains Mono"; font-weight: 100 800; src: url(data:font/ttf;base64,${font}) format("truetype"); }
+${xtermCss}
+html, body { margin: 0; height: 100%; background: ${THEME.background}; overflow: hidden; }
+#t { position: absolute; inset: 0; padding: 10px 12px; }
+.xterm .xterm-viewport { overflow: hidden !important; }
+</style></head><body><div id="t"></div>
+<script>${xtermJs}</script>
+<script>${fitJs}</script>
+<script>
+(async () => {
+  await document.fonts.load('${fontSize}px "JetBrains Mono"');
+  const T = window.Terminal || (window.xterm && window.xterm.Terminal);
+  const Fit = (window.FitAddon && window.FitAddon.FitAddon) || window.FitAddon;
+  const term = new T({
+    fontFamily: '"JetBrains Mono", monospace', fontSize: ${fontSize}, lineHeight: 1.3,
+    cursorBlink: true, cursorStyle: "block", convertEol: true, scrollback: 0,
+    theme: ${JSON.stringify(THEME)},
+  });
+  const fit = new Fit();
+  term.loadAddon(fit);
+  term.open(document.getElementById("t"));
+  fit.fit();
+  term.focus(); // draws the block cursor; unfocused xterm shows only an outline
+  window.__rsTerm = {
+    write: (s) => { term.write(s); },
+    fit: () => { fit.fit(); return { cols: term.cols, rows: term.rows }; },
+    get cols() { return term.cols; },
+    get rows() { return term.rows; },
+    ready: true,
+  };
+})();
+</script></body></html>`;
+    pageCache.set(fontSize, html);
+    return html;
+}

package/dist/theme.d.ts

@@ -0,0 +1,51 @@
+/**
+ * A theme draws the desktop: the wallpaper and menubar behind everything,
+ * a frame (title bar, shadow, rounded corners) around each window, and the
+ * mask that rounds a window's content. The engine composes these per frame.
+ *
+ * Chrome is rendered as HTML by Chromium with fonts bundled in the package,
+ * so the same script produces the same pixels on every platform.
+ */
+export type ThemeName = "macos" | "bare";
+export type WindowKind = "browser" | "terminal";
+export interface RawImage {
+    data: Buffer;
+    width: number;
+    height: number;
+    channels: 4;
+}
+/** A frame image plus where it sits relative to the window's frame origin. */
+export interface FrameImage extends RawImage {
+    dx: number;
+    dy: number;
+}
+export interface WindowStyle {
+    kind: WindowKind;
+    /** Content size. */
+    width: number;
+    height: number;
+    title: string;
+    url: string;
+    focused: boolean;
+}
+/** Renders an HTML document of the given size to a PNG. Provided by the engine. */
+export type HtmlRasterizer = (html: string, width: number, height: number, transparent: boolean) => Promise<Buffer>;
+export interface Theme {
+    /** Height of a window's title bar (0 when windows have no chrome). */
+    readonly titleHeight: number;
+    /** Desktop size when the script doesn't set one, given the main window's content size. */
+    defaultDesktop(viewport: [number, number]): [number, number];
+    /** Frame origin for the first window opened. */
+    mainPlacement(desktop: [number, number], content: [number, number]): {
+        x: number;
+        y: number;
+    };
+    background(desktop: [number, number]): Promise<RawImage>;
+    /** Window chrome, or null for none. */
+    frame(style: WindowStyle): Promise<FrameImage | null>;
+    /** Alpha mask applied to window content, or null for none. */
+    contentMask(width: number, height: number): Promise<RawImage | null>;
+}
+/** @font-face rule embedding the bundled Inter variable font. */
+export declare function bundledFontFace(): string;
+export declare function createTheme(name: ThemeName, rasterize: HtmlRasterizer): Theme;

package/dist/theme.js

@@ -0,0 +1,181 @@
+import sharp from "sharp";
+import { readFileSync } from "node:fs";
+function even(n) {
+    return n % 2 === 0 ? n : n + 1;
+}
+async function toRaw(png) {
+    const { data, info } = await sharp(png).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    return { data, width: info.width, height: info.height, channels: 4 };
+}
+// ---------------------------------------------------------------- font
+let fontFace = null;
+/** @font-face rule embedding the bundled Inter variable font. */
+export function bundledFontFace() {
+    if (!fontFace) {
+        const ttf = readFileSync(new URL("../assets/fonts/InterVariable.ttf", import.meta.url));
+        fontFace = `@font-face { font-family: "Inter"; font-weight: 100 900; font-style: normal;
+      src: url(data:font/ttf;base64,${ttf.toString("base64")}) format("truetype"); }`;
+    }
+    return fontFace;
+}
+// ---------------------------------------------------------------- bare
+class BareTheme {
+    titleHeight = 0;
+    bg = null;
+    defaultDesktop(viewport) {
+        return [even(viewport[0]), even(viewport[1])];
+    }
+    mainPlacement() {
+        return { x: 0, y: 0 };
+    }
+    async background([w, h]) {
+        if (!this.bg || this.bg.width !== w || this.bg.height !== h) {
+            const data = Buffer.alloc(w * h * 4);
+            for (let i = 3; i < data.length; i += 4)
+                data[i] = 255;
+            this.bg = { data, width: w, height: h, channels: 4 };
+        }
+        return this.bg;
+    }
+    async frame() {
+        return null;
+    }
+    async contentMask() {
+        return null;
+    }
+}
+// ---------------------------------------------------------------- macos
+const MENUBAR_H = 28;
+const PAD_X = 72;
+const GAP_TOP = 44;
+const TITLE_H = 48;
+const PAD_BOTTOM = 72;
+const RADIUS = 12;
+/** Room around a frame for its drop shadow. */
+const SHADOW_PAD = 64;
+class MacosTheme {
+    rasterize;
+    titleHeight = TITLE_H;
+    bgCache = new Map();
+    frameCache = new Map();
+    maskCache = new Map();
+    constructor(rasterize) {
+        this.rasterize = rasterize;
+    }
+    defaultDesktop([vw, vh]) {
+        return [even(vw + PAD_X * 2), even(MENUBAR_H + GAP_TOP + TITLE_H + vh + PAD_BOTTOM)];
+    }
+    mainPlacement([dw], [w]) {
+        return { x: Math.round((dw - w) / 2), y: MENUBAR_H + GAP_TOP };
+    }
+    css() {
+        return `${bundledFontFace()}
+html, body { margin: 0; overflow: hidden; font-family: Inter, system-ui, sans-serif; -webkit-font-smoothing: antialiased; }`;
+    }
+    background(desktop) {
+        const [w, h] = desktop;
+        const key = `${w}x${h}`;
+        let p = this.bgCache.get(key);
+        if (!p) {
+            const html = `<!doctype html><html><head><meta charset="utf-8"><style>
+${this.css()}
+html, body { width: ${w}px; height: ${h}px; }
+.wall { position: absolute; inset: 0; background: linear-gradient(135deg, #4f46e5 0%, #c2410c 55%, #f59e0b 100%); }
+.glow { position: absolute; inset: 0; background: radial-gradient(80% 80% at 30% 20%, rgba(255,255,255,.22), rgba(255,255,255,0)); }
+.menubar { position: absolute; left: 0; top: 0; right: 0; height: ${MENUBAR_H}px; background: rgba(255,255,255,.16);
+  color: #fff; font-size: 13px; display: flex; align-items: center; justify-content: space-between; padding: 0 18px; }
+.menubar b { font-weight: 600; }
+</style></head><body>
+<div class="wall"></div><div class="glow"></div>
+<div class="menubar"><b>reelscript</b><span>Tue Sep 23&nbsp;&nbsp;9:41 AM</span></div>
+</body></html>`;
+            p = this.rasterize(html, w, h, false).then(toRaw);
+            this.bgCache.set(key, p);
+        }
+        return p;
+    }
+    frame(style) {
+        const key = JSON.stringify(style);
+        let p = this.frameCache.get(key);
+        if (!p) {
+            const { kind, width, height, focused } = style;
+            const W = width + SHADOW_PAD * 2;
+            const H = height + TITLE_H + SHADOW_PAD * 2;
+            const terminal = kind === "terminal";
+            const urlW = Math.min(560, Math.round(width * 0.46));
+            const lights = focused
+                ? ["#ff5f57", "#febc2e", "#28c840"]
+                : terminal
+                    ? ["#5a5a5e", "#5a5a5e", "#5a5a5e"]
+                    : ["#d4d4d8", "#d4d4d8", "#d4d4d8"];
+            const bar = terminal
+                ? `<div class="ttl">${escapeHtml(style.title)}</div>`
+                : `<div class="url">${escapeHtml(displayUrl(style.url))}</div>`;
+            const html = `<!doctype html><html><head><meta charset="utf-8"><style>
+${this.css()}
+html, body { width: ${W}px; height: ${H}px; background: transparent; }
+.window { position: absolute; left: ${SHADOW_PAD}px; top: ${SHADOW_PAD}px; width: ${width}px; height: ${height + TITLE_H}px;
+  border-radius: ${RADIUS}px; background: ${terminal ? "#1c1c1e" : "#ffffff"}; overflow: hidden;
+  box-shadow: ${focused ? "0 22px 48px rgba(0,0,0,.45), 0 2px 6px rgba(0,0,0,.25)" : "0 12px 28px rgba(0,0,0,.28), 0 1px 4px rgba(0,0,0,.2)"}; }
+.title { position: relative; height: ${TITLE_H}px; background: ${terminal ? "#2c2c2e" : "#f3f3f5"};
+  border-bottom: 1px solid ${terminal ? "#3a3a3c" : "#dcdce1"}; }
+.lights { position: absolute; left: 16px; top: ${TITLE_H / 2 - 6}px; display: flex; gap: 8px; }
+.lights i { display: block; width: 12px; height: 12px; border-radius: 50%; }
+.url { position: absolute; left: 50%; top: 12px; transform: translateX(-50%); width: ${urlW}px; height: ${TITLE_H - 24}px;
+  border-radius: 7px; background: #e6e6ea; color: ${focused ? "#3f3f46" : "#8e8e93"}; font-size: 12.5px;
+  display: flex; align-items: center; justify-content: center; white-space: nowrap; overflow: hidden; }
+.ttl { position: absolute; inset: 0; display: flex; align-items: center; justify-content: center;
+  color: ${focused ? "#a1a1a6" : "#6e6e73"}; font-size: 13px; font-weight: 500; }
+</style></head><body>
+<div class="window"><div class="title">
+  <div class="lights"><i style="background:${lights[0]}"></i><i style="background:${lights[1]}"></i><i style="background:${lights[2]}"></i></div>
+  ${bar}
+</div></div>
+</body></html>`;
+            p = this.rasterize(html, W, H, true)
+                .then(toRaw)
+                .then((img) => ({ ...img, dx: -SHADOW_PAD, dy: -SHADOW_PAD }));
+            this.frameCache.set(key, p);
+        }
+        return p;
+    }
+    contentMask(width, height) {
+        const key = `${width}x${height}`;
+        let p = this.maskCache.get(key);
+        if (!p) {
+            const r = RADIUS;
+            const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">
+        <path d="M0 0 H${width} V${height - r} A${r} ${r} 0 0 1 ${width - r} ${height} H${r} A${r} ${r} 0 0 1 0 ${height - r} Z" fill="#fff"/>
+      </svg>`;
+            p = sharp(Buffer.from(svg)).png().toBuffer().then(toRaw);
+            this.maskCache.set(key, p);
+        }
+        return p;
+    }
+}
+function displayUrl(url) {
+    if (!url)
+        return "";
+    if (url.startsWith("file://"))
+        return url.split("/").pop() ?? url;
+    try {
+        const u = new URL(url);
+        return u.host + (u.pathname === "/" ? "" : u.pathname);
+    }
+    catch {
+        return url;
+    }
+}
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+export function createTheme(name, rasterize) {
+    switch (name) {
+        case "bare":
+            return new BareTheme();
+        case "macos":
+            return new MacosTheme(rasterize);
+        default:
+            throw new Error(`reelscript: unknown theme "${name}"`);
+    }
+}

package/dist/timeline.d.ts

@@ -0,0 +1,103 @@
+import type { Ease } from "./easing.js";
+/** A CSS selector, or an explicit point in page (viewport) coordinates. */
+export type Target = string | {
+    x: number;
+    y: number;
+};
+export type Action = {
+    kind: "browser.goto";
+    url: string;
+    settle?: number;
+} | {
+    kind: "browser.mockAPI";
+    pattern: string;
+    response: unknown;
+    status?: number;
+} | {
+    kind: "cursor.moveTo";
+    target: Target;
+    ease?: Ease;
+    duration?: number;
+    window?: string;
+} | {
+    kind: "cursor.click";
+    button?: "left" | "right";
+} | {
+    kind: "zoom.to";
+    target: Target;
+    scale?: number;
+    duration?: number;
+    ease?: Ease;
+    window?: string;
+} | {
+    kind: "zoom.out";
+    duration?: number;
+    ease?: Ease;
+} | {
+    kind: "type";
+    target?: string;
+    text: string;
+    wpm?: number;
+} | {
+    kind: "press";
+    key: string;
+} | {
+    kind: "wait";
+    ms: number;
+} | {
+    kind: "say";
+    text: string;
+    voice?: string;
+    speed?: number;
+} | {
+    kind: "waitForNarration";
+} | {
+    kind: "terminal.open";
+    title?: string;
+    prompt?: string;
+    fontSize?: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+} | {
+    kind: "window.focus";
+    window: string;
+} | {
+    kind: "window.place";
+    window: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+} | {
+    kind: "terminal.run";
+    command: string;
+    /** Declared output. Omit to replay a recording made by `reelscript record`. */
+    output?: string;
+    /** Spread declared output over this many ms. */
+    duration?: number;
+    /** Typing speed for the command. */
+    wpm?: number;
+    /** Playback speed for recorded output. Default: 1 */
+    speed?: number;
+    /** Cap silences in recorded output, ms. Default: 700 */
+    maxGapMs?: number;
+};
+export type ActionKind = Action["kind"];
+export declare const DEFAULTS: {
+    fps: number;
+    viewport: [number, number];
+    /** ms the page is shown after a goto before the next action */
+    gotoSettle: number;
+    clickDuration: number;
+    typeWpm: number;
+    zoomScale: number;
+    zoomDuration: number;
+    /** frames appended after the last action so the ending doesn't feel clipped */
+    tailMs: number;
+    /** silence between consecutive narration clips */
+    narrationGapMs: number;
+    terminalPrompt: string;
+    terminalTitle: string;
+};

package/dist/timeline.js

@@ -0,0 +1,16 @@
+export const DEFAULTS = {
+    fps: 60,
+    viewport: [1280, 800],
+    /** ms the page is shown after a goto before the next action */
+    gotoSettle: 400,
+    clickDuration: 180,
+    typeWpm: 300,
+    zoomScale: 1.6,
+    zoomDuration: 700,
+    /** frames appended after the last action so the ending doesn't feel clipped */
+    tailMs: 500,
+    /** silence between consecutive narration clips */
+    narrationGapMs: 300,
+    terminalPrompt: "~ % ",
+    terminalTitle: "zsh",
+};

package/dist/tts.d.ts

@@ -0,0 +1,34 @@
+export interface TtsAudio {
+    /** Mono PCM samples in [-1, 1]. */
+    audio: Float32Array;
+    sampleRate: number;
+}
+export interface TtsOptions {
+    voice?: string;
+    /** Playback speed multiplier. Default: 1 */
+    speed?: number;
+}
+export interface TtsEngine {
+    /** Stable identifier; part of the clip cache key. */
+    readonly id: string;
+    synthesize(text: string, opts: TtsOptions): Promise<TtsAudio>;
+}
+export interface Clip {
+    /** Path to a 16-bit mono WAV file. */
+    file: string;
+    seconds: number;
+}
+export declare const DEFAULT_VOICE = "af_heart";
+export declare const KOKORO_MODEL = "onnx-community/Kokoro-82M-v1.0-ONNX";
+/** Root of reelscript's on-disk cache (models, synthesized clips). */
+export declare function cacheDir(): string;
+/** Split narration into sentences; TTS models prefer short inputs. */
+export declare function splitSentences(text: string): string[];
+/** Kokoro-82M via kokoro-js, loaded lazily on first use. */
+export declare function kokoro(model?: string): TtsEngine;
+/** Encode mono float samples as a 16-bit PCM WAV file. */
+export declare function toWav({ audio, sampleRate }: TtsAudio): Buffer;
+/** Synthesize (or fetch from cache) one narration clip. */
+export declare function synthesizeClip(engine: TtsEngine, text: string, opts: TtsOptions): Promise<Clip>;
+/** Replace words the TTS mispronounces, e.g. { Reelscript: "Reel script" }. */
+export declare function applyPronunciations(text: string, map: Record<string, string> | undefined): string;