@bendyline/squisq-cli 1.1.5 → 1.1.6

package/dist/index.js

@@ -1,23 +1,725 @@
-/**
- * squisq CLI
- *
- * Command-line tool for converting and processing Squisq documents.
- * Designed for easy addition of future subcommands (e.g., import).
- *
- * Usage:
- *   squisq convert <input> [options]
- *   squisq --help
- */
-import { Command } from 'commander';
-import { registerConvertCommand } from './commands/convert.js';
-import { registerVideoCommand } from './commands/video.js';
-// Colored banner: cyan brackets, bold white text, dim version
-console.error('\x1b[36m{[\x1b[0m \x1b[1msquiggly square\x1b[0m \x1b[2m—\x1b[0m \x1b[1msquisq\x1b[0m \x1b[2m—\x1b[0m \x1b[33mv1.0.0\x1b[0m \x1b[36m]}\x1b[0m');
-const program = new Command();
-program
-    .name('squisq')
-    .description('Squisq CLI — convert and process markdown-based documents')
-    .version('1.0.0');
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/convert.ts
+import { writeFile, mkdir } from "fs/promises";
+import { dirname, basename, extname as extname2, join as join2, resolve } from "path";
+
+// 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);
+    }
+  }
+  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 };
+    }
+  }
+  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 };
+    }
+  }
+  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/commands/convert.ts
+var ALL_FORMATS = ["docx", "pptx", "pdf", "html", "htmlzip", "epub", "dbk"];
+function parseFormats(value) {
+  const requested = value.split(",").map((s) => s.trim().toLowerCase());
+  const valid = [];
+  for (const r of requested) {
+    if (ALL_FORMATS.includes(r)) {
+      valid.push(r);
+    } else {
+      console.warn(`Unknown format "${r}" \u2014 skipping. Valid: ${ALL_FORMATS.join(", ")}`);
+    }
+  }
+  if (valid.length === 0) {
+    throw new Error(`No valid formats specified. Valid: ${ALL_FORMATS.join(", ")}`);
+  }
+  return valid;
+}
+function registerConvertCommand(program2) {
+  program2.command("convert").description("Convert a markdown document to DOCX, PPTX, PDF, HTML, and DBK container formats").argument("<input>", "Path to .md file, .zip/.dbk container, or folder").option("-o, --output-dir <dir>", "Output directory (default: same as input)").option(
+    "-f, --formats <list>",
+    `Comma-separated formats to produce (default: all). Valid: ${ALL_FORMATS.join(", ")}`
+  ).option("-t, --theme <id>", "Squisq theme ID to apply (e.g., documentary, cinematic, bold)").option(
+    "--transform <style>",
+    "Transform style to apply before export (e.g., documentary, magazine, minimal)"
+  ).action(async (inputPath, opts) => {
+    try {
+      await runConvert(inputPath, opts);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+async function runConvert(inputPath, opts) {
+  const resolvedInput = resolve(inputPath);
+  const formats = opts.formats ? parseFormats(opts.formats) : [...ALL_FORMATS];
+  const outputDir = opts.outputDir ? resolve(opts.outputDir) : dirname(resolvedInput);
+  const inputBasename = basename(resolvedInput);
+  const inputExt = extname2(inputBasename);
+  const baseName = inputExt ? inputBasename.slice(0, -inputExt.length) : inputBasename;
+  await mkdir(outputDir, { recursive: true });
+  if (opts.theme) {
+    const { getAvailableThemes } = await import("@bendyline/squisq/schemas");
+    const themes = getAvailableThemes();
+    if (!themes.includes(opts.theme)) {
+      throw new Error(`Unknown theme "${opts.theme}". Available: ${themes.join(", ")}`);
+    }
+  }
+  if (opts.transform) {
+    const { getTransformStyleIds } = await import("@bendyline/squisq/transform");
+    const styles = getTransformStyleIds();
+    if (!styles.includes(opts.transform)) {
+      throw new Error(
+        `Unknown transform style "${opts.transform}". Available: ${styles.join(", ")}`
+      );
+    }
+  }
+  console.error(`Reading: ${resolvedInput}`);
+  const result = await readInput(resolvedInput);
+  const { container } = result;
+  if (!result.markdownDoc) {
+    throw new Error(
+      "Convert command requires a markdown document. JSON Doc input is not supported for convert \u2014 use the video command instead."
+    );
+  }
+  let exportMarkdownDoc = result.markdownDoc;
+  if (opts.transform) {
+    exportMarkdownDoc = await applyTransformToMarkdown(
+      result.markdownDoc,
+      container,
+      opts.transform,
+      opts.theme
+    );
+    console.error(`  Applied transform: ${opts.transform}`);
+  }
+  const themeId = opts.theme;
+  for (const format of formats) {
+    const outPath = join2(outputDir, `${baseName}.${format}`);
+    switch (format) {
+      case "docx": {
+        const { markdownDocToDocx } = await import("@bendyline/squisq-formats/docx");
+        const buf = await markdownDocToDocx(exportMarkdownDoc, { themeId });
+        await writeFile(outPath, Buffer.from(buf));
+        break;
+      }
+      case "pptx": {
+        const { markdownDocToPptx } = await import("@bendyline/squisq-formats/pptx");
+        const images = await collectContainerImages(container);
+        const buf = await markdownDocToPptx(exportMarkdownDoc, { themeId, images });
+        await writeFile(outPath, Buffer.from(buf));
+        break;
+      }
+      case "pdf": {
+        const { markdownDocToPdf } = await import("@bendyline/squisq-formats/pdf");
+        const buf = await markdownDocToPdf(exportMarkdownDoc, { themeId });
+        await writeFile(outPath, Buffer.from(buf));
+        break;
+      }
+      case "html": {
+        const { markdownToDoc } = await import("@bendyline/squisq/doc");
+        const { docToHtml } = await import("@bendyline/squisq-formats/html");
+        const { PLAYER_BUNDLE } = await import("@bendyline/squisq-react/standalone-source");
+        const doc = markdownToDoc(exportMarkdownDoc);
+        const images = await collectImagesForHtml(doc, container);
+        const html = docToHtml(doc, {
+          playerScript: PLAYER_BUNDLE,
+          images,
+          title: baseName,
+          mode: "static",
+          themeId
+        });
+        await writeFile(outPath, html, "utf-8");
+        break;
+      }
+      case "htmlzip": {
+        const { markdownToDoc } = await import("@bendyline/squisq/doc");
+        const { docToHtmlZip } = await import("@bendyline/squisq-formats/html");
+        const { PLAYER_BUNDLE } = await import("@bendyline/squisq-react/standalone-source");
+        const doc = markdownToDoc(exportMarkdownDoc);
+        const images = await collectImagesForHtml(doc, container);
+        const blob = await docToHtmlZip(doc, {
+          playerScript: PLAYER_BUNDLE,
+          images,
+          title: baseName,
+          mode: "static",
+          themeId
+        });
+        const buf = Buffer.from(await blob.arrayBuffer());
+        await writeFile(outPath.replace(/\.htmlzip$/, ".html.zip"), buf);
+        break;
+      }
+      case "epub": {
+        const { markdownDocToEpub } = await import("@bendyline/squisq-formats/epub");
+        const images = await collectContainerImages(container);
+        const epubAudio = /* @__PURE__ */ new Map();
+        const audioSegments = result.doc?.audio?.segments;
+        if (audioSegments?.length) {
+          for (const seg of audioSegments) {
+            const data = await container.readFile(seg.src);
+            if (data) epubAudio.set(seg.src, data);
+          }
+        }
+        const hasNarration = epubAudio.size > 0;
+        const buf = await markdownDocToEpub(exportMarkdownDoc, {
+          title: baseName,
+          themeId,
+          images,
+          audio: hasNarration ? epubAudio : void 0,
+          audioSegments: hasNarration ? audioSegments : void 0,
+          totalDuration: hasNarration ? result.doc?.duration : void 0
+        });
+        await writeFile(outPath, Buffer.from(buf));
+        break;
+      }
+      case "dbk": {
+        const { containerToZip } = await import("@bendyline/squisq-formats/container");
+        const blob = await containerToZip(container);
+        const buf = await blob.arrayBuffer();
+        await writeFile(outPath, Buffer.from(buf));
+        break;
+      }
+    }
+    console.error(`  \u2713 ${outPath}`);
+  }
+  console.error("Done.");
+}
+async function applyTransformToMarkdown(markdownDoc, container, transformStyle, themeId) {
+  const { markdownToDoc, docToMarkdown } = await import("@bendyline/squisq/doc");
+  const { applyTransform, extractDocImages } = await import("@bendyline/squisq/transform");
+  const doc = markdownToDoc(markdownDoc);
+  const images = extractDocImages(doc.blocks);
+  const result = applyTransform(doc, transformStyle, {
+    themeId,
+    images
+  });
+  return docToMarkdown(result.doc);
+}
+async function collectImagesForHtml(doc, container) {
+  const { collectImagePaths, extractFilename } = await import("@bendyline/squisq-formats/html");
+  const images = /* @__PURE__ */ new Map();
+  const docPaths = collectImagePaths(doc);
+  const needByFilename = /* @__PURE__ */ new Set();
+  for (const imgPath of docPaths) {
+    const data = await container.readFile(imgPath);
+    if (data) {
+      images.set(imgPath, data);
+      const filename = extractFilename(imgPath);
+      if (filename !== imgPath) images.set(filename, data);
+    } else {
+      needByFilename.add(extractFilename(imgPath));
+    }
+  }
+  if (needByFilename.size > 0) {
+    const files = await container.listFiles();
+    for (const file of files) {
+      const filename = extractFilename(file.path);
+      if (needByFilename.has(filename)) {
+        const data = await container.readFile(file.path);
+        if (data) {
+          images.set(filename, data);
+          images.set(file.path, data);
+        }
+      }
+    }
+  }
+  return images;
+}
+async function collectContainerImages(container) {
+  const images = /* @__PURE__ */ new Map();
+  const files = await container.listFiles();
+  for (const file of files) {
+    if (/\.(jpg|jpeg|png|gif|webp|svg|bmp|avif)$/i.test(file.path)) {
+      const data = await container.readFile(file.path);
+      if (data) {
+        images.set(file.path, data);
+      }
+    }
+  }
+  return images;
+}
+
+// src/commands/video.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname2, basename as basename2, extname as extname3, resolve as resolve2 } from "path";
+
+// 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((resolve3) => {
+    execFile(command, ["ffmpeg"], { timeout: 5e3 }, (err, stdout) => {
+      if (err || !stdout.trim()) {
+        resolve3(null);
+        return;
+      }
+      const path = stdout.trim().split("\n")[0].trim();
+      resolve3(path);
+    });
+  });
+}
+
+// src/api.ts
+import { MemoryContentContainer as MemoryContentContainer2 } from "@bendyline/squisq/storage";
+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);
+    }
+  }
+  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);
+  }
+  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 (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();
+      });
+    }
+  }
+  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);
+  let encodingAudio = concatenatedAudio;
+  if (coverPreRoll > 0 && concatenatedAudio) {
+    encodingAudio = await addAudioDelay(ffmpegPath, concatenatedAudio, coverPreRoll);
+  }
+  const { framesToMp4Native } = await import("./nativeEncoder-EXDP2O5B.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
+  };
+}
+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: writeFile2, readFile: readFile2, mkdir: mkdir3, rm } = await import("fs/promises");
+  const { join: join3 } = 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 = join3(tmpdir(), `squisq-audio-concat-${tmpId}`);
+  await mkdir3(workDir, { recursive: true });
+  try {
+    const segmentPaths = [];
+    for (let i = 0; i < buffers.length; i++) {
+      const segPath = join3(workDir, `seg-${i}.mp3`);
+      await writeFile2(segPath, new Uint8Array(buffers[i]));
+      segmentPaths.push(segPath);
+    }
+    const listPath = join3(workDir, "concat-list.txt");
+    const listContent = segmentPaths.map((p) => `file '${p.replace(/\\/g, "/")}'`).join("\n");
+    await writeFile2(listPath, listContent);
+    const outputPath = join3(workDir, "combined.mp3");
+    await new Promise((resolve3, 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 resolve3();
+        }
+      );
+    });
+    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: writeFile2, readFile: readFile2, rm } = await import("fs/promises");
+  const { join: join3 } = 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 = join3(tmpdir(), `squisq-audio-delay-in-${tmpId}.mp3`);
+  const outputPath = join3(tmpdir(), `squisq-audio-delay-out-${tmpId}.mp3`);
+  try {
+    await writeFile2(inputPath, audioData);
+    const delayMs = Math.round(delaySecs * 1e3);
+    await new Promise((resolve3, 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 resolve3();
+        }
+      );
+    });
+    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 });
+  }
+}
+
+// src/commands/video.ts
+var VALID_QUALITIES = ["draft", "normal", "high"];
+var VALID_ORIENTATIONS = ["landscape", "portrait"];
+var VALID_CAPTIONS = ["off", "standard", "social"];
+function registerVideoCommand(program2) {
+  program2.command("video").description("Render a squisq document to MP4 video").argument("<input>", "Path to .md file, .zip/.dbk container, or folder").argument("[output]", "Output MP4 path (default: <input>.mp4)").option("-o, --output <path>", "Output MP4 path (default: <input>.mp4)").option("--fps <number>", "Frames per second (default: 30)", "30").option(
+    "--quality <level>",
+    `Encoding quality: ${VALID_QUALITIES.join(", ")} (default: normal)`,
+    "normal"
+  ).option(
+    "--orientation <orient>",
+    `Video orientation: ${VALID_ORIENTATIONS.join(", ")} (default: landscape)`,
+    "landscape"
+  ).option(
+    "--captions <style>",
+    `Caption style: ${VALID_CAPTIONS.join(", ")} (default: off)`,
+    "off"
+  ).option("--width <pixels>", "Override video width").option("--height <pixels>", "Override video height").action(async (inputPath, outputArg, opts) => {
+    try {
+      if (outputArg && !opts.output) {
+        opts.output = outputArg;
+      }
+      await runVideo(inputPath, opts);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+async function runVideo(inputPath, opts) {
+  const resolvedInput = resolve2(inputPath);
+  const fps = parseInt(opts.fps ?? "30", 10);
+  if (isNaN(fps) || fps < 1 || fps > 120) {
+    throw new Error("FPS must be a number between 1 and 120");
+  }
+  const quality = opts.quality ?? "normal";
+  if (!VALID_QUALITIES.includes(quality)) {
+    throw new Error(`Invalid quality "${quality}". Valid: ${VALID_QUALITIES.join(", ")}`);
+  }
+  const orientation = opts.orientation ?? "landscape";
+  if (!VALID_ORIENTATIONS.includes(orientation)) {
+    throw new Error(
+      `Invalid orientation "${orientation}". Valid: ${VALID_ORIENTATIONS.join(", ")}`
+    );
+  }
+  const captions = opts.captions ?? "off";
+  if (!VALID_CAPTIONS.includes(captions)) {
+    throw new Error(`Invalid captions "${captions}". Valid: ${VALID_CAPTIONS.join(", ")}`);
+  }
+  const captionStyle = captions === "off" ? void 0 : captions;
+  const inputBasename = basename2(resolvedInput);
+  const inputExt = extname3(inputBasename);
+  const baseName = inputExt ? inputBasename.slice(0, -inputExt.length) : inputBasename;
+  const outputPath = opts.output ? resolve2(opts.output) : resolve2(dirname2(resolvedInput), `${baseName}.mp4`);
+  await mkdir2(dirname2(outputPath), { recursive: true });
+  console.error(`Reading: ${resolvedInput}`);
+  const result = await readInput(resolvedInput);
+  const { container } = result;
+  let doc;
+  if (result.doc) {
+    console.error("Using pre-built Doc JSON");
+    doc = result.doc;
+  } else if (result.markdownDoc) {
+    const { markdownToDoc } = await import("@bendyline/squisq/doc");
+    doc = markdownToDoc(result.markdownDoc);
+  } else {
+    throw new Error("No document found in input");
+  }
+  console.error(
+    `Rendering: ${fps} fps, quality: ${quality}, orientation: ${orientation}, captions: ${captions}`
+  );
+  const result2 = await renderDocToMp4(doc, container, {
+    outputPath,
+    fps,
+    quality,
+    orientation,
+    width: opts.width ? parseInt(opts.width, 10) : void 0,
+    height: opts.height ? parseInt(opts.height, 10) : void 0,
+    captionStyle,
+    coverPreRoll: 2,
+    onProgress: (phase, percent) => {
+      writeProgress(phase, percent, 100);
+    }
+  });
+  clearProgress();
+  console.error(
+    `  \u2713 ${outputPath} (${result2.duration.toFixed(1)}s, ${result2.frameCount} frames)`
+  );
+  console.error("Done.");
+}
+var BAR_WIDTH = 30;
+function writeProgress(label, current, total, detail) {
+  const pct = Math.min(100, Math.round(current / total * 100));
+  const filled = Math.round(pct / 100 * BAR_WIDTH);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
+  const suffix = detail ? ` (${detail})` : "";
+  process.stderr.write(`\r  ${label}: ${bar} ${pct}%${suffix}  `);
+}
+function clearProgress() {
+  process.stderr.write("\r" + " ".repeat(80) + "\r");
+}
+
+// src/index.ts
+console.error(
+  "\x1B[36m{[\x1B[0m \x1B[1msquiggly square\x1B[0m \x1B[2m\u2014\x1B[0m \x1B[1msquisq\x1B[0m \x1B[2m\u2014\x1B[0m \x1B[33mv1.0.0\x1B[0m \x1B[36m]}\x1B[0m"
+);
+var program = new Command();
+program.name("squisq").description("Squisq CLI \u2014 convert and process markdown-based documents").version("1.0.0");
 registerConvertCommand(program);
 registerVideoCommand(program);
 program.parse();