@bendyline/squisq-cli 2.4.2 → 2.4.3

package/dist/{chunk-VK6WPOSG.js → chunk-X3GFPKRJ.js}

@@ -6,7 +6,7 @@ import {
 
 // src/api.ts
 import { readFile as readFile3 } from "fs/promises";
-import { resolveMediaSchedule } from "@bendyline/squisq/schemas";
+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";
@@ -19,17 +19,17 @@ import {
 import { execFile } from "child_process";
 function run(command, args, signal) {
   signal?.throwIfAborted();
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     execFile(command, args, { timeout: 5e3, signal }, (err, stdout) => {
       if (signal?.aborted) {
         reject(signal.reason);
         return;
       }
       if (err || !stdout.trim()) {
-        resolve(null);
+        resolve2(null);
         return;
       }
-      resolve(stdout.trim());
+      resolve2(stdout.trim());
     });
   });
 }
@@ -73,7 +73,7 @@ async function detectFfmpegDetailed(signal) {
 import { computeAudioTimeline } from "@bendyline/squisq-video";
 async function buildMixedAudioTrack(doc, container, ffmpegPath, coverPreRoll, signal) {
   signal?.throwIfAborted();
-  const timeline = computeAudioTimeline(doc, coverPreRoll);
+  const timeline = computeAudioTimeline(doc, coverPreRoll, { includeVideoAudio: false });
   if (timeline.length === 0) return null;
   const bytesBySrc = /* @__PURE__ */ new Map();
   const readSrc = async (src) => {
@@ -330,7 +330,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-KYHSJM5T.js");
+        const { renderDocToMp4: renderDocToMp42 } = await import("./api-PBBQQMRP.js");
         await renderDocToMp42(input.doc, input.container, {
           outputPath,
           fps,
@@ -371,7 +371,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-KYHSJM5T.js");
+        const { renderDocToGif: renderDocToGif2 } = await import("./api-PBBQQMRP.js");
         const result = await renderDocToGif2(input.doc, input.container, {
           outputPath,
           fps: typeof gifOpts.fps === "number" ? gifOpts.fps : GIF_DEFAULTS.fps,
@@ -415,13 +415,45 @@ function createCliRegistry() {
 import { MemoryContentContainer as MemoryContentContainer2 } from "@bendyline/squisq/storage";
 
 // src/util/readInput.ts
-import { readFile as readFile2, readdir, stat } from "fs/promises";
-import { join as join2, extname } from "path";
+import { readFile as readFile2, readdir, realpath, stat } from "fs/promises";
+import {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join as join2,
+  posix,
+  relative,
+  resolve,
+  sep,
+  win32
+} from "path";
 import { parseMarkdown, stringifyMarkdown } from "@bendyline/squisq/markdown";
 import { markdownToDoc, resolveAudioMapping } from "@bendyline/squisq/doc";
+import { resolveMediaSchedule, validateDocSchema } from "@bendyline/squisq/schemas";
 import { MemoryContentContainer } from "@bendyline/squisq/storage";
 import { zipToContainer } from "@bendyline/squisq-formats/container";
 import { defaultRegistry as defaultRegistry2 } from "@bendyline/squisq-formats";
+var DocInputValidationError = class extends Error {
+  constructor(source, issues) {
+    const detail = issues.map(formatSchemaIssueForError).join("; ");
+    super(`${source} is not a valid squisq Doc: ${detail}`);
+    this.name = "DocInputValidationError";
+    this.issues = issues;
+    this.diagnostics = issues.map((issue) => ({
+      severity: "error",
+      code: "invalid-doc-schema",
+      message: `${issue.path} ${issue.message}`
+    }));
+  }
+};
+function formatSchemaIssueForError(issue) {
+  if (issue.path === "$") {
+    const got = /\(got ([^)]+)\)/.exec(issue.message)?.[1] ?? "an invalid value";
+    return `expected a JSON object, got ${got}`;
+  }
+  return `"${issue.path}" ${issue.message}`;
+}
 var MIME_TYPES = {
   ".md": "text/markdown",
   ".txt": "text/plain",
@@ -436,7 +468,11 @@ var MIME_TYPES = {
   ".wav": "audio/wav",
   ".ogg": "audio/ogg",
   ".mp4": "video/mp4",
-  ".webm": "video/webm"
+  ".webm": "video/webm",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf"
 };
 var IMPORTER_EXTS = [".docx", ".pptx", ".pdf", ".xlsx", ".csv", ".html", ".htm"];
 function mimeFromExt(filePath) {
@@ -462,8 +498,10 @@ async function readInput(inputPath, options) {
   throwIfAborted(options?.signal);
   const result = await readInputRaw(inputPath, options);
   throwIfAborted(options?.signal);
+  assertValidDoc(result.doc, inputPath);
   const doc = await resolveAudioMapping(result.doc, result.container);
   throwIfAborted(options?.signal);
+  assertValidDoc(doc, inputPath);
   return doc === result.doc ? result : { ...result, doc };
 }
 async function readInputRaw(inputPath, options) {
@@ -516,69 +554,160 @@ async function readUtf8File(filePath, signal) {
 }
 async function readMarkdownFile(filePath, signal) {
   const content = await readUtf8File(filePath, signal);
-  const container = new MemoryContentContainer();
-  await container.writeDocument(content);
-  throwIfAborted(signal);
   const markdownDoc = parseMarkdown(content);
-  return { doc: markdownToDoc(markdownDoc), container, markdownDoc, sourceFormat: "md" };
+  const doc = markdownToDoc(markdownDoc);
+  const container = await buildBareMarkdownContainer(filePath, content, doc, signal);
+  return { doc, container, markdownDoc, sourceFormat: "md" };
 }
-function parseDocJson(content, source) {
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`${source} is not valid JSON: ${detail}`);
-  }
-  const fail = (detail) => {
-    throw new Error(`${source} is not a valid squisq Doc: ${detail}`);
-  };
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    fail(`expected a JSON object, got ${Array.isArray(parsed) ? "an array" : typeof parsed}`);
-  }
-  const doc = parsed;
-  if (!Array.isArray(doc.blocks)) {
-    fail(`"blocks" must be an array${doc.blocks === void 0 ? " (field is missing)" : ""}`);
+var NARRATION_EXTENSIONS = /* @__PURE__ */ new Set([".aac", ".flac", ".m4a", ".mp3", ".ogg", ".wav"]);
+async function buildBareMarkdownContainer(filePath, content, doc, signal) {
+  const container = new MemoryContentContainer();
+  await container.writeDocument(content, basename(filePath));
+  throwIfAborted(signal);
+  const refs = collectAuthoredAssetRefs(content, doc);
+  const root = dirname(resolve(filePath));
+  for (const entry of await readdir(root, { withFileTypes: true })) {
+    throwIfAborted(signal);
+    if (entry.isFile() && NARRATION_EXTENSIONS.has(extname(entry.name).toLowerCase())) {
+      refs.add(entry.name);
+    }
   }
-  for (const [index, block] of doc.blocks.entries()) {
-    if (typeof block !== "object" || block === null || Array.isArray(block)) {
-      fail(`"blocks[${index}]" must be an object`);
+  refs.add("timing.json");
+  for (const ref of [...refs]) {
+    if (NARRATION_EXTENSIONS.has(extname(stripUrlSuffix(ref)).toLowerCase())) {
+      refs.add(`${stripUrlSuffix(ref)}.timing.json`);
     }
   }
-  if (doc.duration !== void 0 && !isFiniteNumber(doc.duration)) {
-    fail(`"duration" must be a finite number, got ${describe(doc.duration)}`);
+  const rootReal = await realpath(root);
+  let fileCount = 0;
+  let totalBytes = 0;
+  for (const authoredRef of refs) {
+    throwIfAborted(signal);
+    const safe = normalizeAssetReference(authoredRef);
+    if (!safe) continue;
+    const absolute = resolve(root, ...safe.split("/"));
+    if (!isContainedPath(root, absolute)) continue;
+    let assetReal;
+    let info;
+    try {
+      assetReal = await realpath(absolute);
+      if (!isContainedPath(rootReal, assetReal)) continue;
+      info = await stat(assetReal);
+    } catch (error) {
+      if (isMissingFileError(error)) continue;
+      throw error;
+    }
+    if (!info.isFile()) continue;
+    if (info.size > MAX_RENDER_MEDIA_FILE_BYTES) {
+      throw new Error(
+        `Sibling asset "${safe}" exceeds the ${formatMiB(MAX_RENDER_MEDIA_FILE_BYTES)} per-file input limit.`
+      );
+    }
+    if (fileCount + 1 > MAX_RENDER_MEDIA_FILES) {
+      throw new Error(
+        `Bare markdown input references more than ${MAX_RENDER_MEDIA_FILES} sibling assets.`
+      );
+    }
+    if (totalBytes + info.size > MAX_RENDER_MEDIA_TOTAL_BYTES) {
+      throw new Error(
+        `Sibling assets exceed the ${formatMiB(MAX_RENDER_MEDIA_TOTAL_BYTES)} total input limit.`
+      );
+    }
+    const data = await readBinaryFile(assetReal, signal);
+    if (data.byteLength > MAX_RENDER_MEDIA_FILE_BYTES) {
+      throw new Error(
+        `Sibling asset "${safe}" exceeds the ${formatMiB(MAX_RENDER_MEDIA_FILE_BYTES)} per-file input limit.`
+      );
+    }
+    if (totalBytes + data.byteLength > MAX_RENDER_MEDIA_TOTAL_BYTES) {
+      throw new Error(
+        `Sibling assets exceed the ${formatMiB(MAX_RENDER_MEDIA_TOTAL_BYTES)} total input limit.`
+      );
+    }
+    await container.writeFile(safe, data, mimeFromExt(safe));
+    fileCount += 1;
+    totalBytes += data.byteLength;
   }
-  if (doc.audio !== void 0) {
-    if (typeof doc.audio !== "object" || doc.audio === null || Array.isArray(doc.audio)) {
-      fail('"audio" must be an object');
+  return container;
+}
+function collectAuthoredAssetRefs(content, doc) {
+  const refs = /* @__PURE__ */ new Set();
+  const add = (value) => {
+    if (typeof value === "string" && value.trim()) refs.add(value.trim());
+  };
+  const scanObject = (value, seen = /* @__PURE__ */ new Set()) => {
+    if (!value || typeof value !== "object") return;
+    if (seen.has(value)) return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      for (const item of value) scanObject(item, seen);
+      return;
     }
-    const segments = doc.audio.segments;
-    if (segments !== void 0) {
-      if (!Array.isArray(segments)) fail('"audio.segments" must be an array');
-      for (const [index, segment] of segments.entries()) {
-        if (typeof segment !== "object" || segment === null) {
-          fail(`"audio.segments[${index}]" must be an object`);
-        }
-        if (!isFiniteNumber(segment.duration)) {
-          fail(
-            `"audio.segments[${index}].duration" must be a finite number, got ${describe(segment.duration)}`
-          );
-        }
+    for (const [key, item] of Object.entries(value)) {
+      if (typeof item === "string" && ["src", "url", "heroSrc", "posterSrc", "staticSrc", "videoSrc", "imageSrc"].includes(key)) {
+        add(item);
+      } else {
+        scanObject(item, seen);
       }
     }
-  }
-  return {
-    ...doc,
-    audio: doc.audio ?? { segments: [] }
   };
+  scanObject(doc);
+  for (const segment of doc.audio.segments) add(segment.src);
+  for (const clip of resolveMediaSchedule(doc)) add(clip.src);
+  const patterns = [
+    /\b(?:src|href)\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s>]+))/gi,
+    /\b(?:src|audio|video|image|font)\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s}\]]+))/gi,
+    /\burl\(\s*(?:"([^"]+)"|'([^']+)'|([^\s)]+))\s*\)/gi,
+    /!?\[[^\]]*\]\(\s*<?([^\s)>]+)>?/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while (match = pattern.exec(content)) add(match.slice(1).find(Boolean));
+  }
+  return refs;
+}
+function normalizeAssetReference(authoredRef) {
+  let value = stripUrlSuffix(authoredRef.trim().replace(/^<|>$/g, ""));
+  try {
+    value = decodeURIComponent(value);
+  } catch {
+    return null;
+  }
+  if (!value || value.includes("\0") || /^[a-z][a-z\d+.-]*:/i.test(value) || posix.isAbsolute(value) || win32.isAbsolute(value) || isAbsolute(value)) {
+    return null;
+  }
+  const parts = value.replace(/\\/g, "/").split("/");
+  if (parts.some((part) => part === "..")) return null;
+  const normalized = parts.filter((part) => part && part !== ".").join("/");
+  return normalized || null;
+}
+function stripUrlSuffix(value) {
+  return value.split(/[?#]/, 1)[0] ?? value;
+}
+function isContainedPath(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
+function formatMiB(bytes) {
+  return `${Math.round(bytes / (1024 * 1024))} MB`;
+}
+function assertValidDoc(value, source) {
+  const issues = validateDocSchema(value);
+  if (issues.length > 0) throw new DocInputValidationError(source, issues);
 }
-function describe(value) {
-  if (typeof value === "number") return Number.isNaN(value) ? "NaN" : String(value);
-  if (typeof value === "string") return JSON.stringify(value);
-  return value === null ? "null" : typeof value;
+function parseDocJson(content, source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`${source} is not valid JSON: ${detail}`);
+  }
+  assertValidDoc(parsed, source);
+  return parsed;
 }
 async function readDocJsonFile(filePath, signal) {
   const content = await readUtf8File(filePath, signal);
@@ -751,7 +880,7 @@ async function captureDocFrames(doc, container, options) {
       audio.set(seg.name, data);
     }
   }
-  const mediaSrcs = new Set(resolveMediaSchedule(doc).map((clip) => clip.src));
+  const mediaSrcs = new Set(resolveMediaSchedule2(doc).map((clip) => clip.src));
   for (const block of flattenBlocks2(doc.blocks)) {
     for (const layer of block.layers ?? []) {
       if (layer.type === "video") mediaSrcs.add(layer.content.src);
@@ -1002,7 +1131,7 @@ async function renderDocToGif(doc, container, options) {
     options.signal?.throwIfAborted();
     options.onProgress?.("done", 100);
     options.signal?.throwIfAborted();
-    const hasAudio = (doc.audio?.segments?.length ?? 0) > 0 || resolveMediaSchedule(doc).some((clip) => clip.kind === "audio");
+    const hasAudio = (doc.audio?.segments?.length ?? 0) > 0 || resolveMediaSchedule2(doc).some((clip) => clip.kind === "audio");
     return {
       duration: capture.totalDuration,
       frameCount,
@@ -1017,8 +1146,30 @@ async function extractThumbnails(options) {
   const { videoPath, outputDir, slug, sizes, force, signal } = options;
   const { existsSync } = await import("fs");
   const { rm: rm2 } = await import("fs/promises");
-  const { join: join3 } = await import("path");
+  const { isAbsolute: isAbsolute2, relative: relative2, resolve: resolve2, sep: sep2 } = await import("path");
   signal?.throwIfAborted();
+  if (typeof slug !== "string" || !/^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,126}[A-Za-z0-9])?$/.test(slug)) {
+    throw new TypeError(
+      "Thumbnail slug must be 1\u2013128 filename-safe characters (letters, numbers, dot, dash, or underscore) and must start and end with a letter or number."
+    );
+  }
+  for (const [index, thumb] of sizes.entries()) {
+    if (!Number.isSafeInteger(thumb.width) || thumb.width <= 0) {
+      throw new TypeError(`Thumbnail sizes[${index}].width must be a positive integer.`);
+    }
+    if (!Number.isSafeInteger(thumb.height) || thumb.height <= 0) {
+      throw new TypeError(`Thumbnail sizes[${index}].height must be a positive integer.`);
+    }
+  }
+  const resolvedOutputDir = resolve2(outputDir);
+  const outputPaths = sizes.map((thumb) => {
+    const outputPath = resolve2(resolvedOutputDir, `${slug}-${thumb.width}x${thumb.height}.jpg`);
+    const rel = relative2(resolvedOutputDir, outputPath);
+    if (rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel)) {
+      throw new TypeError("Thumbnail output path must remain inside outputDir.");
+    }
+    return outputPath;
+  });
   const ffmpegPath = (await detectFfmpegDetailed(signal))?.path ?? null;
   if (!ffmpegPath) {
     throw new Error(
@@ -1027,9 +1178,9 @@ async function extractThumbnails(options) {
   }
   const generatedPaths = [];
   try {
-    for (const thumb of sizes) {
+    for (const [index, thumb] of sizes.entries()) {
       signal?.throwIfAborted();
-      const outputPath = join3(outputDir, `${slug}-${thumb.width}x${thumb.height}.jpg`);
+      const outputPath = outputPaths[index];
       if (!force && existsSync(outputPath)) continue;
       try {
         await runFfmpeg(
@@ -1056,6 +1207,7 @@ async function extractThumbnails(options) {
 }
 
 export {
+  DocInputValidationError,
   readInput,
   getFfmpegVersion,
   detectFfmpegDetailed,

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  DocInputValidationError,
   convert,
   createCliRegistry,
   detectFfmpegDetailed,
@@ -7,7 +8,7 @@ import {
   readInput,
   renderDocToGif,
   renderDocToMp4
-} from "./chunk-VK6WPOSG.js";
+} from "./chunk-X3GFPKRJ.js";
 import "./chunk-GGVASRPG.js";
 
 // src/index.ts
@@ -498,8 +499,7 @@ function clearProgress() {
 }
 
 // src/commands/validate.ts
-import { existsSync, statSync } from "fs";
-import { dirname as dirname3, extname as extname3, join as join2, resolve as resolve3 } from "path";
+import { resolve as resolve3 } 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) => {
@@ -507,6 +507,10 @@ function registerValidateCommand(program2) {
       const exitCode = await runValidate(inputPath, opts);
       process.exitCode = exitCode;
     } catch (err) {
+      if (err instanceof DocInputValidationError) {
+        process.exitCode = report(err.diagnostics, opts);
+        return;
+      }
       const message = err instanceof Error ? err.message : String(err);
       console.error(`Error: ${message}`);
       process.exitCode = 2;
@@ -518,16 +522,12 @@ async function runValidate(inputPath, opts) {
   const { container, markdownDoc, doc } = await readInput(resolvedInput);
   if (!markdownDoc) {
     const diagnostics = doc.diagnostics ?? [];
-    return report(diagnostics, opts, "doc.json input \u2014 markdown-level checks skipped");
+    return report(diagnostics, opts, "doc.json input \u2014 canonical schema valid");
   }
   const entries = await container.listFiles();
   const containerPaths = new Set(entries.map((e) => e.path));
-  const isBareMarkdown = statSync(resolvedInput).isFile() && ![".zip", ".dbk"].includes(extname3(resolvedInput).toLowerCase());
-  const baseDir = dirname3(resolvedInput);
   const hasAsset = (path) => {
-    if (containerPaths.has(path) || containerPaths.has(path.replace(/^\.\//, ""))) return true;
-    if (isBareMarkdown) return existsSync(join2(baseDir, path));
-    return false;
+    return containerPaths.has(path) || containerPaths.has(path.replace(/^\.\//, ""));
   };
   const result = validateMarkdownDoc(markdownDoc, { assets: hasAsset });
   return report(result.diagnostics, opts);
@@ -629,7 +629,7 @@ async function runDoctor(runtime = defaultDoctorRuntime) {
 
 // src/commands/transform.ts
 import { mkdir as mkdir3, readFile } from "fs/promises";
-import { dirname as dirname4, resolve as resolve4 } from "path";
+import { dirname as dirname3, resolve as resolve4 } from "path";
 import { Option as Option2 } from "commander";
 import {
   DEFAULT_WRAP_WIDTH,
@@ -682,9 +682,13 @@ async function runTransform(inputPath, opts) {
       return 1;
     }
   }
-  const width = Number.parseInt(opts.width, 10);
-  if (Number.isNaN(width)) {
-    console.error(`Error: --width must be a number (got "${opts.width}")`);
+  if (!/^\d+$/.test(opts.width)) {
+    console.error(`Error: --width must be an integer between 20 and 500 (got "${opts.width}")`);
+    return 1;
+  }
+  const width = Number(opts.width);
+  if (!Number.isSafeInteger(width) || width < 20 || width > 500) {
+    console.error(`Error: --width must be an integer between 20 and 500 (got "${opts.width}")`);
     return 1;
   }
   let result = source;
@@ -702,7 +706,7 @@ async function runTransform(inputPath, opts) {
   } else if (opts.output) {
     const resolvedOutput = resolve4(opts.output);
     await assertOutputsWritable([resolvedOutput], opts.overwrite);
-    await mkdir3(dirname4(resolvedOutput), { recursive: true });
+    await mkdir3(dirname3(resolvedOutput), { recursive: true });
     await writeFileGuarded(resolvedOutput, bytes, opts.overwrite);
     console.error(`\u2713 ${summary} \u2192 ${resolvedOutput}`);
   } else {