@bendyline/squisq-cli 1.1.5 → 1.1.6

package/dist/api.js

@@ -1,324 +1,413 @@
-/**
- * Programmatic Video API
- *
- * Provides a library-style entry point for rendering Squisq documents to MP4
- * from Node.js callers (e.g., Qualla's pipeline). This avoids the need to shell
- * out to the `squisq video` CLI and gives callers full control over the Doc,
- * MemoryContentContainer, and encoding options.
- *
- * Orchestrates the full pipeline: Doc → render HTML → Playwright frame capture → FFmpeg encode.
- *
- * Usage:
- *   import { renderDocToMp4 } from '@bendyline/squisq-cli/api';
- *
- *   await renderDocToMp4(doc, container, {
- *     outputPath: '/tmp/output.mp4',
- *     fps: 30,
- *     quality: 'normal',
- *     orientation: 'landscape',
- *   });
- */
-import { generateRenderHtml } from '@bendyline/squisq-video';
-import { resolveDimensions } from '@bendyline/squisq-video';
-import { detectFfmpeg } from './util/detectFfmpeg.js';
-export { MemoryContentContainer } from '@bendyline/squisq/storage';
-export { readInput } from './util/readInput.js';
-/**
- * Render a Doc + media container to an MP4 video file.
- *
- * The container should contain audio and image files referenced by the Doc's
- * audio.segments[].src and block image paths. Files are embedded as base64
- * data URIs in a self-contained render HTML page.
- *
- * Requires:
- * - Playwright (chromium) — for headless frame capture
- * - FFmpeg — for video encoding (must be on PATH)
- *
- * @param doc - The Doc structure to render
- * @param container - MemoryContentContainer with audio/image files
- * @param options - Rendering and encoding options
- * @returns Result with duration and frame count
- */
-export async function renderDocToMp4(doc, container, options) {
-    const { outputPath, fps = 30, quality = 'normal', orientation = 'landscape', captionStyle, coverPreRoll = 0, onProgress, } = options;
-    const dimensions = resolveDimensions({
-        orientation,
-        width: options.width,
-        height: options.height,
+// src/api.ts
+import { generateRenderHtml } from "@bendyline/squisq-video";
+import { resolveDimensions } from "@bendyline/squisq-video";
+
+// src/util/detectFfmpeg.ts
+import { execFile } from "child_process";
+async function detectFfmpeg() {
+  const command = process.platform === "win32" ? "where" : "which";
+  return new Promise((resolve) => {
+    execFile(command, ["ffmpeg"], { timeout: 5e3 }, (err, stdout) => {
+      if (err || !stdout.trim()) {
+        resolve(null);
+        return;
+      }
+      const path = stdout.trim().split("\n")[0].trim();
+      resolve(path);
     });
-    // Detect ffmpeg early — needed for audio concat and video encoding
-    const ffmpegPath = await detectFfmpeg();
-    if (!ffmpegPath) {
-        throw new Error('ffmpeg is required but not found in PATH.\n' +
-            'Install it with:\n' +
-            '  macOS:   brew install ffmpeg\n' +
-            '  Ubuntu:  sudo apt install ffmpeg\n' +
-            '  Windows: winget install ffmpeg');
-    }
-    onProgress?.('collecting media', 0);
-    // ── Collect images from container ───────────────────────────────
-    const { collectImagePaths } = await import('@bendyline/squisq-formats/html');
-    const imagePaths = collectImagePaths(doc);
-    const images = new Map();
-    for (const imgPath of imagePaths) {
-        const data = await container.readFile(imgPath);
-        if (data) {
-            images.set(imgPath, data);
-        }
+  });
+}
+
+// src/api.ts
+import { MemoryContentContainer as MemoryContentContainer2 } from "@bendyline/squisq/storage";
+
+// src/util/readInput.ts
+import { readFile, readdir, stat } from "fs/promises";
+import { join, extname } from "path";
+import { parseMarkdown } from "@bendyline/squisq/markdown";
+import { MemoryContentContainer } from "@bendyline/squisq/storage";
+import { zipToContainer } from "@bendyline/squisq-formats/container";
+var MIME_TYPES = {
+  ".md": "text/markdown",
+  ".txt": "text/plain",
+  ".json": "application/json",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm"
+};
+function mimeFromExt(filePath) {
+  return MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+async function walkDir(root, prefix = "") {
+  const entries = await readdir(root, { withFileTypes: true });
+  const paths = [];
+  for (const entry of entries) {
+    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      paths.push(...await walkDir(join(root, entry.name), relPath));
+    } else if (entry.isFile()) {
+      paths.push(relPath);
     }
-    // ── Collect audio segments ──────────────────────────────────────
-    const audio = new Map();
-    const audioBuffers = [];
-    if (doc.audio?.segments?.length) {
-        for (const seg of doc.audio.segments) {
-            const data = await container.readFile(seg.src);
-            if (data) {
-                audio.set(seg.src, data);
-                audio.set(seg.name, data);
-                audioBuffers.push(data);
-            }
-        }
+  }
+  return paths;
+}
+async function readInput(inputPath) {
+  const info = await stat(inputPath);
+  if (info.isDirectory()) {
+    return readFolder(inputPath);
+  }
+  const ext = extname(inputPath).toLowerCase();
+  if (ext === ".zip" || ext === ".dbk") {
+    return readContainer(inputPath);
+  }
+  if (ext === ".json") {
+    return readDocJsonFile(inputPath);
+  }
+  return readMarkdownFile(inputPath);
+}
+async function readMarkdownFile(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  const container = new MemoryContentContainer();
+  await container.writeDocument(content);
+  const markdownDoc = parseMarkdown(content);
+  return { container, markdownDoc };
+}
+async function readDocJsonFile(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  const doc = JSON.parse(content);
+  const container = new MemoryContentContainer();
+  return { container, markdownDoc: null, doc };
+}
+var DOC_JSON_NAMES = ["doc.json", "story.json"];
+async function readContainer(filePath) {
+  const data = await readFile(filePath);
+  const container = await zipToContainer(
+    data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)
+  );
+  for (const name of DOC_JSON_NAMES) {
+    const jsonData = await container.readFile(name);
+    if (jsonData) {
+      const decoder = new TextDecoder();
+      const doc = JSON.parse(decoder.decode(jsonData));
+      return { container, markdownDoc: null, doc };
     }
-    // Concatenate audio for the MP4's audio track
-    let concatenatedAudio = null;
-    if (audioBuffers.length > 0) {
-        concatenatedAudio = await concatenateAudioBuffers(audioBuffers, ffmpegPath);
+  }
+  const markdown = await container.readDocument();
+  if (!markdown) {
+    throw new Error(`No markdown document or doc.json found in container: ${filePath}`);
+  }
+  const markdownDoc = parseMarkdown(markdown);
+  return { container, markdownDoc };
+}
+async function readFolder(dirPath) {
+  const container = new MemoryContentContainer();
+  const files = await walkDir(dirPath);
+  for (const relPath of files) {
+    const absPath = join(dirPath, relPath);
+    const data = await readFile(absPath);
+    await container.writeFile(
+      relPath,
+      new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+      mimeFromExt(relPath)
+    );
+  }
+  for (const name of DOC_JSON_NAMES) {
+    const jsonData = await container.readFile(name);
+    if (jsonData) {
+      const decoder = new TextDecoder();
+      const doc = JSON.parse(decoder.decode(jsonData));
+      return { container, markdownDoc: null, doc };
     }
-    onProgress?.('generating render HTML', 10);
-    // ── Generate self-contained render HTML ─────────────────────────
-    const { PLAYER_BUNDLE } = await import('@bendyline/squisq-react/standalone-source');
-    const renderHtml = generateRenderHtml(doc, {
-        playerScript: PLAYER_BUNDLE,
-        images,
-        audio: audio.size > 0 ? audio : undefined,
-        width: dimensions.width,
-        height: dimensions.height,
-        captionStyle,
-    });
-    onProgress?.('launching browser', 15);
-    // ── Playwright frame capture ────────────────────────────────────
-    const { chromium } = await import('playwright-core');
-    const browser = await chromium.launch({ headless: true });
-    const page = await browser.newPage({
-        viewport: { width: dimensions.width, height: dimensions.height },
-    });
-    const pageErrors = [];
-    page.on('pageerror', (err) => pageErrors.push(err.message));
-    await page.setContent(renderHtml, { waitUntil: 'load' });
-    await page.waitForTimeout(500);
-    try {
-        await page.waitForFunction(() => typeof window.getDuration === 'function', { timeout: 15000 });
+  }
+  const markdown = await container.readDocument();
+  if (!markdown) {
+    throw new Error(`No markdown document or doc.json found in folder: ${dirPath}`);
+  }
+  const markdownDoc = parseMarkdown(markdown);
+  return { container, markdownDoc };
+}
+
+// src/api.ts
+async function renderDocToMp4(doc, container, options) {
+  const {
+    outputPath,
+    fps = 30,
+    quality = "normal",
+    orientation = "landscape",
+    captionStyle,
+    coverPreRoll = 0,
+    onProgress
+  } = options;
+  const dimensions = resolveDimensions({
+    orientation,
+    width: options.width,
+    height: options.height
+  });
+  const ffmpegPath = await detectFfmpeg();
+  if (!ffmpegPath) {
+    throw new Error(
+      "ffmpeg is required but not found in PATH.\nInstall it with:\n  macOS:   brew install ffmpeg\n  Ubuntu:  sudo apt install ffmpeg\n  Windows: winget install ffmpeg"
+    );
+  }
+  onProgress?.("collecting media", 0);
+  const { collectImagePaths } = await import("@bendyline/squisq-formats/html");
+  const imagePaths = collectImagePaths(doc);
+  const images = /* @__PURE__ */ new Map();
+  for (const imgPath of imagePaths) {
+    const data = await container.readFile(imgPath);
+    if (data) {
+      images.set(imgPath, data);
     }
-    catch {
-        await browser.close();
-        const errorDetail = pageErrors.length
-            ? `\nPage errors:\n  ${pageErrors.join('\n  ')}`
-            : '\nNo page errors captured — the player may have failed to mount.';
-        throw new Error(`Render API did not initialize within 15 seconds.${errorDetail}`);
+  }
+  const audio = /* @__PURE__ */ new Map();
+  const audioBuffers = [];
+  if (doc.audio?.segments?.length) {
+    for (const seg of doc.audio.segments) {
+      const data = await container.readFile(seg.src);
+      if (data) {
+        audio.set(seg.src, data);
+        audio.set(seg.name, data);
+        audioBuffers.push(data);
+      }
     }
-    const docDuration = await page.evaluate(() => {
-        return window.getDuration();
+  }
+  let concatenatedAudio = null;
+  if (audioBuffers.length > 0) {
+    concatenatedAudio = await concatenateAudioBuffers(audioBuffers, ffmpegPath);
+  }
+  onProgress?.("generating render HTML", 10);
+  const { PLAYER_BUNDLE } = await import("@bendyline/squisq-react/standalone-source");
+  const renderHtml = generateRenderHtml(doc, {
+    playerScript: PLAYER_BUNDLE,
+    images,
+    audio: audio.size > 0 ? audio : void 0,
+    width: dimensions.width,
+    height: dimensions.height,
+    captionStyle
+  });
+  onProgress?.("launching browser", 15);
+  const { chromium } = await import("playwright-core");
+  const browser = await chromium.launch({ headless: true });
+  const page = await browser.newPage({
+    viewport: { width: dimensions.width, height: dimensions.height }
+  });
+  const pageErrors = [];
+  page.on("pageerror", (err) => pageErrors.push(err.message));
+  await page.setContent(renderHtml, { waitUntil: "load" });
+  await page.waitForTimeout(500);
+  try {
+    await page.waitForFunction(
+      () => typeof window.getDuration === "function",
+      { timeout: 15e3 }
+    );
+  } catch {
+    await browser.close();
+    const errorDetail = pageErrors.length ? `
+Page errors:
+  ${pageErrors.join("\n  ")}` : "\nNo page errors captured \u2014 the player may have failed to mount.";
+    throw new Error(`Render API did not initialize within 15 seconds.${errorDetail}`);
+  }
+  const docDuration = await page.evaluate(() => {
+    return window.getDuration();
+  });
+  if (docDuration <= 0) {
+    await browser.close();
+    throw new Error("Document has zero duration \u2014 nothing to render");
+  }
+  const storyFrameCount = Math.ceil(docDuration * fps);
+  const preRollFrameCount = Math.ceil(coverPreRoll * fps);
+  const totalFrames = preRollFrameCount + storyFrameCount;
+  const frames = [];
+  onProgress?.("capturing frames", 20);
+  if (preRollFrameCount > 0) {
+    const hasCover = await page.evaluate(() => {
+      const w = window;
+      return typeof w.hasCoverBlock === "function" ? w.hasCoverBlock() : false;
     });
-    if (docDuration <= 0) {
-        await browser.close();
-        throw new Error('Document has zero duration — nothing to render');
-    }
-    const storyFrameCount = Math.ceil(docDuration * fps);
-    const preRollFrameCount = Math.ceil(coverPreRoll * fps);
-    const totalFrames = preRollFrameCount + storyFrameCount;
-    const frames = [];
-    onProgress?.('capturing frames', 20);
-    // Cover slide pre-roll (if requested)
-    if (preRollFrameCount > 0) {
-        const hasCover = await page.evaluate(() => {
-            const w = window;
-            return typeof w.hasCoverBlock === 'function' ? w.hasCoverBlock() : false;
-        });
-        if (hasCover) {
-            await page.evaluate(() => {
-                window.showCover();
-            });
-            await page.waitForTimeout(100);
-            const coverFrame = new Uint8Array(await page.screenshot({ type: 'png' }));
-            for (let i = 0; i < preRollFrameCount; i++) {
-                frames.push(coverFrame);
-            }
-            await page.evaluate(() => {
-                window.hideCover();
-            });
-        }
+    if (hasCover) {
+      await page.evaluate(() => {
+        window.showCover();
+      });
+      await page.waitForTimeout(100);
+      const coverFrame = new Uint8Array(await page.screenshot({ type: "png" }));
+      for (let i = 0; i < preRollFrameCount; i++) {
+        frames.push(coverFrame);
+      }
+      await page.evaluate(() => {
+        window.hideCover();
+      });
     }
-    // Story frames via seekTo
-    const frameInterval = 1 / fps;
-    for (let i = 0; i < storyFrameCount; i++) {
-        const time = i * frameInterval;
-        await page.evaluate((t) => {
-            return window.seekTo(t);
-        }, time);
-        const screenshot = await page.screenshot({ type: 'png' });
-        frames.push(new Uint8Array(screenshot));
-        // Report progress: frames phase is 20% to 80%
-        if (i % Math.max(1, Math.floor(fps / 2)) === 0 || i === storyFrameCount - 1) {
-            const pct = 20 + Math.round((frames.length / totalFrames) * 60);
-            onProgress?.('capturing frames', pct);
-        }
+  }
+  const frameInterval = 1 / fps;
+  for (let i = 0; i < storyFrameCount; i++) {
+    const time = i * frameInterval;
+    await page.evaluate((t) => {
+      return window.seekTo(t);
+    }, time);
+    const screenshot = await page.screenshot({ type: "png" });
+    frames.push(new Uint8Array(screenshot));
+    if (i % Math.max(1, Math.floor(fps / 2)) === 0 || i === storyFrameCount - 1) {
+      const pct = 20 + Math.round(frames.length / totalFrames * 60);
+      onProgress?.("capturing frames", pct);
     }
-    await browser.close();
-    onProgress?.('encoding video', 80);
-    // If there's a pre-roll, delay the audio track to match
-    let encodingAudio = concatenatedAudio;
-    if (coverPreRoll > 0 && concatenatedAudio) {
-        // Use FFmpeg to add silence padding at the start (adelay filter)
-        encodingAudio = await addAudioDelay(ffmpegPath, concatenatedAudio, coverPreRoll);
+  }
+  await browser.close();
+  onProgress?.("encoding video", 80);
+  let encodingAudio = concatenatedAudio;
+  if (coverPreRoll > 0 && concatenatedAudio) {
+    encodingAudio = await addAudioDelay(ffmpegPath, concatenatedAudio, coverPreRoll);
+  }
+  const { framesToMp4Native } = await import("./nativeEncoder-MWHOONST.js");
+  await framesToMp4Native(ffmpegPath, frames, encodingAudio, outputPath, {
+    fps,
+    quality,
+    orientation,
+    width: dimensions.width,
+    height: dimensions.height,
+    onProgress: (percent, phase) => {
+      onProgress?.(`encoding: ${phase}`, 80 + Math.round(percent * 0.2));
     }
-    const { framesToMp4Native } = await import('./util/nativeEncoder.js');
-    await framesToMp4Native(ffmpegPath, frames, encodingAudio, outputPath, {
-        fps,
-        quality,
-        orientation,
-        width: dimensions.width,
-        height: dimensions.height,
-        onProgress: (percent, phase) => {
-            onProgress?.(`encoding: ${phase}`, 80 + Math.round(percent * 0.2));
-        },
-    });
-    onProgress?.('done', 100);
-    const totalDuration = docDuration + coverPreRoll;
-    return {
-        duration: totalDuration,
-        frameCount: frames.length,
-        outputPath,
-    };
+  });
+  onProgress?.("done", 100);
+  const totalDuration = docDuration + coverPreRoll;
+  return {
+    duration: totalDuration,
+    frameCount: frames.length,
+    outputPath
+  };
 }
-// ── Audio helpers ─────────────────────────────────────────────────
-/**
- * Concatenate multiple audio buffers into one.
- * Uses native ffmpeg concat when available, falls back to byte concatenation.
- */
 async function concatenateAudioBuffers(buffers, ffmpegPath) {
-    if (buffers.length === 0)
-        return new Uint8Array(0);
-    if (buffers.length === 1)
-        return new Uint8Array(buffers[0]);
-    if (ffmpegPath) {
-        return concatenateAudioNative(ffmpegPath, buffers);
-    }
-    // Fallback: naive byte concatenation (works for MP3)
-    const totalLength = buffers.reduce((sum, b) => sum + b.byteLength, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const buf of buffers) {
-        result.set(new Uint8Array(buf), offset);
-        offset += buf.byteLength;
-    }
-    return result;
+  if (buffers.length === 0) return new Uint8Array(0);
+  if (buffers.length === 1) return new Uint8Array(buffers[0]);
+  if (ffmpegPath) {
+    return concatenateAudioNative(ffmpegPath, buffers);
+  }
+  const totalLength = buffers.reduce((sum, b) => sum + b.byteLength, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buf of buffers) {
+    result.set(new Uint8Array(buf), offset);
+    offset += buf.byteLength;
+  }
+  return result;
 }
 async function concatenateAudioNative(ffmpegPath, buffers) {
-    const { writeFile, readFile, mkdir, rm } = await import('node:fs/promises');
-    const { join } = await import('node:path');
-    const { tmpdir } = await import('node:os');
-    const { randomBytes } = await import('node:crypto');
-    const { execFile } = await import('node:child_process');
-    const tmpId = randomBytes(8).toString('hex');
-    const workDir = join(tmpdir(), `squisq-audio-concat-${tmpId}`);
-    await mkdir(workDir, { recursive: true });
-    try {
-        const segmentPaths = [];
-        for (let i = 0; i < buffers.length; i++) {
-            const segPath = join(workDir, `seg-${i}.mp3`);
-            await writeFile(segPath, new Uint8Array(buffers[i]));
-            segmentPaths.push(segPath);
-        }
-        const listPath = join(workDir, 'concat-list.txt');
-        const listContent = segmentPaths.map((p) => `file '${p.replace(/\\/g, '/')}'`).join('\n');
-        await writeFile(listPath, listContent);
-        const outputPath = join(workDir, 'combined.mp3');
-        await new Promise((resolve, reject) => {
-            execFile(ffmpegPath, ['-y', '-f', 'concat', '-safe', '0', '-i', listPath, '-c', 'copy', outputPath], { timeout: 120000 }, (err) => {
-                if (err)
-                    reject(new Error(`ffmpeg audio concat failed: ${err.message}`));
-                else
-                    resolve();
-            });
-        });
-        const data = await readFile(outputPath);
-        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    }
-    finally {
-        await rm(workDir, { recursive: true, force: true });
+  const { writeFile, readFile: readFile2, mkdir, rm } = await import("fs/promises");
+  const { join: join2 } = await import("path");
+  const { tmpdir } = await import("os");
+  const { randomBytes } = await import("crypto");
+  const { execFile: execFile2 } = await import("child_process");
+  const tmpId = randomBytes(8).toString("hex");
+  const workDir = join2(tmpdir(), `squisq-audio-concat-${tmpId}`);
+  await mkdir(workDir, { recursive: true });
+  try {
+    const segmentPaths = [];
+    for (let i = 0; i < buffers.length; i++) {
+      const segPath = join2(workDir, `seg-${i}.mp3`);
+      await writeFile(segPath, new Uint8Array(buffers[i]));
+      segmentPaths.push(segPath);
     }
+    const listPath = join2(workDir, "concat-list.txt");
+    const listContent = segmentPaths.map((p) => `file '${p.replace(/\\/g, "/")}'`).join("\n");
+    await writeFile(listPath, listContent);
+    const outputPath = join2(workDir, "combined.mp3");
+    await new Promise((resolve, reject) => {
+      execFile2(
+        ffmpegPath,
+        ["-y", "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", outputPath],
+        { timeout: 12e4 },
+        (err) => {
+          if (err) reject(new Error(`ffmpeg audio concat failed: ${err.message}`));
+          else resolve();
+        }
+      );
+    });
+    const data = await readFile2(outputPath);
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  } finally {
+    await rm(workDir, { recursive: true, force: true });
+  }
 }
-/**
- * Add silence at the start of an audio track by re-encoding with adelay filter.
- */
 async function addAudioDelay(ffmpegPath, audioData, delaySecs) {
-    const { writeFile, readFile, rm } = await import('node:fs/promises');
-    const { join } = await import('node:path');
-    const { tmpdir } = await import('node:os');
-    const { randomBytes } = await import('node:crypto');
-    const { execFile } = await import('node:child_process');
-    const tmpId = randomBytes(8).toString('hex');
-    const inputPath = join(tmpdir(), `squisq-audio-delay-in-${tmpId}.mp3`);
-    const outputPath = join(tmpdir(), `squisq-audio-delay-out-${tmpId}.mp3`);
-    try {
-        await writeFile(inputPath, audioData);
-        const delayMs = Math.round(delaySecs * 1000);
-        await new Promise((resolve, reject) => {
-            execFile(ffmpegPath, [
-                '-y',
-                '-i',
-                inputPath,
-                '-af',
-                `adelay=${delayMs}|${delayMs}`,
-                '-c:a',
-                'libmp3lame',
-                '-b:a',
-                '128k',
-                outputPath,
-            ], { timeout: 60000 }, (err) => {
-                if (err)
-                    reject(new Error(`ffmpeg audio delay failed: ${err.message}`));
-                else
-                    resolve();
-            });
-        });
-        const data = await readFile(outputPath);
-        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    }
-    finally {
-        await rm(inputPath, { force: true });
-        await rm(outputPath, { force: true });
-    }
+  const { writeFile, readFile: readFile2, rm } = await import("fs/promises");
+  const { join: join2 } = await import("path");
+  const { tmpdir } = await import("os");
+  const { randomBytes } = await import("crypto");
+  const { execFile: execFile2 } = await import("child_process");
+  const tmpId = randomBytes(8).toString("hex");
+  const inputPath = join2(tmpdir(), `squisq-audio-delay-in-${tmpId}.mp3`);
+  const outputPath = join2(tmpdir(), `squisq-audio-delay-out-${tmpId}.mp3`);
+  try {
+    await writeFile(inputPath, audioData);
+    const delayMs = Math.round(delaySecs * 1e3);
+    await new Promise((resolve, reject) => {
+      execFile2(
+        ffmpegPath,
+        [
+          "-y",
+          "-i",
+          inputPath,
+          "-af",
+          `adelay=${delayMs}|${delayMs}`,
+          "-c:a",
+          "libmp3lame",
+          "-b:a",
+          "128k",
+          outputPath
+        ],
+        { timeout: 6e4 },
+        (err) => {
+          if (err) reject(new Error(`ffmpeg audio delay failed: ${err.message}`));
+          else resolve();
+        }
+      );
+    });
+    const data = await readFile2(outputPath);
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  } finally {
+    await rm(inputPath, { force: true });
+    await rm(outputPath, { force: true });
+  }
 }
-/**
- * Extract thumbnail images from the first frame of an MP4 video.
- * Produces JPEG files at each specified size using FFmpeg video filters.
- */
-export async function extractThumbnails(options) {
-    const { videoPath, outputDir, slug, sizes, force } = options;
-    const { existsSync } = await import('node:fs');
-    const { join } = await import('node:path');
-    const { execFile } = await import('node:child_process');
-    const ffmpegPath = await detectFfmpeg();
-    if (!ffmpegPath) {
-        throw new Error('ffmpeg is required for thumbnail extraction but not found in PATH.\n' +
-            'Install it with:\n' +
-            '  macOS:   brew install ffmpeg\n' +
-            '  Ubuntu:  sudo apt install ffmpeg\n' +
-            '  Windows: winget install ffmpeg');
-    }
-    for (const thumb of sizes) {
-        const outputPath = join(outputDir, `${slug}-${thumb.width}x${thumb.height}.jpg`);
-        if (!force && existsSync(outputPath))
-            continue;
-        await new Promise((resolve, reject) => {
-            execFile(ffmpegPath, ['-y', '-i', videoPath, '-vf', thumb.filter, '-frames:v', '1', '-q:v', '2', outputPath], { timeout: 30000 }, (err) => {
-                if (err)
-                    reject(new Error(`Thumbnail extraction failed (${thumb.name}): ${err.message}`));
-                else
-                    resolve();
-            });
-        });
-    }
+async function extractThumbnails(options) {
+  const { videoPath, outputDir, slug, sizes, force } = options;
+  const { existsSync } = await import("fs");
+  const { join: join2 } = await import("path");
+  const { execFile: execFile2 } = await import("child_process");
+  const ffmpegPath = await detectFfmpeg();
+  if (!ffmpegPath) {
+    throw new Error(
+      "ffmpeg is required for thumbnail extraction but not found in PATH.\nInstall it with:\n  macOS:   brew install ffmpeg\n  Ubuntu:  sudo apt install ffmpeg\n  Windows: winget install ffmpeg"
+    );
+  }
+  for (const thumb of sizes) {
+    const outputPath = join2(outputDir, `${slug}-${thumb.width}x${thumb.height}.jpg`);
+    if (!force && existsSync(outputPath)) continue;
+    await new Promise((resolve, reject) => {
+      execFile2(
+        ffmpegPath,
+        ["-y", "-i", videoPath, "-vf", thumb.filter, "-frames:v", "1", "-q:v", "2", outputPath],
+        { timeout: 3e4 },
+        (err) => {
+          if (err) reject(new Error(`Thumbnail extraction failed (${thumb.name}): ${err.message}`));
+          else resolve();
+        }
+      );
+    });
+  }
 }
+export {
+  MemoryContentContainer2 as MemoryContentContainer,
+  extractThumbnails,
+  readInput,
+  renderDocToMp4
+};
 //# sourceMappingURL=api.js.map