@bendyline/squisq-cli 1.1.6 → 1.2.1

package/dist/api.js

@@ -1,32 +1,198 @@
 // src/api.ts
+import { resolveMediaSchedule } from "@bendyline/squisq/schemas";
+import { flattenBlocks } from "@bendyline/squisq/doc";
 import { generateRenderHtml } from "@bendyline/squisq-video";
 import { resolveDimensions } from "@bendyline/squisq-video";
+import { convert as formatsConvert } from "@bendyline/squisq-formats";
 
 // src/util/detectFfmpeg.ts
 import { execFile } from "child_process";
-async function detectFfmpeg() {
-  const command = process.platform === "win32" ? "where" : "which";
+function run(command, args) {
   return new Promise((resolve) => {
-    execFile(command, ["ffmpeg"], { timeout: 5e3 }, (err, stdout) => {
+    execFile(command, args, { timeout: 5e3 }, (err, stdout) => {
       if (err || !stdout.trim()) {
         resolve(null);
         return;
       }
-      const path = stdout.trim().split("\n")[0].trim();
-      resolve(path);
+      resolve(stdout.trim());
     });
   });
 }
+async function getFfmpegVersion(path) {
+  const out = await run(path, ["-version"]);
+  return out ? out.split("\n")[0].trim() : null;
+}
+async function detectFfmpegDetailed() {
+  const envPath = process.env.SQUISQ_FFMPEG;
+  if (envPath) {
+    const version = await getFfmpegVersion(envPath);
+    if (!version) {
+      throw new Error(
+        `SQUISQ_FFMPEG is set to "${envPath}" but running "${envPath} -version" failed. Fix the path or unset SQUISQ_FFMPEG.`
+      );
+    }
+    return { path: envPath, source: "env" };
+  }
+  const command = process.platform === "win32" ? "where" : "which";
+  const found = await run(command, ["ffmpeg"]);
+  if (found) {
+    return { path: found.split("\n")[0].trim(), source: "path" };
+  }
+  try {
+    const specifier = "ffmpeg-static";
+    const mod = await import(specifier);
+    const candidate = typeof mod === "string" ? mod : typeof mod.default === "string" ? mod.default : null;
+    if (candidate) {
+      return { path: candidate, source: "ffmpeg-static" };
+    }
+  } catch {
+  }
+  return null;
+}
+async function detectFfmpeg() {
+  const detection = await detectFfmpegDetailed();
+  return detection?.path ?? null;
+}
+
+// src/util/audioMix.ts
+import { computeAudioTimeline } from "@bendyline/squisq-video";
+async function buildMixedAudioTrack(doc, container, ffmpegPath, coverPreRoll) {
+  const timeline = computeAudioTimeline(doc, coverPreRoll);
+  if (timeline.length === 0) return null;
+  const bytesBySrc = /* @__PURE__ */ new Map();
+  const readSrc = async (src) => {
+    if (bytesBySrc.has(src)) return bytesBySrc.get(src);
+    const data = await container.readFile(src);
+    bytesBySrc.set(src, data ?? null);
+    return data ?? null;
+  };
+  const usable = [];
+  for (const clip of timeline) {
+    const buffer = await readSrc(clip.src);
+    if (buffer) usable.push({ clip, buffer });
+  }
+  if (usable.length === 0) return null;
+  return mixTimelineClips(ffmpegPath, usable);
+}
+async function mixTimelineClips(ffmpegPath, usable) {
+  const { writeFile, readFile: readFile3, mkdir, rm: rm2 } = await import("fs/promises");
+  const { join: join3 } = await import("path");
+  const { tmpdir: tmpdir2 } = await import("os");
+  const { randomBytes: randomBytes2 } = await import("crypto");
+  const { execFile: execFile2 } = await import("child_process");
+  const workDir = join3(tmpdir2(), `squisq-audio-mix-${randomBytes2(8).toString("hex")}`);
+  await mkdir(workDir, { recursive: true });
+  const ms = (s) => Math.max(0, Math.round(s * 1e3));
+  try {
+    const inputs = [];
+    const filters = [];
+    const labels = [];
+    for (const { clip, buffer } of usable) {
+      const p = join3(workDir, `clip-${inputs.length}.mp3`);
+      await writeFile(p, new Uint8Array(buffer));
+      const i = inputs.push(p) - 1;
+      const delayMs = ms(clip.startSec);
+      const start = Math.max(0, clip.sourceInSec);
+      const end = start + Math.max(0, clip.durationSec);
+      filters.push(
+        `[${i}:a]atrim=start=${start}:end=${end},asetpts=PTS-STARTPTS,adelay=${delayMs}|${delayMs}[a${i}]`
+      );
+      labels.push(`[a${i}]`);
+    }
+    const graph = `${filters.join(";")};${labels.join("")}amix=inputs=${labels.length}:normalize=0:dropout_transition=0[aout]`;
+    const outputPath = join3(workDir, "mixed.mp3");
+    const args = ["-y"];
+    for (const p of inputs) args.push("-i", p);
+    args.push(
+      "-filter_complex",
+      graph,
+      "-map",
+      "[aout]",
+      "-c:a",
+      "libmp3lame",
+      "-b:a",
+      "192k",
+      outputPath
+    );
+    await new Promise((resolve, reject) => {
+      execFile2(ffmpegPath, args, { timeout: 18e4 }, (err) => {
+        if (err) reject(new Error(`ffmpeg audio mix failed: ${err.message}`));
+        else resolve();
+      });
+    });
+    const data = await readFile3(outputPath);
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  } finally {
+    await rm2(workDir, { recursive: true, force: true });
+  }
+}
+
+// src/registry.ts
+import { randomBytes } from "crypto";
+import { readFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { defaultRegistry } from "@bendyline/squisq-formats";
+var MP4_DEFAULTS = {
+  fps: 30,
+  quality: "normal",
+  orientation: "landscape",
+  coverPreRoll: 0
+};
+function mp4Format() {
+  return {
+    id: "mp4",
+    label: "MP4 Video",
+    mimeType: "video/mp4",
+    extensions: [".mp4"],
+    async exportDoc(input, options) {
+      const mp4Opts = options.formatOptions?.mp4 ?? {};
+      const fps = typeof mp4Opts.fps === "number" ? mp4Opts.fps : MP4_DEFAULTS.fps;
+      const quality = typeof mp4Opts.quality === "string" ? mp4Opts.quality : MP4_DEFAULTS.quality;
+      const orientation = typeof mp4Opts.orientation === "string" ? mp4Opts.orientation : MP4_DEFAULTS.orientation;
+      const coverPreRoll = typeof mp4Opts.coverPreRoll === "number" ? mp4Opts.coverPreRoll : MP4_DEFAULTS.coverPreRoll;
+      const outputPath = join(tmpdir(), `squisq-mp4-${randomBytes(8).toString("hex")}.mp4`);
+      try {
+        await renderDocToMp4(input.doc, input.container, {
+          outputPath,
+          fps,
+          quality,
+          orientation,
+          coverPreRoll
+        });
+        const data = await readFile(outputPath);
+        const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        return { bytes, mimeType: "video/mp4", suggestedFilename: "", warnings: [] };
+      } finally {
+        await rm(outputPath, { force: true });
+      }
+    }
+  };
+}
+function createCliRegistry() {
+  const registry = defaultRegistry();
+  registry.register(mp4Format());
+  return registry;
+}
 
 // src/api.ts
 import { MemoryContentContainer as MemoryContentContainer2 } from "@bendyline/squisq/storage";
 
+// src/util/domPolyfill.ts
+import { DOMParser as XmldomDOMParser } from "@xmldom/xmldom";
+var globalScope = globalThis;
+if (typeof globalScope.DOMParser === "undefined") {
+  globalScope.DOMParser = XmldomDOMParser;
+}
+
 // src/util/readInput.ts
-import { readFile, readdir, stat } from "fs/promises";
-import { join, extname } from "path";
-import { parseMarkdown } from "@bendyline/squisq/markdown";
+import { readFile as readFile2, readdir, stat } from "fs/promises";
+import { join as join2, extname } from "path";
+import { parseMarkdown, stringifyMarkdown } from "@bendyline/squisq/markdown";
+import { markdownToDoc } from "@bendyline/squisq/doc";
 import { MemoryContentContainer } from "@bendyline/squisq/storage";
 import { zipToContainer } from "@bendyline/squisq-formats/container";
+import { defaultRegistry as defaultRegistry2 } from "@bendyline/squisq-formats";
 var MIME_TYPES = {
   ".md": "text/markdown",
   ".txt": "text/plain",
@@ -43,6 +209,7 @@ var MIME_TYPES = {
   ".mp4": "video/mp4",
   ".webm": "video/webm"
 };
+var IMPORTER_EXTS = [".docx", ".pptx", ".pdf", ".xlsx", ".csv", ".html", ".htm"];
 function mimeFromExt(filePath) {
   return MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
@@ -52,7 +219,7 @@ async function walkDir(root, prefix = "") {
   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));
+      paths.push(...await walkDir(join2(root, entry.name), relPath));
     } else if (entry.isFile()) {
       paths.push(relPath);
     }
@@ -71,71 +238,99 @@ async function readInput(inputPath) {
   if (ext === ".json") {
     return readDocJsonFile(inputPath);
   }
+  if (IMPORTER_EXTS.includes(ext)) {
+    const def = defaultRegistry2().byExtension(ext);
+    if (def && (def.importContainer || def.importDoc)) {
+      return readViaImporter(inputPath, def);
+    }
+  }
   return readMarkdownFile(inputPath);
 }
+async function readArrayBuffer(filePath) {
+  const data = await readFile2(filePath);
+  return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
 async function readMarkdownFile(filePath) {
-  const content = await readFile(filePath, "utf-8");
+  const content = await readFile2(filePath, "utf-8");
   const container = new MemoryContentContainer();
   await container.writeDocument(content);
   const markdownDoc = parseMarkdown(content);
-  return { container, markdownDoc };
+  return { doc: markdownToDoc(markdownDoc), container, markdownDoc, sourceFormat: "md" };
 }
 async function readDocJsonFile(filePath) {
-  const content = await readFile(filePath, "utf-8");
+  const content = await readFile2(filePath, "utf-8");
   const doc = JSON.parse(content);
   const container = new MemoryContentContainer();
-  return { container, markdownDoc: null, doc };
+  return { doc, container, sourceFormat: "json" };
+}
+async function readViaImporter(filePath, def) {
+  const buffer = await readArrayBuffer(filePath);
+  let container;
+  let markdownDoc;
+  if (def.importContainer) {
+    container = await def.importContainer(buffer, {});
+    const text = await container.readDocument();
+    markdownDoc = text ? parseMarkdown(text) : { type: "document", children: [] };
+  } else {
+    markdownDoc = await def.importDoc(buffer, {});
+    const mem = new MemoryContentContainer();
+    await mem.writeDocument(stringifyMarkdown(markdownDoc));
+    container = mem;
+  }
+  return { doc: markdownToDoc(markdownDoc), container, markdownDoc, sourceFormat: def.id };
 }
 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)
-  );
+async function resolveContainer(container, sourceFormat, missingMessage) {
   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 };
+      const doc = JSON.parse(new TextDecoder().decode(jsonData));
+      return { doc, container, sourceFormat };
     }
   }
   const markdown = await container.readDocument();
   if (!markdown) {
-    throw new Error(`No markdown document or doc.json found in container: ${filePath}`);
+    throw new Error(missingMessage);
   }
   const markdownDoc = parseMarkdown(markdown);
-  return { container, markdownDoc };
+  return { doc: markdownToDoc(markdownDoc), container, markdownDoc, sourceFormat };
+}
+async function readContainer(filePath) {
+  const container = await zipToContainer(await readArrayBuffer(filePath));
+  return resolveContainer(
+    container,
+    "dbk",
+    `No markdown document or doc.json found in container: ${filePath}`
+  );
 }
 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);
+    const absPath = join2(dirPath, relPath);
+    const data = await readFile2(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 };
-    }
-  }
-  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 };
+  return resolveContainer(
+    container,
+    "folder",
+    `No markdown document or doc.json found in folder: ${dirPath}`
+  );
 }
 
 // src/api.ts
+import { ConversionError } from "@bendyline/squisq-formats";
+async function convert(source, to, options = {}) {
+  return formatsConvert(source, to, {
+    registry: createCliRegistry(),
+    resolvePlayerScript: () => import("@bendyline/squisq-react/standalone-source").then((m) => m.PLAYER_BUNDLE),
+    ...options
+  });
+}
 async function renderDocToMp4(doc, container, options) {
   const {
     outputPath,
@@ -154,7 +349,7 @@ async function renderDocToMp4(doc, container, options) {
   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"
+      "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\nOr: npm install ffmpeg-static, or set SQUISQ_FFMPEG to an ffmpeg binary."
     );
   }
   onProgress?.("collecting media", 0);
@@ -168,20 +363,25 @@ async function renderDocToMp4(doc, container, options) {
     }
   }
   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);
       }
     }
   }
-  let concatenatedAudio = null;
-  if (audioBuffers.length > 0) {
-    concatenatedAudio = await concatenateAudioBuffers(audioBuffers, ffmpegPath);
+  const mediaSrcs = new Set(resolveMediaSchedule(doc).map((c) => c.src));
+  for (const block of flattenBlocks(doc.blocks)) {
+    for (const layer of block.layers ?? []) {
+      if (layer.type === "video") mediaSrcs.add(layer.content.src);
+    }
+  }
+  for (const src of mediaSrcs) {
+    if (images.has(src)) continue;
+    const data = await container.readFile(src);
+    if (data) images.set(src, data);
   }
   onProgress?.("generating render HTML", 10);
   const { PLAYER_BUNDLE } = await import("@bendyline/squisq-react/standalone-source");
@@ -195,7 +395,16 @@ async function renderDocToMp4(doc, container, options) {
   });
   onProgress?.("launching browser", 15);
   const { chromium } = await import("playwright-core");
-  const browser = await chromium.launch({ headless: true });
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message.split("\n")[0] : String(err);
+    throw new Error(
+      `Playwright Chromium is not installed. Run: npx playwright install chromium
+(launch failed: ${detail})`
+    );
+  }
   const page = await browser.newPage({
     viewport: { width: dimensions.width, height: dimensions.height }
   });
@@ -213,7 +422,9 @@ async function renderDocToMp4(doc, container, options) {
     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}`);
+    throw new Error(
+      `The standalone player failed to boot in headless Chromium. Render API did not initialize within 15 seconds.${errorDetail}`
+    );
   }
   const docDuration = await page.evaluate(() => {
     return window.getDuration();
@@ -261,11 +472,8 @@ Page errors:
   }
   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");
+  const encodingAudio = await buildMixedAudioTrack(doc, container, ffmpegPath, coverPreRoll);
+  const { framesToMp4Native } = await import("./nativeEncoder-2HGWDEZZ.js");
   await framesToMp4Native(ffmpegPath, frames, encodingAudio, outputPath, {
     fps,
     quality,
@@ -284,103 +492,10 @@ Page errors:
     outputPath
   };
 }
-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);
-  }
-  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: 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 });
-  }
-}
-async function addAudioDelay(ffmpegPath, audioData, delaySecs) {
-  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 });
-  }
-}
 async function extractThumbnails(options) {
   const { videoPath, outputDir, slug, sizes, force } = options;
   const { existsSync } = await import("fs");
-  const { join: join2 } = await import("path");
+  const { join: join3 } = await import("path");
   const { execFile: execFile2 } = await import("child_process");
   const ffmpegPath = await detectFfmpeg();
   if (!ffmpegPath) {
@@ -389,7 +504,7 @@ async function extractThumbnails(options) {
     );
   }
   for (const thumb of sizes) {
-    const outputPath = join2(outputDir, `${slug}-${thumb.width}x${thumb.height}.jpg`);
+    const outputPath = join3(outputDir, `${slug}-${thumb.width}x${thumb.height}.jpg`);
     if (!force && existsSync(outputPath)) continue;
     await new Promise((resolve, reject) => {
       execFile2(
@@ -405,7 +520,10 @@ async function extractThumbnails(options) {
   }
 }
 export {
+  ConversionError,
   MemoryContentContainer2 as MemoryContentContainer,
+  convert,
+  createCliRegistry,
   extractThumbnails,
   readInput,
   renderDocToMp4