hyper-animator-codex 0.7.0 → 0.8.0

package/skills/hyper-animator-codex/references/shotcraft/source/template/src/aifl/live/SceneWbr.tsx

@@ -0,0 +1,299 @@
+import { interpolate, useCurrentFrame, Easing } from 'remotion';
+import { PageCam, CamKey } from './PageCam';
+import layout from '../live-layout.json';
+
+type Block = { x: number; y: number; w: number; h: number; tag: string };
+const blocks = layout.wbr.blocks as Block[];
+const leftRail = layout.wbr.leftRail;
+const rightRail = layout.wbr.rightRail;
+const PAGE_H = layout.wbr.pageH;
+
+const MONO = 'ui-monospace, SFMono-Regular, Menlo, monospace';
+const PAPER = '#fdfcfa';
+const AMBER = 'oklch(52% 0.115 65)';
+const AMBER_WASH = 'oklch(95% 0.05 85)';
+
+// editor-title close-up → ease out to the whole page (both rails on camera)
+// → tiny breathing hold.
+const CAM_KEYS: CamKey[] = [
+  { frame: 0, cx: 920, cy: 280, zoom: 1.25 },
+  { frame: 22, cx: 920, cy: 310, zoom: 1.21 }, // slow push while the title writes in
+  { frame: 64, cx: 960, cy: 540, zoom: 0.997 }, // whole page, rails fully in frame
+  { frame: 78, cx: 960, cy: 540, zoom: 1.003 }, // micro-breath
+  { frame: 102, cx: 960, cy: 540, zoom: 0.995 }, // exhale — whole-page reading hold
+];
+
+const REVEAL_EASE = Easing.bezier(0.4, 0, 0.6, 1);
+
+// 20 content blocks would overshoot the 70-frame reveal budget one-by-one, so
+// blocks are revealed two at a time: pair g starts at 6 + g*3.5, 8 frames each
+// (last pair done by ~49, well before the frame-64 full-page settle).
+const cueFor = (i: number) => 6 + Math.floor(i / 2) * 3.5;
+const WIPE = 8;
+
+// ---- past weeks stack into the left rail: the captured texture only holds
+// the live W28 entry, so W27…W22 drop in from above one after another (list
+// stacking, same vocabulary as the papers shot), landing below it. ----
+const SANS = 'ui-sans-serif, system-ui, -apple-system, sans-serif';
+const PAST_WEEKS = [
+  { week: '2026 第 27 周', date: '7月3日', title: '2026-W27 · Foundation Lab Weekly' },
+  { week: '2026 第 26 周', date: '6月26日', title: '2026-W26 · Foundation Lab Weekly' },
+  { week: '2026 第 25 周', date: '6月19日', title: '2026-W25 · Foundation Lab Weekly' },
+  { week: '2026 第 24 周', date: '6月12日', title: '2026-W24 · Foundation Lab Weekly' },
+  { week: '2026 第 23 周', date: '6月5日', title: '2026-W23 · Foundation Lab Weekly' },
+  { week: '2026 第 22 周', date: '5月29日', title: '2026-W22 · Foundation Lab Weekly' },
+];
+const WEEK_Y0 = 228; // just under the baked-in W28 entry
+const WEEK_H = 56;
+const WEEK_CUE = (i: number) => 58 + i * 5; // after the left rail wipes on (46–56)
+const WEEK_DROP = Easing.bezier(0.2, 1.15, 0.3, 1); // drop with a light bounce
+
+// member-name headings (tag=h2) get the @-mention amber wash; the pinned
+// "Jackie's Download" digest heading (the first h2) is not a member name.
+const memberH2 = new Set<number>();
+{
+  let seenH2 = 0;
+  blocks.forEach((b, i) => {
+    if (b.tag === 'h2' && seenH2++ > 0) memberH2.add(i);
+  });
+}
+
+/** Weekly brief: the full report is "written" in block by block (paper mask
+ * wipes left→right behind an amber caret), member names get an @-mention amber
+ * wash, then the week list (left) and comment sidebar (right) wipe on stage —
+ * the whole page, both rails included, settles into frame. */
+export const SceneWbr: React.FC = () => {
+  const frame = useCurrentFrame();
+
+  // screen-space kicker stamps in
+  const kick = interpolate(frame, [8, 16], [0, 1], {
+    extrapolateLeft: 'clamp',
+    extrapolateRight: 'clamp',
+  });
+
+  // caret follows only the newest block still being written
+  let caretIdx = -1;
+  blocks.forEach((_, i) => {
+    if (frame >= cueFor(i) && frame <= cueFor(i) + WIPE + 2) caretIdx = i;
+  });
+
+  return (
+    <>
+      <PageCam src="textures/live/wbr-full.png" pageH={PAGE_H} keys={CAM_KEYS} ease={Easing.bezier(0.33, 0, 0.15, 1)}>
+        {blocks.map((p, i) => {
+          const cue = cueFor(i);
+          // paper cover wipes away left→right (anchored right, width 100%→0)
+          const coverT = interpolate(frame, [cue, cue + WIPE], [1, 0], {
+            extrapolateLeft: 'clamp',
+            extrapolateRight: 'clamp',
+            easing: REVEAL_EASE,
+          });
+          // li boxes exclude their ::marker dot (drawn ~22px left of the text),
+          // so bullet covers extend left to hide the dot until the wipe.
+          const bx = p.tag === 'li' ? p.x - 28 : p.x - 4;
+          const by = p.y - 3;
+          const bw = p.w + (p.tag === 'li' ? 34 : 10);
+          const bh = p.h + 6;
+
+          // caret rides the reveal front edge (left edge of the cover)
+          const caretX = bx + bw * (1 - coverT);
+          const caretH = Math.min(20, p.h - 2);
+
+          // member-name @-mention wash, 4 frames after the wipe completes,
+          // sized to the heading's true text width
+          const nameCue = cue + WIPE + 4;
+          const nameGrow = memberH2.has(i)
+            ? interpolate(frame, [nameCue, nameCue + 8], [0, 1], {
+                extrapolateLeft: 'clamp',
+                extrapolateRight: 'clamp',
+                easing: Easing.bezier(0.3, 0, 0.2, 1),
+              })
+            : 0;
+
+          return (
+            <div key={i}>
+              {/* @-mention wash on the member name (under the cover) */}
+              {nameGrow > 0 ? (
+                <div
+                  style={{
+                    position: 'absolute',
+                    left: p.x - 3,
+                    top: p.y - 1,
+                    width: (p.w + 8) * nameGrow,
+                    height: p.h + 2,
+                    background: AMBER_WASH,
+                    opacity: 0.7,
+                    borderRadius: 3,
+                    pointerEvents: 'none',
+                  }}
+                />
+              ) : null}
+
+              {/* paper cover that wipes off to reveal the "written" text */}
+              {coverT > 0 ? (
+                <div
+                  style={{
+                    position: 'absolute',
+                    left: bx,
+                    top: by,
+                    width: bw,
+                    height: bh,
+                    overflow: 'hidden',
+                    pointerEvents: 'none',
+                  }}
+                >
+                  <div
+                    style={{
+                      position: 'absolute',
+                      right: 0,
+                      top: 0,
+                      bottom: 0,
+                      width: `${coverT * 100}%`,
+                      background: PAPER,
+                    }}
+                  />
+                </div>
+              ) : null}
+
+              {/* amber caret at the writing front — newest block only */}
+              {i === caretIdx ? (
+                <div
+                  style={{
+                    position: 'absolute',
+                    left: caretX,
+                    top: p.y + (p.h - caretH) / 2,
+                    width: 2,
+                    height: caretH,
+                    background: AMBER,
+                    opacity:
+                      coverT > 0
+                        ? 1
+                        : interpolate(frame, [cue + WIPE, cue + WIPE + 2], [1, 0], {
+                            extrapolateLeft: 'clamp',
+                            extrapolateRight: 'clamp',
+                          }),
+                    pointerEvents: 'none',
+                  }}
+                />
+              ) : null}
+            </div>
+          );
+        })}
+
+        {/* side-rail entrances: each rail hides under a paper patch, then wipes
+            on top→bottom while its inner edge lights up amber and fades. */}
+        {[
+          { rail: leftRail, cue: 46, inner: 'right' as const },
+          { rail: rightRail, cue: 54, inner: 'left' as const },
+        ].map(({ rail, cue, inner }, i) => {
+          const t = interpolate(frame, [cue, cue + 10], [0, 1], {
+            extrapolateLeft: 'clamp',
+            extrapolateRight: 'clamp',
+            easing: Easing.bezier(0.3, 0, 0.2, 1),
+          });
+          const lineFade = interpolate(frame, [cue + 10, cue + 24], [1, 0], {
+            extrapolateLeft: 'clamp',
+            extrapolateRight: 'clamp',
+          });
+          return (
+            <div key={`rail${i}`}>
+              {/* paper patch shrinking downward = rail revealed top→bottom */}
+              {t < 1 ? (
+                <div
+                  style={{
+                    position: 'absolute',
+                    left: rail.x,
+                    top: rail.y + rail.h * t,
+                    width: rail.w,
+                    height: rail.h * (1 - t),
+                    background: PAPER,
+                    pointerEvents: 'none',
+                  }}
+                />
+              ) : null}
+              {/* inner-edge amber line: grows with the wipe, then fades */}
+              {frame >= cue && lineFade > 0 ? (
+                <div
+                  style={{
+                    position: 'absolute',
+                    left: inner === 'right' ? rail.x + rail.w - 1.5 : rail.x,
+                    top: rail.y,
+                    width: 1.5,
+                    height: rail.h * t,
+                    background: AMBER,
+                    opacity: lineFade,
+                    pointerEvents: 'none',
+                  }}
+                />
+              ) : null}
+            </div>
+          );
+        })}
+        {/* past weeks drop into the left rail from above, stacking in order */}
+        {PAST_WEEKS.map((w, i) => {
+          const cue = WEEK_CUE(i);
+          if (frame < cue) return null;
+          const t = interpolate(frame, [cue, cue + 8], [0, 1], {
+            extrapolateLeft: 'clamp',
+            extrapolateRight: 'clamp',
+            easing: WEEK_DROP,
+          });
+          const appear = interpolate(frame, [cue, cue + 3], [0, 1], {
+            extrapolateLeft: 'clamp',
+            extrapolateRight: 'clamp',
+          });
+          const air = Math.max(0, 1 - t);
+          return (
+            <div
+              key={w.week}
+              style={{
+                position: 'absolute',
+                left: 4,
+                top: WEEK_Y0 + i * WEEK_H,
+                width: leftRail.w - 8,
+                height: WEEK_H,
+                transform: `translateY(${-44 * air}px)`,
+                opacity: appear,
+                boxShadow: air > 0.02 ? `0 ${10 * air}px ${20 * air}px rgba(30,25,18,${0.16 * air})` : 'none',
+                background: PAPER,
+                borderBottom: '1px solid rgba(31,41,55,0.07)',
+                padding: '8px 10px 0',
+                boxSizing: 'border-box',
+                fontFamily: SANS,
+                pointerEvents: 'none',
+              }}
+            >
+              <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'baseline' }}>
+                <span style={{ fontSize: 13, fontWeight: 500, color: '#1f2937' }}>{w.week}</span>
+                <span style={{ fontSize: 10, color: '#9ca3af' }}>{w.date}</span>
+              </div>
+              <div style={{ marginTop: 2, fontSize: 11, color: '#6b7280', whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis' }}>
+                {w.title}
+              </div>
+            </div>
+          );
+        })}
+      </PageCam>
+
+      {/* screen-space kicker, top-right */}
+      <div
+        style={{
+          position: 'absolute',
+          top: 16, // inside the page's empty top-nav band at full-page framing,
+          right: 96, // clear of the comment rail's own header
+
+          textAlign: 'right',
+          fontFamily: MONO,
+          fontSize: 24,
+          letterSpacing: '0.14em',
+          color: 'oklch(50% 0.006 82)',
+          textTransform: 'uppercase',
+          opacity: kick,
+          pointerEvents: 'none',
+        }}
+      >
+        Weekly Brief · 2026-W28
+      </div>
+    </>
+  );
+};

package/skills/hyper-animator-codex/references/shotcraft/source/template/src/index.ts

@@ -0,0 +1,4 @@
+import { registerRoot } from 'remotion';
+import { Root } from './Root';
+
+registerRoot(Root);

package/skills/hyper-animator-codex/references/shotcraft/source-notes.md

@@ -0,0 +1,10 @@
+# ShotCraft reference bundle
+
+This is a lightweight, read-only knowledge layer derived from video-shotcraft
+revision `bdd94be16d60fa8f` under Apache-2.0.
+
+It contains 106 shot cards, 164 style
+records, core production notes, and TypeScript/TSX references. Preview video,
+audio, raster media, dependencies, and a runnable Remotion project are
+intentionally excluded. Use `scripts/query_shotcraft.mjs` to select
+references, then author the final output as HyperFrames HTML.

package/skills/hyper-animator-codex/scripts/generate_minimax_music.mjs

@@ -11,6 +11,7 @@ import {
 } from "./minimax_runtime_config.mjs";
 
 const DEFAULT_ENDPOINT = "https://api.minimaxi.com/v1/music_generation";
+const PROVIDER = "minimax_cn";
 const scriptDir = dirname(fileURLToPath(import.meta.url));
 const skillRoot = dirname(scriptDir);
 
@@ -107,7 +108,7 @@ Options:
   --format <mp3|wav|pcm>       Audio encoding format, default mp3
   --sample-rate <rate>         16000, 24000, 32000, or 44100; default 44100
   --bitrate <bits>             32000, 64000, 128000, or 256000; default 256000
-  --model <model>              music-2.6 or music-2.6-free
+  --model <model>              music-3.0, music-2.6, or music-2.6-free
   --config <file>              Explicit MiniMax config JSON
   --request-json <file>        Read request options from a JSON file
   --dry-run                    Print redacted request without contacting MiniMax
@@ -147,18 +148,32 @@ function mergeOptions(jsonOptions, cliOptions) {
 }
 
 function endpointFromEnv(env = process.env) {
-  return env.MINIMAX_MUSIC_ENDPOINT || DEFAULT_ENDPOINT;
+  const endpoint = env.MINIMAX_MUSIC_ENDPOINT || DEFAULT_ENDPOINT;
+  if (!URL.canParse(endpoint)) {
+    throw minimaxError(`MiniMax mainland China endpoint is not a valid URL: ${endpoint}`, {
+      kind: "validation",
+      retryable: false,
+    });
+  }
+  if (endpoint !== DEFAULT_ENDPOINT && env.MINIMAX_ALLOW_TEST_ENDPOINT !== "1") {
+    throw minimaxError(`MiniMax music generation must use the mainland China endpoint ${DEFAULT_ENDPOINT}`, {
+      kind: "validation",
+      retryable: false,
+    });
+  }
+  return endpoint;
 }
 
 function timeoutFromEnv(env = process.env) {
-  const value = Number.parseInt(env.MINIMAX_REQUEST_TIMEOUT_MS || "60000", 10);
+  const value = Number.parseInt(env.MINIMAX_REQUEST_TIMEOUT_MS || "1800000", 10);
   return Number.isFinite(value) && value > 0 ? value : 60000;
 }
 
 function makeErrorEnvelope(error, attempts = 0) {
   return {
     ok: false,
-    provider: "minimax",
+    provider: PROVIDER,
+    region: "cn",
     error: {
       kind: error.kind || "validation",
       message: error.message,
@@ -431,7 +446,8 @@ async function writeAudioOutput({ responseJson, request, outputDir, prompt, endp
   await writeFile(
     metadataPath,
     `${JSON.stringify({
-      provider: "minimax",
+      provider: PROVIDER,
+      region: "cn",
       endpoint,
       request,
       response: {
@@ -456,13 +472,12 @@ async function writeAudioOutput({ responseJson, request, outputDir, prompt, endp
 async function main() {
   try {
     const cliOptions = parseArgs(process.argv.slice(2));
-    const endpoint = endpointFromEnv();
-    const timeoutMs = timeoutFromEnv();
-
     if (cliOptions.help) {
       printHelp();
       return;
     }
+    const endpoint = endpointFromEnv();
+    const timeoutMs = timeoutFromEnv();
 
     const requestJson = await readRequestJson(cliOptions.request_json);
     const options = mergeOptions(requestJson, cliOptions);
@@ -499,7 +514,8 @@ async function main() {
       printJson({
         ok: true,
         dry_run: true,
-        provider: "minimax",
+        provider: PROVIDER,
+        region: "cn",
         endpoint,
         config: {
           source: runtime.source,
@@ -527,7 +543,8 @@ async function main() {
 
     printJson({
       ok: true,
-      provider: "minimax",
+      provider: PROVIDER,
+      region: "cn",
       model: request.model,
       attempts,
       output_path: output.audioPath,

package/skills/hyper-animator-codex/scripts/generate_minimax_tts.mjs

@@ -10,6 +10,9 @@ import {
 
 const DEFAULT_TTS_ENDPOINT = "https://api.minimaxi.com/v1/t2a_v2";
 const DEFAULT_VOICE_ENDPOINT = "https://api.minimaxi.com/v1/get_voice";
+const BACKUP_TTS_ENDPOINT = "https://api-bj.minimaxi.com/v1/t2a_v2";
+const BACKUP_VOICE_ENDPOINT = "https://api-bj.minimaxi.com/v1/get_voice";
+const PROVIDER = "minimax_cn";
 const DEFAULT_TTS_MODEL = "speech-2.8-hd";
 const DEFAULT_VOICE_ID = "XiaoR_001";
 const EMOTIONS = new Set(["happy", "sad", "angry", "fearful", "disgusted", "surprised", "calm", "fluent", "whipser"]);
@@ -46,6 +49,7 @@ function parseArgs(args) {
     pitch: undefined,
     subtitle_enable: undefined,
     config_path: undefined,
+    split_scenes: false,
     dry_run: false,
   };
 
@@ -106,6 +110,8 @@ function parseArgs(args) {
     } else if (arg === "--config") {
       parsed.config_path = requireValue(args, index, arg);
       index += 1;
+    } else if (arg === "--split-scenes") {
+      parsed.split_scenes = true;
     } else if (arg === "--dry-run") {
       parsed.dry_run = true;
     } else if (arg === "--help" || arg === "-h") {
@@ -142,6 +148,7 @@ Options:
   --volume <value>           Default 1
   --pitch <value>            Default 0
   --subtitle-enable          Ask MiniMax to include subtitle data when available
+  --split-scenes             Generate one file per narration scene and an exact timing manifest
   --config <file>            Explicit MiniMax config JSON
   --dry-run                  Print redacted request without contacting MiniMax
 `);
@@ -160,7 +167,8 @@ function minimaxError(message, fields = {}) {
 function makeErrorEnvelope(error, attempts = 0) {
   return {
     ok: false,
-    provider: "minimax",
+    provider: PROVIDER,
+    region: "cn",
     error: {
       kind: error.kind || "validation",
       message: error.message,
@@ -280,14 +288,34 @@ function buildTtsRequest(options) {
 }
 
 function endpointFromEnv(env = process.env) {
+  const tts = env.MINIMAX_TTS_ENDPOINT || DEFAULT_TTS_ENDPOINT;
+  const voice = env.MINIMAX_VOICE_ENDPOINT || DEFAULT_VOICE_ENDPOINT;
+  const allowTest = env.MINIMAX_ALLOW_TEST_ENDPOINT === "1";
+
+  for (const [label, endpoint, allowed] of [
+    ["TTS", tts, [DEFAULT_TTS_ENDPOINT, BACKUP_TTS_ENDPOINT]],
+    ["voice", voice, [DEFAULT_VOICE_ENDPOINT, BACKUP_VOICE_ENDPOINT]],
+  ]) {
+    if (!URL.canParse(endpoint)) {
+      throw minimaxError(`MiniMax mainland China ${label} endpoint is not a valid URL: ${endpoint}`, {
+        kind: "validation",
+      });
+    }
+    if (!allowTest && !allowed.includes(endpoint)) {
+      throw minimaxError(`MiniMax ${label} requests must use a mainland China minimaxi.com endpoint`, {
+        kind: "validation",
+      });
+    }
+  }
+
   return {
-    tts: env.MINIMAX_TTS_ENDPOINT || DEFAULT_TTS_ENDPOINT,
-    voice: env.MINIMAX_VOICE_ENDPOINT || DEFAULT_VOICE_ENDPOINT,
+    tts,
+    voice,
   };
 }
 
 function timeoutFromEnv(env = process.env) {
-  const value = Number.parseInt(env.MINIMAX_REQUEST_TIMEOUT_MS || "60000", 10);
+  const value = Number.parseInt(env.MINIMAX_REQUEST_TIMEOUT_MS || "1800000", 10);
   return Number.isFinite(value) && value > 0 ? value : 60000;
 }
 
@@ -392,7 +420,7 @@ function safeFileStem(value) {
   return stem || "minimax-tts";
 }
 
-async function writeTtsOutput({ responseJson, request, outputDir, endpoint }) {
+async function writeTtsOutput({ responseJson, request, outputDir, endpoint, fileStem }) {
   if (responseJson.data?.status !== 2) {
     throw minimaxError(`MiniMax TTS generation is not complete; data.status is ${responseJson.data?.status}`, { kind: "provider" });
   }
@@ -401,15 +429,16 @@ async function writeTtsOutput({ responseJson, request, outputDir, endpoint }) {
   }
 
   await mkdir(outputDir, { recursive: true });
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const extension = request.audio_setting.format === "pcm" ? "pcm" : request.audio_setting.format;
-  const stem = `${safeFileStem(request.voice_setting.voice_id)}-${timestamp}`;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const stem = fileStem || `${safeFileStem(request.voice_setting.voice_id)}-${timestamp}`;
   const audioPath = join(outputDir, `${stem}.${extension}`);
   const metadataPath = join(outputDir, `${stem}.minimax-tts.json`);
 
   await writeFile(audioPath, decodeHexAudio(responseJson.data.audio));
   await writeFile(metadataPath, `${JSON.stringify({
-    provider: "minimax",
+    provider: PROVIDER,
+    region: "cn",
     endpoint,
     request,
     response: {
@@ -467,7 +496,8 @@ async function listVoices(options, runtime, endpoints, timeoutMs) {
 
   return {
     ok: true,
-    provider: "minimax",
+    provider: PROVIDER,
+    region: "cn",
     endpoint: endpoints.voice,
     voice_type: options.voice_type,
     config: {
@@ -479,16 +509,84 @@ async function listVoices(options, runtime, endpoints, timeoutMs) {
   };
 }
 
+async function generateSplitScenes({
+  narration,
+  options,
+  runtime,
+  endpoint,
+  timeoutMs,
+  narrationPath,
+}) {
+  if (!narration) {
+    throw minimaxError("--split-scenes requires --narration-json", { kind: "validation" });
+  }
+
+  await mkdir(options.output_dir, { recursive: true });
+  const scenes = [];
+  let elapsedMs = 0;
+
+  for (let index = 0; index < narration.scenes.length; index += 1) {
+    const scene = narration.scenes[index];
+    const sceneOptions = { ...options, text: scene.narration.trim() };
+    validateOptions(sceneOptions);
+    const request = buildTtsRequest(sceneOptions);
+    const responseJson = await postMiniMax(runtime.config, endpoint, request, timeoutMs);
+    const output = await writeTtsOutput({
+      responseJson,
+      request,
+      outputDir: options.output_dir,
+      endpoint,
+      fileStem: `scene-${String(index + 1).padStart(3, "0")}`,
+    });
+    const durationMs = Number(responseJson.extra_info?.audio_length);
+    if (!Number.isFinite(durationMs) || durationMs <= 0) {
+      throw minimaxError(`MiniMax scene ${index + 1} did not return extra_info.audio_length`, {
+        kind: "response",
+      });
+    }
+
+    scenes.push({
+      scene: scene.scene ?? index + 1,
+      title: scene.title ?? null,
+      sync_hint: scene.sync_hint ?? null,
+      narration: scene.narration,
+      duration_ms: durationMs,
+      start_seconds: elapsedMs / 1000,
+      end_seconds: (elapsedMs + durationMs) / 1000,
+      output_path: output.audioPath,
+      metadata_path: output.metadataPath,
+    });
+    elapsedMs += durationMs;
+  }
+
+  const manifestPath = join(options.output_dir, "narration-manifest.json");
+  await writeFile(manifestPath, `${JSON.stringify({
+    schema_version: "1.0.0",
+    provider: PROVIDER,
+    region: "cn",
+    endpoint,
+    narration_path: narrationPath,
+    model: options.model,
+    voice_id: options.voice_id,
+    emotion: options.emotion,
+    duration_ms: elapsedMs,
+    duration_seconds: elapsedMs / 1000,
+    scenes,
+  }, null, 2)}\n`, "utf8");
+
+  return { manifestPath, scenes, durationMs: elapsedMs };
+}
+
 async function main() {
   try {
     const cliOptions = parseArgs(process.argv.slice(2));
-    const endpoints = endpointFromEnv();
-    const timeoutMs = timeoutFromEnv();
 
     if (cliOptions.help) {
       printHelp();
       return;
     }
+    const endpoints = endpointFromEnv();
+    const timeoutMs = timeoutFromEnv();
 
     const runtime = await readRuntime(cliOptions);
 
@@ -514,7 +612,8 @@ async function main() {
       printJson({
         ok: true,
         dry_run: true,
-        provider: "minimax",
+        provider: PROVIDER,
+        region: "cn",
         endpoint: endpoints.tts,
         config: {
           source: runtime.source,
@@ -524,11 +623,40 @@ async function main() {
         request_path: cliOptions.request_json,
         narration_path: cliOptions.narration_json,
         request,
+        scene_requests: cliOptions.split_scenes
+          ? narration.scenes.map((scene) => buildTtsRequest({ ...options, text: scene.narration.trim() }))
+          : undefined,
         output_dir: options.output_dir,
       });
       return;
     }
 
+    if (cliOptions.split_scenes) {
+      const split = await generateSplitScenes({
+        narration,
+        options,
+        runtime,
+        endpoint: endpoints.tts,
+        timeoutMs,
+        narrationPath: cliOptions.narration_json,
+      });
+      printJson({
+        ok: true,
+        provider: PROVIDER,
+        region: "cn",
+        mode: "split_scenes",
+        model: options.model,
+        voice_id: options.voice_id,
+        emotion: options.emotion,
+        scene_count: split.scenes.length,
+        duration_ms: split.durationMs,
+        duration_seconds: split.durationMs / 1000,
+        manifest_path: split.manifestPath,
+        outputs: split.scenes.map((scene) => scene.output_path),
+      });
+      return;
+    }
+
     const responseJson = await postMiniMax(runtime.config, endpoints.tts, request, timeoutMs);
     const output = await writeTtsOutput({
       responseJson,
@@ -539,7 +667,8 @@ async function main() {
 
     printJson({
       ok: true,
-      provider: "minimax",
+      provider: PROVIDER,
+      region: "cn",
       model: request.model,
       voice_id: request.voice_setting.voice_id,
       emotion: request.voice_setting.emotion,