@lingjingai/scriptctl 0.28.0 → 0.28.2

package/dist/domain/direct-core.js

@@ -12,13 +12,31 @@ export const _TECHNICAL_EP_TITLE_RE = /^(?:ep|episode)[\s_\-#:.]*[0-9０-９]+$/
 const _TIME_MAP = {
     "日": "day", "白天": "day", "上午": "day", "下午": "day", "午后": "day", "中午": "day",
     "晨": "day", "清晨": "day", "早晨": "day", "黎明": "day",
-    "夜": "night", "夜晚": "night", "深夜": "night", "凌晨": "night", "黄昏": "night", "傍晚": "night",
+    "夜": "night", "夜晚": "night", "夜间": "night", "夜里": "night", "深夜": "night", "凌晨": "night", "黄昏": "night", "傍晚": "night",
+};
+const _LOCATION_TIME_STATE_MAP = {
+    "白天": "白天",
+    "日间": "白天",
+    "上午": "上午",
+    "下午": "下午",
+    "午后": "午后",
+    "中午": "中午",
+    "清晨": "清晨",
+    "早晨": "早晨",
+    "黎明": "黎明",
+    "夜晚": "夜晚",
+    "夜间": "夜晚",
+    "夜里": "夜晚",
+    "深夜": "深夜",
+    "凌晨": "凌晨",
+    "黄昏": "黄昏",
+    "傍晚": "黄昏",
 };
 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 _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*(.+)$/;
@@ -47,7 +65,7 @@ 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_TIME_SPACE_RE = /^(内|外|interior|exterior|in|out)\s+(\S+)$/i;
 const _MD_CHAR_ENTRY_RE = /^([^()（）,，]+?)(?:[（(]([^）)]+)[）)])?$/;
 const _MD_ACTION_ANCHOR_RE = /^>\s*\[([A-Za-z]+)(?:\|([^|\]]+?)(?:\|([^|\]]+?))?)?\]\s*(.*)$/;
 const _MD_ASSET_ENTRY_RE = /^-\s*([^:：]+?)(?:\s*[:：]\s*(.+?))?\s*$/;
@@ -494,6 +512,17 @@ export function splitLocationState(raw) {
     }
     return [locName, states.length > 0 ? states[states.length - 1] : null];
 }
+function locationTimeState(raw) {
+    const token = strOf(raw).trim();
+    if (!token || token === "日" || token === "夜")
+        return null;
+    return _LOCATION_TIME_STATE_MAP[token] ?? null;
+}
+function coarseSceneTime(raw) {
+    const token = strOf(raw).trim();
+    const lower = token.toLowerCase();
+    return _MD_TIME_NORM[lower] ?? _MD_TIME_NORM[token] ?? _TIME_MAP[token] ?? "day";
+}
 export function stateLabelError(stateName) {
     const text = strOf(stateName).trim().replace(/\s+/g, "");
     if (!text)
@@ -538,22 +567,28 @@ export function stripLocationState(location) {
 export function parseSceneHeader(line) {
     const timeFirst = reMatch(_SCENE_TIME_FIRST_RE, line);
     if (timeFirst) {
+        const timeToken = timeFirst[3];
         const [locName, locState] = stripLocationState(timeFirst[5].trim());
+        const locTimeState = locationTimeState(timeToken);
         return {
             space: _SPACE_MAP[timeFirst[4]] ?? "interior",
-            time: _TIME_MAP[timeFirst[3]] ?? "day",
+            time: _TIME_MAP[timeToken] ?? "day",
             location_name: locName || "未知场景",
             location_state: locState,
+            ...(locTimeState ? { location_time_state: locTimeState } : {}),
         };
     }
     const locFirst = reMatch(_SCENE_LOCATION_FIRST_RE, line);
     if (locFirst) {
+        const timeToken = locFirst[4];
         const [locName, locState] = stripLocationState(locFirst[3].trim());
+        const locTimeState = locationTimeState(timeToken);
         return {
             space: _SPACE_MAP[locFirst[5]] ?? "interior",
-            time: _TIME_MAP[locFirst[4]] ?? "day",
+            time: _TIME_MAP[timeToken] ?? "day",
             location_name: locName || "未知场景",
             location_state: locState,
+            ...(locTimeState ? { location_time_state: locTimeState } : {}),
         };
     }
     return null;
@@ -615,6 +650,7 @@ export function deterministicExtractEpisode(sourceText, episodePlan) {
                 environment: { space: sceneHeader["space"], time: sceneHeader["time"] },
                 location_name: sceneHeader["location_name"],
                 location_state: sceneHeader["location_state"],
+                location_time_state: sceneHeader["location_time_state"],
                 actor_names: [],
                 actor_states: {},
                 prop_names: [],
@@ -1538,10 +1574,14 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
                 if (key === "时空") {
                     const tsMatch = reMatch(_MD_TIME_SPACE_RE, value);
                     if (tsMatch) {
+                        const timeToken = tsMatch[2];
                         scene["environment"] = {
                             space: _MD_SPACE_NORM[tsMatch[1].toLowerCase()] ?? "interior",
-                            time: _MD_TIME_NORM[tsMatch[2].toLowerCase()] ?? "day",
+                            time: coarseSceneTime(timeToken),
                         };
+                        const state = locationTimeState(timeToken);
+                        if (state)
+                            scene["location_time_state"] = state;
                     }
                     else {
                         const env = scene["environment"];
@@ -1549,8 +1589,12 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
                             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];
+                            const coarse = coarseSceneTime(tok);
+                            if (tl in _MD_TIME_NORM || tok in _TIME_MAP)
+                                env["time"] = coarse;
+                            const state = locationTimeState(tok);
+                            if (state)
+                                scene["location_time_state"] = state;
                         }
                     }
                 }
@@ -1665,40 +1709,6 @@ export function parseMarkdownBatch(text, batchPlan, opts = {}) {
     for (const scene of scenes) {
         scene["actions"] = scene["actions"].filter((a) => strOf(a["content"]).trim().length > 0);
     }
-    if (!fragmentMode) {
-        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 propStates = scene["prop_states"] || {};
-            const filteredPropStates = {};
-            for (const [propName, stateName] of Object.entries(propStates)) {
-                const allowed = stateLookup.get(`prop::${propName.trim()}`) ?? new Set();
-                if (allowed.has(strOf(stateName).trim()))
-                    filteredPropStates[propName] = stateName;
-            }
-            scene["prop_states"] = filteredPropStates;
-            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) {
         const hint = fragmentMode
             ? "no scenes parsed in fragment; expected at least one '## 场景 N' header under '# 剧本'"
@@ -2021,6 +2031,7 @@ export function expandCompactEpisodeResult(result, episodePlan) {
             },
             location_name: strOf(rawScene["loc"] || "未知场景").trim() || "未知场景",
             location_state: strOf(rawScene["ls"]).trim() || null,
+            location_time_state: strOf(rawScene["lts"]).trim() || null,
             actor_names: actorNames,
             actor_states: actorStates,
             prop_names: propNames,
@@ -2067,6 +2078,9 @@ export function compactEpisodeResult(result) {
         const locationState = strOf(scene["location_state"]).trim();
         if (locationState)
             compactScene["ls"] = locationState;
+        const locationTimeState = strOf(scene["location_time_state"]).trim();
+        if (locationTimeState)
+            compactScene["lts"] = locationTimeState;
         const actorStates = isDict(scene["actor_states"]) ? scene["actor_states"] : {};
         const compactActors = [];
         for (const actorName of asList(scene["actor_names"])) {
@@ -2412,29 +2426,8 @@ export function normalizeEpisodeResult(result, episodePlan) {
     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);
         }
@@ -3161,16 +3154,372 @@ export function curateScriptAssets(script, rawCuration = null) {
         locations: locationDecisions,
     };
 }
-export function mergeEpisodeResults(results, title, opts = {}) {
+function emptyAssetNormalizationReport() {
+    return {
+        version: 1,
+        mode: "conservative",
+        summary: {
+            asset_merges: 0,
+            location_states_from_names: 0,
+            location_states_from_time: 0,
+            review_items: 0,
+        },
+        decisions: [],
+    };
+}
+function addNormalizationDecision(report, decision) {
+    report.decisions.push(decision);
+    if (decision.action === "canonical_merge")
+        report.summary.asset_merges += 1;
+    else if (decision.action === "location_state_from_name")
+        report.summary.location_states_from_names += 1;
+    else if (decision.action === "location_state_from_time")
+        report.summary.location_states_from_time += 1;
+    else
+        report.summary.review_items += 1;
+}
+export function canonicalAssetNameKey(kind, rawName) {
+    const cleaned = cleanName(rawName)
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+    const folded = cleaned.replace(/[\s_\-–—·.,，、:：;；'"“”‘’()[\]{}（）【】《》<>]+/g, "");
+    return `${kind}::${folded}`;
+}
+function makeAssetNameRegistry(kind) {
+    return { kind, displayByKey: new Map(), aliasesByDisplay: new Map() };
+}
+function canonicalAssetDisplay(registry, rawName, report) {
+    const name = cleanName(rawName);
+    if (!name)
+        return "";
+    const key = canonicalAssetNameKey(registry.kind, name);
+    const existing = registry.displayByKey.get(key);
+    if (!existing) {
+        registry.displayByKey.set(key, name);
+        return name;
+    }
+    if (existing !== name) {
+        if (!registry.aliasesByDisplay.has(existing))
+            registry.aliasesByDisplay.set(existing, new Set());
+        const aliases = registry.aliasesByDisplay.get(existing);
+        if (!aliases.has(name)) {
+            aliases.add(name);
+            addNormalizationDecision(report, {
+                action: "canonical_merge",
+                kind: registry.kind,
+                from: name,
+                into: existing,
+                reason: "同类资产 canonical key 相同，保留首个显示名并把后续名字作为 alias。",
+            });
+        }
+    }
+    return existing;
+}
+const LOCATION_STATE_PREFIX_RE = /^(白天|日间|上午|下午|午后|中午|清晨|早晨|黎明|夜晚|夜间|夜里|深夜|凌晨|黄昏|傍晚)(?:的|\s+)?(.+)$/;
+function splitLocationStatePhrase(rawName) {
+    const name = cleanName(rawName);
+    const match = LOCATION_STATE_PREFIX_RE.exec(name);
+    if (!match)
+        return null;
+    const state = _LOCATION_TIME_STATE_MAP[match[1]] ?? match[1];
+    const locationName = cleanName(match[2]);
+    if (!locationName)
+        return null;
+    return { name: locationName, state };
+}
+function addStateDefinition(stateDefinitions, seen, kind, assetName, stateName, description = null) {
+    const state = strOf(stateName).trim();
+    if (!assetName || !state || stateRejectionReason(kind, state))
+        return;
+    const key = `${kind}::${assetName}::${state}`;
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    const item = { kind, asset_name: assetName, state_name: state };
+    const desc = strOf(description).trim();
+    if (desc)
+        item["description"] = desc;
+    stateDefinitions.push(item);
+}
+function rawStringMap(value) {
+    const out = {};
+    if (!isDict(value))
+        return out;
+    for (const [key, raw] of Object.entries(value)) {
+        const state = strOf(raw).trim();
+        if (state)
+            out[cleanName(key)] = state;
+    }
+    return out;
+}
+function normalizeSpeakerNameInAction(action, actorRegistry, locationRegistry, propRegistry, report) {
+    const item = { ...action };
+    const normalizeByKind = (speaker, speakerKind) => {
+        const kind = strOf(speakerKind || "actor").trim() || "actor";
+        if (kind === "actor")
+            return canonicalAssetDisplay(actorRegistry, speaker, report);
+        if (kind === "location")
+            return canonicalAssetDisplay(locationRegistry, speaker, report);
+        if (kind === "prop")
+            return canonicalAssetDisplay(propRegistry, speaker, report);
+        return cleanName(speaker);
+    };
+    if (item["speaker"])
+        item["speaker"] = normalizeByKind(item["speaker"], item["speaker_kind"]);
+    if (isList(item["speakers"])) {
+        item["speakers"] = asList(item["speakers"]).map((speaker) => ({
+            ...speaker,
+            speaker: normalizeByKind(speaker["speaker"], speaker["speaker_kind"]),
+        }));
+    }
+    if (isList(item["lines"])) {
+        item["lines"] = asList(item["lines"]).map((line) => ({
+            ...line,
+            speaker: normalizeByKind(line["speaker"], line["speaker_kind"]),
+        }));
+    }
+    return item;
+}
+function attachRegistryAliases(results, registries) {
+    if (results.length === 0)
+        return;
+    const first = results[0];
+    const pluralByKind = { actor: "actors", location: "locations", prop: "props" };
+    for (const registry of registries) {
+        const key = pluralByKind[registry.kind];
+        if (!isList(first[key]))
+            first[key] = [];
+        for (const [display, aliases] of registry.aliasesByDisplay) {
+            const aliasList = [...aliases].filter((alias) => alias && alias !== display);
+            if (aliasList.length === 0)
+                continue;
+            first[key].push({ name: display, aliases: aliasList });
+        }
+    }
+}
+function normalizeEpisodeResultsForAssets(results, opts) {
+    const report = emptyAssetNormalizationReport();
+    if (opts.assetNormalization === "off")
+        return { results, report };
+    const actorRegistry = makeAssetNameRegistry("actor");
+    const locationRegistry = makeAssetNameRegistry("location");
+    const propRegistry = makeAssetNameRegistry("prop");
+    const normalizedResults = [];
+    const globalStateDefinitions = [];
+    const seenStateDefinitions = new Set();
+    for (const result of results) {
+        const normalized = { ...result, actors: [], locations: [], props: [], speakers: [], state_definitions: [] };
+        for (const asset of asList(result["actors"])) {
+            if (!isDict(asset))
+                continue;
+            const rawName = cleanName(asset["name"]);
+            const name = canonicalAssetDisplay(actorRegistry, rawName, report);
+            if (name)
+                normalized["actors"].push({ ...asset, name });
+        }
+        for (const asset of asList(result["locations"])) {
+            if (!isDict(asset))
+                continue;
+            const split = splitLocationStatePhrase(asset["name"]);
+            const name = canonicalAssetDisplay(locationRegistry, split ? split.name : asset["name"], report);
+            if (name)
+                normalized["locations"].push({ ...asset, name });
+            if (split && name) {
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "location", name, split.state, asset["description"]);
+                addNormalizationDecision(report, {
+                    action: "location_state_from_name",
+                    kind: "location",
+                    from: cleanName(asset["name"]),
+                    into: name,
+                    state: split.state,
+                    reason: "地点名包含时间状态，拆成稳定地点 + 场景状态。",
+                });
+            }
+        }
+        for (const asset of asList(result["props"])) {
+            if (!isDict(asset))
+                continue;
+            const name = canonicalAssetDisplay(propRegistry, asset["name"], report);
+            if (name)
+                normalized["props"].push({ ...asset, name });
+        }
+        for (const speaker of asList(result["speakers"])) {
+            if (!isDict(speaker))
+                continue;
+            const sourceKind = strOf(speaker["source_kind"] || "other").trim();
+            if (sourceKind === "prop") {
+                normalized["speakers"].push({
+                    ...speaker,
+                    name: canonicalAssetDisplay(propRegistry, speaker["name"], report),
+                });
+            }
+            else if (sourceKind === "location") {
+                normalized["speakers"].push({
+                    ...speaker,
+                    name: canonicalAssetDisplay(locationRegistry, speaker["name"], report),
+                });
+            }
+            else if (sourceKind === "actor") {
+                normalized["speakers"].push({
+                    ...speaker,
+                    name: canonicalAssetDisplay(actorRegistry, speaker["name"], report),
+                });
+            }
+            else {
+                normalized["speakers"].push(speaker);
+            }
+        }
+        for (const stateDef of asList(result["state_definitions"])) {
+            if (!isDict(stateDef))
+                continue;
+            const kind = strOf(stateDef["kind"]);
+            if (kind !== "actor" && kind !== "location" && kind !== "prop")
+                continue;
+            if (kind === "actor") {
+                const assetName = canonicalAssetDisplay(actorRegistry, stateDef["asset_name"], report);
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "actor", assetName, stateDef["state_name"], stateDef["description"]);
+            }
+            else if (kind === "location") {
+                const split = splitLocationStatePhrase(stateDef["asset_name"]);
+                const assetName = canonicalAssetDisplay(locationRegistry, split ? split.name : stateDef["asset_name"], report);
+                if (split) {
+                    addStateDefinition(globalStateDefinitions, seenStateDefinitions, "location", assetName, split.state, stateDef["description"]);
+                    addNormalizationDecision(report, {
+                        action: "location_state_from_name",
+                        kind: "location",
+                        from: cleanName(stateDef["asset_name"]),
+                        into: assetName,
+                        state: split.state,
+                        reason: "地点状态定义的资产名含时间状态，拆成稳定地点 + 状态。",
+                    });
+                }
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "location", assetName, stateDef["state_name"], stateDef["description"]);
+            }
+            else {
+                const assetName = canonicalAssetDisplay(propRegistry, stateDef["asset_name"], report);
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "prop", assetName, stateDef["state_name"], stateDef["description"]);
+            }
+        }
+        const scenes = [];
+        for (const scene of asList(result["scenes"])) {
+            const sceneNum = normalizeInt(scene["scene_num"], scenes.length + 1);
+            const splitLocation = splitLocationStatePhrase(scene["location_name"]);
+            const locationName = canonicalAssetDisplay(locationRegistry, splitLocation ? splitLocation.name : scene["location_name"], report) || "未知场景";
+            const explicitLocationState = strOf(scene["location_state"]).trim();
+            let locationState = explicitLocationState;
+            if (!locationState && splitLocation) {
+                locationState = splitLocation.state;
+                addNormalizationDecision(report, {
+                    action: "location_state_from_name",
+                    kind: "location",
+                    from: cleanName(scene["location_name"]),
+                    into: locationName,
+                    state: locationState,
+                    episode: Number(result["episode"] ?? 0),
+                    scene_num: sceneNum,
+                    reason: "场景地点写成时间 + 地点，拆成稳定地点 + 场景状态。",
+                });
+            }
+            const timeState = strOf(scene["location_time_state"]).trim();
+            if (!locationState && timeState) {
+                locationState = timeState;
+                addNormalizationDecision(report, {
+                    action: "location_state_from_time",
+                    kind: "location",
+                    into: locationName,
+                    state: locationState,
+                    episode: Number(result["episode"] ?? 0),
+                    scene_num: sceneNum,
+                    reason: "场景时空包含细粒度时间，作为地点状态绑定。",
+                });
+            }
+            if (locationState)
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "location", locationName, locationState);
+            const actorStates = rawStringMap(scene["actor_states"]);
+            const actorNames = [];
+            const normalizedActorStates = {};
+            const propNames = [];
+            const normalizedPropStates = {};
+            for (const rawActor of asList(scene["actor_names"])) {
+                const cleanActor = cleanName(rawActor);
+                const actorName = canonicalAssetDisplay(actorRegistry, cleanActor, report);
+                if (!actorName)
+                    continue;
+                uniqueAdd(actorNames, actorName);
+                const state = actorStates[cleanActor] || actorStates[actorName] || "";
+                if (!state)
+                    continue;
+                normalizedActorStates[actorName] = state;
+                addStateDefinition(globalStateDefinitions, seenStateDefinitions, "actor", actorName, state);
+            }
+            const propStates = rawStringMap(scene["prop_states"]);
+            for (const rawProp of asList(scene["prop_names"])) {
+                const propName = canonicalAssetDisplay(propRegistry, rawProp, report);
+                if (!propName)
+                    continue;
+                uniqueAdd(propNames, propName);
+                const state = propStates[cleanName(rawProp)] || propStates[propName] || "";
+                if (state) {
+                    normalizedPropStates[propName] = state;
+                    addStateDefinition(globalStateDefinitions, seenStateDefinitions, "prop", propName, state);
+                }
+            }
+            const actions = asList(scene["actions"]).map((action) => normalizeSpeakerNameInAction(action, actorRegistry, locationRegistry, propRegistry, report));
+            const normalizedScene = {
+                ...scene,
+                scene_num: sceneNum,
+                location_name: locationName,
+                location_state: locationState || null,
+                actor_names: actorNames,
+                actor_states: normalizedActorStates,
+                prop_names: propNames,
+                prop_states: normalizedPropStates,
+                actions,
+            };
+            delete normalizedScene["location_time_state"];
+            scenes.push(normalizedScene);
+        }
+        normalized["scenes"] = scenes;
+        normalizedResults.push(normalized);
+    }
+    if (normalizedResults.length > 0) {
+        normalizedResults[0]["state_definitions"] = globalStateDefinitions;
+        attachRegistryAliases(normalizedResults, [actorRegistry, locationRegistry, propRegistry]);
+    }
+    return { results: normalizedResults, report };
+}
+// ---------------------------------------------------------------------------
+// Merge episode results into a final script
+// ---------------------------------------------------------------------------
+function mergeEpisodeResultsInternal(results, title, opts = {}) {
     const actorNames = [];
     const locationNames = [];
     const propNames = [];
     const actorDescriptions = new Map();
     const locationDescriptions = new Map();
     const propDescriptions = new Map();
+    const actorAliases = new Map();
+    const locationAliases = new Map();
+    const propAliases = new Map();
     const stateDefinitions = [];
     const speakerRecords = new Map();
     const speakerOrder = [];
+    const rememberAliases = (aliasesByName, name, aliasesRaw) => {
+        if (!name)
+            return;
+        const existing = aliasesByName.get(name) ?? [];
+        const seen = new Set(existing);
+        for (const rawAlias of asList(aliasesRaw)) {
+            const alias = cleanName(rawAlias);
+            if (!alias || alias === name || seen.has(alias))
+                continue;
+            existing.push(alias);
+            seen.add(alias);
+        }
+        if (existing.length > 0)
+            aliasesByName.set(name, existing);
+    };
     const rememberSpeaker = (name, sourceKind = "other", description = "") => {
         const speakerName = strOf(name).trim();
         if (!speakerName)
@@ -3199,6 +3548,7 @@ export function mergeEpisodeResults(results, title, opts = {}) {
             const desc = strOf(asset["description"]).trim();
             if (name && desc && !actorDescriptions.has(name))
                 actorDescriptions.set(name, desc);
+            rememberAliases(actorAliases, name, asset["aliases"]);
         }
         for (const asset of asList(result["locations"])) {
             if (!isDict(asset))
@@ -3207,6 +3557,7 @@ export function mergeEpisodeResults(results, title, opts = {}) {
             const desc = strOf(asset["description"]).trim();
             if (name && desc && !locationDescriptions.has(name))
                 locationDescriptions.set(name, desc);
+            rememberAliases(locationAliases, name, asset["aliases"]);
         }
         for (const asset of asList(result["props"])) {
             if (!isDict(asset))
@@ -3215,6 +3566,7 @@ export function mergeEpisodeResults(results, title, opts = {}) {
             const desc = strOf(asset["description"]).trim();
             if (name && desc && !propDescriptions.has(name))
                 propDescriptions.set(name, desc);
+            rememberAliases(propAliases, name, asset["aliases"]);
         }
         for (const speaker of _normalize_speaker_list(result["speakers"])) {
             rememberSpeaker(speaker["name"], speaker["source_kind"], speaker["description"]);
@@ -3345,6 +3697,9 @@ export function mergeEpisodeResults(results, title, opts = {}) {
         const entry = { actor_id: actorIds.get(name), actor_name: name };
         if (actorDescriptions.has(name))
             entry["description"] = actorDescriptions.get(name);
+        const aliases = actorAliases.get(name) ?? [];
+        if (aliases.length > 0)
+            entry["aliases"] = aliases;
         const states = [];
         for (const stateDef of stateDefsByTarget.get(`actor::${name}`) ?? []) {
             stateCounter += 1;
@@ -3367,6 +3722,9 @@ export function mergeEpisodeResults(results, title, opts = {}) {
         const entry = { location_id: locationIds.get(name), location_name: name, group: name };
         if (locationDescriptions.has(name))
             entry["description"] = locationDescriptions.get(name);
+        const aliases = locationAliases.get(name) ?? [];
+        if (aliases.length > 0)
+            entry["aliases"] = aliases;
         const states = [];
         for (const stateDef of stateDefsByTarget.get(`location::${name}`) ?? []) {
             stateCounter += 1;
@@ -3389,6 +3747,9 @@ export function mergeEpisodeResults(results, title, opts = {}) {
         const entry = { prop_id: propIds.get(name), prop_name: name };
         if (propDescriptions.has(name))
             entry["description"] = propDescriptions.get(name);
+        const aliases = propAliases.get(name) ?? [];
+        if (aliases.length > 0)
+            entry["aliases"] = aliases;
         const states = [];
         for (const stateDef of stateDefsByTarget.get(`prop::${name}`) ?? []) {
             stateCounter += 1;
@@ -3572,4 +3933,14 @@ export function mergeEpisodeResults(results, title, opts = {}) {
         episodes,
     };
 }
+export function mergeEpisodeResultsWithReport(results, title, opts = {}) {
+    const normalized = normalizeEpisodeResultsForAssets(results, opts);
+    return {
+        script: mergeEpisodeResultsInternal(normalized.results, title, opts),
+        assetNormalization: normalized.report,
+    };
+}
+export function mergeEpisodeResults(results, title, opts = {}) {
+    return mergeEpisodeResultsWithReport(results, title, opts).script;
+}
 //# sourceMappingURL=direct-core.js.map