@bendyline/squisq-cli 2.5.5 → 2.6.1

package/dist/{chunk-SFBZGL54.js → chunk-2ZJW7F62.js}

@@ -5,11 +5,12 @@ import {
 } from "./chunk-GGVASRPG.js";
 
 // src/api.ts
-import { readFile as readFile3 } from "fs/promises";
+import { mkdir, readFile as readFile3, writeFile } from "fs/promises";
+import { dirname as dirname2, resolve as resolvePath } from "path";
 import { resolveMediaSchedule as resolveMediaSchedule2 } from "@bendyline/squisq/schemas";
 import { flattenBlocks as flattenBlocks2 } from "@bendyline/squisq/doc";
 import { ffmpegGifOutputArgs, generateRenderHtml } from "@bendyline/squisq-video";
-import { resolveDimensions } from "@bendyline/squisq-video";
+import { resolveDashboardDimensions, resolveDimensions } from "@bendyline/squisq-video";
 import {
   convert as formatsConvert,
   prepareConversion as formatsPrepareConversion
@@ -94,13 +95,13 @@ async function buildMixedAudioTrack(doc, container, ffmpegPath, coverPreRoll, si
   return mixTimelineClips(ffmpegPath, usable, signal);
 }
 async function mixTimelineClips(ffmpegPath, usable, signal) {
-  const { writeFile, readFile: readFile4, mkdir, rm: rm2 } = await import("fs/promises");
+  const { writeFile: writeFile2, readFile: readFile4, mkdir: mkdir2, rm: rm2 } = await import("fs/promises");
   const { join: join3 } = await import("path");
   const { tmpdir: tmpdir2 } = await import("os");
   const { randomBytes: randomBytes2 } = await import("crypto");
   signal?.throwIfAborted();
   const workDir = join3(tmpdir2(), `squisq-audio-mix-${randomBytes2(8).toString("hex")}`);
-  await mkdir(workDir, { recursive: true });
+  await mkdir2(workDir, { recursive: true });
   const ms = (s) => Math.max(0, Math.round(s * 1e3));
   try {
     signal?.throwIfAborted();
@@ -110,7 +111,7 @@ async function mixTimelineClips(ffmpegPath, usable, signal) {
     for (const { clip, buffer } of usable) {
       signal?.throwIfAborted();
       const p = join3(workDir, `clip-${inputs.length}.mp3`);
-      await writeFile(p, new Uint8Array(buffer));
+      await writeFile2(p, new Uint8Array(buffer));
       signal?.throwIfAborted();
       const i = inputs.push(p) - 1;
       const delayMs = ms(clip.startSec);
@@ -330,7 +331,7 @@ function mp4Format() {
       const animationsEnabled = typeof mp4Opts.animationsEnabled === "boolean" ? mp4Opts.animationsEnabled : MP4_DEFAULTS.animationsEnabled;
       const outputPath = join(tmpdir(), `squisq-mp4-${randomBytes(8).toString("hex")}.mp4`);
       try {
-        const { renderDocToMp4: renderDocToMp42 } = await import("./api-E5PDCULT.js");
+        const { renderDocToMp4: renderDocToMp42 } = await import("./api-O3IMGDPH.js");
         await renderDocToMp42(input.doc, input.container, {
           outputPath,
           fps,
@@ -371,7 +372,7 @@ function gifFormat() {
       const defaultHeight = portrait ? GIF_DEFAULTS.width : GIF_DEFAULTS.height;
       const outputPath = join(tmpdir(), `squisq-gif-${randomBytes(8).toString("hex")}.gif`);
       try {
-        const { renderDocToGif: renderDocToGif2 } = await import("./api-E5PDCULT.js");
+        const { renderDocToGif: renderDocToGif2 } = await import("./api-O3IMGDPH.js");
         const result = await renderDocToGif2(input.doc, input.container, {
           outputPath,
           fps: typeof gifOpts.fps === "number" ? gifOpts.fps : GIF_DEFAULTS.fps,
@@ -404,10 +405,38 @@ function gifFormat() {
     }
   };
 }
+function pngFormat() {
+  return {
+    id: "png",
+    templateAnnotationHandling: "rendered",
+    label: "Dashboard Image",
+    mimeType: "image/png",
+    extensions: [".png"],
+    async exportDoc(input, options) {
+      options.signal?.throwIfAborted();
+      const pngOpts = options.formatOptions?.png ?? {};
+      const { renderDocToDashboardPng: renderDocToDashboardPng2 } = await import("./api-O3IMGDPH.js");
+      const result = await renderDocToDashboardPng2(input.doc, input.container, {
+        resolution: pngOpts.resolution,
+        width: pngOpts.width,
+        height: pngOpts.height,
+        layout: pngOpts.layout,
+        style: pngOpts.style,
+        title: pngOpts.title,
+        documentTitle: options.title ?? input.baseName,
+        signal: options.signal,
+        onProgress: pngOpts.onProgress
+      });
+      options.signal?.throwIfAborted();
+      return { bytes: result.bytes, mimeType: "image/png", suggestedFilename: "", warnings: [] };
+    }
+  };
+}
 function createCliRegistry() {
   const registry = defaultRegistry();
   registry.register(mp4Format());
   registry.register(gifFormat());
+  registry.register(pngFormat());
   return registry;
 }
 
@@ -824,6 +853,12 @@ function throwIfAborted(signal) {
 }
 
 // src/api.ts
+import {
+  DASHBOARD_RESOLUTIONS,
+  DEFAULT_DASHBOARD_RESOLUTION,
+  resolveDashboardDimensions as resolveDashboardDimensions2,
+  validateDashboardImageDimensions
+} from "@bendyline/squisq-video";
 import { ConversionError } from "@bendyline/squisq-formats";
 var playerBundlePromise;
 var fullPlayerBundlePromise;
@@ -863,17 +898,18 @@ async function prepareConversion(source, options = {}) {
     ...options
   });
 }
-async function captureDocFrames(doc, container, options) {
-  const { fps, width, height, captionStyle, coverPreRoll, animationsEnabled, onProgress, signal } = options;
-  signal?.throwIfAborted();
-  resolveAppliedCoverPreRoll(coverPreRoll, true);
-  const ffmpegPath = (await detectFfmpegDetailed(signal))?.path ?? null;
-  signal?.throwIfAborted();
-  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\nOr: npm install ffmpeg-static, or set SQUISQ_FFMPEG to an ffmpeg binary."
-    );
-  }
+async function withRenderPage(doc, container, options, fn) {
+  const {
+    signal,
+    width,
+    height,
+    includeAudio,
+    captionStyle,
+    animationsEnabled,
+    displayMode,
+    dashboard,
+    onProgress
+  } = options;
   onProgress?.("collecting media", 0);
   signal?.throwIfAborted();
   const { collectImagePaths } = await import("@bendyline/squisq-formats/html");
@@ -890,14 +926,16 @@ async function captureDocFrames(doc, container, options) {
     }
   }
   const audio = /* @__PURE__ */ new Map();
-  for (const seg of doc.audio?.segments ?? []) {
-    signal?.throwIfAborted();
-    const data = await container.readFile(seg.src);
-    signal?.throwIfAborted();
-    if (data) {
-      budget.admit(seg.src, data);
-      audio.set(seg.src, data);
-      audio.set(seg.name, data);
+  if (includeAudio) {
+    for (const seg of doc.audio?.segments ?? []) {
+      signal?.throwIfAborted();
+      const data = await container.readFile(seg.src);
+      signal?.throwIfAborted();
+      if (data) {
+        budget.admit(seg.src, data);
+        audio.set(seg.src, data);
+        audio.set(seg.name, data);
+      }
     }
   }
   const mediaSrcs = new Set(resolveMediaSchedule2(doc).map((clip) => clip.src));
@@ -927,7 +965,9 @@ async function captureDocFrames(doc, container, options) {
     width,
     height,
     captionStyle,
-    animationsEnabled
+    animationsEnabled,
+    displayMode,
+    dashboard
   });
   onProgress?.("launching browser", 15);
   signal?.throwIfAborted();
@@ -953,7 +993,6 @@ async function captureDocFrames(doc, container, options) {
   }
   signal?.addEventListener("abort", handleAbort, { once: true });
   let renderAPI = null;
-  const capturedFrames = new CapturedFrameCollector();
   try {
     const page = await browser.newPage({ viewport: { width, height } });
     const pageErrors = [];
@@ -994,58 +1033,135 @@ Page errors:
       return api;
     });
     signal?.throwIfAborted();
-    const docDuration = await renderAPI.evaluate((api) => api.getDuration());
-    signal?.throwIfAborted();
-    if (docDuration <= 0) throw new Error("Document has zero duration \u2014 nothing to render");
-    const hasCover = coverPreRoll > 0 ? await renderAPI.evaluate((api) => api.hasCoverBlock()) : false;
-    const appliedCoverPreRoll = resolveAppliedCoverPreRoll(coverPreRoll, hasCover);
-    const storyFrameCount = Math.ceil(docDuration * fps);
-    const preRollFrameCount = Math.ceil(appliedCoverPreRoll * fps);
-    const totalFrames = preRollFrameCount + storyFrameCount;
-    onProgress?.("capturing frames", 20);
-    capturedFrames.throwIfAborted(signal);
-    if (preRollFrameCount > 0) {
-      capturedFrames.throwIfAborted(signal);
-      await renderAPI.evaluate((api) => api.showCover());
-      await page.waitForTimeout(100);
-      capturedFrames.throwIfAborted(signal);
-      const coverFrame = await page.screenshot({ type: "png" });
-      capturedFrames.throwIfAborted(signal);
-      capturedFrames.append(coverFrame, preRollFrameCount);
-      await renderAPI.evaluate((api) => api.hideCover());
-    }
-    const frameInterval = 1 / fps;
-    for (let i = 0; i < storyFrameCount; i++) {
-      capturedFrames.throwIfAborted(signal);
-      const time = i * frameInterval;
-      await renderAPI.evaluate((api, t) => api.seekTo(t), time);
-      const frame = await page.screenshot({ type: "png" });
-      capturedFrames.throwIfAborted(signal);
-      capturedFrames.append(frame);
-      if (i % Math.max(1, Math.floor(fps / 2)) === 0 || i === storyFrameCount - 1) {
-        onProgress?.(
-          "capturing frames",
-          20 + Math.round(capturedFrames.frameCount / totalFrames * 60)
-        );
+    return await fn({ page, renderAPI });
+  } finally {
+    signal?.removeEventListener("abort", handleAbort);
+    await renderAPI?.dispose().catch(() => void 0);
+    await browser.close().catch(() => void 0);
+  }
+}
+async function captureDocFrames(doc, container, options) {
+  const { fps, width, height, captionStyle, coverPreRoll, animationsEnabled, onProgress, signal } = options;
+  signal?.throwIfAborted();
+  resolveAppliedCoverPreRoll(coverPreRoll, true);
+  const ffmpegPath = (await detectFfmpegDetailed(signal))?.path ?? null;
+  signal?.throwIfAborted();
+  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\nOr: npm install ffmpeg-static, or set SQUISQ_FFMPEG to an ffmpeg binary."
+    );
+  }
+  const capturedFrames = new CapturedFrameCollector();
+  try {
+    return await withRenderPage(
+      doc,
+      container,
+      { signal, width, height, includeAudio: true, captionStyle, animationsEnabled, onProgress },
+      async ({ page, renderAPI }) => {
+        const docDuration = await renderAPI.evaluate((api) => api.getDuration());
+        signal?.throwIfAborted();
+        if (docDuration <= 0) throw new Error("Document has zero duration \u2014 nothing to render");
+        const hasCover = coverPreRoll > 0 ? await renderAPI.evaluate((api) => api.hasCoverBlock()) : false;
+        const appliedCoverPreRoll = resolveAppliedCoverPreRoll(coverPreRoll, hasCover);
+        const storyFrameCount = Math.ceil(docDuration * fps);
+        const preRollFrameCount = Math.ceil(appliedCoverPreRoll * fps);
+        const totalFrames = preRollFrameCount + storyFrameCount;
+        onProgress?.("capturing frames", 20);
         capturedFrames.throwIfAborted(signal);
+        if (preRollFrameCount > 0) {
+          capturedFrames.throwIfAborted(signal);
+          await renderAPI.evaluate((api) => api.showCover());
+          await page.waitForTimeout(100);
+          capturedFrames.throwIfAborted(signal);
+          const coverFrame = await page.screenshot({ type: "png" });
+          capturedFrames.throwIfAborted(signal);
+          capturedFrames.append(coverFrame, preRollFrameCount);
+          await renderAPI.evaluate((api) => api.hideCover());
+        }
+        const frameInterval = 1 / fps;
+        for (let i = 0; i < storyFrameCount; i++) {
+          capturedFrames.throwIfAborted(signal);
+          const time = i * frameInterval;
+          await renderAPI.evaluate((api, t) => api.seekTo(t), time);
+          const frame = await page.screenshot({ type: "png" });
+          capturedFrames.throwIfAborted(signal);
+          capturedFrames.append(frame);
+          if (i % Math.max(1, Math.floor(fps / 2)) === 0 || i === storyFrameCount - 1) {
+            onProgress?.(
+              "capturing frames",
+              20 + Math.round(capturedFrames.frameCount / totalFrames * 60)
+            );
+            capturedFrames.throwIfAborted(signal);
+          }
+        }
+        return {
+          frames: capturedFrames.release(),
+          totalDuration: docDuration + appliedCoverPreRoll,
+          appliedCoverPreRoll,
+          ffmpegPath
+        };
       }
-    }
-    return {
-      frames: capturedFrames.release(),
-      totalDuration: docDuration + appliedCoverPreRoll,
-      appliedCoverPreRoll,
-      ffmpegPath
-    };
+    );
   } catch (err) {
     capturedFrames.clear();
     signal?.throwIfAborted();
     throw err;
-  } finally {
-    signal?.removeEventListener("abort", handleAbort);
-    await renderAPI?.dispose().catch(() => void 0);
-    await browser.close().catch(() => void 0);
   }
 }
+async function renderDocToDashboardPng(doc, container, options = {}) {
+  const {
+    signal,
+    outputPath,
+    resolution,
+    width,
+    height,
+    layout,
+    title,
+    style,
+    documentTitle,
+    onProgress
+  } = options;
+  signal?.throwIfAborted();
+  const dimensions = resolveDashboardDimensions({ resolution, width, height });
+  const bytes = await withRenderPage(
+    doc,
+    container,
+    {
+      signal,
+      width: dimensions.width,
+      height: dimensions.height,
+      includeAudio: false,
+      animationsEnabled: false,
+      displayMode: "dashboard",
+      dashboard: { layout, title, style, documentTitle },
+      onProgress
+    },
+    async ({ page, renderAPI }) => {
+      onProgress?.("rendering dashboard", 50);
+      signal?.throwIfAborted();
+      await renderAPI.evaluate((api) => api.seekTo(0));
+      signal?.throwIfAborted();
+      await page.waitForTimeout(100);
+      signal?.throwIfAborted();
+      onProgress?.("capturing image", 85);
+      return await page.screenshot({ type: "png" });
+    }
+  );
+  let writtenPath;
+  if (outputPath) {
+    const absolute = resolvePath(outputPath);
+    await mkdir(dirname2(absolute), { recursive: true });
+    await writeFile(absolute, bytes);
+    writtenPath = absolute;
+  }
+  onProgress?.("done", 100);
+  return {
+    bytes,
+    width: dimensions.width,
+    height: dimensions.height,
+    ...writtenPath ? { outputPath: writtenPath } : {}
+  };
+}
 async function renderDocToMp4(doc, container, options) {
   options.signal?.throwIfAborted();
   const fps = options.fps ?? 30;
@@ -1235,10 +1351,15 @@ export {
   CapturedFrameBudgetError,
   convert,
   prepareConversion,
+  renderDocToDashboardPng,
   renderDocToMp4,
   renderDocToGif,
   extractThumbnails,
   MemoryContentContainer2 as MemoryContentContainer,
+  DASHBOARD_RESOLUTIONS,
+  DEFAULT_DASHBOARD_RESOLUTION,
+  resolveDashboardDimensions2 as resolveDashboardDimensions,
+  validateDashboardImageDimensions,
   ConversionError,
   createCliRegistry
 };

package/dist/index.js

@@ -6,9 +6,10 @@ import {
   detectFfmpegDetailed,
   getFfmpegVersion,
   readInput,
+  renderDocToDashboardPng,
   renderDocToGif,
   renderDocToMp4
-} from "./chunk-SFBZGL54.js";
+} from "./chunk-2ZJW7F62.js";
 import "./chunk-GGVASRPG.js";
 
 // src/index.ts
@@ -137,7 +138,7 @@ function suggestId(value, candidates) {
 }
 
 // src/commands/convert.ts
-var VALID_FORMATS = [...BUILTIN_FORMAT_IDS, "mp4", "gif"];
+var VALID_FORMATS = [...BUILTIN_FORMAT_IDS, "mp4", "gif", "png"];
 var DEFAULT_FORMATS = [
   "docx",
   "pptx",
@@ -187,7 +188,7 @@ function formatFromOutputPath(outputPath) {
 }
 function registerConvertCommand(program2) {
   program2.command("convert").description(
-    "Convert a document to DOCX, PPTX, PDF, HTML, EPUB, MP4, animated GIF, and container formats"
+    "Convert a document to DOCX, PPTX, PDF, HTML, EPUB, MP4, animated GIF, dashboard PNG, and container formats"
   ).argument("<input>", "Path to .md/.docx/.pptx/.pdf/.xlsx/.csv/.html file, .zip/.dbk, or folder").addOption(
     new Option(
       "-o, --output <file>",
@@ -498,8 +499,157 @@ function clearProgress() {
   process.stderr.write("\r" + " ".repeat(80) + "\r");
 }
 
+// src/commands/image.ts
+import { mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname3, basename as basename3, extname as extname3, resolve as resolve3 } from "path";
+import {
+  DASHBOARD_AUTO_LAYOUT_ID,
+  DASHBOARD_STYLE_IDS,
+  listDashboardLayouts,
+  resolveDashboardStyleId
+} from "@bendyline/squisq/doc";
+import {
+  DASHBOARD_RESOLUTIONS,
+  DEFAULT_DASHBOARD_RESOLUTION,
+  resolveDashboardDimensions
+} from "@bendyline/squisq-video";
+var IMAGE_COMMAND_NAME = "image";
+var VALID_IMAGE_FORMATS = ["png"];
+function registerImageCommand(program2) {
+  const resolutionIds = DASHBOARD_RESOLUTIONS.map((preset) => preset.id).join(", ");
+  program2.command(IMAGE_COMMAND_NAME).description("Render a squisq document's Dashboard to a PNG image").argument("<input>", "Path to .md/.json file, .zip/.dbk container, or folder").argument("[output]", "Output .png path (default: <input>.png)").option("-o, --output <path>", "Output .png path").option("--format <format>", `Output format: ${VALID_IMAGE_FORMATS.join(", ")} (default: png)`).option(
+    "--resolution <preset>",
+    `Named resolution: ${resolutionIds} (default: ${DEFAULT_DASHBOARD_RESOLUTION})`
+  ).option("--width <pixels>", "Custom image width (requires --height; excludes --resolution)").option("--height <pixels>", "Custom image height (requires --width; excludes --resolution)").option(
+    "--layout <id>",
+    `Dashboard layout id, or "${DASHBOARD_AUTO_LAYOUT_ID}" to pick by block count (default)`
+  ).option(
+    "--style <variant>",
+    `Cell style variant: ${DASHBOARD_STYLE_IDS.join(", ")} (default: the document's own setting)`
+  ).option("--title", "Include the document-title band (default: the document's own setting)").option("--no-title", "Hide the document-title band").option(
+    "--no-auto-templates",
+    "Disable content-aware template auto-picking for unannotated headings"
+  ).option("-t, --theme <id>", "Squisq theme ID to apply (e.g., documentary, cinematic, bold)").option(
+    "--transform <style>",
+    "Transform style to apply before rendering (e.g., documentary, magazine, minimal)"
+  ).option("--overwrite", "Replace an existing output file (default: refuse and exit non-zero)").action(async (inputPath, outputArg, opts) => {
+    try {
+      if (outputArg && opts.output) {
+        throw new Error("The positional output and --output cannot be used together.");
+      }
+      if (outputArg) opts.output = outputArg;
+      await runImage(inputPath, opts);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Error: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+async function runImage(inputPath, opts) {
+  const resolvedInput = resolve3(inputPath);
+  const requestedFormat = opts.format?.toLowerCase();
+  if (requestedFormat !== void 0 && !VALID_IMAGE_FORMATS.includes(requestedFormat)) {
+    throw new Error(
+      `Invalid format "${requestedFormat}". Valid: ${VALID_IMAGE_FORMATS.join(", ")}`
+    );
+  }
+  if (opts.output && extname3(opts.output).toLowerCase() !== ".png") {
+    throw new Error("Output path must end in .png");
+  }
+  const width = opts.width === void 0 ? void 0 : Number(opts.width);
+  const height = opts.height === void 0 ? void 0 : Number(opts.height);
+  const dimensions = resolveDashboardDimensions({
+    resolution: opts.resolution,
+    width,
+    height
+  });
+  if (opts.layout !== void 0 && opts.layout.trim().length === 0) {
+    throw new Error("The --layout id must be a non-empty string.");
+  }
+  const requestedStyle = opts.style === void 0 ? void 0 : resolveDashboardStyleId(opts.style);
+  if (opts.style !== void 0 && requestedStyle === void 0) {
+    throw new Error(
+      `Unknown dashboard style "${opts.style}". Valid: ${DASHBOARD_STYLE_IDS.join(", ")}`
+    );
+  }
+  if (opts.transform) {
+    await assertValidTransformStyle(opts.transform);
+  }
+  const inputBasename = basename3(resolvedInput);
+  const inputExt = extname3(inputBasename);
+  const baseName = inputExt ? inputBasename.slice(0, -inputExt.length) : inputBasename;
+  const outputPath = opts.output ? resolve3(opts.output) : resolve3(dirname3(resolvedInput), `${baseName}.png`);
+  await assertOutputsWritable([outputPath], opts.overwrite);
+  await mkdir3(dirname3(outputPath), { recursive: true });
+  console.error(`Reading: ${resolvedInput}`);
+  const result = await readInput(resolvedInput);
+  const { container } = result;
+  if (opts.theme) {
+    await assertValidThemeId(opts.theme, result);
+  }
+  let doc = result.doc;
+  if (result.markdownDoc) {
+    if (opts.autoTemplates === false) {
+      const { markdownToDoc, resolveAudioMapping } = await import("@bendyline/squisq/doc");
+      doc = await resolveAudioMapping(
+        markdownToDoc(result.markdownDoc, { autoTemplates: false }),
+        container
+      );
+    }
+  } else {
+    console.error("Using pre-built Doc JSON");
+  }
+  const requestedLayout = opts.layout?.trim().toLowerCase();
+  if (requestedLayout && requestedLayout !== DASHBOARD_AUTO_LAYOUT_ID) {
+    const available = listDashboardLayouts(doc);
+    if (!available.some((layout) => layout.id === requestedLayout)) {
+      const known = available.map((layout) => layout.id).join(", ");
+      throw new Error(
+        `Unknown dashboard layout "${requestedLayout}". Valid: ${DASHBOARD_AUTO_LAYOUT_ID}, ${known}`
+      );
+    }
+  }
+  if (opts.transform) {
+    doc = await applyTransformToDoc(doc, opts.transform, opts.theme);
+    console.error(`  Applied transform: ${opts.transform}`);
+  }
+  if (opts.theme) {
+    doc = { ...doc, themeId: opts.theme };
+  }
+  console.error(
+    `Rendering dashboard PNG: ${dimensions.width}\xD7${dimensions.height}, layout: ${requestedLayout ?? DASHBOARD_AUTO_LAYOUT_ID}, style: ${requestedStyle ?? "document"}, title: ${titleReadout(opts.title)}`
+  );
+  const rendered = await renderDocToDashboardPng(doc, container, {
+    outputPath,
+    ...opts.resolution !== void 0 ? { resolution: opts.resolution } : width !== void 0 && height !== void 0 ? { width, height } : {},
+    layout: requestedLayout,
+    style: requestedStyle,
+    title: opts.title,
+    documentTitle: baseName,
+    onProgress: (phase, percent) => writeProgress2(phase, percent, 100)
+  });
+  clearProgress2();
+  console.error(`  \u2713 ${rendered.outputPath} (${rendered.width}\xD7${rendered.height})`);
+  console.error("Done.");
+}
+function titleReadout(title) {
+  if (title === void 0) return "document";
+  return title ? "on" : "off";
+}
+var BAR_WIDTH2 = 30;
+function writeProgress2(label, current, total) {
+  const pct = Math.min(100, Math.round(current / total * 100));
+  const filled = Math.round(pct / 100 * BAR_WIDTH2);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH2 - filled);
+  process.stderr.write(`\r  ${label}: ${bar} ${pct}%  `);
+}
+function clearProgress2() {
+  process.stderr.write("\r" + " ".repeat(80) + "\r");
+}
+
 // src/commands/validate.ts
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 import { validateMarkdownDoc } from "@bendyline/squisq/doc";
 function registerValidateCommand(program2) {
   program2.command("validate").description("Validate a squisq markdown document and report structural problems").argument("<input>", "Path to .md file, .zip/.dbk container, or folder").option("--json", "Output diagnostics as JSON (for tooling and agents)").option("--strict", "Exit non-zero on warnings as well as errors").action(async (inputPath, opts) => {
@@ -518,7 +668,7 @@ function registerValidateCommand(program2) {
   });
 }
 async function runValidate(inputPath, opts) {
-  const resolvedInput = resolve3(inputPath);
+  const resolvedInput = resolve4(inputPath);
   const { container, markdownDoc, doc } = await readInput(resolvedInput);
   if (!markdownDoc) {
     const diagnostics = doc.diagnostics ?? [];
@@ -585,13 +735,16 @@ var defaultDoctorRuntime = {
   log: (line) => console.error(line)
 };
 function registerDoctorCommand(program2) {
-  program2.command("doctor").description("Check that ffmpeg and Playwright Chromium are available for video rendering").action(async () => {
+  program2.command("doctor").description(
+    "Check that ffmpeg and Playwright Chromium are available for video/image rendering"
+  ).action(async () => {
     const allPresent = await runDoctor();
     process.exitCode = allPresent ? 0 : 1;
   });
 }
 async function runDoctor(runtime = defaultDoctorRuntime) {
-  let allPresent = true;
+  let ffmpegOk = true;
+  let chromiumOk = true;
   runtime.log(`Node:     ${runtime.nodeVersion}`);
   try {
     const detection = await runtime.detectFfmpeg();
@@ -601,7 +754,7 @@ async function runDoctor(runtime = defaultDoctorRuntime) {
         `ffmpeg:   ${detection.path} (source: ${detection.source}) \u2014 ${version2 ?? "version unknown"}`
       );
     } else {
-      allPresent = false;
+      ffmpegOk = false;
       runtime.log("ffmpeg:   not found.");
       runtime.log("          Install it with:");
       runtime.log("            macOS:   brew install ffmpeg");
@@ -610,7 +763,7 @@ async function runDoctor(runtime = defaultDoctorRuntime) {
       runtime.log("          Or: npm install ffmpeg-static, or set SQUISQ_FFMPEG.");
     }
   } catch (err) {
-    allPresent = false;
+    ffmpegOk = false;
     runtime.log(`ffmpeg:   ${err instanceof Error ? err.message : String(err)}`);
   }
   try {
@@ -618,18 +771,21 @@ async function runDoctor(runtime = defaultDoctorRuntime) {
     await browser.close();
     runtime.log(`Chromium: available (${browser.executablePath})`);
   } catch (err) {
-    allPresent = false;
+    chromiumOk = false;
     const detail = err instanceof Error ? err.message.split("\n")[0] : String(err);
     runtime.log(`Chromium: not available \u2014 ${detail}`);
     runtime.log("          Run: npx playwright install chromium");
   }
+  runtime.log(`video/gif (ffmpeg + Chromium): ${ffmpegOk && chromiumOk ? "ready" : "not ready"}`);
+  runtime.log(`image PNG (Chromium only):     ${chromiumOk ? "ready" : "not ready"}`);
+  const allPresent = ffmpegOk && chromiumOk;
   runtime.log(allPresent ? "\n\u2713 All checks passed" : "\n\u2717 Some checks failed");
   return allPresent;
 }
 
 // src/commands/transform.ts
-import { mkdir as mkdir3, readFile } from "fs/promises";
-import { dirname as dirname3, resolve as resolve4 } from "path";
+import { mkdir as mkdir4, readFile } from "fs/promises";
+import { dirname as dirname4, resolve as resolve5 } from "path";
 import { Option as Option2 } from "commander";
 import {
   DEFAULT_WRAP_WIDTH,
@@ -662,7 +818,7 @@ function registerTransformCommand(program2) {
   });
 }
 async function runTransform(inputPath, opts) {
-  const resolvedInput = resolve4(inputPath);
+  const resolvedInput = resolve5(inputPath);
   let source;
   try {
     source = await readFile(resolvedInput, { encoding: "utf-8" });
@@ -704,9 +860,9 @@ async function runTransform(inputPath, opts) {
     await writeFileGuarded(resolvedInput, bytes, true);
     console.error(`\u2713 ${summary} \u2192 ${resolvedInput}`);
   } else if (opts.output) {
-    const resolvedOutput = resolve4(opts.output);
+    const resolvedOutput = resolve5(opts.output);
     await assertOutputsWritable([resolvedOutput], opts.overwrite);
-    await mkdir3(dirname3(resolvedOutput), { recursive: true });
+    await mkdir4(dirname4(resolvedOutput), { recursive: true });
     await writeFileGuarded(resolvedOutput, bytes, opts.overwrite);
     console.error(`\u2713 ${summary} \u2192 ${resolvedOutput}`);
   } else {
@@ -728,6 +884,7 @@ var program = new Command2();
 program.name("squisq").description("Squisq CLI \u2014 convert and process markdown-based documents").version(version);
 registerConvertCommand(program);
 registerVideoCommand(program);
+registerImageCommand(program);
 registerValidateCommand(program);
 registerDoctorCommand(program);
 registerTransformCommand(program);