@lingjingai/scriptctl 0.1.0

package/dist/domain/direct-core.js

@@ -0,0 +1,3040 @@
+import { ACTION_TYPE_VALUES, ACTOR_REUSE_SCENE_LIMIT, CliError, DEFAULT_BATCH_MAX_CHARS, DEFAULT_BATCH_MIN_LINES, DEFAULT_BATCH_MODE, DEFAULT_BATCH_TARGET_LINES, DEFAULT_PROVIDER_ATTEMPTS, EXIT_NEEDS_AGENT, EXIT_RUNTIME, PROP_REUSE_SCENE_LIMIT, SCRIPT_SCHEMA_VERSION, SCRIPT_TARGET_KINDS, WORLDVIEW_VALUES, fmtId, } from "../common.js";
+// ---------------------------------------------------------------------------
+// Regexes & lookup tables (shared with infra/converters.ts via re-export)
+// ---------------------------------------------------------------------------
+export const _ZH_DIGITS = {
+    "零": 0, "〇": 0, "一": 1, "二": 2, "两": 2, "三": 3, "四": 4,
+    "五": 5, "六": 6, "七": 7, "八": 8, "九": 9,
+};
+export const _EP_HEADER_RE = /^[\t ]*(?:[#=]+[\t ]*)?(?:第[\t ]*(?<zh>[0-9０-９一二三四五六七八九十百千零〇两]+)[\t ]*集|(?:EP|Episode)[\t _\-#:.]*(?<ep>[0-9０-９]+))[^\n]*$/gim;
+export const _EP_TITLE_PREFIX_RE = /^[#=\s]*(?:第\s*([0-9０-９一二三四五六七八九十百千零〇两]+)\s*集|(?:EP|Episode)[\s_\-#:.]*([0-9０-９]+))/i;
+export const _TECHNICAL_EP_TITLE_RE = /^(?:ep|episode)[\s_\-#:.]*[0-9０-９]+$/i;
+const _TIME_MAP = {
+    "日": "day", "白天": "day", "上午": "day", "下午": "day", "午后": "day", "中午": "day",
+    "晨": "day", "清晨": "day", "早晨": "day", "黎明": "day",
+    "夜": "night", "夜晚": "night", "深夜": "night", "凌晨": "night", "黄昏": "night", "傍晚": "night",
+};
+const _SPACE_MAP = {
+    "内": "interior", "外": "exterior", "内/外": "interior", "外/内": "exterior",
+};
+const _SCENE_TIME_FIRST_RE = /^(?:场)?(\d+)-(\d+)\s+(日|夜|晨|清晨|黄昏|午后|凌晨|夜晚|深夜|黎明|白天|傍晚|中午|上午|下午|早晨)\s+((?:内|外|内\/外|外\/内))\s+(.+?)\s*$/;
+const _SCENE_LOCATION_FIRST_RE = /^(?:场)?(\d+)-(\d+)\s+(.+?)\s+(日|夜|晨|清晨|黄昏|午后|凌晨|夜晚|深夜|黎明|白天|傍晚|中午|上午|下午|早晨)\s+((?:内|外|内\/外|外\/内))\s*$/;
+const _CHAR_RE = /^(?:登场|出场)?人物[：:](.+)$/;
+const _PROP_RE = /^道具[：:](.+)$/;
+const _ACTION_RE = /^[▲△]\s*(.+)$/;
+const _OS_RE = /^(.+?)[（(]OS[）)][：:](.+)$/i;
+const _DIALOGUE_RE = /^([^：:]{1,40}?)(?:[（(]([^）)]{1,30})[）)])?[：:](.+)$/;
+const _BRACKET_RE = /^【([^：:】]+)[：:](.+?)】?$/;
+const _STATE_RE = /【([^】]+)】/g;
+const _PAREN_ANNOTATION_RE = /[（(]([^）)]+)[）)]/g;
+const _ANNOTATION_RE = /(?:【[^】]*】|[（(][^）)]*[）)])/g;
+export const BRACKET_ACTION_LABELS = new Set([
+    "字幕", "音效", "特效", "屏幕字", "人物牌", "旁白", "画面", "转场",
+]);
+const _SOURCE_SCENE_LINE_RE = /^(?:场)?\d+\s*-\s*\d+/;
+const _SOURCE_META_LINE_RE = /^(?:人物|道具)[：:]/;
+const _SOURCE_PREVIEW_LINE_RE = /^[（(【\[]?\s*(?:本集)?(?:看点|预告|亮点)(?:\s*[：:·].*)?[）)】\]]?$/;
+const _EMPTY_SPEAKER_LINE_RE = /^[^：:【】]{1,40}(?:[（(][^）)]{1,30}[）)])?[：:]\s*$/;
+const _OS_EXT_RE = /^(.+?)[（(](OS[^）)]*)[）)][：:](.*)$/i;
+const _BRACKET_PREFIX_RE = /^【[^】]+】.+$/;
+const _STATE_MIXED_SEPARATORS = ["/", "／", "+", "、", "，", ","];
+const _COMPACT_SPACE_TO_LONG = { in: "interior", out: "exterior" };
+const _LONG_SPACE_TO_COMPACT = { interior: "in", exterior: "out" };
+const _COMPACT_ACTION_TO_LONG = { act: "action", dlg: "dialogue", think: "inner_thought" };
+const _LONG_ACTION_TO_COMPACT = { action: "act", dialogue: "dlg", inner_thought: "think" };
+const _MD_TOP_HEADER_RE = /^#\s+(.+?)\s*$/;
+const _MD_SUB_HEADER_RE = /^##\s+(.+?)\s*$/;
+const _MD_SCENE_HEADER_RE = /^##\s*场景\s*(\d+)\s*$/;
+const _MD_SCENE_FIELD_RE = /^-\s*(时空|地点|角色|道具)\s*[:：]\s*(.+?)\s*$/;
+const _MD_TIME_SPACE_RE = /^(内|外|interior|exterior|in|out)\s+(日|夜|day|night)$/i;
+const _MD_LOC_STATE_RE = /^(.+?)(?:【([^】]+)】)?$/;
+const _MD_CHAR_ENTRY_RE = /^([^()（）,，]+?)(?:[（(]([^）)]+)[）)])?$/;
+const _MD_ACTION_ANCHOR_RE = /^>\s*\[([A-Za-z]+)(?:\|([^|\]]+?)(?:\|([^|\]]+?))?)?\]\s*(.*)$/;
+const _MD_ASSET_ENTRY_RE = /^-\s*([^:：]+?)(?:\s*[:：]\s*(.+?))?\s*$/;
+const _MD_SPACE_NORM = {
+    "内": "interior", "interior": "interior", "in": "interior",
+    "外": "exterior", "exterior": "exterior", "out": "exterior",
+};
+const _MD_TIME_NORM = {
+    "日": "day", "day": "day",
+    "夜": "night", "night": "night",
+};
+const _MD_KIND_NORM = {
+    act: "action", dlg: "dialogue", think: "inner_thought",
+};
+const _MD_SPEAKER_KIND_NORM = {
+    "actor": "actor", "角色": "actor", "人物": "actor",
+    "system": "system", "系统": "system", "系统音": "system", "系统提示音": "system",
+    "broadcast": "broadcast", "广播": "broadcast", "喇叭": "broadcast",
+    "group": "group", "群体": "group", "众人": "group",
+    "prop": "prop", "道具": "prop",
+    "location": "location", "地点": "location", "场景": "location",
+    "other": "other", "其他": "other",
+};
+const _MD_DELIVERY_NORM = {
+    "single": "single", "单人": "single",
+    "simultaneous": "simultaneous", "同时": "simultaneous", "齐声": "simultaneous", "同声": "simultaneous", "一起": "simultaneous",
+    "overlap": "overlap", "重叠": "overlap", "交叠": "overlap", "同时不同句": "overlap",
+    "group": "group", "群体": "group", "众人": "group",
+};
+const _MD_ASSET_SUBSECTION_MAP = {
+    "人物": "actors", "角色": "actors",
+    "场景": "locations", "地点": "locations",
+    "道具": "props",
+    "发声源": "speakers", "声音": "speakers", "speaker": "speakers", "speakers": "speakers",
+    "人物状态": "actor_states", "角色状态": "actor_states",
+    "场景状态": "location_states", "地点状态": "location_states",
+    "道具状态": "prop_states",
+};
+// ---------------------------------------------------------------------------
+// Generic helpers (Python builtin equivalents)
+// ---------------------------------------------------------------------------
+function strOf(v) {
+    if (v === null || v === undefined)
+        return "";
+    return String(v);
+}
+function isDict(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isList(v) {
+    return Array.isArray(v);
+}
+function asList(v) {
+    return Array.isArray(v) ? v : [];
+}
+function asDict(v) {
+    return isDict(v) ? v : {};
+}
+function isAsciiDigitString(s) {
+    if (!s)
+        return false;
+    for (const ch of s) {
+        if (ch < "0" || ch > "9")
+            return false;
+    }
+    return true;
+}
+/** Python `s.splitlines(keepends=True)` */
+function splitLinesKeepEnds(text) {
+    if (!text)
+        return [];
+    const out = [];
+    let start = 0;
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === "\n") {
+            out.push(text.slice(start, i + 1));
+            i += 1;
+            start = i;
+        }
+        else if (ch === "\r") {
+            if (text[i + 1] === "\n") {
+                out.push(text.slice(start, i + 2));
+                i += 2;
+            }
+            else {
+                out.push(text.slice(start, i + 1));
+                i += 1;
+            }
+            start = i;
+        }
+        else {
+            i += 1;
+        }
+    }
+    if (start < text.length)
+        out.push(text.slice(start));
+    return out;
+}
+/** Python `re.split(pattern, s, maxsplit=N)`. */
+function reSplit(pattern, s, maxsplit = -1) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g";
+    const re = new RegExp(pattern.source, flags);
+    const result = [];
+    let lastIndex = 0;
+    let count = 0;
+    let m;
+    while ((m = re.exec(s)) !== null) {
+        if (maxsplit >= 0 && count >= maxsplit)
+            break;
+        result.push(s.slice(lastIndex, m.index));
+        for (let g = 1; g < m.length; g++)
+            result.push(m[g] ?? "");
+        lastIndex = m.index + m[0].length;
+        count += 1;
+        if (m[0].length === 0)
+            re.lastIndex += 1;
+    }
+    result.push(s.slice(lastIndex));
+    return result;
+}
+function reSearch(pattern, s) {
+    const flags = pattern.flags.includes("g") ? pattern.flags.replace("g", "") : pattern.flags;
+    return new RegExp(pattern.source, flags).exec(s);
+}
+function reMatch(pattern, s) {
+    const src = pattern.source.startsWith("^") ? pattern.source : "^" + pattern.source;
+    const flags = pattern.flags.includes("g") ? pattern.flags.replace("g", "") : pattern.flags;
+    return new RegExp(src, flags).exec(s);
+}
+function reFullMatch(pattern, s) {
+    let src = pattern.source;
+    if (!src.startsWith("^"))
+        src = "^" + src;
+    if (!src.endsWith("$"))
+        src = src + "$";
+    const flags = pattern.flags.includes("g") ? pattern.flags.replace("g", "") : pattern.flags;
+    return new RegExp(src, flags).exec(s);
+}
+function reFindAll(pattern, s) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g";
+    const re = new RegExp(pattern.source, flags);
+    const out = [];
+    let m;
+    while ((m = re.exec(s)) !== null) {
+        out.push(m.length > 1 ? (m[1] ?? "") : m[0]);
+        if (m[0].length === 0)
+            re.lastIndex += 1;
+    }
+    return out;
+}
+function reFindAllMatches(pattern, s) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g";
+    const re = new RegExp(pattern.source, flags);
+    const out = [];
+    let m;
+    while ((m = re.exec(s)) !== null) {
+        out.push(m);
+        if (m[0].length === 0)
+            re.lastIndex += 1;
+    }
+    return out;
+}
+function reReplace(pattern, s, replacement) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g";
+    return s.replace(new RegExp(pattern.source, flags), replacement);
+}
+/** Python `str.partition(sep)` */
+function partition(s, sep) {
+    const idx = s.indexOf(sep);
+    if (idx < 0)
+        return [s, "", ""];
+    return [s.slice(0, idx), sep, s.slice(idx + sep.length)];
+}
+/** Python `str.strip(chars)` */
+function pyStrip(s, chars) {
+    if (chars === undefined)
+        return s.trim();
+    let start = 0;
+    let end = s.length;
+    while (start < end && chars.includes(s[start]))
+        start += 1;
+    while (end > start && chars.includes(s[end - 1]))
+        end -= 1;
+    return s.slice(start, end);
+}
+function pyLstrip(s, chars) {
+    if (chars === undefined)
+        return s.replace(/^\s+/, "");
+    let start = 0;
+    while (start < s.length && chars.includes(s[start]))
+        start += 1;
+    return s.slice(start);
+}
+function countOccurrences(s, sub, end) {
+    if (!sub)
+        return 0;
+    const slice = s.slice(0, end);
+    let count = 0;
+    let pos = 0;
+    while ((pos = slice.indexOf(sub, pos)) !== -1) {
+        count += 1;
+        pos += sub.length;
+    }
+    return count;
+}
+// ---------------------------------------------------------------------------
+// Scene context
+// ---------------------------------------------------------------------------
+export function sceneContext(scene) {
+    const context = isDict(scene["context"]) ? scene["context"] : {};
+    return {
+        locations: isList(context["locations"]) ? context["locations"] : (asList(scene["locations"]) ?? []),
+        actors: isList(context["actors"]) ? context["actors"] : (asList(scene["actors"]) ?? []),
+        props: isList(context["props"]) ? context["props"] : (asList(scene["props"]) ?? []),
+    };
+}
+export function setSceneContext(scene, context) {
+    const ctx = {
+        locations: [...asList(context["locations"])],
+        actors: [...asList(context["actors"])],
+        props: [...asList(context["props"])],
+    };
+    scene["context"] = ctx;
+    scene["locations"] = ctx.locations;
+    scene["actors"] = ctx.actors;
+    scene["props"] = ctx.props;
+}
+// ---------------------------------------------------------------------------
+// Number / title parsing
+// ---------------------------------------------------------------------------
+export function normalizeDigits(value) {
+    let out = "";
+    for (const ch of value) {
+        const code = ch.charCodeAt(0);
+        if (code >= 0xFF10 && code <= 0xFF19) {
+            out += String.fromCharCode(code - 0xFF10 + 48);
+        }
+        else {
+            out += ch;
+        }
+    }
+    return out;
+}
+export function parseEpNumber(raw) {
+    const value = normalizeDigits(raw.trim());
+    if (isAsciiDigitString(value))
+        return parseInt(value, 10);
+    if (value === "十")
+        return 10;
+    if (value.startsWith("十"))
+        return 10 + (_ZH_DIGITS[value.slice(1)] ?? 0);
+    if (value.endsWith("十"))
+        return (_ZH_DIGITS[value.slice(0, -1)] ?? 0) * 10;
+    if (value.includes("百")) {
+        const [left, , right] = partition(value, "百");
+        return (_ZH_DIGITS[left] ?? 0) * 100 + (parseEpNumber(right) ?? 0);
+    }
+    if (value.includes("十")) {
+        const [left, , right] = partition(value, "十");
+        return (_ZH_DIGITS[left] ?? 0) * 10 + (right ? (_ZH_DIGITS[right] ?? 0) : 0);
+    }
+    return _ZH_DIGITS[value] ?? null;
+}
+export function episodeNumberFromValue(value, defaultVal = null) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0)
+        return value;
+    const text = strOf(value).trim();
+    if (!text)
+        return defaultVal;
+    const marker = reSearch(/(?:第\s*([0-9０-９一二三四五六七八九十百千零〇两]+)\s*集|(?:EP|Episode)[\s_\-#:.]*([0-9０-９]+))/i, text);
+    if (marker) {
+        const parsed = parseEpNumber(marker[1] || marker[2] || "");
+        if (parsed)
+            return parsed;
+    }
+    const digits = normalizeDigits(text);
+    if (isAsciiDigitString(digits))
+        return parseInt(digits, 10);
+    return defaultVal;
+}
+export function cleanEpisodeShortTitle(rawTitle) {
+    let title = strOf(rawTitle).trim();
+    title = title.replace(/^[#=\s]+/, "").trim();
+    for (let i = 0; i < 2; i++) {
+        const match = reMatch(_EP_TITLE_PREFIX_RE, title);
+        if (!match)
+            break;
+        title = title.slice(match[0].length).trim();
+        title = pyStrip(title, " \t\r\n:：-—–《》");
+    }
+    title = title.replace(/\s+/g, " ");
+    return pyStrip(title, " \t\r\n:：-—–《》「」『』“”\"'");
+}
+export function isTechnicalEpisodeTitle(rawTitle) {
+    const value = strOf(rawTitle).trim();
+    if (!value)
+        return true;
+    const short = cleanEpisodeShortTitle(value);
+    if (!short)
+        return true;
+    const normalized = normalizeDigits(short).trim();
+    const compact = pyStrip(normalized.replace(/\s+/g, ""), " \t\r\n:：-—–_#.");
+    if (!compact)
+        return true;
+    if (isAsciiDigitString(compact))
+        return true;
+    if (reFullMatch(_TECHNICAL_EP_TITLE_RE, normalized))
+        return true;
+    if (reFullMatch(/第[0-9一二三四五六七八九十百千零〇两]+集/, compact))
+        return true;
+    return false;
+}
+export function formatEpisodeTitle(episodeNum, rawTitle) {
+    const short = cleanEpisodeShortTitle(rawTitle);
+    if (isTechnicalEpisodeTitle(short))
+        return null;
+    return `第${episodeNum}集：${short}`;
+}
+export function extractEpisodeTitleCandidate(header) {
+    let value = strOf(header).trim().replace(/^[#=\s]*/, "");
+    const match = reMatch(_EP_TITLE_PREFIX_RE, value);
+    if (match)
+        value = value.slice(match[0].length);
+    return pyStrip(value, " \t\r\n:：-—–《》");
+}
+// ---------------------------------------------------------------------------
+// Episode plan
+// ---------------------------------------------------------------------------
+export function buildEpisodePlan(sourceText) {
+    const matches = reFindAllMatches(_EP_HEADER_RE, sourceText);
+    const episodes = [];
+    let confidence;
+    let strategy;
+    if (matches.length > 0) {
+        for (let idx = 0; idx < matches.length; idx++) {
+            const match = matches[idx];
+            const groups = match.groups ?? {};
+            const raw = groups["zh"] || groups["ep"] || String(idx + 1);
+            const epNum = parseEpNumber(raw) ?? idx + 1;
+            const end = idx + 1 < matches.length ? matches[idx + 1].index : sourceText.length;
+            const header = match[0].trim();
+            const rawTitle = extractEpisodeTitleCandidate(header);
+            const title = formatEpisodeTitle(epNum, rawTitle);
+            const titleStatus = title ? "explicit" : (rawTitle ? "technical" : "missing");
+            episodes.push({
+                episode: epNum,
+                title,
+                raw_header: header,
+                raw_title: rawTitle,
+                title_status: titleStatus,
+                title_source: title ? "source" : titleStatus,
+                source_span: { start: match.index, end },
+                header_span: { start: match.index, end: match.index + match[0].length },
+                char_count: end - match.index,
+            });
+        }
+        confidence = "high";
+        strategy = "explicit_episode_markers";
+    }
+    else {
+        episodes.push({
+            episode: 1,
+            title: null,
+            raw_header: "",
+            raw_title: "",
+            title_status: "missing",
+            title_source: "missing",
+            source_span: { start: 0, end: sourceText.length },
+            header_span: null,
+            char_count: sourceText.length,
+        });
+        confidence = "low";
+        strategy = "single_episode_fallback";
+    }
+    return {
+        version: 1,
+        strategy,
+        boundary_confidence: confidence,
+        total_episodes: episodes.length,
+        episodes,
+    };
+}
+// ---------------------------------------------------------------------------
+// Name / state utilities
+// ---------------------------------------------------------------------------
+export function cleanName(name) {
+    let value = strOf(name).trim();
+    value = reReplace(_ANNOTATION_RE, value, "");
+    return pyStrip(value, " \t\r\n:：,，、");
+}
+export function splitEntityState(raw) {
+    const value = strOf(raw).trim();
+    if (!value)
+        return ["", null];
+    const states = [];
+    for (const item of reFindAll(_STATE_RE, value)) {
+        const v = item.trim();
+        if (v)
+            states.push(v);
+    }
+    for (const item of reFindAll(_PAREN_ANNOTATION_RE, value)) {
+        const v = item.trim();
+        if (v)
+            states.push(v);
+    }
+    return [cleanName(value), states.length > 0 ? states[states.length - 1] : null];
+}
+export function stateLabelError(stateName) {
+    const text = strOf(stateName).trim().replace(/\s+/g, "");
+    if (!text)
+        return "empty";
+    if (_STATE_MIXED_SEPARATORS.some((sep) => text.includes(sep)))
+        return "mixed_state_label";
+    return null;
+}
+export function isStateLabelValid(stateName) {
+    return stateLabelError(stateName) === null;
+}
+export function stateRejectionReason(targetKind, stateName) {
+    const kind = strOf(targetKind).trim();
+    if (kind === "actor" || kind === "location" || kind === "prop") {
+        return stateLabelError(stateName);
+    }
+    const text = strOf(stateName).trim().replace(/\s+/g, "");
+    if (!text)
+        return "empty";
+    return null;
+}
+export function isReusableState(targetKind, stateName) {
+    return stateRejectionReason(targetKind, stateName) === null;
+}
+export function splitNames(raw) {
+    let s = raw.replace(/；/g, "、").replace(/;/g, "、").replace(/,/g, "、");
+    const result = [];
+    for (let item of s.split(/[、，]/)) {
+        item = item.trim();
+        if (!item || ["无", "暂无", "/", "—"].includes(item))
+            continue;
+        const [name, state] = splitEntityState(item);
+        if (name && !reSearch(/若干|众人|等人|们$|×\d+|x\d+/i, name)) {
+            result.push([name, state]);
+        }
+    }
+    return result;
+}
+export function stripLocationState(location) {
+    return splitEntityState(location);
+}
+export function parseSceneHeader(line) {
+    const timeFirst = reMatch(_SCENE_TIME_FIRST_RE, line);
+    if (timeFirst) {
+        const [locName, locState] = stripLocationState(timeFirst[5].trim());
+        return {
+            space: _SPACE_MAP[timeFirst[4]] ?? "interior",
+            time: _TIME_MAP[timeFirst[3]] ?? "day",
+            location_name: locName || "未知场景",
+            location_state: locState,
+        };
+    }
+    const locFirst = reMatch(_SCENE_LOCATION_FIRST_RE, line);
+    if (locFirst) {
+        const [locName, locState] = stripLocationState(locFirst[3].trim());
+        return {
+            space: _SPACE_MAP[locFirst[5]] ?? "interior",
+            time: _TIME_MAP[locFirst[4]] ?? "day",
+            location_name: locName || "未知场景",
+            location_state: locState,
+        };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Line spans / scene helpers
+// ---------------------------------------------------------------------------
+export function lineItemsWithSpans(text, base) {
+    const items = [];
+    let cursor = 0;
+    for (const raw of splitLinesKeepEnds(text)) {
+        const line = raw.replace(/[\r\n]+$/, "");
+        const stripped = line.trim();
+        if (stripped) {
+            const left = line.indexOf(stripped);
+            const start = base + cursor + left;
+            items.push([stripped, start, start + stripped.length]);
+        }
+        cursor += raw.length;
+    }
+    return items;
+}
+export function contentSpan(line, lineStart, content) {
+    const idx = line.indexOf(content);
+    if (idx < 0)
+        return { start: lineStart, end: lineStart + line.length };
+    return { start: lineStart + idx, end: lineStart + idx + content.length };
+}
+function ensureScene(scenes, _episodeNum) {
+    if (scenes.length > 0)
+        return scenes[scenes.length - 1];
+    const scene = {
+        scene_num: 1,
+        environment: { space: "interior", time: "day" },
+        location_name: "未知场景",
+        location_state: null,
+        actor_names: [],
+        actor_states: {},
+        prop_names: [],
+        actions: [],
+    };
+    scenes.push(scene);
+    return scene;
+}
+// ---------------------------------------------------------------------------
+// Deterministic episode extraction
+// ---------------------------------------------------------------------------
+export function deterministicExtractEpisode(sourceText, episodePlan) {
+    const span = episodePlan["source_span"];
+    const epText = sourceText.slice(span.start, span.end);
+    const scenes = [];
+    for (const [line, start] of lineItemsWithSpans(epText, span.start)) {
+        if (reMatch(_EP_HEADER_RE, line) || reMatch(_SOURCE_PREVIEW_LINE_RE, line))
+            continue;
+        const sceneHeader = parseSceneHeader(line);
+        if (sceneHeader) {
+            scenes.push({
+                scene_num: scenes.length + 1,
+                environment: { space: sceneHeader["space"], time: sceneHeader["time"] },
+                location_name: sceneHeader["location_name"],
+                location_state: sceneHeader["location_state"],
+                actor_names: [],
+                actor_states: {},
+                prop_names: [],
+                actions: [],
+            });
+            continue;
+        }
+        const scene = ensureScene(scenes, Number(episodePlan["episode"] ?? 1));
+        const charMatch = reMatch(_CHAR_RE, line);
+        if (charMatch) {
+            for (const [name, state] of splitNames(charMatch[1])) {
+                const actors = scene["actor_names"];
+                if (!actors.includes(name))
+                    actors.push(name);
+                if (state && isStateLabelValid(state)) {
+                    scene["actor_states"][name] = state;
+                }
+            }
+            continue;
+        }
+        const propMatch = reMatch(_PROP_RE, line);
+        if (propMatch) {
+            for (const [prop] of splitNames(propMatch[1])) {
+                const props = scene["prop_names"];
+                if (!props.includes(prop))
+                    props.push(prop);
+            }
+            continue;
+        }
+        const bracket = reMatch(_BRACKET_RE, line);
+        if (bracket) {
+            const label = bracket[1].trim();
+            const content = bracket[2].trim();
+            if (BRACKET_ACTION_LABELS.has(label)) {
+                scene["actions"].push({
+                    type: "action",
+                    content,
+                    source_span: contentSpan(line, start, content),
+                });
+            }
+            else {
+                const item = {
+                    type: "dialogue",
+                    content,
+                    source_span: contentSpan(line, start, content),
+                };
+                applyDialogueSpeaker(item, scene, label);
+                scene["actions"].push(item);
+            }
+            continue;
+        }
+        const action = reMatch(_ACTION_RE, line);
+        if (action) {
+            const content = action[1].trim();
+            scene["actions"].push({
+                type: "action",
+                content,
+                source_span: contentSpan(line, start, content),
+            });
+            continue;
+        }
+        const osMatch = reMatch(_OS_RE, line);
+        if (osMatch) {
+            const speaker = cleanName(osMatch[1]);
+            const content = osMatch[2].trim();
+            const item = {
+                type: "inner_thought",
+                content,
+                source_span: contentSpan(line, start, content),
+            };
+            applyDialogueSpeaker(item, scene, speaker);
+            scene["actions"].push(item);
+            continue;
+        }
+        const dialogue = reMatch(_DIALOGUE_RE, line);
+        if (dialogue) {
+            const speaker = cleanName(dialogue[1]);
+            const emotion = dialogue[2] ? dialogue[2].trim() : null;
+            const content = dialogue[3].trim();
+            if (speaker && speaker !== "旁白") {
+                const item = {
+                    type: "dialogue",
+                    speaker,
+                    content,
+                    source_span: contentSpan(line, start, content),
+                };
+                applyDialogueSpeaker(item, scene, speaker);
+                if (emotion)
+                    item["emotion"] = emotion;
+                scene["actions"].push(item);
+            }
+            else {
+                scene["actions"].push({
+                    type: "action",
+                    content,
+                    source_span: contentSpan(line, start, content),
+                });
+            }
+            continue;
+        }
+        scene["actions"].push({
+            type: "action",
+            content: line,
+            source_span: { start, end: start + line.length },
+        });
+    }
+    if (scenes.length === 0) {
+        scenes.push({
+            scene_num: 1,
+            environment: { space: "interior", time: "day" },
+            location_name: "未知场景",
+            location_state: null,
+            actor_names: [],
+            actor_states: {},
+            prop_names: [],
+            actions: [],
+        });
+    }
+    return {
+        episode: episodePlan["episode"],
+        title: episodePlan["title"],
+        source_span: episodePlan["source_span"],
+        scenes,
+    };
+}
+// ---------------------------------------------------------------------------
+// Misc number helpers
+// ---------------------------------------------------------------------------
+export function normalizeInt(value, defaultVal) {
+    if (typeof value === "number" && Number.isInteger(value))
+        return value;
+    const text = strOf(value).trim();
+    if (isAsciiDigitString(text))
+        return parseInt(text, 10);
+    const match = reSearch(/(\d+)\s*$/, text);
+    return match ? parseInt(match[1], 10) : defaultVal;
+}
+// ---------------------------------------------------------------------------
+// Source line classification
+// ---------------------------------------------------------------------------
+export function validateResultActionTypes(planItem, result) {
+    let label = `episode ${planItem["episode"]}`;
+    if (planItem["batch_id"]) {
+        label = `${planItem["batch_id"]} episode ${planItem["episode"]} part ${planItem["part"]}`;
+    }
+    const scenes = asList(result["scenes"]);
+    for (let i = 0; i < scenes.length; i++) {
+        const scene = scenes[i];
+        const actions = asList(scene["actions"]);
+        for (let j = 0; j < actions.length; j++) {
+            const action = actions[j];
+            const kind = strOf(action["type"]).trim();
+            if (!ACTION_TYPE_VALUES.has(kind)) {
+                throw new CliError("INIT FAILED: Provider returned unsupported action type", "Provider returned unsupported action type.", {
+                    exitCode: EXIT_NEEDS_AGENT,
+                    required: ["action.type from final contract: dialogue, inner_thought, action"],
+                    received: [`${label} scene ${i + 1} action ${j + 1}: ${kind || "<empty>"}`],
+                    nextSteps: ["Rerun init; the invalid checkpoint will not be reused."],
+                });
+            }
+        }
+    }
+}
+export function validateEpisodeExtractionQuality(_sourceText, episodePlan, result) {
+    validateResultActionTypes(episodePlan, result);
+}
+export function isMetadataLine(line) {
+    return Boolean(reMatch(_EP_HEADER_RE, line) ||
+        reMatch(_SOURCE_SCENE_LINE_RE, line) ||
+        reMatch(_SOURCE_META_LINE_RE, line) ||
+        reMatch(_SOURCE_PREVIEW_LINE_RE, line));
+}
+export function isSceneLine(line) {
+    return Boolean(reMatch(_SOURCE_SCENE_LINE_RE, line) || parseSceneHeader(line));
+}
+export function extractSourceLineAction(line, start) {
+    if (isMetadataLine(line) || isSceneLine(line) || reMatch(_CHAR_RE, line) || reMatch(_PROP_RE, line)) {
+        return null;
+    }
+    const bracket = reMatch(_BRACKET_RE, line);
+    if (bracket) {
+        const label = bracket[1].trim();
+        const content = bracket[2].trim();
+        if (!content)
+            return null;
+        const span = contentSpan(line, start, content);
+        if (BRACKET_ACTION_LABELS.has(label)) {
+            return { type: "action", content, source_span: span };
+        }
+        const speaker = cleanName(label);
+        const result = { type: "dialogue", speaker, content, source_span: span };
+        const speakerKind = inferNonActorSpeakerKind(speaker);
+        if (speakerKind !== "actor")
+            result["speaker_kind"] = speakerKind;
+        return result;
+    }
+    const action = reMatch(_ACTION_RE, line);
+    if (action) {
+        const content = action[1].trim();
+        if (!content)
+            return null;
+        return { type: "action", content, source_span: contentSpan(line, start, content) };
+    }
+    const osMatch = reMatch(_OS_EXT_RE, line);
+    if (osMatch) {
+        const content = osMatch[3].trim();
+        if (!content)
+            return null;
+        const rawEmotion = pyStrip(osMatch[2].trim().slice(2), " ，,、");
+        const result = {
+            type: "inner_thought",
+            speaker: cleanName(osMatch[1]),
+            content,
+            source_span: contentSpan(line, start, content),
+        };
+        if (rawEmotion)
+            result["emotion"] = rawEmotion;
+        return result;
+    }
+    if (reMatch(_BRACKET_PREFIX_RE, line)) {
+        return { type: "action", content: line, source_span: { start, end: start + line.length } };
+    }
+    const dialogue = reMatch(_DIALOGUE_RE, line);
+    if (dialogue) {
+        const content = dialogue[3].trim();
+        if (!content)
+            return null;
+        const speaker = cleanName(dialogue[1]);
+        if (speaker && speaker !== "旁白") {
+            const result = { type: "dialogue", speaker, content, source_span: contentSpan(line, start, content) };
+            const speakerKind = inferNonActorSpeakerKind(speaker);
+            if (speakerKind !== "actor")
+                result["speaker_kind"] = speakerKind;
+            const emotion = dialogue[2] ? dialogue[2].trim() : "";
+            if (emotion)
+                result["emotion"] = emotion;
+            return result;
+        }
+        return { type: "action", content, source_span: contentSpan(line, start, content) };
+    }
+    if (reMatch(_EMPTY_SPEAKER_LINE_RE, line))
+        return null;
+    return { type: "action", content: line, source_span: { start, end: start + line.length } };
+}
+export function sourceContentLineRecords(sourceText, planItem) {
+    const span = planItem["source_span"];
+    const records = [];
+    for (const [line, start, end] of lineItemsWithSpans(sourceText.slice(span.start, span.end), span.start)) {
+        const action = extractSourceLineAction(line, start);
+        if (action === null)
+            continue;
+        records.push({
+            id: `l${String(records.length + 1).padStart(3, "0")}`,
+            line,
+            start,
+            end,
+            action,
+        });
+    }
+    return records;
+}
+// ---------------------------------------------------------------------------
+// Episode titles
+// ---------------------------------------------------------------------------
+export function episodesNeedingGeneratedTitles(episodePlan) {
+    const out = [];
+    for (const episode of asList(episodePlan["episodes"])) {
+        if (!isDict(episode))
+            continue;
+        const title = strOf(episode["title"]).trim();
+        const status = strOf(episode["title_status"]).trim();
+        if (!title || status === "missing" || status === "technical" || isTechnicalEpisodeTitle(title)) {
+            out.push(episode);
+        }
+    }
+    return out;
+}
+export function deterministicEpisodeShortTitle(sourceText, episode) {
+    for (const record of sourceContentLineRecords(sourceText, episode)) {
+        const action = isDict(record["action"]) ? record["action"] : {};
+        let content = strOf(action["content"] || record["line"]).trim();
+        content = content.replace(/[^\w一-鿿]+/gu, "");
+        if (content.length >= 2)
+            return content.slice(0, 8);
+    }
+    const episodeNum = episode["episode"];
+    const suffix = episodeNum ? strOf(episodeNum).trim() : "";
+    return suffix ? `剧情转折${suffix}` : "剧情转折";
+}
+export function buildEpisodeTitleContext(sourceText, episodePlan) {
+    const context = [];
+    for (const episode of episodesNeedingGeneratedTitles(episodePlan)) {
+        const records = sourceContentLineRecords(sourceText, episode);
+        const previewLines = [];
+        for (const r of records.slice(0, 10)) {
+            const v = strOf(r["line"]).trim();
+            if (v)
+                previewLines.push(v);
+        }
+        const tailLines = [];
+        for (const r of records.slice(-4)) {
+            const v = strOf(r["line"]).trim();
+            if (v)
+                tailLines.push(v);
+        }
+        context.push({
+            episode: Number(episode["episode"] ?? 0),
+            raw_header: strOf(episode["raw_header"]).trim(),
+            title_status: strOf(episode["title_status"]).trim() || "missing",
+            preview: previewLines,
+            ending: tailLines,
+        });
+    }
+    return context;
+}
+export function episodeTitleResponseMap(payload) {
+    const rawItems = isDict(payload) ? payload["episode_titles"] : payload;
+    const result = new Map();
+    if (!isList(rawItems))
+        return result;
+    for (const item of rawItems) {
+        if (!isDict(item))
+            continue;
+        const episodeNum = episodeNumberFromValue(item["episode"] ?? item["episode_id"]);
+        const title = strOf(item["title"]).trim();
+        if (episodeNum && title)
+            result.set(episodeNum, title);
+    }
+    return result;
+}
+export async function enrichEpisodePlanTitles(sourceText, episodePlan, provider) {
+    const needsTitles = episodesNeedingGeneratedTitles(episodePlan);
+    if (needsTitles.length === 0)
+        return episodePlan;
+    let payload;
+    if (provider.extractEpisodeTitles) {
+        payload = await provider.extractEpisodeTitles(sourceText, episodePlan);
+    }
+    else {
+        payload = {
+            episode_titles: needsTitles.map((ep) => ({
+                episode: Number(ep["episode"] ?? 0),
+                title: deterministicEpisodeShortTitle(sourceText, ep),
+            })),
+        };
+    }
+    const generated = episodeTitleResponseMap(payload);
+    for (const episode of needsTitles) {
+        const episodeNum = Number(episode["episode"] ?? 0);
+        let rawTitle = generated.get(episodeNum) || deterministicEpisodeShortTitle(sourceText, episode);
+        let title = formatEpisodeTitle(episodeNum, rawTitle);
+        if (!title) {
+            rawTitle = deterministicEpisodeShortTitle(sourceText, episode);
+            title = formatEpisodeTitle(episodeNum, rawTitle) || `第${episodeNum}集：剧情转折${episodeNum}`;
+        }
+        episode["generated_title"] = rawTitle;
+        episode["title"] = title;
+        episode["title_status"] = "generated";
+        episode["title_source"] = "generated";
+    }
+    return episodePlan;
+}
+// ---------------------------------------------------------------------------
+// Batch source formatting and planning
+// ---------------------------------------------------------------------------
+export function formatBatchSource(sourceText, batchPlan) {
+    const span = batchPlan["source_span"];
+    const contentStarts = new Set();
+    for (const r of sourceContentLineRecords(sourceText, batchPlan)) {
+        contentStarts.add(Number(r["start"]));
+    }
+    const lines = [];
+    for (const [line, start] of lineItemsWithSpans(sourceText.slice(span.start, span.end), span.start)) {
+        lines.push(contentStarts.has(start) ? line : `[meta] ${line}`);
+    }
+    return lines.join("\n");
+}
+export function lineNumberAt(sourceText, offset) {
+    return countOccurrences(sourceText, "\n", Math.max(0, offset)) + 1;
+}
+export function batchContextFor(sourceText, episode, start) {
+    const context = {};
+    const headerSpan = episode["header_span"];
+    if (isDict(headerSpan) && typeof headerSpan["start"] === "number" && typeof headerSpan["end"] === "number") {
+        context["episode_header"] = sourceText.slice(headerSpan["start"], headerSpan["end"]).trim();
+    }
+    let latestScene = "";
+    let latestCharacters = "";
+    let latestProps = "";
+    const span = episode["source_span"];
+    for (const [line, , lineEnd] of lineItemsWithSpans(sourceText.slice(span.start, start), span.start)) {
+        if (lineEnd > start)
+            break;
+        if (isSceneLine(line))
+            latestScene = line;
+        else if (reMatch(_CHAR_RE, line))
+            latestCharacters = line;
+        else if (reMatch(_PROP_RE, line))
+            latestProps = line;
+    }
+    if (latestScene)
+        context["scene_header"] = latestScene;
+    if (latestCharacters)
+        context["characters"] = latestCharacters;
+    if (latestProps)
+        context["props"] = latestProps;
+    return context;
+}
+function batchResultKey(batch) {
+    const bid = strOf(batch["batch_id"]).trim();
+    if (bid)
+        return bid;
+    return `bat_${String(Number(batch["batch_index"] ?? 0)).padStart(4, "0")}`;
+}
+export function makeBatch(sourceText, episode, batchIndex, part, lines) {
+    const epSpan = episode["source_span"];
+    const start = lines.length > 0 ? lines[0][1] : epSpan.start;
+    const end = lines.length > 0 ? lines[lines.length - 1][2] : epSpan.end;
+    const firstLine = lines.length > 0 ? lines[0][0] : "";
+    let signalCount = 0;
+    for (const [line, lstart] of lines) {
+        if (extractSourceLineAction(line, lstart) !== null)
+            signalCount += 1;
+    }
+    return {
+        batch_id: `bat_${String(batchIndex).padStart(4, "0")}`,
+        episode: Number(episode["episode"]),
+        title: episode["title"],
+        part,
+        source_span: { start, end },
+        line_range: { start: lineNumberAt(sourceText, start), end: lineNumberAt(sourceText, end) },
+        signal_line_count: signalCount,
+        starts_inside_scene: part > 1 && !isSceneLine(firstLine),
+        context: batchContextFor(sourceText, episode, start),
+    };
+}
+export function buildBatchPlan(sourceText, episodePlan, opts = {}) {
+    const targetLines = opts.targetLines ?? DEFAULT_BATCH_TARGET_LINES;
+    const maxChars = opts.maxChars ?? DEFAULT_BATCH_MAX_CHARS;
+    const minLines = opts.minLines ?? DEFAULT_BATCH_MIN_LINES;
+    const mode = opts.mode ?? DEFAULT_BATCH_MODE;
+    if (mode !== "episode") {
+        throw new Error(`Unsupported batch mode: ${mode}`);
+    }
+    const batches = [];
+    let batchIndex = 0;
+    for (const episode of asList(episodePlan["episodes"])) {
+        if (!isDict(episode))
+            continue;
+        const epSpan = episode["source_span"];
+        const items = lineItemsWithSpans(sourceText.slice(epSpan.start, epSpan.end), epSpan.start);
+        if (items.length === 0) {
+            batchIndex += 1;
+            batches.push(makeBatch(sourceText, episode, batchIndex, 1, []));
+            continue;
+        }
+        let startIdx = 0;
+        let part = 1;
+        let signalCount = 0;
+        for (let idx = 0; idx < items.length; idx++) {
+            const [line, lstart, lend] = items[idx];
+            if (extractSourceLineAction(line, lstart) !== null)
+                signalCount += 1;
+            const currentStart = items[startIdx][1];
+            const charCount = lend - currentStart;
+            const nextIsScene = idx + 1 < items.length && isSceneLine(items[idx + 1][0]);
+            const currentIsMetadata = isMetadataLine(line);
+            const shouldCut = idx + 1 < items.length &&
+                signalCount >= minLines &&
+                (signalCount >= targetLines ||
+                    charCount >= maxChars ||
+                    (nextIsScene && signalCount >= minLines)) &&
+                !currentIsMetadata;
+            if (shouldCut) {
+                batchIndex += 1;
+                batches.push(makeBatch(sourceText, episode, batchIndex, part, items.slice(startIdx, idx + 1)));
+                startIdx = idx + 1;
+                part += 1;
+                signalCount = 0;
+            }
+        }
+        if (startIdx < items.length) {
+            batchIndex += 1;
+            batches.push(makeBatch(sourceText, episode, batchIndex, part, items.slice(startIdx)));
+        }
+    }
+    return {
+        version: 1,
+        mode,
+        target_lines: targetLines,
+        max_chars: maxChars,
+        min_lines: minLines,
+        total_batches: batches.length,
+        total_episodes: Number(episodePlan["total_episodes"] ?? asList(episodePlan["episodes"]).length),
+        batches,
+    };
+}
+export function validateBatchExtractionQuality(_sourceText, batchPlan, result) {
+    validateResultActionTypes(batchPlan, result);
+}
+export function recoverBatchFromSource(sourceText, batchPlan) {
+    const result = normalizeEpisodeResult(deterministicExtractEpisode(sourceText, batchPlan), batchPlan);
+    validateBatchExtractionQuality(sourceText, batchPlan, result);
+    return result;
+}
+export function isRecoverableBatchCliError(exc) {
+    return (exc.title === "INIT FAILED: Provider output truncated" ||
+        exc.title === "INIT FAILED: Provider returned invalid markdown" ||
+        exc.title === "INIT FAILED: Provider returned unsupported action type");
+}
+export function isRetryableProviderError(exc) {
+    const anyExc = exc;
+    const statusCode = normalizeInt(anyExc?.status_code ?? anyExc?.statusCode ?? anyExc?.status, 0);
+    if ([408, 409, 429, 500, 502, 503, 504, 529].includes(statusCode))
+        return true;
+    if ([400, 401, 403, 404].includes(statusCode))
+        return false;
+    const name = (anyExc?.name ?? "").toLowerCase();
+    const message = (typeof exc === "object" && exc !== null && "message" in exc ? String(exc.message) : String(exc)).toLowerCase();
+    const retryMarkers = [
+        "apierror", "apiconnectionerror", "apitimeouterror", "ratelimiterror",
+        "remoteprotocolerror", "timeout", "overloaded", "rate_limit", "temporarily",
+        "service unavailable", "bad gateway", "gateway timeout", "connection reset",
+        "peer closed", "incomplete chunked read",
+    ];
+    return retryMarkers.some((m) => name.includes(m) || message.includes(m));
+}
+export function providerAttempts() {
+    const raw = (process.env.SCRIPTCTL_PROVIDER_ATTEMPTS ?? "").trim();
+    let attempts = DEFAULT_PROVIDER_ATTEMPTS;
+    if (raw) {
+        const parsed = parseInt(raw, 10);
+        if (!Number.isNaN(parsed))
+            attempts = parsed;
+    }
+    return Math.max(1, Math.min(attempts, 6));
+}
+export async function providerExtractBatch(provider, sourceText, batch) {
+    if (provider.extractBatch)
+        return await provider.extractBatch(sourceText, batch);
+    if (provider.extractEpisode)
+        return await provider.extractEpisode(sourceText, batch);
+    throw new Error("Provider has neither extractBatch nor extractEpisode");
+}
+export async function providerExtractAssetCuration(provider, sourceText, script) {
+    if (provider.extractAssetCuration) {
+        const payload = await provider.extractAssetCuration(sourceText, script);
+        return isDict(payload) ? payload : {};
+    }
+    return {};
+}
+function sleepMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function extractBatchWithRecovery(provider, sourceText, batch) {
+    const attempts = providerAttempts();
+    let lastExc = null;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            const rawResult = await providerExtractBatch(provider, sourceText, batch);
+            const result = normalizeEpisodeResult(rawResult, batch);
+            validateBatchExtractionQuality(sourceText, batch, result);
+            return result;
+        }
+        catch (exc) {
+            const retryable = isRetryableProviderError(exc);
+            if (retryable && attempt < attempts) {
+                lastExc = exc;
+                await sleepMs(Math.min(8000, 800 * attempt));
+                continue;
+            }
+            throw exc;
+        }
+    }
+    if (lastExc)
+        throw lastExc;
+    throw new CliError("INIT FAILED: Batch extraction failed", "Batch extraction failed.", {
+        exitCode: EXIT_RUNTIME,
+        required: ["provider result that passes batch quality gates"],
+        received: [batchResultKey(batch)],
+        nextSteps: ["Rerun init; only failed batches will retry."],
+    });
+}
+// ---------------------------------------------------------------------------
+// Markdown parsing helpers
+// ---------------------------------------------------------------------------
+function _mdInvalid(label, detail) {
+    return new CliError("INIT FAILED: Provider returned invalid markdown", "Provider returned invalid markdown.", {
+        exitCode: EXIT_RUNTIME,
+        required: ["markdown matching the documented batch template"],
+        received: [`${label}: ${detail}`],
+        nextSteps: ["Rerun init; the invalid batch checkpoint will not be reused."],
+    });
+}
+export function _md_push_asset(items, rawName, description) {
+    const name = cleanName(strOf(rawName));
+    if (!name)
+        return;
+    for (const item of items) {
+        if (item["name"] === name) {
+            if (description && !item["description"])
+                item["description"] = description;
+            return;
+        }
+    }
+    items.push({ name, description: description || null });
+}
+function _md_push_state_def(items, kind, rawName, description) {
+    const [namePart, sep, statePart] = partition(strOf(rawName), "|");
+    const assetName = cleanName(namePart);
+    const stateName = statePart.trim();
+    if (!sep || !assetName || !stateName)
+        return;
+    for (const item of items) {
+        if (item["kind"] === kind && item["asset_name"] === assetName && item["state_name"] === stateName) {
+            if (description && !item["description"])
+                item["description"] = description;
+            return;
+        }
+    }
+    items.push({ kind, asset_name: assetName, state_name: stateName, description: description || null });
+}
+export function parseSpeakerRef(raw) {
+    const value = strOf(raw).trim();
+    if (!value)
+        return ["actor", ""];
+    if (value.includes(":") || value.includes("：")) {
+        const parts = reSplit(/[:：]/, value, 1);
+        const left = parts[0] ?? "";
+        const right = parts[2] ?? "";
+        const kind = _MD_SPEAKER_KIND_NORM[left.trim().toLowerCase()] ?? _MD_SPEAKER_KIND_NORM[left.trim()];
+        if (kind)
+            return [kind, right.trim()];
+    }
+    return ["actor", value];
+}
+export function parseSpeakerAsset(raw) {
+    const value = strOf(raw).trim();
+    const [kind, name] = parseSpeakerRef(value);
+    if (kind !== "actor")
+        return [kind, name];
+    const match = reMatch(/^(.+?)[（(]([^）)]+)[）)]$/, value);
+    if (match) {
+        const parsedKind = _MD_SPEAKER_KIND_NORM[match[2].trim().toLowerCase()] ?? _MD_SPEAKER_KIND_NORM[match[2].trim()];
+        if (parsedKind && parsedKind !== "actor")
+            return [parsedKind, match[1].trim()];
+    }
+    return ["other", value];
+}
+export function inferNonActorSpeakerKind(name, scene = null) {
+    const value = strOf(name).trim();
+    if (!value)
+        return "actor";
+    if (reSearch(/系统|提示音|提示声|机械音|电子音/, value))
+        return "system";
+    if (reSearch(/广播(?!员)|喇叭|电台|播报|通知|警报/, value))
+        return "broadcast";
+    if (reSearch(/众人|众|群体|全体|大家|人群/, value))
+        return "group";
+    if (scene) {
+        const propSet = new Set(asList(scene["prop_names"]).map((p) => strOf(p).trim()));
+        if (propSet.has(value))
+            return "prop";
+        if (value === strOf(scene["location_name"]).trim())
+            return "location";
+    }
+    return "actor";
+}
+export function normalizeDeliveryToken(value) {
+    const token = strOf(value).trim();
+    if (!token)
+        return "";
+    return _MD_DELIVERY_NORM[token.toLowerCase()] ?? _MD_DELIVERY_NORM[token] ?? "";
+}
+export function contentHasSpeakerPrefix(content, speakerNames) {
+    for (const rawPart of reSplit(/\s*(?:\/|／|\n)\s*/, strOf(content))) {
+        const part = rawPart.trim();
+        if (!part || (!part.includes(":") && !part.includes("：")))
+            continue;
+        const prefix = reSplit(/[:：]/, part, 1)[0].trim();
+        if (!prefix)
+            continue;
+        if (speakerNames.has(prefix))
+            return true;
+        if (_MD_SPEAKER_KIND_NORM[prefix.toLowerCase()] || _MD_SPEAKER_KIND_NORM[prefix])
+            return true;
+    }
+    return false;
+}
+export function splitSpeakerRefs(raw) {
+    const value = strOf(raw).trim();
+    if (!value)
+        return [];
+    if (normalizeDeliveryToken(value))
+        return [];
+    const parts = reSplit(/\s*(?:\/|／|\+|&|、|，|,|\s+和\s+|\s+与\s+)\s*/, value);
+    return parts.filter((p) => p.trim().length > 0).map((p) => p.trim());
+}
+export function speakerRefEntry(scene, rawSpeaker, defaultKind = "actor") {
+    const [explicitKind, raw] = parseSpeakerRef(rawSpeaker);
+    const speaker = cleanName(raw);
+    if (!speaker)
+        return null;
+    let speakerKind = explicitKind !== "actor" ? explicitKind : defaultKind;
+    if (speakerKind === "actor") {
+        const inferred = inferNonActorSpeakerKind(speaker, scene);
+        speakerKind = inferred !== "actor" ? inferred : "actor";
+    }
+    if (speakerKind === "prop") {
+        const props = asList(scene["prop_names"]);
+        if (!props.includes(speaker)) {
+            if (!Array.isArray(scene["prop_names"]))
+                scene["prop_names"] = [];
+            scene["prop_names"].push(speaker);
+        }
+    }
+    if (speakerKind === "actor") {
+        const actors = scene["actor_names"];
+        if (!actors.includes(speaker))
+            actors.push(speaker);
+    }
+    return { speaker, speaker_kind: speakerKind };
+}
+export function applyDialogueSpeaker(action, scene, rawSpeaker, defaultKind = "actor") {
+    const entry = speakerRefEntry(scene, rawSpeaker, defaultKind);
+    if (!entry)
+        return;
+    action["speaker"] = entry.speaker;
+    if (entry.speaker_kind !== "actor")
+        action["speaker_kind"] = entry.speaker_kind;
+}
+export function parseOverlapMarkdownLines(content, scene) {
+    const lines = [];
+    for (const rawPart of reSplit(/\s*(?:\/|／|\n)\s*/, strOf(content).trim())) {
+        const part = rawPart.trim();
+        if (!part || (!part.includes(":") && !part.includes("：")))
+            continue;
+        const pieces = reSplit(/[:：]/, part);
+        let rawSpeaker;
+        let lineContent;
+        if (pieces.length >= 3) {
+            const maybeKind = pieces[0].trim();
+            const parsedKind = _MD_SPEAKER_KIND_NORM[maybeKind.toLowerCase()] ?? _MD_SPEAKER_KIND_NORM[maybeKind];
+            if (parsedKind && parsedKind !== "actor") {
+                rawSpeaker = `${parsedKind}:${pieces[1].trim()}`;
+                lineContent = pieces.slice(2).join(":");
+            }
+            else {
+                const parts = reSplit(/[:：]/, part, 1);
+                rawSpeaker = parts[0] ?? "";
+                lineContent = parts[2] ?? "";
+            }
+        }
+        else {
+            const parts = reSplit(/[:：]/, part, 1);
+            rawSpeaker = parts[0] ?? "";
+            lineContent = parts[2] ?? "";
+        }
+        const entry = speakerRefEntry(scene, rawSpeaker);
+        lineContent = lineContent.trim();
+        if (!entry || !lineContent)
+            continue;
+        lines.push({ speaker: entry.speaker, speaker_kind: entry.speaker_kind, content: lineContent });
+    }
+    return lines;
+}
+function applyMarkdownDialogueAnchor(action, scene, rawSpeakerArg, rawTag) {
+    let raw_speaker = rawSpeakerArg;
+    let delivery = normalizeDeliveryToken(rawTag);
+    let emotion = delivery ? "" : strOf(rawTag).trim();
+    if (!delivery && normalizeDeliveryToken(raw_speaker)) {
+        delivery = normalizeDeliveryToken(raw_speaker);
+        raw_speaker = "";
+    }
+    if (delivery === "overlap") {
+        const lines = parseOverlapMarkdownLines(strOf(action["content"]), scene);
+        if (lines.length > 0) {
+            action["delivery"] = "overlap";
+            action["lines"] = lines;
+            action["content"] = lines.map((l) => l.content).join(" / ");
+        }
+        else if (raw_speaker) {
+            applyDialogueSpeaker(action, scene, raw_speaker);
+            action["delivery"] = "overlap";
+        }
+    }
+    else if (raw_speaker) {
+        const speakerRefs = splitSpeakerRefs(raw_speaker);
+        if (speakerRefs.length > 1) {
+            const speakers = [];
+            for (const ref of speakerRefs) {
+                const entry = speakerRefEntry(scene, ref);
+                if (entry)
+                    speakers.push(entry);
+            }
+            if (speakers.length > 0) {
+                action["speakers"] = speakers;
+                action["delivery"] = delivery || "simultaneous";
+                action["speaker"] = speakers.map((s) => s.speaker).join(" / ");
+            }
+        }
+        else {
+            applyDialogueSpeaker(action, scene, raw_speaker);
+            if (delivery && delivery !== "single")
+                action["delivery"] = delivery;
+        }
+    }
+    if (emotion)
+        action["emotion"] = emotion;
+}
+export function parseMarkdownBatch(text, batchPlan) {
+    const label = `${batchPlan["batch_id"] || "batch"} episode ${batchPlan["episode"]} part ${batchPlan["part"]}`;
+    let section = null;
+    let assetSubsection = null;
+    const scenes = [];
+    const actors = [];
+    const locations = [];
+    const props = [];
+    const speakers = [];
+    const stateDefs = [];
+    let lastAction = null;
+    for (const rawLine of text.split(/\r?\n/)) {
+        const stripped = rawLine.trim();
+        const subMatch = reMatch(_MD_SUB_HEADER_RE, stripped);
+        const sceneMatch = subMatch ? reMatch(_MD_SCENE_HEADER_RE, stripped) : null;
+        if (sceneMatch && section === "script") {
+            scenes.push({
+                scene_num: parseInt(sceneMatch[1], 10),
+                environment: { space: "interior", time: "day" },
+                location_name: "未知场景",
+                location_state: null,
+                actor_names: [],
+                actor_states: {},
+                prop_names: [],
+                actions: [],
+            });
+            lastAction = null;
+            continue;
+        }
+        if (subMatch && section === "asset") {
+            const heading = subMatch[1].trim();
+            assetSubsection = _MD_ASSET_SUBSECTION_MAP[heading] ?? null;
+            lastAction = null;
+            continue;
+        }
+        if (subMatch) {
+            lastAction = null;
+            continue;
+        }
+        const topMatch = reMatch(_MD_TOP_HEADER_RE, stripped);
+        if (topMatch) {
+            const heading = topMatch[1].trim();
+            if (heading.startsWith("剧本")) {
+                section = "script";
+            }
+            else if (heading.startsWith("资产")) {
+                section = "asset";
+                assetSubsection = null;
+            }
+            else {
+                section = null;
+            }
+            lastAction = null;
+            continue;
+        }
+        if (section === "script") {
+            const fieldMatch = reMatch(_MD_SCENE_FIELD_RE, stripped);
+            if (fieldMatch && scenes.length > 0) {
+                const scene = scenes[scenes.length - 1];
+                const key = fieldMatch[1];
+                const value = fieldMatch[2].trim();
+                if (key === "时空") {
+                    const tsMatch = reMatch(_MD_TIME_SPACE_RE, value);
+                    if (tsMatch) {
+                        scene["environment"] = {
+                            space: _MD_SPACE_NORM[tsMatch[1].toLowerCase()] ?? "interior",
+                            time: _MD_TIME_NORM[tsMatch[2].toLowerCase()] ?? "day",
+                        };
+                    }
+                    else {
+                        const env = scene["environment"];
+                        for (const tok of value.split(/\s+/)) {
+                            const tl = tok.toLowerCase();
+                            if (tl in _MD_SPACE_NORM)
+                                env["space"] = _MD_SPACE_NORM[tl];
+                            if (tl in _MD_TIME_NORM)
+                                env["time"] = _MD_TIME_NORM[tl];
+                        }
+                    }
+                }
+                else if (key === "地点") {
+                    const locMatch = reMatch(_MD_LOC_STATE_RE, value);
+                    if (locMatch) {
+                        const [locName, locStateFromName] = splitEntityState(value);
+                        scene["location_name"] = locName || "未知场景";
+                        const locState = (locMatch[2] || locStateFromName || "").trim();
+                        scene["location_state"] = locState && isReusableState("location", locState) ? locState : null;
+                    }
+                }
+                else if (key === "角色") {
+                    for (let entry of value.split(/[,，、]/)) {
+                        entry = entry.trim();
+                        if (!entry)
+                            continue;
+                        const charMatch = reMatch(_MD_CHAR_ENTRY_RE, entry);
+                        if (!charMatch)
+                            continue;
+                        const [name, inferredState] = splitEntityState(entry);
+                        const state = (charMatch[2] || inferredState || "").trim() || null;
+                        if (!name)
+                            continue;
+                        const actorNames = scene["actor_names"];
+                        if (!actorNames.includes(name))
+                            actorNames.push(name);
+                        if (state && isReusableState("actor", state)) {
+                            scene["actor_states"][name] = state;
+                        }
+                    }
+                }
+                else if (key === "道具") {
+                    for (const entry of value.split(/[,，、]/)) {
+                        const [prop] = splitEntityState(entry);
+                        const propNames = scene["prop_names"];
+                        if (prop && !propNames.includes(prop))
+                            propNames.push(prop);
+                    }
+                }
+                lastAction = null;
+                continue;
+            }
+            const actionMatch = reMatch(_MD_ACTION_ANCHOR_RE, stripped);
+            if (actionMatch && scenes.length > 0) {
+                const kindRaw = actionMatch[1].toLowerCase();
+                const kind = _MD_KIND_NORM[kindRaw];
+                if (!kind)
+                    throw _mdInvalid(label, `unknown action kind in anchor: ${kindRaw}`);
+                const rawSpeaker = (actionMatch[2] || "").trim();
+                const rawTag = (actionMatch[3] || "").trim();
+                const content = (actionMatch[4] || "").replace(/\s+$/, "");
+                const action = { type: kind, content };
+                if (kind === "dialogue") {
+                    applyMarkdownDialogueAnchor(action, scenes[scenes.length - 1], rawSpeaker, rawTag);
+                }
+                else {
+                    if (rawSpeaker)
+                        applyDialogueSpeaker(action, scenes[scenes.length - 1], rawSpeaker);
+                    if (rawTag)
+                        action["emotion"] = rawTag;
+                }
+                scenes[scenes.length - 1]["actions"].push(action);
+                lastAction = action;
+                continue;
+            }
+            if (!stripped) {
+                lastAction = null;
+                continue;
+            }
+            if (lastAction !== null && !stripped.startsWith("-")) {
+                if (lastAction["content"]) {
+                    lastAction["content"] = strOf(lastAction["content"]) + "\n" + stripped;
+                }
+                else {
+                    lastAction["content"] = stripped;
+                }
+                continue;
+            }
+        }
+        else if (section === "asset") {
+            if (assetSubsection === null || !stripped)
+                continue;
+            const entryMatch = reMatch(_MD_ASSET_ENTRY_RE, stripped);
+            if (entryMatch) {
+                const name = entryMatch[1].trim();
+                const description = (entryMatch[2] || "").trim() || null;
+                if (assetSubsection === "actors")
+                    _md_push_asset(actors, name, description);
+                else if (assetSubsection === "locations")
+                    _md_push_asset(locations, name, description);
+                else if (assetSubsection === "props")
+                    _md_push_asset(props, name, description);
+                else if (assetSubsection === "speakers") {
+                    const [sourceKind, displayName] = parseSpeakerAsset(name);
+                    if (displayName)
+                        speakers.push({ name: displayName, source_kind: sourceKind, description });
+                }
+                else if (assetSubsection === "actor_states") {
+                    _md_push_state_def(stateDefs, "actor", name, description);
+                }
+                else if (assetSubsection === "location_states") {
+                    _md_push_state_def(stateDefs, "location", name, description);
+                }
+                else if (assetSubsection === "prop_states") {
+                    _md_push_state_def(stateDefs, "prop", name, description);
+                }
+            }
+        }
+    }
+    for (const scene of scenes) {
+        scene["actions"] = scene["actions"].filter((a) => strOf(a["content"]).trim().length > 0);
+    }
+    const stateLookup = new Map();
+    for (const stateDef of stateDefs) {
+        const key = `${strOf(stateDef["kind"])}::${strOf(stateDef["asset_name"])}`;
+        if (!stateLookup.has(key))
+            stateLookup.set(key, new Set());
+        stateLookup.get(key).add(strOf(stateDef["state_name"]).trim());
+    }
+    for (const scene of scenes) {
+        const actorStates = scene["actor_states"] || {};
+        const filteredActorStates = {};
+        for (const [actorName, stateName] of Object.entries(actorStates)) {
+            const allowed = stateLookup.get(`actor::${actorName.trim()}`) ?? new Set();
+            if (allowed.has(strOf(stateName).trim()))
+                filteredActorStates[actorName] = stateName;
+        }
+        scene["actor_states"] = filteredActorStates;
+        const locName = strOf(scene["location_name"]).trim();
+        const locState = strOf(scene["location_state"]).trim();
+        if (locState) {
+            const allowed = stateLookup.get(`location::${locName}`) ?? new Set();
+            if (!allowed.has(locState))
+                scene["location_state"] = null;
+        }
+    }
+    if (scenes.length === 0) {
+        throw _mdInvalid(label, "no scenes parsed; expected '## 场景 N' headers under '# 剧本'");
+    }
+    return {
+        episode: Number(batchPlan["episode"] ?? 0),
+        title: batchPlan["title"],
+        source_span: batchPlan["source_span"],
+        scenes,
+        actors,
+        locations,
+        props,
+        speakers,
+        state_definitions: stateDefs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Compact / expand transforms
+// ---------------------------------------------------------------------------
+export function expandCompactEpisodeResult(result, episodePlan) {
+    if (!("sc" in result))
+        return { ...result };
+    const scenes = [];
+    const rawScenes = asList(result["sc"]);
+    for (let index = 0; index < rawScenes.length; index++) {
+        const rawScene = rawScenes[index];
+        if (!isDict(rawScene))
+            continue;
+        const rawEnv = isDict(rawScene["env"]) ? rawScene["env"] : {};
+        const actorNames = [];
+        const actorStates = {};
+        for (const rawActor of asList(rawScene["ch"])) {
+            let name = "";
+            let state = "";
+            if (typeof rawActor === "string") {
+                name = rawActor.trim();
+            }
+            else if (isDict(rawActor)) {
+                name = strOf(rawActor["n"]).trim();
+                state = strOf(rawActor["st"]).trim();
+            }
+            else
+                continue;
+            if (!name)
+                continue;
+            uniqueAdd(actorNames, name);
+            if (state && isStateLabelValid(state))
+                actorStates[name] = state;
+        }
+        const actions = [];
+        for (const rawAction of asList(rawScene["a"])) {
+            if (!isDict(rawAction))
+                continue;
+            const content = strOf(rawAction["c"]).trim();
+            if (!content)
+                continue;
+            const rawKind = strOf(rawAction["k"]).trim();
+            const kind = _COMPACT_ACTION_TO_LONG[rawKind] ?? rawKind ?? "action";
+            const action = { type: kind, content };
+            const speaker = strOf(rawAction["p"]).trim();
+            if (speaker) {
+                action["speaker"] = speaker;
+                const speakerKind = strOf(rawAction["pk"]).trim();
+                if (speakerKind)
+                    action["speaker_kind"] = speakerKind;
+                if ((kind === "dialogue" || kind === "inner_thought") && !speakerKind)
+                    uniqueAdd(actorNames, speaker);
+            }
+            const delivery = normalizeDeliveryToken(rawAction["d"]);
+            if (delivery)
+                action["delivery"] = delivery;
+            const rawSpeakers = rawAction["sp"];
+            if (isList(rawSpeakers)) {
+                const speakerList = [];
+                for (const item of rawSpeakers) {
+                    if (!isDict(item))
+                        continue;
+                    const sn = strOf(item["p"]).trim();
+                    if (!sn)
+                        continue;
+                    const sk = strOf(item["pk"]).trim() || "actor";
+                    speakerList.push({ speaker: sn, speaker_kind: sk });
+                    if (sk === "actor")
+                        uniqueAdd(actorNames, sn);
+                }
+                if (speakerList.length > 0)
+                    action["speakers"] = speakerList;
+            }
+            const rawLines = rawAction["ln"];
+            if (isList(rawLines)) {
+                const lineList = [];
+                for (const item of rawLines) {
+                    if (!isDict(item))
+                        continue;
+                    const sn = strOf(item["p"]).trim();
+                    const lc = strOf(item["c"]).trim();
+                    if (!sn || !lc)
+                        continue;
+                    const sk = strOf(item["pk"]).trim() || "actor";
+                    lineList.push({ speaker: sn, speaker_kind: sk, content: lc });
+                    if (sk === "actor")
+                        uniqueAdd(actorNames, sn);
+                }
+                if (lineList.length > 0)
+                    action["lines"] = lineList;
+            }
+            const emotion = strOf(rawAction["m"]).trim();
+            if (emotion)
+                action["emotion"] = emotion;
+            const refs = rawAction["_source_line_ids"] ?? rawAction["source_line_ids"];
+            if (isList(refs)) {
+                action["source_line_ids"] = refs.map((r) => strOf(r).trim()).filter((r) => r);
+            }
+            const span = rawAction["_source_span"] ?? rawAction["source_span"];
+            if (isDict(span) && typeof span["start"] === "number" && typeof span["end"] === "number") {
+                action["source_span"] = { start: span["start"], end: span["end"] };
+            }
+            actions.push(action);
+        }
+        scenes.push({
+            scene_num: normalizeInt(rawScene["n"], index + 1),
+            environment: {
+                space: _COMPACT_SPACE_TO_LONG[strOf(rawEnv["s"])] ?? "interior",
+                time: rawEnv["t"] === "day" || rawEnv["t"] === "night" ? rawEnv["t"] : "day",
+            },
+            location_name: strOf(rawScene["loc"] || "未知场景").trim() || "未知场景",
+            location_state: strOf(rawScene["ls"]).trim() || null,
+            actor_names: actorNames,
+            actor_states: actorStates,
+            prop_names: isList(rawScene["pr"])
+                ? rawScene["pr"].map((it) => strOf(it).trim()).filter((it) => it)
+                : [],
+            actions,
+        });
+    }
+    const expanded = {
+        episode: episodePlan["episode"],
+        title: episodePlan["title"],
+        source_span: episodePlan["source_span"],
+        scenes,
+    };
+    for (const key of ["actors", "locations", "props"]) {
+        if (key in result)
+            expanded[key] = result[key];
+    }
+    if ("speakers" in result)
+        expanded["speakers"] = result["speakers"];
+    if ("state_definitions" in result)
+        expanded["state_definitions"] = result["state_definitions"];
+    return expanded;
+}
+export function compactEpisodeResult(result) {
+    const compactScenes = [];
+    for (const scene of asList(result["scenes"])) {
+        if (!isDict(scene))
+            continue;
+        const env = isDict(scene["environment"]) ? scene["environment"] : {};
+        const compactScene = {
+            n: normalizeInt(scene["scene_num"], compactScenes.length + 1),
+            env: {
+                s: _LONG_SPACE_TO_COMPACT[strOf(env["space"])] ?? "in",
+                t: env["time"] === "day" || env["time"] === "night" ? env["time"] : "day",
+            },
+            loc: strOf(scene["location_name"] || "未知场景").trim() || "未知场景",
+            a: [],
+        };
+        const locationState = strOf(scene["location_state"]).trim();
+        if (locationState)
+            compactScene["ls"] = locationState;
+        const actorStates = isDict(scene["actor_states"]) ? scene["actor_states"] : {};
+        const compactActors = [];
+        for (const actorName of asList(scene["actor_names"])) {
+            const name = strOf(actorName).trim();
+            if (!name)
+                continue;
+            const actorItem = { n: name };
+            const state = strOf(actorStates[name]).trim();
+            if (state)
+                actorItem["st"] = state;
+            compactActors.push(actorItem);
+        }
+        if (compactActors.length > 0)
+            compactScene["ch"] = compactActors;
+        const propList = isList(scene["prop_names"])
+            ? scene["prop_names"].map((it) => strOf(it).trim()).filter((it) => it)
+            : [];
+        if (propList.length > 0)
+            compactScene["pr"] = propList;
+        const compactActions = [];
+        for (const action of asList(scene["actions"])) {
+            if (!isDict(action))
+                continue;
+            const content = strOf(action["content"]).trim();
+            if (!content)
+                continue;
+            const actionItem = {
+                k: _LONG_ACTION_TO_COMPACT[strOf(action["type"])] ?? "act",
+                c: content,
+            };
+            const speaker = strOf(action["speaker"]).trim();
+            if (speaker)
+                actionItem["p"] = speaker;
+            const speakerKind = strOf(action["speaker_kind"]).trim();
+            if (speakerKind && speakerKind !== "actor")
+                actionItem["pk"] = speakerKind;
+            const delivery = strOf(action["delivery"]).trim();
+            if (delivery && delivery !== "single")
+                actionItem["d"] = delivery;
+            const speakers = asList(action["speakers"]);
+            if (speakers.length > 0) {
+                actionItem["sp"] = speakers
+                    .filter((it) => isDict(it) && strOf(it["speaker"]).trim())
+                    .map((it) => ({
+                    p: strOf(it["speaker"]).trim(),
+                    pk: strOf(it["speaker_kind"]).trim() || "actor",
+                }));
+            }
+            const lines = asList(action["lines"]);
+            if (lines.length > 0) {
+                actionItem["ln"] = lines
+                    .filter((it) => isDict(it) && strOf(it["speaker"]).trim() && strOf(it["content"]).trim())
+                    .map((it) => ({
+                    p: strOf(it["speaker"]).trim(),
+                    pk: strOf(it["speaker_kind"]).trim() || "actor",
+                    c: strOf(it["content"]).trim(),
+                }));
+            }
+            const emotion = strOf(action["emotion"]).trim();
+            if (emotion)
+                actionItem["m"] = emotion;
+            compactActions.push(actionItem);
+        }
+        compactScene["a"] = compactActions;
+        compactScenes.push(compactScene);
+    }
+    return { sc: compactScenes };
+}
+export function compactBatchResult(result) {
+    const compact = compactEpisodeResult(result);
+    const compactScenes = asList(compact["sc"]);
+    const sourceScenes = asList(result["scenes"]);
+    for (let i = 0; i < Math.min(compactScenes.length, sourceScenes.length); i++) {
+        const compactActions = asList(compactScenes[i]["a"]);
+        const sourceActions = asList(sourceScenes[i]["actions"]);
+        for (let j = 0; j < Math.min(compactActions.length, sourceActions.length); j++) {
+            const sourceAction = sourceActions[j];
+            const refs = isDict(sourceAction) ? sourceAction["source_line_ids"] : null;
+            if (!isList(refs) || refs.length === 0)
+                continue;
+            delete compactActions[j]["c"];
+            compactActions[j]["r"] = refs.map((r) => strOf(r).trim()).filter((r) => r);
+        }
+    }
+    for (const key of ["actors", "locations", "props", "speakers", "state_definitions"]) {
+        const items = result[key];
+        if (isList(items) && items.length > 0) {
+            compact[key] = items.map((item) => {
+                if (!isDict(item))
+                    return item;
+                const cleaned = {};
+                for (const [k, v] of Object.entries(item)) {
+                    if (v !== null && v !== undefined)
+                        cleaned[k] = v;
+                }
+                return cleaned;
+            });
+        }
+    }
+    return compact;
+}
+// ---------------------------------------------------------------------------
+// Normalize episode result
+// ---------------------------------------------------------------------------
+export function normalizeEpisodeResult(result, episodePlan) {
+    let normalized = expandCompactEpisodeResult(result, episodePlan);
+    normalized["episode"] = normalizeInt(normalized["episode"], Number(episodePlan["episode"]));
+    normalized["title"] = normalized["title"] || episodePlan["title"];
+    normalized["source_span"] = normalized["source_span"] || episodePlan["source_span"];
+    const scenes = isList(normalized["scenes"]) ? normalized["scenes"] : [];
+    normalized["scenes"] = scenes;
+    for (let idx = 0; idx < scenes.length; idx++) {
+        const scene = scenes[idx];
+        scene["scene_num"] = normalizeInt(scene["scene_num"], idx + 1);
+        const env = isDict(scene["environment"]) ? scene["environment"] : {};
+        scene["environment"] = {
+            space: env["space"] === "interior" || env["space"] === "exterior" ? env["space"] : "interior",
+            time: env["time"] === "day" || env["time"] === "night" ? env["time"] : "day",
+        };
+        const [locName, locStateFromName] = splitEntityState(strOf(scene["location_name"] || "未知场景"));
+        scene["location_name"] = locName || "未知场景";
+        const rawLocationState = strOf(scene["location_state"] || locStateFromName || "").trim();
+        scene["location_state"] = rawLocationState && isReusableState("location", rawLocationState) ? rawLocationState : null;
+        const actorNames = [];
+        const inferredActorStates = {};
+        for (const rawName of asList(scene["actor_names"])) {
+            const [actorName, stateFromName] = splitEntityState(rawName);
+            if (!actorName)
+                continue;
+            uniqueAdd(actorNames, actorName);
+            if (stateFromName && isReusableState("actor", stateFromName))
+                inferredActorStates[actorName] = stateFromName;
+        }
+        scene["actor_names"] = actorNames;
+        const rawActorStates = scene["actor_states"];
+        const actorStates = { ...inferredActorStates };
+        if (isDict(rawActorStates)) {
+            for (const [actorName, state] of Object.entries(rawActorStates)) {
+                const [normalizedActor] = splitEntityState(actorName);
+                const normalizedState = strOf(state).trim();
+                if (normalizedActor && normalizedState && isReusableState("actor", normalizedState)) {
+                    actorStates[normalizedActor] = normalizedState;
+                }
+            }
+        }
+        else if (isList(rawActorStates)) {
+            for (const item of rawActorStates) {
+                if (!isDict(item))
+                    continue;
+                const [actorName] = splitEntityState(strOf(item["actor_name"]));
+                const state = strOf(item["state"]).trim();
+                if (actorName && state && isReusableState("actor", state))
+                    actorStates[actorName] = state;
+            }
+        }
+        scene["actor_states"] = actorStates;
+        const propNames = [];
+        for (const rawProp of asList(scene["prop_names"])) {
+            const [propName] = splitEntityState(rawProp);
+            uniqueAdd(propNames, propName);
+        }
+        scene["prop_names"] = propNames;
+        const actions = [];
+        for (const action of asList(scene["actions"])) {
+            if (!isDict(action))
+                continue;
+            const rawKind = strOf(action["type"]).trim();
+            const kind = rawKind || "action";
+            const content = strOf(action["content"]).trim();
+            if (!content)
+                continue;
+            const item = { type: kind, content };
+            const hasStructuredSpeakers = Boolean(action["speakers"]) || Boolean(action["lines"]);
+            if (action["speaker"] && !hasStructuredSpeakers) {
+                const speakerKind = strOf(action["speaker_kind"] || "actor").trim() || "actor";
+                const entry = speakerRefEntry(scene, action["speaker"], speakerKind);
+                if (entry) {
+                    item["speaker"] = entry.speaker;
+                    if (entry.speaker_kind !== "actor")
+                        item["speaker_kind"] = entry.speaker_kind;
+                }
+            }
+            const delivery = normalizeDeliveryToken(action["delivery"]);
+            if (delivery)
+                item["delivery"] = delivery;
+            const speakerList = [];
+            for (const speaker of asList(action["speakers"])) {
+                if (!isDict(speaker))
+                    continue;
+                const speakerKind = strOf(speaker["speaker_kind"] || speaker["kind"] || "actor").trim() || "actor";
+                const entry = speakerRefEntry(scene, speaker["speaker"] || speaker["name"], speakerKind);
+                if (entry)
+                    speakerList.push(entry);
+            }
+            if (speakerList.length > 0)
+                item["speakers"] = speakerList;
+            const lineList = [];
+            for (const line of asList(action["lines"])) {
+                if (!isDict(line))
+                    continue;
+                const lineContent = strOf(line["content"]).trim();
+                if (!lineContent)
+                    continue;
+                const speakerKind = strOf(line["speaker_kind"] || line["kind"] || "actor").trim() || "actor";
+                const entry = speakerRefEntry(scene, line["speaker"] || line["name"], speakerKind);
+                if (entry)
+                    lineList.push({ speaker: entry.speaker, speaker_kind: entry.speaker_kind, content: lineContent });
+            }
+            if (lineList.length > 0)
+                item["lines"] = lineList;
+            if (action["emotion"])
+                item["emotion"] = strOf(action["emotion"]).trim();
+            const span = action["source_span"];
+            if (isDict(span) && typeof span["start"] === "number" && typeof span["end"] === "number") {
+                item["source_span"] = { start: span["start"], end: span["end"] };
+            }
+            const refs = action["source_line_ids"];
+            if (isList(refs))
+                item["source_line_ids"] = refs.map((r) => strOf(r).trim()).filter((r) => r);
+            actions.push(item);
+        }
+        scene["actions"] = actions;
+    }
+    normalized["actors"] = _normalizeAssetList(normalized["actors"]);
+    normalized["locations"] = _normalizeAssetList(normalized["locations"]);
+    normalized["props"] = _normalizeAssetList(normalized["props"]);
+    normalized["speakers"] = _normalize_speaker_list(normalized["speakers"]);
+    normalized["state_definitions"] = _normalizeStateDefinitions(normalized["state_definitions"]);
+    const stateLookup = new Map();
+    for (const stateDef of asList(normalized["state_definitions"])) {
+        const key = `${strOf(stateDef["kind"])}::${strOf(stateDef["asset_name"])}`;
+        if (!stateLookup.has(key))
+            stateLookup.set(key, new Set());
+        stateLookup.get(key).add(strOf(stateDef["state_name"]).trim());
+    }
+    for (const scene of scenes) {
+        const allowedActorStates = {};
+        const sceneActorStates = scene["actor_states"] || {};
+        for (const [actorName, actorState] of Object.entries(sceneActorStates)) {
+            const allowed = stateLookup.get(`actor::${strOf(actorName).trim()}`) ?? new Set();
+            if (allowed.has(strOf(actorState).trim()))
+                allowedActorStates[actorName] = actorState;
+        }
+        scene["actor_states"] = allowedActorStates;
+        const loc = strOf(scene["location_name"]).trim();
+        const ls = strOf(scene["location_state"]).trim();
+        if (ls) {
+            const allowed = stateLookup.get(`location::${loc}`) ?? new Set();
+            if (!allowed.has(ls))
+                scene["location_state"] = null;
+        }
+        for (const name of asList(scene["actor_names"])) {
+            _md_push_asset(normalized["actors"], strOf(name), null);
+        }
+        if (loc && loc !== "未知场景")
+            _md_push_asset(normalized["locations"], loc, null);
+        for (const prop of asList(scene["prop_names"])) {
+            _md_push_asset(normalized["props"], strOf(prop), null);
+        }
+    }
+    return normalized;
+}
+function _normalizeAssetList(items) {
+    if (!isList(items))
+        return [];
+    const out = [];
+    const byName = new Map();
+    for (const item of items) {
+        let name = "";
+        let description = null;
+        if (isDict(item)) {
+            name = cleanName(strOf(item["name"]));
+            description = strOf(item["description"]).trim() || null;
+        }
+        else if (typeof item === "string") {
+            name = cleanName(item);
+        }
+        else
+            continue;
+        if (!name)
+            continue;
+        if (byName.has(name)) {
+            const existing = byName.get(name);
+            if (description && !existing["description"])
+                existing["description"] = description;
+            continue;
+        }
+        const entry = { name, description };
+        byName.set(name, entry);
+        out.push(entry);
+    }
+    return out;
+}
+export function _normalize_speaker_list(items) {
+    if (!isList(items))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of items) {
+        let rawName = "";
+        let sourceKind = "";
+        let description = null;
+        if (isDict(item)) {
+            rawName = strOf(item["name"] || item["display_name"]).trim();
+            sourceKind = strOf(item["source_kind"] || item["kind"]).trim();
+            description = strOf(item["description"] || item["voice_desc"]).trim() || null;
+        }
+        else if (typeof item === "string") {
+            rawName = item.trim();
+        }
+        else
+            continue;
+        const [parsedKind, parsedName] = parseSpeakerAsset(rawName);
+        let kind = sourceKind || parsedKind;
+        kind = _MD_SPEAKER_KIND_NORM[kind.toLowerCase()] ?? _MD_SPEAKER_KIND_NORM[kind] ?? "other";
+        const name = cleanName(parsedName);
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        out.push({ name, source_kind: kind, description });
+    }
+    return out;
+}
+function _normalizeStateDefinitions(items) {
+    if (!isList(items))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of items) {
+        if (!isDict(item))
+            continue;
+        const kind = strOf(item["kind"] || item["target_kind"]).trim();
+        if (!SCRIPT_TARGET_KINDS.has(kind))
+            continue;
+        const assetName = cleanName(strOf(item["asset_name"] || item["name"]));
+        const stateName = strOf(item["state_name"] || item["state"]).trim();
+        if (!assetName || !stateName || stateRejectionReason(kind, stateName))
+            continue;
+        const key = `${kind}::${assetName}::${stateName}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({
+            kind,
+            asset_name: assetName,
+            state_name: stateName,
+            description: strOf(item["description"]).trim() || null,
+        });
+    }
+    return out;
+}
+export function uniqueAdd(order, value) {
+    if (value && !order.includes(value))
+        order.push(value);
+}
+// ---------------------------------------------------------------------------
+// Metadata / asset curation contexts
+// ---------------------------------------------------------------------------
+export function clipText(text, limit = 120) {
+    const cleaned = strOf(text).trim().replace(/\s+/g, " ");
+    return cleaned.slice(0, limit);
+}
+export function sceneExample(scene, limit = 160) {
+    const parts = [];
+    for (const action of asList(scene["actions"])) {
+        const content = clipText(strOf(action["content"]), 80);
+        if (content)
+            parts.push(content);
+        if (parts.length >= 2)
+            break;
+    }
+    return clipText(parts.join(" / "), limit);
+}
+export function buildMetadataContext(script) {
+    const actorExamples = {};
+    const locationExamples = {};
+    const propExamples = {};
+    for (const ep of asList(script["episodes"])) {
+        for (const scene of asList(ep["scenes"])) {
+            const example = sceneExample(scene);
+            if (!example)
+                continue;
+            for (const ref of asList(scene["actors"])) {
+                const actorId = strOf(ref["actor_id"]);
+                if (actorId) {
+                    if (!actorExamples[actorId])
+                        actorExamples[actorId] = [];
+                    uniqueAdd(actorExamples[actorId], example);
+                }
+            }
+            for (const ref of asList(scene["locations"])) {
+                const locId = strOf(ref["location_id"]);
+                if (locId) {
+                    if (!locationExamples[locId])
+                        locationExamples[locId] = [];
+                    uniqueAdd(locationExamples[locId], example);
+                }
+            }
+            for (const ref of asList(scene["props"])) {
+                const propId = strOf(ref["prop_id"]);
+                if (propId) {
+                    if (!propExamples[propId])
+                        propExamples[propId] = [];
+                    uniqueAdd(propExamples[propId], example);
+                }
+            }
+        }
+    }
+    const compactStates = (asset) => {
+        const states = [];
+        for (const state of asList(asset["states"])) {
+            const name = strOf(state["state_name"]).trim();
+            if (name)
+                states.push(name);
+        }
+        return states.slice(0, 8);
+    };
+    return {
+        title: script["title"],
+        worldview_options: WORLDVIEW_VALUES,
+        episodes: asList(script["episodes"]).slice(0, 80).map((ep) => ({
+            episode_id: ep["episode_id"],
+            title: ep["title"],
+        })),
+        actors: asList(script["actors"]).map((actor) => ({
+            actor_id: actor["actor_id"],
+            actor_name: actor["actor_name"],
+            states: compactStates(actor),
+            examples: (actorExamples[strOf(actor["actor_id"])] ?? []).slice(0, 3),
+        })),
+        locations: asList(script["locations"]).map((loc) => ({
+            location_id: loc["location_id"],
+            location_name: loc["location_name"],
+            states: compactStates(loc),
+            examples: (locationExamples[strOf(loc["location_id"])] ?? []).slice(0, 2),
+        })),
+        props: asList(script["props"]).map((prop) => ({
+            prop_id: prop["prop_id"],
+            prop_name: prop["prop_name"],
+            examples: (propExamples[strOf(prop["prop_id"])] ?? []).slice(0, 2),
+        })),
+    };
+}
+export function deterministicExtractMetadata(script) {
+    const actors = [];
+    const scriptActors = asList(script["actors"]);
+    for (let idx = 0; idx < scriptActors.length; idx++) {
+        const actor = scriptActors[idx];
+        const name = strOf(actor["actor_name"] || actor["actor_id"]).trim();
+        const states = [];
+        for (const state of asList(actor["states"])) {
+            const stateName = strOf(state["state_name"]).trim();
+            if (stateName)
+                states.push(stateName);
+        }
+        let description = name;
+        if (states.length > 0)
+            description = `${name}；状态：${states.slice(0, 6).join("、")}`;
+        actors.push({
+            actor_id: actor["actor_id"],
+            role_type: idx === 0 ? "主角" : "配角",
+            description,
+        });
+    }
+    return {
+        confidence: "high",
+        worldview: "现代",
+        worldview_raw: "mock provider generated metadata for CLI tests",
+        actors,
+        locations: asList(script["locations"]).map((loc) => ({
+            location_id: loc["location_id"],
+            description: strOf(loc["location_name"] || loc["location_id"]).trim(),
+        })),
+        props: asList(script["props"]).map((prop) => ({
+            prop_id: prop["prop_id"],
+            description: strOf(prop["prop_name"] || prop["prop_id"]).trim(),
+        })),
+    };
+}
+export function applyMetadataToScript(script, metadata) {
+    script["worldview"] = metadata["worldview"];
+    script["worldview_raw"] = strOf(metadata["worldview_raw"]).trim();
+    const actorMeta = new Map();
+    for (const item of asList(metadata["actors"])) {
+        if (isDict(item))
+            actorMeta.set(strOf(item["actor_id"]), item);
+    }
+    for (const actor of asList(script["actors"])) {
+        const item = actorMeta.get(strOf(actor["actor_id"]));
+        if (!item)
+            continue;
+        actor["role_type"] = item["role_type"];
+        actor["description"] = strOf(item["description"]).trim();
+    }
+    const locationMeta = new Map();
+    for (const item of asList(metadata["locations"])) {
+        if (isDict(item))
+            locationMeta.set(strOf(item["location_id"]), item);
+    }
+    for (const loc of asList(script["locations"])) {
+        const item = locationMeta.get(strOf(loc["location_id"]));
+        if (item)
+            loc["description"] = strOf(item["description"]).trim();
+    }
+    const propMeta = new Map();
+    for (const item of asList(metadata["props"])) {
+        if (isDict(item))
+            propMeta.set(strOf(item["prop_id"]), item);
+    }
+    for (const prop of asList(script["props"])) {
+        const item = propMeta.get(strOf(prop["prop_id"]));
+        if (item)
+            prop["description"] = strOf(item["description"]).trim();
+    }
+}
+export function sceneAssetUsage(script, refKey, idKey) {
+    const usage = new Map();
+    for (const ep of asList(script["episodes"])) {
+        const episodeId = strOf(ep["episode_id"]);
+        for (const scene of asList(ep["scenes"])) {
+            const sceneId = strOf(scene["scene_id"]);
+            const ctx = sceneContext(scene);
+            for (const ref of asList(ctx[refKey])) {
+                if (!isDict(ref))
+                    continue;
+                const assetId = strOf(ref[idKey]);
+                if (!assetId)
+                    continue;
+                if (!usage.has(assetId))
+                    usage.set(assetId, { episodes: new Set(), scenes: new Set() });
+                const item = usage.get(assetId);
+                if (episodeId)
+                    item.episodes.add(episodeId);
+                if (sceneId)
+                    item.scenes.add(sceneId);
+            }
+        }
+    }
+    return usage;
+}
+function compactStateNames(asset) {
+    const out = [];
+    for (const state of asList(asset["states"])) {
+        if (!isDict(state))
+            continue;
+        const n = strOf(state["state_name"]).trim();
+        if (n)
+            out.push(n);
+    }
+    return out;
+}
+function usagePayload(usage) {
+    return {
+        episode_count: usage.episodes.size,
+        scene_count: usage.scenes.size,
+        episodes: [...usage.episodes].sort().slice(0, 12),
+        scenes: [...usage.scenes].sort().slice(0, 12),
+    };
+}
+export function buildAssetCurationContext(script) {
+    const locationUsage = sceneAssetUsage(script, "locations", "location_id");
+    return {
+        title: script["title"],
+        guidance: [
+            "Decide from the script context, not from asset names alone.",
+            "Merge a location only when it is clearly the same stable space as an existing target location.",
+            "Keep a location whenever no stable parent location is clear.",
+        ],
+        locations: asList(script["locations"]).filter(isDict).map((loc) => ({
+            location_id: loc["location_id"],
+            location_name: loc["location_name"],
+            description: loc["description"],
+            aliases: isList(loc["aliases"]) ? loc["aliases"] : [],
+            states: compactStateNames(loc),
+            usage: usagePayload(locationUsage.get(strOf(loc["location_id"])) ?? { episodes: new Set(), scenes: new Set() }),
+            examples: locationUsageExamples(script, strOf(loc["location_id"])),
+        })),
+    };
+}
+export function locationUsageExamples(script, locationId) {
+    const examples = [];
+    for (const ep of asList(script["episodes"])) {
+        for (const scene of asList(ep["scenes"])) {
+            const refs = asList(sceneContext(scene)["locations"]);
+            const found = refs.some((ref) => isDict(ref) && ref["location_id"] === locationId);
+            if (!found)
+                continue;
+            const example = sceneExample(scene);
+            if (example) {
+                examples.push({ episode_id: ep["episode_id"], scene_id: scene["scene_id"], example });
+            }
+            if (examples.length >= 4)
+                return examples;
+        }
+    }
+    return examples;
+}
+function compactAssetRefs(refs, idKey, replacements, droppedIds) {
+    const compacted = [];
+    const seen = new Set();
+    for (const ref of asList(refs)) {
+        if (!isDict(ref))
+            continue;
+        const rawId = strOf(ref[idKey]);
+        if (!rawId || droppedIds.has(rawId))
+            continue;
+        const nextId = replacements.get(rawId) ?? rawId;
+        const stateId = nextId !== rawId ? null : ref["state_id"];
+        const key = `${nextId}::${strOf(stateId)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        compacted.push({ [idKey]: nextId, state_id: stateId });
+    }
+    return compacted;
+}
+function addLocationAlias(target, aliasRaw) {
+    const alias = cleanName(aliasRaw);
+    const targetName = strOf(target["location_name"]).trim();
+    if (!alias || alias === targetName)
+        return;
+    if (!isList(target["aliases"]))
+        target["aliases"] = [];
+    uniqueAdd(target["aliases"], alias);
+}
+export function applyLocationMerges(script, replacements) {
+    if (replacements.size === 0)
+        return;
+    const locations = asList(script["locations"]);
+    const byId = new Map();
+    for (const loc of locations) {
+        if (isDict(loc))
+            byId.set(strOf(loc["location_id"]), loc);
+    }
+    for (const [oldId, targetId] of replacements) {
+        const old = byId.get(oldId);
+        const target = byId.get(targetId);
+        if (!old || !target)
+            continue;
+        addLocationAlias(target, strOf(old["location_name"]));
+        for (const alias of asList(old["aliases"])) {
+            addLocationAlias(target, strOf(alias));
+        }
+    }
+    script["locations"] = locations.filter((loc) => isDict(loc) && !replacements.has(strOf(loc["location_id"])));
+}
+function sceneCountFromUsage(usage) {
+    return usage.scenes.size;
+}
+export function actorCurationDecisions(script) {
+    const usage = sceneAssetUsage(script, "actors", "actor_id");
+    const decisions = [];
+    for (const actor of asList(script["actors"])) {
+        if (!isDict(actor))
+            continue;
+        const actorId = strOf(actor["actor_id"]);
+        const u = usage.get(actorId) ?? { episodes: new Set(), scenes: new Set() };
+        const sceneCount = sceneCountFromUsage(u);
+        let decision;
+        let reason;
+        if (sceneCount <= ACTOR_REUSE_SCENE_LIMIT) {
+            decision = "remove";
+            reason = `固定裁剪：仅出现在 ${sceneCount} 个 scene，不作为跨场景复用人物资产；对白归因保留在 speakers/actions。`;
+        }
+        else {
+            decision = "keep";
+            reason = `保留：出现在 ${sceneCount} 个 scene，超过单场人物裁剪阈值。`;
+        }
+        decisions.push({ actor_id: actorId, name: actor["actor_name"], scene_count: sceneCount, decision, reason });
+    }
+    return decisions;
+}
+export function propCurationDecisions(script) {
+    const usage = sceneAssetUsage(script, "props", "prop_id");
+    const decisions = [];
+    for (const prop of asList(script["props"])) {
+        if (!isDict(prop))
+            continue;
+        const propId = strOf(prop["prop_id"]);
+        const u = usage.get(propId) ?? { episodes: new Set(), scenes: new Set() };
+        const sceneCount = sceneCountFromUsage(u);
+        let decision;
+        let reason;
+        if (sceneCount <= PROP_REUSE_SCENE_LIMIT) {
+            decision = "remove";
+            reason = `固定裁剪：仅出现在 ${sceneCount} 个 scene，未超过 ${PROP_REUSE_SCENE_LIMIT} 个 scene 的道具复用阈值；原文动作保留。`;
+        }
+        else {
+            decision = "keep";
+            reason = `保留：出现在 ${sceneCount} 个 scene，超过道具复用裁剪阈值。`;
+        }
+        decisions.push({ prop_id: propId, name: prop["prop_name"], scene_count: sceneCount, decision, reason });
+    }
+    return decisions;
+}
+function rewriteStateChanges(changes, locationReplacements, droppedPropIds, droppedActorIds) {
+    const rewritten = [];
+    for (const change of asList(changes)) {
+        if (!isDict(change))
+            continue;
+        const targetKind = strOf(change["target_kind"]);
+        const targetId = strOf(change["target_id"]);
+        if (targetKind === "actor" && droppedActorIds.has(targetId))
+            continue;
+        if (targetKind === "prop" && droppedPropIds.has(targetId))
+            continue;
+        const next = { ...change };
+        if (targetKind === "location" && locationReplacements.has(targetId)) {
+            next["target_id"] = locationReplacements.get(targetId);
+            delete next["from_state_id"];
+            delete next["to_state_id"];
+        }
+        rewritten.push(next);
+    }
+    return rewritten;
+}
+function rewriteTransitionPrompt(transition, locationReplacements, droppedPropIds, droppedActorIds) {
+    if (!isDict(transition))
+        return transition;
+    const targetKind = strOf(transition["target_kind"]);
+    const targetId = strOf(transition["target_id"]);
+    if (targetKind === "actor" && droppedActorIds.has(targetId))
+        return null;
+    if (targetKind === "prop" && droppedPropIds.has(targetId))
+        return null;
+    const next = { ...transition };
+    if (targetKind === "location" && locationReplacements.has(targetId)) {
+        next["target_id"] = locationReplacements.get(targetId);
+    }
+    return next;
+}
+function applyAssetCurationRefs(script, locationReplacements, droppedPropIds, droppedActorIds) {
+    if (locationReplacements.size === 0 && droppedPropIds.size === 0 && droppedActorIds.size === 0)
+        return;
+    for (const ep of asList(script["episodes"])) {
+        for (const scene of asList(ep["scenes"])) {
+            const ctx = sceneContext(scene);
+            if (locationReplacements.size > 0) {
+                ctx["locations"] = compactAssetRefs(ctx["locations"], "location_id", locationReplacements, new Set());
+            }
+            if (droppedActorIds.size > 0) {
+                ctx["actors"] = compactAssetRefs(ctx["actors"], "actor_id", new Map(), droppedActorIds);
+            }
+            if (droppedPropIds.size > 0) {
+                ctx["props"] = compactAssetRefs(ctx["props"], "prop_id", new Map(), droppedPropIds);
+            }
+            setSceneContext(scene, ctx);
+            for (const action of asList(scene["actions"])) {
+                if (!isDict(action))
+                    continue;
+                if (droppedActorIds.has(strOf(action["actor_id"])))
+                    delete action["actor_id"];
+                if (action["state_changes"] !== undefined && action["state_changes"] !== null) {
+                    action["state_changes"] = rewriteStateChanges(action["state_changes"], locationReplacements, droppedPropIds, droppedActorIds);
+                }
+                if (action["transition_prompt"] !== undefined && action["transition_prompt"] !== null) {
+                    const transition = rewriteTransitionPrompt(action["transition_prompt"], locationReplacements, droppedPropIds, droppedActorIds);
+                    if (transition === null)
+                        delete action["transition_prompt"];
+                    else
+                        action["transition_prompt"] = transition;
+                }
+            }
+        }
+    }
+    for (const speaker of asList(script["speakers"])) {
+        if (!isDict(speaker))
+            continue;
+        const sourceKind = strOf(speaker["source_kind"]);
+        const sourceId = strOf(speaker["source_id"]);
+        if (sourceKind === "actor" && droppedActorIds.has(sourceId)) {
+            speaker["source_kind"] = "other";
+            speaker["source_id"] = null;
+        }
+        else if (sourceKind === "location" && locationReplacements.has(sourceId)) {
+            speaker["source_id"] = locationReplacements.get(sourceId);
+        }
+        else if (sourceKind === "prop" && droppedPropIds.has(sourceId)) {
+            speaker["source_kind"] = "other";
+            speaker["source_id"] = null;
+        }
+    }
+}
+export function normalizeAssetCuration(script, rawCuration) {
+    const payload = isDict(rawCuration) ? rawCuration : {};
+    const rawLocations = new Map();
+    for (const item of asList(payload["locations"])) {
+        if (!isDict(item))
+            continue;
+        const id = strOf(item["location_id"]);
+        if (id)
+            rawLocations.set(id, item);
+    }
+    const locationUsage = sceneAssetUsage(script, "locations", "location_id");
+    const validLocationIds = new Set();
+    for (const loc of asList(script["locations"])) {
+        if (isDict(loc)) {
+            const id = strOf(loc["location_id"]);
+            if (id)
+                validLocationIds.add(id);
+        }
+    }
+    const rawLocationDecisions = new Map();
+    for (const [locId, item] of rawLocations) {
+        rawLocationDecisions.set(locId, strOf(item["decision"]).trim());
+    }
+    const locations = [];
+    for (const loc of asList(script["locations"])) {
+        if (!isDict(loc))
+            continue;
+        const locationId = strOf(loc["location_id"]);
+        const sceneCount = sceneCountFromUsage(locationUsage.get(locationId) ?? { episodes: new Set(), scenes: new Set() });
+        const item = rawLocations.get(locationId) ?? {};
+        let decision = strOf(item["decision"]).trim();
+        let targetLocationId = strOf(item["target_location_id"]).trim() || null;
+        let reason = strOf(item["reason"]).trim() || "provider 基于剧本上下文给出决策。";
+        if (decision === "merge") {
+            if (targetLocationId === null ||
+                !validLocationIds.has(targetLocationId) ||
+                targetLocationId === locationId ||
+                rawLocationDecisions.get(targetLocationId) === "merge") {
+                decision = "keep";
+                targetLocationId = null;
+                reason = "保留：provider 给出的地点合并目标无效。";
+            }
+        }
+        else if (decision !== "keep") {
+            decision = "keep";
+            targetLocationId = null;
+            reason = "保留：provider 未给出有效地点裁剪决策。";
+        }
+        else {
+            targetLocationId = null;
+        }
+        locations.push({
+            location_id: locationId,
+            name: loc["location_name"],
+            scene_count: sceneCount,
+            decision,
+            target_location_id: targetLocationId,
+            reason,
+        });
+    }
+    return {
+        version: 2,
+        actors: actorCurationDecisions(script),
+        props: propCurationDecisions(script),
+        locations,
+    };
+}
+export function curateScriptAssets(script, rawCuration = null) {
+    const actorsBefore = asList(script["actors"]).length;
+    const propsBefore = asList(script["props"]).length;
+    const locationsBefore = asList(script["locations"]).length;
+    const normalized = normalizeAssetCuration(script, rawCuration);
+    const actorDecisions = normalized["actors"];
+    const propDecisions = normalized["props"];
+    const locationDecisions = normalized["locations"];
+    const droppedActorIds = new Set(actorDecisions.filter((it) => it["decision"] === "remove").map((it) => strOf(it["actor_id"])).filter((s) => s));
+    const droppedPropIds = new Set(propDecisions.filter((it) => it["decision"] === "remove").map((it) => strOf(it["prop_id"])).filter((s) => s));
+    if (droppedActorIds.size > 0) {
+        script["actors"] = asList(script["actors"]).filter((a) => isDict(a) && !droppedActorIds.has(strOf(a["actor_id"])));
+    }
+    if (droppedPropIds.size > 0) {
+        script["props"] = asList(script["props"]).filter((p) => isDict(p) && !droppedPropIds.has(strOf(p["prop_id"])));
+    }
+    const locationReplacements = new Map();
+    for (const item of locationDecisions) {
+        if (item["decision"] === "merge") {
+            const fromId = strOf(item["location_id"]);
+            const toId = strOf(item["target_location_id"]);
+            if (fromId && toId)
+                locationReplacements.set(fromId, toId);
+        }
+    }
+    applyLocationMerges(script, locationReplacements);
+    applyAssetCurationRefs(script, locationReplacements, droppedPropIds, droppedActorIds);
+    const actorsAfter = asList(script["actors"]).length;
+    const propsAfter = asList(script["props"]).length;
+    const locationsAfter = asList(script["locations"]).length;
+    return {
+        version: normalized["version"],
+        summary: {
+            actors_before: actorsBefore,
+            actors_after: actorsAfter,
+            actors_removed: actorsBefore - actorsAfter,
+            props_before: propsBefore,
+            props_after: propsAfter,
+            props_removed: propsBefore - propsAfter,
+            locations_before: locationsBefore,
+            locations_after: locationsAfter,
+            locations_merged: locationsBefore - locationsAfter,
+        },
+        actors: actorDecisions,
+        props: propDecisions,
+        locations: locationDecisions,
+    };
+}
+// ---------------------------------------------------------------------------
+// Merge episode results into a final script
+// ---------------------------------------------------------------------------
+export function mergeEpisodeResults(results, title) {
+    const actorNames = [];
+    const locationNames = [];
+    const propNames = [];
+    const actorDescriptions = new Map();
+    const locationDescriptions = new Map();
+    const propDescriptions = new Map();
+    const stateDefinitions = [];
+    const speakerRecords = new Map();
+    const speakerOrder = [];
+    const rememberSpeaker = (name, sourceKind = "other", description = "") => {
+        const speakerName = strOf(name).trim();
+        if (!speakerName)
+            return;
+        let kind = strOf(sourceKind).trim() || "other";
+        kind = _MD_SPEAKER_KIND_NORM[kind.toLowerCase()] ?? _MD_SPEAKER_KIND_NORM[kind] ?? "other";
+        if (kind === "actor") {
+            uniqueAdd(actorNames, speakerName);
+            return;
+        }
+        if (!speakerOrder.includes(speakerName))
+            speakerOrder.push(speakerName);
+        const existing = speakerRecords.get(speakerName) ?? { source_kind: "other" };
+        if (existing.source_kind === "other" || kind !== "other")
+            existing.source_kind = kind;
+        const desc = strOf(description).trim();
+        if (desc && !existing.description)
+            existing.description = desc;
+        speakerRecords.set(speakerName, existing);
+    };
+    for (const result of results) {
+        for (const asset of asList(result["actors"])) {
+            if (!isDict(asset))
+                continue;
+            const name = cleanName(strOf(asset["name"]));
+            const desc = strOf(asset["description"]).trim();
+            if (name && desc && !actorDescriptions.has(name))
+                actorDescriptions.set(name, desc);
+        }
+        for (const asset of asList(result["locations"])) {
+            if (!isDict(asset))
+                continue;
+            const name = cleanName(strOf(asset["name"]));
+            const desc = strOf(asset["description"]).trim();
+            if (name && desc && !locationDescriptions.has(name))
+                locationDescriptions.set(name, desc);
+        }
+        for (const asset of asList(result["props"])) {
+            if (!isDict(asset))
+                continue;
+            const name = cleanName(strOf(asset["name"]));
+            const desc = strOf(asset["description"]).trim();
+            if (name && desc && !propDescriptions.has(name))
+                propDescriptions.set(name, desc);
+        }
+        for (const speaker of _normalize_speaker_list(result["speakers"])) {
+            rememberSpeaker(speaker["name"], speaker["source_kind"], speaker["description"]);
+        }
+        for (const stateDef of _normalizeStateDefinitions(result["state_definitions"])) {
+            stateDefinitions.push(stateDef);
+            const assetName = strOf(stateDef["asset_name"]).trim();
+            if (stateDef["kind"] === "actor")
+                uniqueAdd(actorNames, assetName);
+            else if (stateDef["kind"] === "location")
+                uniqueAdd(locationNames, assetName);
+            else if (stateDef["kind"] === "prop")
+                uniqueAdd(propNames, assetName);
+        }
+        for (const scene of asList(result["scenes"])) {
+            const locName = cleanName(strOf(scene["location_name"] || "未知场景")) || "未知场景";
+            uniqueAdd(locationNames, locName);
+            for (const actor of asList(scene["actor_names"])) {
+                uniqueAdd(actorNames, cleanName(strOf(actor)));
+            }
+            for (const prop of asList(scene["prop_names"])) {
+                uniqueAdd(propNames, cleanName(strOf(prop)));
+            }
+            for (const action of asList(scene["actions"])) {
+                for (const speakerRef of asList(action["speakers"])) {
+                    if (!isDict(speakerRef))
+                        continue;
+                    const speaker = cleanName(strOf(speakerRef["speaker"]));
+                    const speakerKind = strOf(speakerRef["speaker_kind"] || "actor").trim() || "actor";
+                    if (speakerKind === "actor")
+                        uniqueAdd(actorNames, speaker);
+                    else {
+                        rememberSpeaker(speaker, speakerKind);
+                        if (speakerKind === "prop")
+                            uniqueAdd(propNames, speaker);
+                        else if (speakerKind === "location")
+                            uniqueAdd(locationNames, speaker);
+                    }
+                }
+                for (const line of asList(action["lines"])) {
+                    if (!isDict(line))
+                        continue;
+                    const speaker = cleanName(strOf(line["speaker"]));
+                    const speakerKind = strOf(line["speaker_kind"] || "actor").trim() || "actor";
+                    if (speakerKind === "actor")
+                        uniqueAdd(actorNames, speaker);
+                    else {
+                        rememberSpeaker(speaker, speakerKind);
+                        if (speakerKind === "prop")
+                            uniqueAdd(propNames, speaker);
+                        else if (speakerKind === "location")
+                            uniqueAdd(locationNames, speaker);
+                    }
+                }
+                const speaker = cleanName(strOf(action["speaker"]));
+                const hasStructured = Boolean(action["speakers"]) || Boolean(action["lines"]);
+                if (speaker &&
+                    !hasStructured &&
+                    (action["type"] === "dialogue" || action["type"] === "inner_thought")) {
+                    const speakerKind = strOf(action["speaker_kind"] || "actor").trim() || "actor";
+                    if (speakerKind === "actor")
+                        uniqueAdd(actorNames, speaker);
+                    else {
+                        rememberSpeaker(speaker, speakerKind);
+                        if (speakerKind === "prop")
+                            uniqueAdd(propNames, speaker);
+                        else if (speakerKind === "location")
+                            uniqueAdd(locationNames, speaker);
+                    }
+                }
+            }
+        }
+    }
+    const actorIds = new Map(actorNames.map((name, idx) => [name, fmtId("act", idx + 1)]));
+    const locationIds = new Map(locationNames.map((name, idx) => [name, fmtId("loc", idx + 1)]));
+    const propIds = new Map(propNames.map((name, idx) => [name, fmtId("prp", idx + 1)]));
+    const stateDefsByTarget = new Map();
+    for (const stateDef of stateDefinitions) {
+        const key = `${strOf(stateDef["kind"])}::${strOf(stateDef["asset_name"])}`;
+        if (!stateDefsByTarget.has(key))
+            stateDefsByTarget.set(key, []);
+        stateDefsByTarget.get(key).push(stateDef);
+    }
+    const speakers = actorNames.map((name) => ({
+        speaker_id: `spk_${actorIds.get(name)}`,
+        display_name: name,
+        source_kind: "actor",
+        source_id: actorIds.get(name),
+        voice_desc: "",
+    }));
+    const speakerIdsByName = new Map();
+    const speakerKindCounts = new Map();
+    for (const name of speakerOrder) {
+        const record = speakerRecords.get(name) ?? { source_kind: "other" };
+        let sourceKind = record.source_kind || "other";
+        let sourceId = null;
+        if (sourceKind === "prop")
+            sourceId = propIds.get(name) ?? null;
+        else if (sourceKind === "location")
+            sourceId = locationIds.get(name) ?? null;
+        if ((sourceKind === "prop" || sourceKind === "location") && !sourceId)
+            sourceKind = "other";
+        speakerKindCounts.set(sourceKind, (speakerKindCounts.get(sourceKind) ?? 0) + 1);
+        const speakerId = `spk_${sourceKind}_${String(speakerKindCounts.get(sourceKind)).padStart(3, "0")}`;
+        speakerIdsByName.set(`${sourceKind}::${name}`, speakerId);
+        speakerIdsByName.set(`${record.source_kind}::${name}`, speakerId);
+        speakers.push({
+            speaker_id: speakerId,
+            display_name: name,
+            source_kind: sourceKind,
+            source_id: sourceId,
+            voice_desc: record.description ?? "",
+        });
+    }
+    let stateCounter = 0;
+    const stateIdsByTarget = new Map();
+    const actors = [];
+    for (const name of actorNames) {
+        const entry = { actor_id: actorIds.get(name), actor_name: name };
+        if (actorDescriptions.has(name))
+            entry["description"] = actorDescriptions.get(name);
+        const states = [];
+        for (const stateDef of stateDefsByTarget.get(`actor::${name}`) ?? []) {
+            stateCounter += 1;
+            const sid = fmtId("st", stateCounter);
+            const stateName = strOf(stateDef["state_name"]).trim();
+            stateIdsByTarget.set(`actor::${name}::${stateName}`, sid);
+            const stateEntry = { state_id: sid, state_name: stateName };
+            const description = strOf(stateDef["description"]).trim();
+            if (description)
+                stateEntry["description"] = description;
+            states.push(stateEntry);
+        }
+        if (states.length > 0)
+            entry["states"] = states;
+        actors.push(entry);
+    }
+    const locations = [];
+    for (const name of locationNames) {
+        const entry = { location_id: locationIds.get(name), location_name: name, group: name };
+        if (locationDescriptions.has(name))
+            entry["description"] = locationDescriptions.get(name);
+        const states = [];
+        for (const stateDef of stateDefsByTarget.get(`location::${name}`) ?? []) {
+            stateCounter += 1;
+            const sid = fmtId("st", stateCounter);
+            const stateName = strOf(stateDef["state_name"]).trim();
+            stateIdsByTarget.set(`location::${name}::${stateName}`, sid);
+            const stateEntry = { state_id: sid, state_name: stateName };
+            const description = strOf(stateDef["description"]).trim();
+            if (description)
+                stateEntry["description"] = description;
+            states.push(stateEntry);
+        }
+        if (states.length > 0)
+            entry["states"] = states;
+        locations.push(entry);
+    }
+    const props = [];
+    for (const name of propNames) {
+        const entry = { prop_id: propIds.get(name), prop_name: name };
+        if (propDescriptions.has(name))
+            entry["description"] = propDescriptions.get(name);
+        const states = [];
+        for (const stateDef of stateDefsByTarget.get(`prop::${name}`) ?? []) {
+            stateCounter += 1;
+            const sid = fmtId("st", stateCounter);
+            const stateName = strOf(stateDef["state_name"]).trim();
+            stateIdsByTarget.set(`prop::${name}::${stateName}`, sid);
+            const stateEntry = { state_id: sid, state_name: stateName };
+            const description = strOf(stateDef["description"]).trim();
+            if (description)
+                stateEntry["description"] = description;
+            states.push(stateEntry);
+        }
+        if (states.length > 0)
+            entry["states"] = states;
+        props.push(entry);
+    }
+    const speakerIdForSceneRef = (ref) => {
+        const speaker = cleanName(strOf(ref["speaker"]));
+        const speakerKind = strOf(ref["speaker_kind"] || "actor").trim() || "actor";
+        if (!speaker)
+            return null;
+        if (speakerKind === "actor" && actorIds.has(speaker))
+            return `spk_${actorIds.get(speaker)}`;
+        const normKind = _MD_SPEAKER_KIND_NORM[speakerKind.toLowerCase()] ?? _MD_SPEAKER_KIND_NORM[speakerKind] ?? "other";
+        return speakerIdsByName.get(`${normKind}::${speaker}`) ?? speakerIdsByName.get(`other::${speaker}`) ?? null;
+    };
+    const sortedResults = [...results].sort((a, b) => Number(a["episode"] ?? 0) - Number(b["episode"] ?? 0));
+    const episodes = [];
+    let sceneCounter = 0;
+    for (const result of sortedResults) {
+        const scenes = [];
+        for (const scene of asList(result["scenes"])) {
+            sceneCounter += 1;
+            const locName = cleanName(strOf(scene["location_name"] || "未知场景")) || "未知场景";
+            const locState = strOf(scene["location_state"]).trim();
+            const locStateId = locState ? stateIdsByTarget.get(`location::${locName}::${locState}`) ?? null : null;
+            const sceneActorRefs = [];
+            for (const actorRaw of asList(scene["actor_names"])) {
+                const actor = cleanName(strOf(actorRaw));
+                const aid = actorIds.get(actor);
+                if (!aid)
+                    continue;
+                const actorStates = isDict(scene["actor_states"]) ? scene["actor_states"] : {};
+                const state = actorStates[actor];
+                const stateId = state ? stateIdsByTarget.get(`actor::${actor}::${strOf(state).trim()}`) ?? null : null;
+                sceneActorRefs.push({ actor_id: aid, state_id: stateId });
+            }
+            const scenePropRefs = [];
+            for (const rawProp of asList(scene["prop_names"])) {
+                const prop = cleanName(strOf(rawProp));
+                if (propIds.has(prop))
+                    scenePropRefs.push({ prop_id: propIds.get(prop), state_id: null });
+            }
+            const actions = [];
+            for (const action of asList(scene["actions"])) {
+                const item = { type: action["type"], content: action["content"] };
+                const delivery = normalizeDeliveryToken(action["delivery"]);
+                if (action["type"] === "dialogue" && delivery)
+                    item["delivery"] = delivery;
+                if (action["type"] === "dialogue" && delivery === "overlap" && asList(action["lines"]).length > 0) {
+                    const lines = [];
+                    for (const line of asList(action["lines"])) {
+                        if (!isDict(line))
+                            continue;
+                        const speakerId = speakerIdForSceneRef(line);
+                        const content = strOf(line["content"]).trim();
+                        if (speakerId && content)
+                            lines.push({ speaker_id: speakerId, content });
+                    }
+                    if (lines.length > 0) {
+                        item["lines"] = lines;
+                        item["content"] = lines.map((l) => l["content"]).join(" / ");
+                    }
+                }
+                else if (action["type"] === "dialogue" && asList(action["speakers"]).length > 0) {
+                    const speakerIds = [];
+                    for (const ref of asList(action["speakers"])) {
+                        if (!isDict(ref))
+                            continue;
+                        const sid = speakerIdForSceneRef(ref);
+                        if (sid)
+                            speakerIds.push(sid);
+                    }
+                    if (speakerIds.length > 0) {
+                        item["delivery"] = delivery || (speakerIds.length > 1 ? "simultaneous" : "single");
+                        item["speakers"] = speakerIds.map((sid) => ({ speaker_id: sid }));
+                        if (speakerIds.length === 1) {
+                            const sid = speakerIds[0];
+                            const actorId = sid.startsWith("spk_act_") ? sid.slice(4) : null;
+                            if (actorId) {
+                                item["actor_id"] = actorId;
+                                item["speaker_id"] = sid;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const speaker = action["speaker"];
+                    if ((action["type"] === "dialogue" || action["type"] === "inner_thought") && speaker) {
+                        const sid = speakerIdForSceneRef({
+                            speaker,
+                            speaker_kind: strOf(action["speaker_kind"] || "actor").trim() || "actor",
+                        });
+                        if (sid) {
+                            item["speaker_id"] = sid;
+                            const actorId = sid.startsWith("spk_act_") ? sid.slice(4) : null;
+                            if (actorId)
+                                item["actor_id"] = actorId;
+                        }
+                    }
+                }
+                if (action["emotion"])
+                    item["emotion"] = action["emotion"];
+                actions.push(item);
+            }
+            const context = {
+                locations: [{ location_id: locationIds.get(locName) ?? null, state_id: locStateId }],
+                actors: sceneActorRefs,
+                props: scenePropRefs,
+            };
+            scenes.push({
+                scene_id: fmtId("scn", sceneCounter),
+                environment: scene["environment"],
+                context,
+                locations: context["locations"],
+                actors: context["actors"],
+                props: context["props"],
+                actions,
+            });
+        }
+        episodes.push({
+            episode_id: fmtId("ep", Number(result["episode"] ?? episodes.length + 1)),
+            title: result["title"],
+            scenes,
+        });
+    }
+    return {
+        version: SCRIPT_SCHEMA_VERSION,
+        title,
+        worldview: "",
+        worldview_raw: "",
+        style: "",
+        actors,
+        locations,
+        props,
+        speakers,
+        episodes,
+    };
+}
+//# sourceMappingURL=direct-core.js.map