@lingjingai/scriptctl 0.25.2 → 0.25.4

package/dist/usecases/script/synopsis-generate.js

@@ -0,0 +1,801 @@
+import * as path from "node:path";
+import { CliError, DEFAULT_CONCURRENCY, EXIT_NEEDS_AGENT, EXIT_OK, EXIT_RUNTIME, EXIT_USAGE, directDir, sha256Text, } from "../../common.js";
+import { fileCheckpointer, llm, loom, } from "../../domain/loom/index.js";
+import { asList, isDict, strOf, } from "../../domain/script/shared.js";
+import { makeProvider } from "../../infra/providers.js";
+import { loadScriptForEdit, saveScriptSession, syncValidationResult, validateSession, } from "./session.js";
+import { summarizeIssues } from "../direct.js";
+export const DEFAULT_SYNOPSIS_GENERATE_CONFIG = {
+    episodeInputMaxChars: 6000,
+    episodeChunkTargetChars: 4800,
+    arcEpisodeCount: 10,
+    finalMaxInputChars: 12000,
+};
+export const DEFAULT_SYNOPSIS_PROVIDER = "openai";
+export const DEFAULT_SYNOPSIS_MODEL = "deepseek-v4-pro-packy";
+const CHUNK_INSTRUCTION = "从当前剧本片段中提取剧情梗概和关键事件。只基于当前片段，不要推测后续。";
+export const CHUNK_FORMAT = [
+    "输出格式：一个纯文本结构化文档。不要包裹代码块，不要在文档前后添加解释。",
+    "",
+    "## 片段梗概",
+    "<如果当前集只有一个片段，写 200-300 字；如果当前集被切成多个片段，写 80-150 字。按发生顺序概括，只写当前片段。>",
+    "",
+    "## 关键事件",
+    "- <事件1>",
+    "- <事件2>",
+    "",
+    "## 人物变化",
+    "- <人物名> | <变化>",
+    "",
+    "## 结尾钩子",
+    "<有则写一句；没有则留空>",
+].join("\n");
+const EPISODE_INSTRUCTION = "把同一集的多个片段梗概合并为一集梗概。只使用输入片段，不要新增剧情。";
+export const EPISODE_FORMAT = [
+    "输出格式：一个纯文本结构化文档。不要包裹代码块，不要在文档前后添加解释。",
+    "",
+    "## 分集梗概",
+    "<200-300 字，按剧情发生顺序写成连贯段落。>",
+    "",
+    "## 单句梗概",
+    "<30-50 字，概括本集主线。>",
+    "",
+    "## 关键事件",
+    "- <事件1>",
+    "- <事件2>",
+].join("\n");
+const ARC_INSTRUCTION = "把一组连续分集梗概压缩为阶段梗概。只使用输入分集，不要新增剧情。";
+export const ARC_FORMAT = [
+    "输出格式：一个纯文本结构化文档。不要包裹代码块，不要在文档前后添加解释。",
+    "",
+    "## 阶段梗概",
+    "<400-600 字，概括这一阶段的主线推进。>",
+    "",
+    "## 关键转折",
+    "- <转折1>",
+    "- <转折2>",
+    "",
+    "## 未解决悬念",
+    "- <悬念1>",
+].join("\n");
+const FINAL_INSTRUCTION = "根据分集索引和阶段梗概生成全剧总览。只使用输入内容，不要新增剧情、人物或关系。";
+export const FINAL_FORMAT = [
+    "输出格式：一个纯文本结构化文档。不要包裹代码块，不要在文档前后添加解释。",
+    "",
+    "## 全文梗概",
+    "<800-1200 字，覆盖全剧主线、关键关系、主要冲突和结局走向。>",
+    "",
+    "## 主题",
+    "<一句话或一个短语>",
+    "",
+    "## 一句话",
+    "<一句完整 logline>",
+    "",
+    "## 风格",
+    "<类型 / 气质 / 叙事风格>",
+    "",
+    "## 主要人物",
+    "- <名字> | <角色定位>",
+].join("\n");
+export function renderEpisodeSource(script, episode, index) {
+    const episodeId = strOf(episode["episode_id"]).trim() || `ep_${String(index + 1).padStart(3, "0")}`;
+    const episodeNo = episodeNumber(episodeId, index);
+    const title = strOf(episode["title"]).trim();
+    const lines = [];
+    const scriptTitle = strOf(script["title"]).trim();
+    if (scriptTitle)
+        lines.push(`剧名：${scriptTitle}`);
+    lines.push(`集数：第${episodeNo}集`);
+    if (title)
+        lines.push(`标题：${title}`);
+    lines.push("");
+    for (const scene of asList(episode["scenes"])) {
+        lines.push(renderSceneHeader(script, scene));
+        for (const action of asList(scene["actions"])) {
+            const rendered = renderAction(script, action);
+            if (rendered)
+                lines.push(rendered);
+        }
+        lines.push("");
+    }
+    return {
+        episodeIndex: index,
+        episodeId,
+        episodeNo,
+        title,
+        existingSynopsis: strOf(episode["synopsis"]).trim(),
+        text: lines.join("\n").trim(),
+    };
+}
+export function splitEpisodeSource(source, config = DEFAULT_SYNOPSIS_GENERATE_CONFIG) {
+    const rawLines = source.text.split(/\r?\n/);
+    const lines = rawLines.flatMap((line) => splitLongLine(line, config.episodeChunkTargetChars));
+    if (source.text.length <= config.episodeInputMaxChars && lines.length === rawLines.length) {
+        return [{
+                episodeIndex: source.episodeIndex,
+                episodeId: source.episodeId,
+                episodeNo: source.episodeNo,
+                title: source.title,
+                part: 1,
+                partCount: 1,
+                text: source.text,
+                sourceHash: sha256Text(source.text),
+            }];
+    }
+    const chunks = [];
+    let current = [];
+    let currentChars = 0;
+    for (const line of lines) {
+        const lineChars = line.length + (current.length > 0 ? 1 : 0);
+        if (current.length > 0 && currentChars + lineChars > config.episodeChunkTargetChars) {
+            chunks.push(current.join("\n").trim());
+            current = [];
+            currentChars = 0;
+        }
+        const nextLineChars = line.length + (current.length > 0 ? 1 : 0);
+        current.push(line);
+        currentChars += nextLineChars;
+    }
+    if (current.length > 0)
+        chunks.push(current.join("\n").trim());
+    return chunks.map((text, idx) => ({
+        episodeIndex: source.episodeIndex,
+        episodeId: source.episodeId,
+        episodeNo: source.episodeNo,
+        title: source.title,
+        part: idx + 1,
+        partCount: chunks.length,
+        text,
+        sourceHash: sha256Text(text),
+    }));
+}
+export function parseChunkBrief(text, chunk) {
+    const sections = sectionMap(text);
+    return {
+        episodeIndex: chunk.episodeIndex,
+        episodeId: chunk.episodeId,
+        episodeNo: chunk.episodeNo,
+        title: chunk.title,
+        part: chunk.part,
+        partCount: chunk.partCount,
+        synopsis: requiredSection(sections, "片段梗概"),
+        events: parseBullets(sections.get("关键事件") ?? ""),
+        characterChanges: parseCharacterChanges(sections.get("人物变化") ?? ""),
+        hook: (sections.get("结尾钩子") ?? "").trim(),
+    };
+}
+export function reduceChunkBriefs(items, ctx) {
+    const source = requireScope(ctx.scope, "episode");
+    const ordered = [...items].sort((a, b) => a.part - b.part);
+    return {
+        episodeIndex: source.episodeIndex,
+        episodeId: source.episodeId,
+        episodeNo: source.episodeNo,
+        title: source.title,
+        synopsis: ordered.map((item) => item.synopsis).filter((s) => s.trim()).join("\n"),
+        oneLine: firstNonEmpty(ordered.map((item) => item.synopsis)),
+        events: uniqueStrings(ordered.flatMap((item) => item.events)),
+    };
+}
+export function parseEpisodeBrief(text, source) {
+    const sections = sectionMap(text);
+    return {
+        episodeIndex: source.episodeIndex,
+        episodeId: source.episodeId,
+        episodeNo: source.episodeNo,
+        title: source.title,
+        synopsis: requiredSection(sections, "分集梗概"),
+        oneLine: requiredSection(sections, "单句梗概"),
+        events: parseBullets(sections.get("关键事件") ?? ""),
+    };
+}
+export function buildArcParcels(episodes, arcEpisodeCount) {
+    const parcels = [];
+    for (let i = 0; i < episodes.length; i += arcEpisodeCount) {
+        const group = episodes.slice(i, i + arcEpisodeCount);
+        const first = group[0];
+        const last = group[group.length - 1];
+        parcels.push({
+            index: parcels.length + 1,
+            startEpisodeNo: first.episodeNo,
+            endEpisodeNo: last.episodeNo,
+            text: renderEpisodeBriefs(group),
+        });
+    }
+    return parcels;
+}
+export function buildArcParcelsFromArcs(arcs, fanout) {
+    const parcels = [];
+    for (let i = 0; i < arcs.length; i += fanout) {
+        const group = arcs.slice(i, i + fanout);
+        const first = group[0];
+        const last = group[group.length - 1];
+        parcels.push({
+            index: parcels.length + 1,
+            startEpisodeNo: first.startEpisodeNo,
+            endEpisodeNo: last.endEpisodeNo,
+            text: renderArcBriefs(group),
+        });
+    }
+    return parcels;
+}
+export function parseArcBrief(text, parcel) {
+    const sections = sectionMap(text);
+    return {
+        index: parcel.index,
+        startEpisodeNo: parcel.startEpisodeNo,
+        endEpisodeNo: parcel.endEpisodeNo,
+        synopsis: requiredSection(sections, "阶段梗概"),
+        turns: parseBullets(sections.get("关键转折") ?? ""),
+        openQuestions: parseBullets(sections.get("未解决悬念") ?? ""),
+    };
+}
+export function reduceArcBriefs(items) {
+    const ordered = [...items].sort((a, b) => a.startEpisodeNo - b.startEpisodeNo);
+    const first = ordered[0];
+    const last = ordered[ordered.length - 1];
+    if (!first || !last)
+        throw new Error("arc reduce requires at least one item");
+    return {
+        index: first.index,
+        startEpisodeNo: first.startEpisodeNo,
+        endEpisodeNo: last.endEpisodeNo,
+        synopsis: ordered.map((item) => `第${item.startEpisodeNo}-${item.endEpisodeNo}集：${item.synopsis}`).join("\n"),
+        turns: uniqueStrings(ordered.flatMap((item) => item.turns)),
+        openQuestions: uniqueStrings(ordered.flatMap((item) => item.openQuestions)),
+    };
+}
+export function renderFinalInput(episodes, arcs) {
+    const lines = ["分集索引："];
+    for (const ep of [...episodes].sort((a, b) => a.episodeNo - b.episodeNo)) {
+        lines.push(`第${ep.episodeNo}集：${ep.oneLine || ep.synopsis}`);
+    }
+    lines.push("", "阶段梗概：");
+    for (const arc of [...arcs].sort((a, b) => a.startEpisodeNo - b.startEpisodeNo)) {
+        lines.push(`第${arc.startEpisodeNo}-${arc.endEpisodeNo}集：${arc.synopsis}`);
+    }
+    return lines.join("\n");
+}
+export function parseScriptOverview(text) {
+    const sections = sectionMap(text);
+    return {
+        synopsis: requiredSection(sections, "全文梗概"),
+        theme: requiredSection(sections, "主题"),
+        logline: requiredSection(sections, "一句话"),
+        style: requiredSection(sections, "风格"),
+        mainCharacters: parseMainCharacters(requiredSection(sections, "主要人物")),
+    };
+}
+export async function generateSynopsisFromScript(opts) {
+    const config = opts.config ?? DEFAULT_SYNOPSIS_GENERATE_CONFIG;
+    const episodes = asList(opts.script["episodes"]);
+    if (episodes.length === 0) {
+        throw new CliError("SYNOPSIS GENERATE BLOCKED: episodes missing", "No episodes found in script.", {
+            exitCode: EXIT_USAGE,
+            required: ["script.episodes[] with at least one episode"],
+            received: ["episodes: 0"],
+            nextSteps: ["Create or parse episodes before generating synopsis."],
+            errorCode: "SCRIPT_EPISODES_MISSING",
+        });
+    }
+    const allSources = episodes.map((episode, index) => renderEpisodeSource(opts.script, episode, index));
+    const sources = opts.overwrite ? allSources : allSources.filter((source) => !source.existingSynopsis);
+    const episodeRun = sources.length === 0
+        ? []
+        : await loom(opts.script)
+            .split({
+            scope: "episode",
+            partition: () => sources,
+            chunk: (source) => splitEpisodeSource(source, config),
+        })
+            .extract(llm({
+            instruction: CHUNK_INSTRUCTION,
+            format: CHUNK_FORMAT,
+            input: ({ parcel }) => renderChunkInput(parcel),
+            parse: ({ text, parcel }) => parseChunkBrief(text, parcel),
+        }))
+            .reduce("episode", reduceChunkBriefs)
+            .extract(llm({
+            instruction: EPISODE_INSTRUCTION,
+            format: EPISODE_FORMAT,
+            input: ({ parcel }) => renderEpisodeReduceInput(parcel),
+            parse: ({ text, parcel }) => parseEpisodeBrief(text, parcel),
+        }))
+            .reduce("root", (items) => [...items].sort((a, b) => a.episodeNo - b.episodeNo))
+            .run({
+            concurrency: opts.concurrency,
+            checkpoint: fileCheckpointer(path.join(opts.checkpointDir, "episode")),
+            checkpointSalt: opts.checkpointSalt,
+            model: opts.model,
+        });
+    const generatedEpisodeBriefs = Array.isArray(episodeRun) ? episodeRun : episodeRun.value;
+    const byIndex = new Map(generatedEpisodeBriefs.map((brief) => [brief.episodeIndex, brief]));
+    const episodeBriefs = allSources.map((source) => byIndex.get(source.episodeIndex) ?? {
+        episodeIndex: source.episodeIndex,
+        episodeId: source.episodeId,
+        episodeNo: source.episodeNo,
+        title: source.title,
+        synopsis: source.existingSynopsis,
+        oneLine: synopsisPreviewLine(source.existingSynopsis),
+        events: [],
+    });
+    const missing = episodeBriefs.filter((brief) => !brief.synopsis.trim()).map((brief) => brief.episodeId);
+    if (missing.length > 0) {
+        throw new CliError("SYNOPSIS GENERATE BLOCKED: episode synopsis missing", "Some episode synopses are still missing.", {
+            exitCode: EXIT_RUNTIME,
+            required: ["every episode has synopsis"],
+            received: missing,
+            nextSteps: ["Use --overwrite to regenerate, or manually set missing episode synopses."],
+            errorCode: "EPISODE_SYNOPSIS_MISSING",
+        });
+    }
+    const overviewNeeded = opts.overwrite || scriptOverviewMissing(opts.script);
+    const arcRun = overviewNeeded
+        ? await generateArcBriefs({
+            episodes: episodeBriefs,
+            model: opts.model,
+            checkpointDir: path.join(opts.checkpointDir, "arc"),
+            checkpointSalt: opts.checkpointSalt,
+            concurrency: opts.concurrency,
+            config,
+        })
+        : { value: [], report: { reused: 0, ran: 0 } };
+    const overviewRun = overviewNeeded
+        ? await generateScriptOverview({
+            episodes: episodeBriefs,
+            arcs: arcRun.value,
+            model: opts.model,
+            checkpointDir: path.join(opts.checkpointDir, "final"),
+            checkpointSalt: opts.checkpointSalt,
+            config,
+        })
+        : { value: existingScriptOverview(opts.script), report: { reused: 0, ran: 0 } };
+    return {
+        episodeBriefs,
+        overview: overviewRun.value,
+        overviewGenerated: overviewNeeded,
+        report: {
+            reused: (Array.isArray(episodeRun) ? 0 : episodeRun.report.reused) + arcRun.report.reused + overviewRun.report.reused,
+            ran: (Array.isArray(episodeRun) ? 0 : episodeRun.report.ran) + arcRun.report.ran + overviewRun.report.ran,
+        },
+    };
+}
+export async function commandSynopsisGenerate(opts) {
+    const providerName = strOf(opts["provider"] || DEFAULT_SYNOPSIS_PROVIDER);
+    const modelName = strOf(opts["model"] || DEFAULT_SYNOPSIS_MODEL);
+    const concurrency = parsePositiveInt(opts["concurrency"], DEFAULT_CONCURRENCY, "--concurrency");
+    const overwrite = Boolean(opts["overwrite"]);
+    const apply = Boolean(opts["apply"]);
+    const dryRun = Boolean(opts["dry_run"]);
+    if (apply && dryRun) {
+        throw new CliError("SYNOPSIS GENERATE BLOCKED: flags mutually exclusive", "--apply and --dry-run are mutually exclusive.", {
+            exitCode: EXIT_USAGE,
+            required: ["at most one of --apply / --dry-run"],
+            received: ["--apply", "--dry-run"],
+            nextSteps: ["Pick one mode and retry."],
+            errorCode: "SYNOPSIS_GENERATE_FLAG_CONFLICT",
+        });
+    }
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    const session = await loadScriptForEdit(opts);
+    const provider = makeProvider(providerName, modelName);
+    if (!provider.completeText) {
+        throw new CliError("SYNOPSIS GENERATE BLOCKED: provider lacks text completion", "Provider does not support text completion.", {
+            exitCode: EXIT_USAGE,
+            required: ["provider.completeText"],
+            received: [`--provider ${providerName}`],
+            nextSteps: ["Use --provider openai, --provider anthropic, or --provider mock."],
+            errorCode: "PROVIDER_TEXT_UNSUPPORTED",
+        });
+    }
+    const completeText = provider.completeText.bind(provider);
+    const checkpoint = strOf(opts["checkpoint"]).trim() || path.join(directDir(workspace), "loom", "synopsis-generate");
+    const result = await generateSynopsisFromScript({
+        script: session.script,
+        model: (request) => completeText(request),
+        checkpointDir: checkpoint,
+        checkpointSalt: { provider: providerName, model: modelName },
+        concurrency,
+        overwrite,
+    });
+    const changedEpisodeIds = new Set();
+    const scriptEpisodes = asList(session.script["episodes"]);
+    for (const brief of result.episodeBriefs) {
+        const episode = scriptEpisodes[brief.episodeIndex];
+        if (episode && (overwrite || !strOf(episode["synopsis"]).trim())) {
+            if (strOf(episode["synopsis"]) !== brief.synopsis) {
+                episode["synopsis"] = brief.synopsis;
+                changedEpisodeIds.add(brief.episodeId);
+            }
+        }
+    }
+    let overviewChanged = false;
+    overviewChanged = setTextField(session.script, "synopsis", result.overview.synopsis, overwrite) || overviewChanged;
+    overviewChanged = setTextField(session.script, "theme", result.overview.theme, overwrite) || overviewChanged;
+    overviewChanged = setTextField(session.script, "logline", result.overview.logline, overwrite) || overviewChanged;
+    overviewChanged = setTextField(session.script, "style", result.overview.style, overwrite) || overviewChanged;
+    if (overwrite || asList(session.script["main_characters"]).length === 0) {
+        const nextMainCharacters = result.overview.mainCharacters.map((item) => ({ name: item.name, role: item.role }));
+        if (JSON.stringify(session.script["main_characters"] ?? []) !== JSON.stringify(nextMainCharacters)) {
+            session.script["main_characters"] = nextMainCharacters;
+            overviewChanged = true;
+        }
+    }
+    const hasChanges = changedEpisodeIds.size > 0 || overviewChanged;
+    const validation = validateSession(session);
+    const passed = Boolean(validation["passed"]);
+    const resultLines = [
+        `episodes: ${result.episodeBriefs.length}`,
+        `episode_synopses: ${changedEpisodeIds.size}`,
+        `overview: ${result.overviewGenerated ? "generated" : "reused"}`,
+        `loom: ran=${result.report.ran}, reused=${result.report.reused}`,
+        `changed: ${String(hasChanges).toLowerCase()}`,
+        `validation: ${passed ? apply ? "passed" : "would pass" : apply ? "needs repair" : "would need repair"}`,
+        `dry-run: ${apply ? "false" : "true"}`,
+    ];
+    if (apply && hasChanges) {
+        const [newRevision, idempotent] = await saveScriptSession(session, opts, "synopsis.generate");
+        await syncValidationResult(session, validation, newRevision);
+        if (session.remote) {
+            resultLines.push(`revision: ${newRevision}`);
+            resultLines.push(`idempotent: ${String(idempotent).toLowerCase()}`);
+        }
+    }
+    const report = {
+        title: apply && !hasChanges
+            ? "SYNOPSIS GENERATE: No changes"
+            : apply
+                ? passed ? "SYNOPSIS GENERATED" : "SYNOPSIS GENERATED: Validation needs repair"
+                : "SYNOPSIS GENERATE DRY-RUN (no write)",
+        op: apply ? "synopsis.generate" : "synopsis.generate.dry-run",
+        changed: apply && hasChanges,
+        summary: `prepared ${result.episodeBriefs.length} episode synopsis record(s) and whole-script overview`,
+        result: resultLines,
+        warnings: passed ? [] : summarizeIssues(asList(validation["issues"])),
+        issues: summarizeIssues(asList(validation["issues"])),
+        artifacts: apply && hasChanges ? [session.artifactLabel, path.join(directDir(workspace), "validation.json")] : [session.artifactLabel],
+        next: [apply ? "Review the generated synopsis fields." : "Re-run with --apply to write the generated synopsis fields."],
+        episode_synopses: result.episodeBriefs.map((brief) => ({
+            episode_id: brief.episodeId,
+            title: brief.title,
+            synopsis: brief.synopsis,
+            one_line: brief.oneLine,
+        })),
+    };
+    return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
+}
+function splitLongLine(line, maxChars) {
+    if (line.length <= maxChars)
+        return [line];
+    const parts = [];
+    for (let i = 0; i < line.length; i += maxChars) {
+        parts.push(line.slice(i, i + maxChars));
+    }
+    return parts;
+}
+async function generateArcBriefs(opts) {
+    let current = buildArcParcels(opts.episodes, opts.config.arcEpisodeCount);
+    let level = 1;
+    const report = { reused: 0, ran: 0 };
+    while (true) {
+        const run = await loom(current)
+            .split({
+            scope: "arc",
+            partition: (parcels) => parcels,
+            chunk: (parcel) => [parcel],
+        })
+            .extract(llm({
+            instruction: ARC_INSTRUCTION,
+            format: ARC_FORMAT,
+            input: ({ parcel }) => renderArcInput(parcel),
+            parse: ({ text, parcel }) => parseArcBrief(text, parcel),
+        }))
+            .reduce("arc", (items) => requireSingle(items, "arc"))
+            .reduce("root", (items) => [...items].sort((a, b) => a.startEpisodeNo - b.startEpisodeNo))
+            .run({
+            concurrency: opts.concurrency,
+            checkpoint: fileCheckpointer(path.join(opts.checkpointDir, `level-${level}`)),
+            checkpointSalt: opts.checkpointSalt,
+            model: opts.model,
+        });
+        report.reused += run.report.reused;
+        report.ran += run.report.ran;
+        const briefs = run.value;
+        const finalInput = renderFinalInput(opts.episodes, briefs);
+        if (finalInput.length <= opts.config.finalMaxInputChars || briefs.length <= 1)
+            return { value: briefs, report };
+        current = buildArcParcelsFromArcs(briefs, opts.config.arcEpisodeCount);
+        level += 1;
+    }
+}
+async function generateScriptOverview(opts) {
+    let arcs = opts.arcs;
+    while (renderFinalInput(opts.episodes, arcs).length > opts.config.finalMaxInputChars && arcs.length > 1) {
+        arcs = [reduceArcBriefs(arcs)];
+    }
+    const run = await loom({ episodes: opts.episodes, arcs })
+        .extract(llm({
+        instruction: FINAL_INSTRUCTION,
+        format: FINAL_FORMAT,
+        input: ({ parcel }) => renderFinalInput(parcel.episodes, parcel.arcs),
+        parse: ({ text }) => parseScriptOverview(text),
+    }))
+        .run({
+        concurrency: 1,
+        checkpoint: fileCheckpointer(opts.checkpointDir),
+        checkpointSalt: opts.checkpointSalt,
+        model: opts.model,
+    });
+    return { value: run.value, report: run.report };
+}
+function renderSceneHeader(script, scene) {
+    const env = isDict(scene["environment"]) ? scene["environment"] : {};
+    const space = strOf(env["space"]).trim();
+    const time = strOf(env["time"]).trim();
+    const context = isDict(scene["context"]) ? scene["context"] : {};
+    const locations = asList(context["locations"]).map((ref) => assetName(script, "locations", "location_id", "location_name", strOf(ref["location_id"]))).filter((s) => s);
+    const actors = asList(context["actors"]).map((ref) => assetName(script, "actors", "actor_id", "actor_name", strOf(ref["actor_id"]))).filter((s) => s);
+    const location = locations.join("、") || "-";
+    const envText = [space, time].filter((s) => s).join(" ");
+    return `[场景] ${envText || "-"}｜${location}｜出场：${actors.join("、") || "-"}`;
+}
+function renderAction(script, action) {
+    const type = strOf(action["type"]).trim();
+    if (type === "dialogue") {
+        if (strOf(action["delivery"]) === "overlap" && asList(action["lines"]).length > 0) {
+            const lines = asList(action["lines"]).map((line) => {
+                const speaker = speakerName(script, strOf(line["speaker_id"])) || strOf(line["speaker_id"]);
+                const content = strOf(line["content"]).trim();
+                return speaker && content ? `${speaker}：${content}` : content;
+            }).filter((line) => line);
+            return lines.length > 0 ? `[对白] ${lines.join(" / ")}` : "";
+        }
+        const speaker = actionSpeakerName(script, action);
+        const content = strOf(action["content"]).trim();
+        return content ? `[对白] ${speaker ? `${speaker}：` : ""}${content}` : "";
+    }
+    if (type === "inner_thought") {
+        const speaker = actionSpeakerName(script, action);
+        const content = strOf(action["content"]).trim();
+        return content ? `[心声] ${speaker ? `${speaker}：` : ""}${content}` : "";
+    }
+    const content = strOf(action["content"]).trim();
+    return content ? `[动作] ${content}` : "";
+}
+function actionSpeakerName(script, action) {
+    const speakerId = strOf(action["speaker_id"]).trim();
+    if (speakerId)
+        return speakerName(script, speakerId) || speakerId;
+    const actorId = strOf(action["actor_id"]).trim();
+    if (actorId)
+        return assetName(script, "actors", "actor_id", "actor_name", actorId) || actorId;
+    const speakers = asList(action["speakers"]).map((ref) => speakerName(script, strOf(ref["speaker_id"])) || strOf(ref["speaker_id"])).filter((s) => s);
+    return speakers.join("/");
+}
+function speakerName(script, speakerId) {
+    const speaker = asList(script["speakers"]).find((item) => strOf(item["speaker_id"]) === speakerId);
+    return speaker ? strOf(speaker["display_name"]).trim() : "";
+}
+function assetName(script, collection, idKey, nameKey, id) {
+    const item = asList(script[collection]).find((entry) => strOf(entry[idKey]) === id);
+    return item ? strOf(item[nameKey]).trim() : "";
+}
+function episodeNumber(episodeId, index) {
+    const m = /^ep_(\d+)$/.exec(episodeId);
+    return m ? Number(m[1]) : index + 1;
+}
+function sectionMap(text) {
+    const sections = new Map();
+    let current = null;
+    let lines = [];
+    const flush = () => {
+        if (current)
+            sections.set(current, lines.join("\n").trim());
+        lines = [];
+    };
+    for (const rawLine of text.split(/\r?\n/)) {
+        const heading = parseSectionHeading(rawLine);
+        if (heading) {
+            if (current === heading.name && heading.inline) {
+                lines.push(rawLine);
+                continue;
+            }
+            flush();
+            current = heading.name;
+            if (heading.inline)
+                lines.push(heading.inline);
+            continue;
+        }
+        if (current)
+            lines.push(rawLine);
+    }
+    flush();
+    return sections;
+}
+const SYNOPSIS_SECTION_NAMES = new Set([
+    "片段梗概",
+    "关键事件",
+    "人物变化",
+    "结尾钩子",
+    "分集梗概",
+    "单句梗概",
+    "阶段梗概",
+    "关键转折",
+    "未解决悬念",
+    "全文梗概",
+    "主题",
+    "一句话",
+    "风格",
+    "主要人物",
+]);
+function parseSectionHeading(rawLine) {
+    const line = rawLine.trim();
+    const md = /^#{1,6}\s+(.+?)\s*$/.exec(line);
+    if (md) {
+        const name = md[1].trim();
+        return SYNOPSIS_SECTION_NAMES.has(name) ? { name, inline: "" } : null;
+    }
+    const colon = line.search(/[:：]/);
+    const name = (colon >= 0 ? line.slice(0, colon) : line).trim();
+    if (!SYNOPSIS_SECTION_NAMES.has(name))
+        return null;
+    return { name, inline: colon >= 0 ? line.slice(colon + 1).trim() : "" };
+}
+function requiredSection(sections, name) {
+    const value = (sections.get(name) ?? "").trim();
+    if (!value)
+        throw new Error(`synopsis output missing section: ${name}`);
+    return value;
+}
+function parseBullets(text) {
+    return text.split(/\r?\n/)
+        .map((line) => line.trim())
+        .map((line) => line.replace(/^[-*]\s*/, "").trim())
+        .filter((line) => line.length > 0);
+}
+function parseCharacterChanges(text) {
+    return parseBullets(text).map((line) => {
+        const [name, ...rest] = line.split("|");
+        return { name: strOf(name).trim(), change: rest.join("|").trim() };
+    }).filter((item) => item.name && item.change);
+}
+function parseMainCharacters(text) {
+    return parseBullets(text).map((line) => {
+        const [name, ...rest] = line.split("|");
+        return { name: strOf(name).trim(), role: rest.join("|").trim() };
+    }).filter((item) => item.name && item.role);
+}
+function renderChunkInput(chunk) {
+    return [
+        `当前分集：第${chunk.episodeNo}集 ${chunk.title || ""}`.trim(),
+        `当前片段：${chunk.part}/${chunk.partCount}`,
+        "",
+        "这是当前任务的原文：",
+        chunk.text,
+    ].join("\n");
+}
+function renderEpisodeReduceInput(episode) {
+    return [
+        `当前分集：第${episode.episodeNo}集 ${episode.title || ""}`.trim(),
+        "",
+        "片段梗概：",
+        episode.synopsis,
+        "",
+        "片段关键事件：",
+        ...episode.events.map((event) => `- ${event}`),
+    ].join("\n");
+}
+function renderEpisodeBriefs(episodes) {
+    const lines = [];
+    for (const ep of episodes) {
+        lines.push(`第${ep.episodeNo}集 ${ep.title || ""}`.trim());
+        lines.push(`单句：${ep.oneLine}`);
+        lines.push(`梗概：${ep.synopsis}`);
+        if (ep.events.length > 0) {
+            lines.push("关键事件：");
+            for (const event of ep.events)
+                lines.push(`- ${event}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+function renderArcBriefs(arcs) {
+    const lines = [];
+    for (const arc of arcs) {
+        lines.push(`第${arc.startEpisodeNo}-${arc.endEpisodeNo}集`);
+        lines.push(`阶段梗概：${arc.synopsis}`);
+        if (arc.turns.length > 0) {
+            lines.push("关键转折：");
+            for (const turn of arc.turns)
+                lines.push(`- ${turn}`);
+        }
+        if (arc.openQuestions.length > 0) {
+            lines.push("未解决悬念：");
+            for (const q of arc.openQuestions)
+                lines.push(`- ${q}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+function renderArcInput(parcel) {
+    return [
+        `当前阶段：第${parcel.startEpisodeNo}-${parcel.endEpisodeNo}集`,
+        "",
+        "分集梗概：",
+        parcel.text,
+    ].join("\n");
+}
+function requireScope(scope, name) {
+    if (scope === null)
+        throw new Error(`${name} scope missing`);
+    return scope;
+}
+function requireSingle(items, name) {
+    const item = items[0];
+    if (!item || items.length !== 1)
+        throw new Error(`${name} reduce requires exactly one item`);
+    return item;
+}
+function firstNonEmpty(values) {
+    return values.map((value) => value.trim()).find((value) => value.length > 0) ?? "";
+}
+function uniqueStrings(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values.map((v) => v.trim()).filter((v) => v.length > 0)) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        out.push(value);
+    }
+    return out;
+}
+function synopsisPreviewLine(text) {
+    const clean = text.replace(/\s+/g, " ").trim();
+    return clean.length > 50 ? clean.slice(0, 50) : clean;
+}
+function parsePositiveInt(value, fallback, label) {
+    if (value === undefined || value === null || value === "")
+        return fallback;
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new CliError("SYNOPSIS GENERATE BLOCKED: numeric option invalid", `${label} must be a positive integer.`, {
+            exitCode: EXIT_USAGE,
+            required: [`${label}: positive integer`],
+            received: [strOf(value)],
+            nextSteps: [`Pass ${label} ${fallback}.`],
+            errorCode: "NUMERIC_OPTION_INVALID",
+        });
+    }
+    return Math.floor(n);
+}
+function setTextField(script, key, value, overwrite) {
+    if (!overwrite && strOf(script[key]).trim())
+        return false;
+    if (strOf(script[key]) === value)
+        return false;
+    script[key] = value;
+    return true;
+}
+function scriptOverviewMissing(script) {
+    return !strOf(script["synopsis"]).trim()
+        || !strOf(script["theme"]).trim()
+        || !strOf(script["logline"]).trim()
+        || !strOf(script["style"]).trim()
+        || asList(script["main_characters"]).length === 0;
+}
+function existingScriptOverview(script) {
+    return {
+        synopsis: strOf(script["synopsis"]).trim(),
+        theme: strOf(script["theme"]).trim(),
+        logline: strOf(script["logline"]).trim(),
+        style: strOf(script["style"]).trim(),
+        mainCharacters: asList(script["main_characters"]).map((item) => ({
+            name: strOf(item["name"]).trim(),
+            role: strOf(item["role"]).trim(),
+        })).filter((item) => item.name && item.role),
+    };
+}
+//# sourceMappingURL=synopsis-generate.js.map