@lalalic/markcut 2.3.0 → 2.4.1

package/src/player/bundle/player.js

@@ -30520,7 +30520,7 @@ function VideoLeaf({ stream: stream2 }) {
   const startFrom = stream2.startFrom ?? 0;
   const endAt = stream2.endAt ?? totalDur;
   const volume = stream2.volume ?? 1;
-  const playbackRate = stream2.loop ? 1 : Math.min(1, toPlaybackRate((endAt - startFrom) / (end - start)));
+  const playbackRate = Math.min(1, toPlaybackRate((endAt - startFrom) / (end - start)));
   const streamStyle = cssJS(stream2.style);
   const hasAnimation = "animation" in streamStyle;
   return /* @__PURE__ */ (0, import_jsx_runtime78.jsx)(
@@ -30580,7 +30580,7 @@ function AudioLeaf({ stream: stream2 }) {
   const startFrom = stream2.startFrom ?? 0;
   const endAt = stream2.endAt ?? totalDur;
   const volume = stream2.volume ?? 1;
-  const playbackRate = stream2.loop ? 1 : toPlaybackRate((endAt - startFrom) / (end - start));
+  const playbackRate = toPlaybackRate((endAt - startFrom) / (end - start));
   return /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(
     Sequence,
     {
@@ -30597,7 +30597,6 @@ function AudioLeaf({ stream: stream2 }) {
           endAt: Math.floor(startFrom * fps) + Math.floor((endAt - startFrom) * fps / playbackRate),
           muted: volume === 0 || !!ctx?.foreground,
           volume,
-          loop: (stream2.loop ?? 1) > 1,
           playbackRate,
           showInTimeline: false
         }
@@ -44711,11 +44710,6 @@ function getCurrentStep(leg, currentInSecond) {
 // src/types/Include.tsx
 var React41 = __toESM(require_react(), 1);
 var import_jsx_runtime84 = __toESM(require_jsx_runtime(), 1);
-var ASPECT_DIMS = {
-  "16x9": { width: 1920, height: 1080 },
-  "9x16": { width: 1080, height: 1920 },
-  "1x1": { width: 1080, height: 1080 }
-};
 function isSceneBased(data2) {
   if (!data2 || typeof data2 !== "object") return false;
   const d2 = data2;
@@ -44838,8 +44832,7 @@ function IncludeLeaf({ stream: stream2 }) {
     if (isSceneBased(externalData)) {
       const vj = externalData;
       const vjFps = vj.meta.fps ?? parentFps;
-      const aspectKey = vj.meta.aspects?.[0] ?? "16x9";
-      const dims = ASPECT_DIMS[aspectKey] ?? { width: parentWidth, height: parentHeight };
+      const dims = { width: parentWidth, height: parentHeight };
       return /* @__PURE__ */ (0, import_jsx_runtime84.jsxs)(AbsoluteFill, { style: { backgroundColor: "#0a0a0a", width: dims.width, height: dims.height }, children: [
         vj.bgm && /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(Audio, { src: vj.bgm.src, volume: vj.bgm.baseVolume }),
         vj.scenes.map((scene2) => {
@@ -45891,15 +45884,41 @@ function supportHtml(text) {
   });
   return el;
 }
+function stripHtml(text) {
+  return text.replace(/<[^>]*>/g, "").trim();
+}
+function groupConsecutiveCues(cues) {
+  const groups = [];
+  let current2 = [];
+  for (const cue of cues) {
+    const plain = stripHtml(cue.text);
+    if (current2.length === 0) {
+      current2.push(cue);
+    } else {
+      const prevPlain = stripHtml(current2[current2.length - 1].text);
+      if (plain === prevPlain) {
+        current2.push(cue);
+      } else {
+        groups.push(current2);
+        current2 = [cue];
+      }
+    }
+  }
+  if (current2.length > 0) groups.push(current2);
+  return groups;
+}
 function CueFrame({
   cue,
   fps,
   CaptionComponent,
-  subtitle
+  subtitle,
+  cueGroup
 }) {
-  const durationInFrames = Math.max(1, Math.floor((cue.endAt - cue.startFrom) * fps));
-  const from = Math.floor(cue.startFrom * fps);
-  const captionText = React46.useMemo(() => supportHtml(cue.text), [cue.text]);
+  const group = cueGroup ?? [cue];
+  const startFrom = group[0].startFrom;
+  const endAt = group[group.length - 1].endAt;
+  const durationInFrames = Math.max(1, Math.floor((endAt - startFrom) * fps));
+  const from = Math.floor(startFrom * fps);
   const textStyle = React46.useMemo(
     () => ({
       ...DEFAULT_TEXT_STYLE,
@@ -45909,7 +45928,33 @@ function CueFrame({
     }),
     [subtitle.fontSize, subtitle.fontFamily, subtitle.fontStyle]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(Sequence, { layout: "none", durationInFrames, from, children: /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(CaptionComponent, { text: captionText, style: textStyle }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(Sequence, { layout: "none", durationInFrames, from, children: /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(
+    GroupedCueInner,
+    {
+      group,
+      fps,
+      CaptionComponent,
+      textStyle
+    }
+  ) });
+}
+function GroupedCueInner({
+  group,
+  fps,
+  CaptionComponent,
+  textStyle
+}) {
+  const frame = useCurrentFrame();
+  const currentTime = frame / fps;
+  let activeCue = group[group.length - 1];
+  for (const c3 of group) {
+    if (currentTime >= c3.startFrom && currentTime < c3.endAt) {
+      activeCue = c3;
+      break;
+    }
+  }
+  const captionText = React46.useMemo(() => supportHtml(activeCue.text), [activeCue.text]);
+  return /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(CaptionComponent, { text: captionText, style: textStyle });
 }
 function SubtitleOverlay({ subtitle }) {
   const { fps } = useVideoConfig();
@@ -45955,15 +46000,17 @@ function SubtitleOverlay({ subtitle }) {
   }, [subtitle.src]);
   if (!cues) return null;
   const boxCss = subtitle.style ? cssJS(subtitle.style) : {};
-  return /* @__PURE__ */ (0, import_jsx_runtime88.jsx)("div", { className: `${subtitle.type || "default"} subtitle-overlay`, style: { ...DEFAULT_BOX_STYLE, ...boxCss }, children: cues.map((cue, i3) => /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(
+  const cueGroups = React46.useMemo(() => groupConsecutiveCues(cues), [cues]);
+  return /* @__PURE__ */ (0, import_jsx_runtime88.jsx)("div", { className: `${subtitle.type || "default"} subtitle-overlay`, style: { ...DEFAULT_BOX_STYLE, ...boxCss }, children: cueGroups.map((group, gi) => /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(
     CueFrame,
     {
-      cue,
+      cue: group[0],
+      cueGroup: group,
       fps,
       CaptionComponent,
       subtitle
     },
-    `${i3}-${cue.startFrom}-${cue.endAt}`
+    `g${gi}-${group[0].startFrom}-${group[group.length - 1].endAt}`
   )) });
 }
 
@@ -59804,15 +59851,13 @@ var video = base.extend({
   volume: external_exports.number().min(0).max(1).default(1),
   playbackRate: external_exports.number().optional(),
   width: external_exports.number().default(1080),
-  height: external_exports.number().default(1920),
-  loop: external_exports.number().int().min(1).optional().describe(">1 = loop count")
+  height: external_exports.number().default(1920)
 });
 var audio = base.extend({
   type: external_exports.literal("audio").default("audio"),
   src: external_exports.string().optional(),
   volume: external_exports.number().min(0).max(1).default(1),
   foreground: external_exports.boolean().optional().describe("ducks parent video audio while playing"),
-  loop: external_exports.number().int().min(1).optional().describe(">1 = loop count"),
   speaker: external_exports.string().optional().describe("speaker name for multi-turn dialogue; set by resolveDialogue")
 });
 var image = base.extend({
@@ -60361,8 +60406,8 @@ function SceneThumbnails({ currentTime, onSeek }) {
   }, []);
   if (scenes.length === 0) return null;
   let activeIdx = -1;
-  for (let i3 = 0; i3 < scenes.length; i3++) {
-    if (currentTime >= scenes[i3].start && currentTime < scenes[i3].end) {
+  for (let i3 = scenes.length - 1; i3 >= 0; i3--) {
+    if (currentTime >= scenes[i3].start) {
       activeIdx = i3;
       break;
     }
@@ -60498,9 +60543,9 @@ function PlayerApp() {
     const scenes = window.__scenes;
     if (!scenes) return;
     let found = "";
-    for (const s2 of scenes) {
-      if (currentTime >= s2.start && currentTime < s2.end) {
-        found = s2.name || "";
+    for (let i3 = scenes.length - 1; i3 >= 0; i3--) {
+      if (currentTime >= scenes[i3].start) {
+        found = scenes[i3].name || "";
         break;
       }
     }
@@ -60555,10 +60600,20 @@ function PlayerApp() {
   const handleFrameUpdate = React55.useCallback((frame) => {
     currentFrameRef.current = frame;
     setCurrentTime((prev) => {
-      const newTime = frame / (data2?.fps ?? 30);
-      return Math.abs(newTime - prev) > 0.5 ? newTime : prev;
+      const newTime = frame / fps;
+      return Math.abs(newTime - prev) > 0.1 ? newTime : prev;
     });
-  }, [data2?.fps]);
+  }, [fps]);
+  React55.useEffect(() => {
+    const p2 = playerRef.current;
+    if (!p2 || typeof p2.addEventListener !== "function") return;
+    const listener = (e) => {
+      const frame = e?.detail?.frame;
+      if (typeof frame === "number") handleFrameUpdate(frame);
+    };
+    p2.addEventListener("frameupdate", listener);
+    return () => p2.removeEventListener("frameupdate", listener);
+  }, [ready, data2, handleFrameUpdate]);
   React55.useEffect(() => {
     if (!ready || !playerRef.current) return;
     const FWD_SECONDS = 5;
@@ -60567,13 +60622,16 @@ function PlayerApp() {
     function seekRelative(deltaSec) {
       const p2 = playerRef.current;
       if (!p2) return;
-      const frame = p2.getCurrentFrame() + Math.round(deltaSec * fps);
-      p2.seekTo(Math.max(0, frame));
+      const frame = Math.max(0, p2.getCurrentFrame() + Math.round(deltaSec * fps));
+      p2.seekTo(frame);
+      setCurrentTime(frame / fps);
     }
     function seekPercent(pct) {
       const p2 = playerRef.current;
       if (!p2) return;
-      p2.seekTo(Math.round(pct * durationInFrames));
+      const frame = Math.round(pct * durationInFrames);
+      p2.seekTo(frame);
+      setCurrentTime(frame / fps);
     }
     function showHelp() {
       console.log(`%c\u{1F3AC} MarkCut Player Shortcuts
@@ -60746,8 +60804,7 @@ function PlayerApp() {
             allowFullscreen: true,
             clickToPlay: false,
             doubleClickToFullscreen: true,
-            autoPlay,
-            onFrameUpdate: handleFrameUpdate
+            autoPlay
           }
         ) }),
         /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(
@@ -60756,8 +60813,9 @@ function PlayerApp() {
             currentTime,
             onSeek: (t) => {
               if (playerRef.current) {
-                const frame = Math.round(t * (data2?.fps ?? 30));
+                const frame = Math.round(t * fps);
                 playerRef.current.seekTo(frame);
+                setCurrentTime(t);
               }
             }
           }

package/src/player/components/SceneThumbnails.tsx

@@ -35,9 +35,12 @@ export function SceneThumbnails({ currentTime, onSeek }: SceneThumbnailsProps) {
 
   if (scenes.length === 0) return null;
 
+  // With transition overlaps, scenes can overlap in time (scene[i].end > scene[i+1].start).
+  // Iterate backward so the latest scene whose start <= currentTime wins — i.e., as
+  // soon as the next scene starts (during a transition), it becomes the active one.
   let activeIdx = -1;
-  for (let i = 0; i < scenes.length; i++) {
-    if (currentTime >= scenes[i].start && currentTime < scenes[i].end) {
+  for (let i = scenes.length - 1; i >= 0; i--) {
+    if (currentTime >= scenes[i].start) {
       activeIdx = i;
       break;
     }

package/src/player/pipeline.mjs

@@ -259,7 +259,6 @@ function compileLeaf(node2, ctx, parentKind) {
         src: node2.src,
         volume: node2.volume ?? 1,
         foreground: node2.foreground,
-        loop: node2.loop,
         speaker: node2.speaker
       };
       return { stream, duration: end };
@@ -709,8 +708,11 @@ function resolveVariantOverrides(root, variantChain) {
 }
 function compileDescriptiveRoot(input, options = {}) {
   const root = typeof input === "string" ? JSON.parse(input) : input;
-  const resolved = resolveTransition(root.layout ? root.transition ?? root.layout : root.transition, root.transitionTime);
-  const rootKind = root.layout === "parallel" ? "parallel" : "series";
+  const resolved = resolveTransition(
+    root.layout === "transitionSeries" ? root.transition ?? "fade" : root.transition,
+    root.transitionTime
+  );
+  const rootKind = root.layout === "parallel" ? "parallel" : root.layout === "transitionSeries" ? "transitionSeries" : "series";
   const googleMapsApiKey = options.googleMapsApiKey ?? "";
   const ctx = {
     defaults: {
@@ -736,8 +738,8 @@ function compileDescriptiveRoot(input, options = {}) {
     stylesheet: input.stylesheet,
     subtitle: input.subtitle,
     isSeries: rootKind !== "parallel",
-    transition: rootKind === "transitionSeries" ? resolved.name : void 0,
-    transitionTime: rootKind === "transitionSeries" ? resolved.time : 0.5,
+    transition: root.transition || root.layout === "transitionSeries" ? resolved.name : void 0,
+    transitionTime: root.transition || root.layout === "transitionSeries" ? resolved.time : 0.5,
     children: children.map((c) => c.stream),
     durationInSeconds: duration
   };
@@ -10131,7 +10133,6 @@ function preserveVariantAttrs(node2, attrs) {
     "duration",
     "startFrom",
     "endAt",
-    "loop",
     "width",
     "height",
     "fit",
@@ -10264,7 +10265,6 @@ function parseNodeLine(content3, lineNum) {
         endAt: attrs.endAt,
         volume: attrs.volume,
         foreground: attrs.foreground,
-        loop: attrs.loop,
         instruction: attrs.instruction,
         script: attrs.script,
         visible: attrs.visible,
@@ -10594,6 +10594,9 @@ function applyRootAttrs(root, attrs) {
       case "metadata":
         root.metadata = String(v);
         break;
+      case "seed":
+        root.seed = Number(v);
+        break;
       case "stylesheet":
         root.stylesheet = String(v);
         break;
@@ -11148,7 +11151,7 @@ async function resolveAll2(root, options = {}) {
     variant: options.variants?.[0] ?? "video"
   });
   result = await resolveMediaSrcs(result, { baseDir: options.baseDir });
-  const generationSeed = result.seed ?? options.seed;
+  const generationSeed = result.seed ?? options.seed ?? Math.floor(Math.random() * 2147483647);
   if (options.mediaOutputDir) {
     result = await resolveGeneratedMedia(result, {
       outputDir: options.mediaOutputDir,
@@ -11205,6 +11208,7 @@ async function resolveAndCompile(data, options = {}) {
     ttsCli: options.ttsCli,
     sttCli: options.sttCli,
     subtitleOutputDir: options.subtitleOutputDir,
+    seed: options.seed,
     variants: options.variants
   });
   const compiled = compileDescriptiveRoot(resolved, {

package/src/player/pipeline.ts

@@ -36,6 +36,9 @@ export interface ResolveAndCompileOptions {
   /** Separate output dir for the merged subtitles.vtt (e.g., per-variant).
    *  Per-clip VTTs stay in scriptOutputDir; defaults to scriptOutputDir. */
   subtitleOutputDir?: string;
+  /** Global seed for reproducible TTI/TTV generation. Applied when the CLI
+   *  template contains {seed}. Overrides root.seed if set. */
+  seed?: number;
   /** Variant chain to apply to include nodes (e.g. ["zh", "tiktok"]).
    *  When set, included .md files are parsed with variant awareness. */
   variants?: string[];
@@ -90,6 +93,7 @@ export async function resolveAndCompile(
     ttsCli: options.ttsCli,
     sttCli: options.sttCli,
     subtitleOutputDir: options.subtitleOutputDir,
+    seed: options.seed,
     variants: options.variants,
   });
 

package/src/player/server-shared.mjs

@@ -35,24 +35,33 @@ export function extractScenes(root) {
 
   // Format 1: scenes as direct children of root
   if (root.children?.length && !root.children.find(c => c.name === "scenes" || c.id === "scenes")) {
-    let offset = 0;
+    const overlap = root.transition ? (root.transitionTime ?? 0.5) : 0;
+    let offset = 0; // cumulative scene durations (without transition overlap)
     for (const s of root.children) {
       if (!(s.type === "folder" || s.type === "scene" || s.children?.length)) continue;
       if (s.isBackground) continue;
+      // Use durationInSeconds (set by compiler) as the definitive duration.
+      // Fall back to leaf end-start for backward compatibility.
       const leaf = (s.children || []).find(c => c.src && (c.type === "image" || c.type === "video"));
-      const src2 = leaf || s;
-      const dur = (src2.end ?? 5) - (src2.start ?? 0);
+      let dur = s.durationInSeconds;
+      if (!dur || dur <= 0) {
+        const src2 = leaf || s;
+        dur = (src2.end ?? 5) - (src2.start ?? 0);
+      }
+      // Account for transition overlap: scene i starts at offset - i*overlap
+      const transitionOffset = scenes.length * overlap;
+      const start = Math.max(0, offset - transitionOffset);
       scenes.push({
         name: s.name || s.id || "scene",
-        start: offset,
-        end: offset + dur,
+        start,
+        end: start + dur,
         duration: dur,
         src: leaf?.src || "",
         mediaType: leaf?.type || "unknown",
       });
       offset += dur;
     }
-    totalDuration = offset;
+    totalDuration = offset - Math.max(0, (scenes.length - 1)) * overlap;
   }
 
   // Format 2: scenes wrapped in a "scenes" folder

package/src/render/cli.mjs

@@ -21,12 +21,6 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const ROOT = resolve(__dirname, "../..");
 
-const ASPECTS = {
-  "16x9": { width: 1920, height: 1080 },
-  "9x16": { width: 1080, height: 1920 },
-  "1x1": { width: 1080, height: 1080 },
-};
-
 /**
  * How many "Rendered X/Y" lines to skip before printing one.
  * E.g. 50 means print every 50th frame — for 1860 frames that's ~37 lines.
@@ -52,6 +46,7 @@ markcut CLI — Markdown/JSON → video pipeline
 npx @lalalic/markcut <command> [options]
 
 global options:
+  --dev                                Use development build (unminified React error messages)
   --show-clis                          Print all default CLI templates and exit
 
   --tti <template>                     Override default TTI CLI template
@@ -92,7 +87,7 @@ Commands:
 
 
 /**
- * Render one aspect ratio with compact progress output.
+ * Render a stream tree to an MP4 video with compact progress output.
  *
  * In compact mode (default), "Rendered X/Y" lines are shown only every
  * PROGRESS_INTERVAL frames and at the final frame, drastically reducing
@@ -100,28 +95,49 @@ Commands:
  *
  * Use --verbose to see every frame line (original behavior).
  */
+
+/**
+ * Resolve a potentially relative source path against baseDir, skipping
+ * absolute paths, URLs, and data URIs.
+ */
+function resolveAssetPath(src, baseDir) {
+  if (!src || typeof src !== "string") return null;
+  // Already absolute on disk
+  if (src.startsWith("/")) return src;
+  // URL or data URI — can't stage locally
+  if (/^(https?:|data:|blob:)/.test(src)) return null;
+  // Relative path: resolve against the input file's directory
+  const abs = resolve(baseDir, src);
+  if (existsSync(abs)) return abs;
+  return null;
+}
+
 /**
- * Stage local absolute-path assets (TTS audio, TTI/TTV media, subtitles from
- * .markcut/) into ROOT/public/.render-assets/ and rewrite srcs to relative
- * paths, so `npx remotion render` (publicDir = ROOT/public) can serve them.
- * The preview server handles these paths via multi-root serving; the render
- * CLI needs them staged into the one public dir Remotion knows about.
+ * Stage all local src files (absolute and relative) into
+ * ROOT/public/.render-assets/ so `npx remotion render` (publicDir = ROOT/public)
+ * can serve them. Relative paths are resolved against `baseDir` (the input
+ * file's directory). The preview server handles these paths via multi-root
+ * serving; the render CLI needs them staged into the one public dir Remotion
+ * knows about.
  */
-function stageLocalAssets(tree) {
+function stageLocalAssets(tree, baseDir) {
   const assetsDir = join(ROOT, "public", ".render-assets");
   const seen = new Map();
   const walk = (node) => {
     if (!node || typeof node !== "object") return;
-    if (typeof node.src === "string" && node.src.startsWith("/") && !node.src.startsWith("//") && existsSync(node.src)) {
-      let staged = seen.get(node.src);
-      if (!staged) {
-        const name = createHash("md5").update(node.src).digest("hex").slice(0, 12) + extname(node.src);
-        mkdirSync(assetsDir, { recursive: true });
-        copyFileSync(node.src, join(assetsDir, name));
-        staged = `.render-assets/${name}`;
-        seen.set(node.src, staged);
+    if (typeof node.src === "string") {
+      const absPath = resolveAssetPath(node.src, baseDir);
+      if (absPath) {
+        let staged = seen.get(absPath);
+        if (!staged) {
+          const name = createHash("md5").update(absPath).digest("hex").slice(0, 12) + extname(absPath);
+          mkdirSync(assetsDir, { recursive: true });
+          copyFileSync(absPath, join(assetsDir, name));
+          staged = `.render-assets/${name}`;
+          seen.set(absPath, staged);
+        }
+        node.src = staged;
       }
-      node.src = staged;
     }
     for (const value of Object.values(node)) {
       if (value && typeof value === "object") walk(value);
@@ -131,21 +147,24 @@ function stageLocalAssets(tree) {
   return tree;
 }
 
-function renderOne(streamTree, aspect, outputPath, verbose) {
-  const dims = ASPECTS[aspect];
-  if (!dims) throw new Error(`Unknown aspect: ${aspect}`);
-
-  const adapted = stageLocalAssets(JSON.parse(JSON.stringify({ ...streamTree, width: dims.width, height: dims.height })));
-  const tmpProps = join(ROOT, ".tmp", `render-${aspect}.json`);
+function renderOne(streamTree, outputPath, verbose, baseDir) {
+  const adapted = stageLocalAssets(JSON.parse(JSON.stringify(streamTree)), baseDir);
+  const tmpProps = join(ROOT, ".tmp", "render-stream.json");
   mkdirSync(dirname(tmpProps), { recursive: true });
   writeFileSync(tmpProps, JSON.stringify({ root: adapted }));
 
   mkdirSync(dirname(outputPath), { recursive: true });
 
-  console.log(`\n▶ Rendering ${aspect} → ${outputPath}`);
+console.log(`\n▶ Rendering → ${outputPath}`);
 
   return new Promise((resolvePromise, reject) => {
-    const proc = spawn("npx", ["remotion", "render", "Root", outputPath, "--props", tmpProps, "--config", "remotion.config.ts"], { cwd: ROOT, stdio: ["ignore", "inherit", "pipe"] });
+    // Pass NODE_ENV=development to get unminified React error messages (--dev flag)
+    const spawnOpts = { cwd: ROOT, stdio: ["ignore", "inherit", "pipe"] };
+    // args is imported from config.mjs — check dev flag there
+    if (args.dev) {
+      spawnOpts.env = { ...process.env, NODE_ENV: "development" };
+    }
+    const proc = spawn("npx", ["remotion", "render", "Root", outputPath, "--props", tmpProps, "--config", "remotion.config.ts"], spawnOpts);
 
     let lastLoggedFrame = 0;
     let totalFrames = 0;
@@ -401,7 +420,8 @@ edit=${DEFAULT_EDIT_CLI}`);
     }
 
     const output = args.output ? resolve(args.output) : join(ROOT, "out", "video.mp4");
-    await renderOne(streamTree, "16x9", output, args.verbose);
+    const fileDir = dirname(resolve(args.file));
+    await renderOne(streamTree, output, args.verbose, fileDir);
 
     console.log("\n✅ Render complete.");
     process.exit(0);
@@ -441,12 +461,27 @@ function hasScript(root) {
     emitInfo(`File: ${filePath}`);
     emitInfo(`Format: ${isMarkdown ? "Markdown" : "JSON"}`);
 
-    const { compileDescriptiveRoot, parseMarkdownDescriptive, parseImportsBlock } = await import("../player/pipeline.mjs");
+    const { compileDescriptiveRoot, parseMarkdownDescriptive, parseMarkdownVariants, parseImportsBlock } = await import("../player/pipeline.mjs");
 
     try {
       let descriptive, needsTti, needsTtv;
       if (isMarkdown) {
         descriptive = parseMarkdownDescriptive(raw);
+
+        // Check if content accidentally went into a variant section
+        // (happens when root heading is e.g. "# My Movie" instead of "# video")
+        const hasChildren = (descriptive.children?.length ?? 0) > 0;
+        if (!hasChildren) {
+          const variantResult = parseMarkdownVariants(raw);
+          const variantNames = [...variantResult.variants.keys()];
+          const variantChildren = variantNames.filter(n => (variantResult.variants.get(n)?.children?.length ?? 0) > 0);
+          if (variantChildren.length > 0) {
+            warnings.push(
+              `No scenes found in the main section (use '# video' as the root heading). ` +
+              `Content appears in variant section(s): ${variantChildren.join(", ")}`,
+            );
+          }
+        }
       } else {
         const parsed = JSON.parse(raw);
         const root = parsed.root ?? parsed;

package/src/schema/index.ts

@@ -104,7 +104,6 @@ export const video = base.extend({
   playbackRate: z.number().optional(),
   width: z.number().default(1080),
   height: z.number().default(1920),
-  loop: z.number().int().min(1).optional().describe(">1 = loop count"),
 });
 export type Video = z.infer<typeof video>;
 
@@ -113,7 +112,6 @@ export const audio = base.extend({
   src: z.string().optional(),
   volume: z.number().min(0).max(1).default(1),
   foreground: z.boolean().optional().describe("ducks parent video audio while playing"),
-  loop: z.number().int().min(1).optional().describe(">1 = loop count"),
   speaker: z.string().optional().describe("speaker name for multi-turn dialogue; set by resolveDialogue"),
 });
 export type Audio = z.infer<typeof audio>;

package/src/types/Audio.tsx

@@ -24,7 +24,7 @@ export function AudioLeaf({ stream }: { stream: Audio }) {
   const startFrom = stream.startFrom ?? 0;
   const endAt = stream.endAt ?? totalDur;
   const volume = stream.volume ?? 1;
-  const playbackRate = stream.loop ? 1 : toPlaybackRate((endAt - startFrom) / (end - start));
+  const playbackRate = toPlaybackRate((endAt - startFrom) / (end - start));
   return (
     <Sequence
       name={stream.src ?? "audio"}
@@ -39,7 +39,6 @@ export function AudioLeaf({ stream }: { stream: Audio }) {
         endAt={Math.floor(startFrom * fps) + Math.floor(((endAt - startFrom) * fps) / playbackRate)}
         muted={volume === 0 || !!ctx?.foreground}
         volume={volume}
-        loop={(stream.loop ?? 1) > 1}
         playbackRate={playbackRate}
         showInTimeline={false}
       />

package/src/types/Include.tsx

@@ -5,15 +5,8 @@ import { cssJS, toClassName, getDurationInSeconds, type DurationStream } from ".
 import type { Include as IncludeStream, Root } from "../schema/index";
 import { FolderLeaf } from "./Folder";
 
-// Aspect dimensions for scene-based video content
-const ASPECT_DIMS: Record<string, { width: number; height: number }> = {
-  "16x9": { width: 1920, height: 1080 },
-  "9x16": { width: 1080, height: 1920 },
-  "1x1": { width: 1080, height: 1080 },
-};
-
 interface SceneBasedVideo {
-  meta: { title: string; fps: number; aspects?: string[] };
+  meta: { title: string; fps: number };
   voiceover?: { tts: string; voice: string };
   bgm?: { src: string; baseVolume: number };
   scenes: Array<{
@@ -207,9 +200,8 @@ export function IncludeLeaf({ stream }: { stream: IncludeStream }) {
       // ── Scene-based video.json ──────────────────────────────────
       const vj = externalData;
       const vjFps = vj.meta.fps ?? parentFps;
-      // Use first aspect's dimensions (default to 16x9)
-      const aspectKey = (vj.meta.aspects?.[0] ?? "16x9") as keyof typeof ASPECT_DIMS;
-      const dims = ASPECT_DIMS[aspectKey] ?? { width: parentWidth, height: parentHeight };
+      // Use parent composition dimensions (dimensions come from the stream file)
+      const dims = { width: parentWidth, height: parentHeight };
 
       return (
         <AbsoluteFill style={{ backgroundColor: "#0a0a0a", width: dims.width, height: dims.height }}>