@lingjingai/scriptctl 0.32.0 → 0.33.0

package/dist/domain/direct-core.js

@@ -3927,7 +3927,7 @@ export function validateAssetGroupingPlan(script, kind, rawPlan) {
         retainedByName.set(key, list);
     }
     const duplicateMerges = [];
-    const omittedInvalid = [];
+    const omittedSingletons = [];
     for (const id of inputIds) {
         if (mentioned.has(id))
             continue;
@@ -3937,7 +3937,13 @@ export function validateAssetGroupingPlan(script, kind, rawPlan) {
         const key = assetGroupingNameKey(kind, asset[assetNameKey(kind)]);
         const targets = key ? retainedByName.get(key) ?? [] : [];
         if (targets.length === 0) {
-            omittedInvalid.push(`${kind}:${id}:${strOf(asset[assetNameKey(kind)])}`);
+            groups.push({
+                kind,
+                ids: [id],
+                reason: "omitted by grouping; review as standalone asset",
+            });
+            mentioned.add(id);
+            omittedSingletons.push(id);
             continue;
         }
         duplicateMerges.push({
@@ -3949,9 +3955,6 @@ export function validateAssetGroupingPlan(script, kind, rawPlan) {
             reason: "name-level duplicate omitted by asset grouping",
         });
     }
-    if (omittedInvalid.length > 0) {
-        curationBlocked("Asset grouping omitted non-duplicate asset ids.", omittedInvalid.slice(0, 40));
-    }
     return {
         version: 1,
         format: "asset-grouping-v1",
@@ -3966,6 +3969,7 @@ export function validateAssetGroupingPlan(script, kind, rawPlan) {
             group_count: groups.length,
             mentioned_count: mentioned.size,
             omitted_duplicate_count: duplicateMerges.length,
+            omitted_singleton_count: omittedSingletons.length,
             normalization_count: normalizations.length,
         },
     };
@@ -5049,6 +5053,14 @@ function parseCurationExpression(expression) {
     match = /^PROP\s+(actor|location|prop)\s+(\S+)\s+->\s+(\S+)\s+"((?:\\.|[^"\\])*)"$/i.exec(command);
     if (match) {
         const target = match[3];
+        const normalizedTarget = target.toLowerCase();
+        const targetPrefix = /^([A-Za-z]+):(.+)$/.exec(target);
+        if ((targetPrefix && targetPrefix[1].toLowerCase() !== "prop") ||
+            normalizedTarget === "actor" ||
+            normalizedTarget === "location" ||
+            normalizedTarget === "prop") {
+            curationBlocked("PROP target must be NEW or an existing prop id.", [expression]);
+        }
         const decision = {
             kind: match[1].toLowerCase(),
             source_id: match[2],
@@ -5058,7 +5070,7 @@ function parseCurationExpression(expression) {
             reason,
         };
         if (target.toUpperCase() !== "NEW")
-            decision["target_id"] = target;
+            decision["target_id"] = targetPrefix ? targetPrefix[2] : target;
         return decision;
     }
     curationBlocked("Unknown or malformed curation expression.", [expression]);
@@ -6171,6 +6183,650 @@ export function curateScriptAssets(script, rawCuration = null) {
     };
 }
 // ---------------------------------------------------------------------------
+// State curation
+// ---------------------------------------------------------------------------
+export const STATE_CURATION_MAX_ASSETS = 4;
+export const STATE_CURATION_MAX_CONTEXT_CHARS = 28000;
+function stateCurationBlocked(message, received) {
+    throw new CliError("DIRECT STATE CURATION BLOCKED: invalid provider plan", message, {
+        exitCode: EXIT_NEEDS_AGENT,
+        required: ["valid state curation expressions referencing existing asset/state ids"],
+        received,
+        nextSteps: ["Inspect state_curation.json, adjust the draft manually, or rerun direct init after provider plan fixes."],
+    });
+}
+function stateCurationSourceKey(kind, assetId, stateId) {
+    return `${kind}:${assetId}/${stateId}`;
+}
+function stateCurationDecisionSourceKey(decision) {
+    return stateCurationSourceKey(strOf(decision["kind"]), strOf(decision["asset_id"]), strOf(decision["state_id"]));
+}
+function stateCurationUsageFor(script) {
+    const usage = new Map();
+    const ensure = (kind, assetId, stateId) => {
+        const key = stateCurationSourceKey(kind, assetId, stateId);
+        const current = usage.get(key);
+        if (current)
+            return current;
+        const next = { sceneRefs: new Set(), stateChanges: new Set() };
+        usage.set(key, next);
+        return next;
+    };
+    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 sceneRef = [episodeId, sceneId].filter((item) => item).join("/");
+            const ctx = sceneContext(scene);
+            for (const kind of ["actor", "location", "prop"]) {
+                const idKey = assetIdKey(kind);
+                const refKey = assetListKey(kind);
+                for (const ref of asList(ctx[refKey])) {
+                    const assetId = strOf(ref[idKey]);
+                    const stateId = strOf(ref["state_id"]);
+                    if (assetId && stateId && sceneRef)
+                        ensure(kind, assetId, stateId).sceneRefs.add(sceneRef);
+                }
+            }
+            for (const [actionIndex, action] of asList(scene["actions"]).entries()) {
+                if (!isDict(action))
+                    continue;
+                for (const change of asList(action["state_changes"])) {
+                    if (!isDict(change))
+                        continue;
+                    const kind = strOf(change["target_kind"]);
+                    if (!isAssetKindValue(kind))
+                        continue;
+                    const assetId = strOf(change["target_id"]);
+                    if (!assetId)
+                        continue;
+                    const actionRef = `${sceneRef}#${actionIndex}`;
+                    const fromStateId = strOf(change["from_state_id"]);
+                    const toStateId = strOf(change["to_state_id"]);
+                    if (fromStateId)
+                        ensure(kind, assetId, fromStateId).stateChanges.add(actionRef);
+                    if (toStateId)
+                        ensure(kind, assetId, toStateId).stateChanges.add(actionRef);
+                }
+            }
+        }
+    }
+    return usage;
+}
+function statefulAssetsForCuration(script) {
+    const refs = [];
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            if (!isDict(asset))
+                continue;
+            const assetId = strOf(asset[assetIdKey(kind)]).trim();
+            if (!assetId || asList(asset["states"]).filter(isDict).length === 0)
+                continue;
+            refs.push({ kind, asset_id: assetId });
+        }
+    }
+    return refs;
+}
+function stateCurationAssetByRef(script, ref) {
+    return assetMapById(script, ref.kind).get(ref.asset_id) ?? null;
+}
+function compactStateCurationText(value, maxChars = 120) {
+    const text = strOf(value).replace(/\s+/g, " ").replace(/\|/g, "/").trim();
+    return text.length > maxChars ? `${text.slice(0, maxChars - 1)}…` : text;
+}
+function formatStateCurationUsage(usage) {
+    if (!usage)
+        return "refs=0 changes=0";
+    return `refs=${usage.sceneRefs.size} changes=${usage.stateChanges.size}`;
+}
+function stateCurationPrefix(kind) {
+    if (kind === "actor")
+        return "A";
+    if (kind === "location")
+        return "L";
+    return "P";
+}
+function formatStateCurationAssetBlock(script, ref, usageByKey) {
+    const asset = stateCurationAssetByRef(script, ref);
+    if (!asset)
+        return [];
+    const name = compactStateCurationText(asset[assetNameKey(ref.kind)], 80);
+    const description = compactStateCurationText(asset["description"], 160);
+    const states = asList(asset["states"]).filter(isDict);
+    const lines = [
+        `${stateCurationPrefix(ref.kind)} | ${ref.kind} | ${ref.asset_id} | ${name || "-"} | states=${states.length} | desc=${description || "-"}`,
+    ];
+    for (const state of states) {
+        const stateId = compactStateCurationText(state["state_id"], 40);
+        const stateName = compactStateCurationText(state["state_name"], 80);
+        if (!stateId || !stateName)
+            continue;
+        const usage = usageByKey.get(stateCurationSourceKey(ref.kind, ref.asset_id, stateId));
+        lines.push(`  S | ${stateId} | ${stateName} | ${formatStateCurationUsage(usage)} | desc=${compactStateCurationText(state["description"], 180) || "-"}`);
+    }
+    return lines;
+}
+export function buildStateCurationContextText(script, refs) {
+    const selectedRefs = refs && refs.length > 0 ? refs : statefulAssetsForCuration(script);
+    const usage = stateCurationUsageFor(script);
+    const lines = [];
+    lines.push("# State Curation Context");
+    lines.push(`title: ${compactStateCurationText(script["title"], 120) || "-"}`);
+    lines.push("");
+    lines.push("Goal: compress each asset's states to reusable production visual states.");
+    lines.push("");
+    lines.push("Policy:");
+    lines.push("- A state is a large reusable visual asset form, not a plot/action/emotion/pose label.");
+    lines.push("- KEEP only states that require a visibly different reusable asset: major form transformation, Q version, non-human/beast/god/giant form, durable outfit/appearance redesign, major damage/repair condition, or a prop/location physical condition that must recur.");
+    lines.push("- MERGE states that are only degree/progress variants of the same major appearance. Rename one representative to the broad canonical state, then merge the variants into it.");
+    lines.push("- DROP or ACTION_STATE transient states: emotions, poses, unconscious/asleep/lying/sitting, holding/carrying an item, temporary glow/VFX intensity, minor mark brightness/thickness/spread, one-off ordinary clothing, camera effects, or scene-only actions.");
+    lines.push("- For actor states, held objects are not actor states. If the state is just holding/using an item, use ACTION_STATE unless the item must remain a separate prop.");
+    lines.push("- Every S line below must receive exactly one expression.");
+    lines.push("- Use only state_id values listed under the same asset block. Do not invent ids or cross-asset merge targets.");
+    lines.push("- If a broad canonical state name is needed, RENAME_STATE one existing representative state and MERGE_STATE the variants into it.");
+    lines.push("");
+    lines.push("Expression grammar:");
+    lines.push("- <exp>KEEP_STATE <kind> <asset_id> <state_id> # reason</exp>");
+    lines.push("- <exp>MERGE_STATE <kind> <asset_id> <state_id> -> <target_state_id> # reason</exp>");
+    lines.push("- <exp>DROP_STATE <kind> <asset_id> <state_id> # reason</exp>");
+    lines.push("- <exp>ACTION_STATE <kind> <asset_id> <state_id> # reason</exp>");
+    lines.push("- <exp>RENAME_STATE <kind> <asset_id> <state_id> \"<new_name>\" # reason</exp>");
+    lines.push("- <kind> is one of actor, location, prop. Use double quotes for names; escape only \\\" and \\\\.");
+    lines.push("");
+    lines.push("Assets:");
+    for (const ref of selectedRefs) {
+        const block = formatStateCurationAssetBlock(script, ref, usage);
+        if (block.length > 0)
+            lines.push(...block);
+    }
+    lines.push("");
+    lines.push("required_state_ids:");
+    for (const ref of selectedRefs) {
+        const asset = stateCurationAssetByRef(script, ref);
+        if (!asset)
+            continue;
+        for (const state of asList(asset["states"])) {
+            const stateId = strOf(state["state_id"]);
+            if (stateId)
+                lines.push(`- ${stateCurationSourceKey(ref.kind, ref.asset_id, stateId)}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function buildStateCurationChunks(script, options = {}) {
+    const maxAssets = Math.max(1, Math.floor(options.maxAssets ?? STATE_CURATION_MAX_ASSETS));
+    const maxContextChars = Math.max(2000, Math.floor(options.maxContextChars ?? STATE_CURATION_MAX_CONTEXT_CHARS));
+    const refs = statefulAssetsForCuration(script);
+    const chunks = [];
+    let current = [];
+    const flush = () => {
+        if (current.length === 0)
+            return;
+        chunks.push({ part_id: `part.${String(chunks.length + 1).padStart(3, "0")}`, refs: current });
+        current = [];
+    };
+    for (const ref of refs) {
+        const singletonLength = buildStateCurationContextText(script, [ref]).length;
+        if (current.length === 0) {
+            current.push(ref);
+            if (singletonLength > maxContextChars)
+                flush();
+            continue;
+        }
+        const candidate = [...current, ref];
+        if (candidate.length > maxAssets || buildStateCurationContextText(script, candidate).length > maxContextChars) {
+            flush();
+            current.push(ref);
+            if (singletonLength > maxContextChars)
+                flush();
+        }
+        else {
+            current = candidate;
+        }
+    }
+    flush();
+    return chunks;
+}
+function splitStateCurationExpressionReason(expression) {
+    let inQuote = false;
+    let escaped = false;
+    for (let index = 0; index < expression.length; index += 1) {
+        const ch = expression[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (ch === "\"") {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (ch === "#" && !inQuote) {
+            const command = expression.slice(0, index).trim();
+            const reason = expression.slice(index + 1).trim();
+            if (!command)
+                stateCurationBlocked("State curation expression is missing an operation before # reason.", [expression]);
+            if (!reason)
+                stateCurationBlocked("State curation expression is missing reason text after #.", [expression]);
+            return { command, reason };
+        }
+    }
+    stateCurationBlocked("State curation expression must include `# reason`.", [expression]);
+}
+function unquoteStateCurationExpressionString(value) {
+    let out = "";
+    let escaped = false;
+    for (const ch of value) {
+        if (escaped) {
+            if (ch !== "\\" && ch !== "\"")
+                stateCurationBlocked("Unsupported escape sequence in state curation expression string.", [`\\${ch}`]);
+            out += ch;
+            escaped = false;
+        }
+        else if (ch === "\\") {
+            escaped = true;
+        }
+        else {
+            out += ch;
+        }
+    }
+    if (escaped)
+        stateCurationBlocked("Unterminated escape sequence in state curation expression string.", [value]);
+    return out;
+}
+function parseStateCurationExpression(expression) {
+    if (expression.includes("\n") || expression.includes("\r")) {
+        stateCurationBlocked("Each state curation expression must be a single line.", [expression]);
+    }
+    const { command, reason } = splitStateCurationExpressionReason(expression.trim());
+    if (/^NOOP$/i.test(command))
+        return null;
+    let match = /^KEEP_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)$/i.exec(command);
+    if (match) {
+        return { kind: match[1].toLowerCase(), asset_id: match[2], state_id: match[3], decision: "keep", reason };
+    }
+    match = /^MERGE_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)\s+->\s+(\S+)$/i.exec(command);
+    if (match) {
+        return {
+            kind: match[1].toLowerCase(),
+            asset_id: match[2],
+            state_id: match[3],
+            decision: "merge",
+            target_state_id: match[4],
+            reason,
+        };
+    }
+    match = /^DROP_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)$/i.exec(command);
+    if (match) {
+        return { kind: match[1].toLowerCase(), asset_id: match[2], state_id: match[3], decision: "drop", reason };
+    }
+    match = /^ACTION_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)$/i.exec(command);
+    if (match) {
+        return { kind: match[1].toLowerCase(), asset_id: match[2], state_id: match[3], decision: "action_desc", reason };
+    }
+    match = /^RENAME_STATE\s+(actor|location|prop)\s+(\S+)\s+(\S+)\s+"((?:\\.|[^"\\])*)"$/i.exec(command);
+    if (match) {
+        return {
+            kind: match[1].toLowerCase(),
+            asset_id: match[2],
+            state_id: match[3],
+            decision: "rename",
+            new_name: unquoteStateCurationExpressionString(match[4]),
+            reason,
+        };
+    }
+    stateCurationBlocked("Unknown or malformed state curation expression.", [expression]);
+}
+function extractStateCurationExpressions(rawText) {
+    const expressions = [];
+    const re = /<exp>([\s\S]*?)<\/exp>/g;
+    let outside = "";
+    let lastIndex = 0;
+    let match;
+    while ((match = re.exec(rawText)) !== null) {
+        outside += rawText.slice(lastIndex, match.index);
+        expressions.push(strOf(match[1]).trim());
+        lastIndex = match.index + match[0].length;
+    }
+    outside += rawText.slice(lastIndex);
+    if (outside.trim()) {
+        stateCurationBlocked("State curation response must contain only <exp>...</exp> lines.", [outside.trim().slice(0, 200)]);
+    }
+    if (expressions.length === 0) {
+        stateCurationBlocked("State curation response did not contain any <exp> expressions.", [rawText.slice(0, 200)]);
+    }
+    return expressions;
+}
+export function parseStateCurationExpressions(rawText) {
+    const decisions = [];
+    const expressions = extractStateCurationExpressions(rawText);
+    let noop = false;
+    for (const expression of expressions) {
+        const decision = parseStateCurationExpression(expression);
+        if (decision === null)
+            noop = true;
+        else
+            decisions.push(decision);
+    }
+    if (noop && decisions.length > 0) {
+        stateCurationBlocked("NOOP cannot be combined with actionable state curation expressions.", [rawText.slice(0, 200)]);
+    }
+    return {
+        version: 1,
+        format: "state-curation-exp-v1",
+        expression_text: rawText,
+        expressions,
+        decisions,
+    };
+}
+function renderStateCurationDecisionExpression(decision) {
+    const kind = strOf(decision["kind"]);
+    const assetId = strOf(decision["asset_id"]);
+    const stateId = strOf(decision["state_id"]);
+    const reason = strOf(decision["reason"]).trim() || "state curation decision";
+    const action = strOf(decision["decision"]);
+    if (action === "keep")
+        return `KEEP_STATE ${kind} ${assetId} ${stateId} # ${reason}`;
+    if (action === "merge")
+        return `MERGE_STATE ${kind} ${assetId} ${stateId} -> ${strOf(decision["target_state_id"])} # ${reason}`;
+    if (action === "drop")
+        return `DROP_STATE ${kind} ${assetId} ${stateId} # ${reason}`;
+    if (action === "action_desc")
+        return `ACTION_STATE ${kind} ${assetId} ${stateId} # ${reason}`;
+    if (action === "rename")
+        return `RENAME_STATE ${kind} ${assetId} ${stateId} ${quoteCurationExpressionString(decision["new_name"])} # ${reason}`;
+    stateCurationBlocked("Cannot render unknown state curation decision.", [`decision: ${action || "<empty>"}`]);
+}
+export function formatStateCurationDecisionExpressions(plan) {
+    const decisions = asList(plan["decisions"]).filter(isDict);
+    if (decisions.length === 0)
+        return "<exp>NOOP # no state curation changes</exp>";
+    return `${decisions.map((decision) => `<exp>${renderStateCurationDecisionExpression(decision)}</exp>`).join("\n")}\n`;
+}
+function stateCurationAllSourceKeys(script) {
+    const keys = [];
+    for (const ref of statefulAssetsForCuration(script)) {
+        const asset = stateCurationAssetByRef(script, ref);
+        if (!asset)
+            continue;
+        for (const state of asList(asset["states"])) {
+            const stateId = strOf(state["state_id"]);
+            if (stateId)
+                keys.push(stateCurationSourceKey(ref.kind, ref.asset_id, stateId));
+        }
+    }
+    return keys;
+}
+export function stateCurationSourceKeysForRefs(script, refs) {
+    const keys = [];
+    for (const ref of refs) {
+        const asset = stateCurationAssetByRef(script, ref);
+        if (!asset)
+            continue;
+        for (const state of asList(asset["states"])) {
+            const stateId = strOf(state["state_id"]);
+            if (stateId)
+                keys.push(stateCurationSourceKey(ref.kind, ref.asset_id, stateId));
+        }
+    }
+    return keys;
+}
+function stateCurationDecisionMap(decisions) {
+    const map = new Map();
+    for (const decision of decisions) {
+        map.set(stateCurationDecisionSourceKey(decision), decision);
+    }
+    return map;
+}
+export function missingStateCurationRequiredSourceKeys(script, plan, requiredKeys) {
+    const keys = requiredKeys && requiredKeys.length > 0 ? [...requiredKeys] : stateCurationAllSourceKeys(script);
+    const decisions = stateCurationDecisionMap(asList(plan["decisions"]).filter(isDict));
+    return keys.filter((key) => !decisions.has(key));
+}
+function assertStateExistsForCuration(script, kind, assetId, stateId) {
+    const asset = assertAssetExists(script, kind, assetId);
+    for (const state of asList(asset["states"])) {
+        if (strOf(state["state_id"]) === stateId)
+            return state;
+    }
+    stateCurationBlocked("State curation decision references an unknown state.", [stateCurationSourceKey(kind, assetId, stateId)]);
+}
+function validateStateCurationDecision(script, decision) {
+    const kind = strOf(decision["kind"]);
+    if (!isAssetKindValue(kind))
+        stateCurationBlocked("Unknown state curation kind.", [`kind: ${kind || "<empty>"}`]);
+    const assetId = strOf(decision["asset_id"]);
+    const stateId = strOf(decision["state_id"]);
+    const action = strOf(decision["decision"]);
+    const reason = strOf(decision["reason"]);
+    if (!assetId || !stateId)
+        stateCurationBlocked("State curation decision is missing asset_id/state_id.", [`${kind}:${assetId}/${stateId}`]);
+    if (!reason)
+        stateCurationBlocked("State curation decision is missing reason.", [`${kind}:${assetId}/${stateId}`]);
+    assertStateExistsForCuration(script, kind, assetId, stateId);
+    if (action === "merge") {
+        const targetStateId = strOf(decision["target_state_id"]);
+        if (!targetStateId || targetStateId === stateId) {
+            stateCurationBlocked("MERGE_STATE requires a different target_state_id.", [`${kind}:${assetId}/${stateId}`]);
+        }
+        assertStateExistsForCuration(script, kind, assetId, targetStateId);
+    }
+    else if (action === "rename") {
+        const newName = strOf(decision["new_name"]).trim();
+        if (!newName)
+            stateCurationBlocked("RENAME_STATE requires a non-empty new_name.", [`${kind}:${assetId}/${stateId}`]);
+    }
+    else if (action !== "keep" && action !== "drop" && action !== "action_desc") {
+        stateCurationBlocked("Unknown state curation decision.", [`decision: ${action || "<empty>"}`]);
+    }
+}
+function normalizeStateCurationMergeTargets(decisions) {
+    const bySource = stateCurationDecisionMap(decisions);
+    for (const decision of decisions) {
+        if (strOf(decision["decision"]) !== "merge")
+            continue;
+        const kind = strOf(decision["kind"]);
+        const assetId = strOf(decision["asset_id"]);
+        let targetStateId = strOf(decision["target_state_id"]);
+        const seen = new Set([stateCurationDecisionSourceKey(decision)]);
+        while (targetStateId) {
+            const targetKey = stateCurationSourceKey(kind, assetId, targetStateId);
+            if (seen.has(targetKey))
+                stateCurationBlocked("State curation merge plan contains a cycle.", [`cycle at ${targetKey}`]);
+            seen.add(targetKey);
+            const targetDecision = bySource.get(targetKey);
+            if (!targetDecision)
+                break;
+            const targetAction = strOf(targetDecision["decision"]);
+            if (targetAction === "merge") {
+                targetStateId = strOf(targetDecision["target_state_id"]);
+                decision["target_state_id"] = targetStateId;
+                continue;
+            }
+            if (targetAction === "drop" || targetAction === "action_desc") {
+                decision["decision"] = targetAction;
+                delete decision["target_state_id"];
+            }
+            break;
+        }
+    }
+}
+export function assertStateCurationPlan(script, plan, requiredKeys) {
+    const rawDecisions = asList(plan["decisions"]).filter(isDict);
+    const decisions = [...stateCurationDecisionMap(rawDecisions).values()];
+    for (const decision of decisions)
+        validateStateCurationDecision(script, decision);
+    normalizeStateCurationMergeTargets(decisions);
+    const missing = missingStateCurationRequiredSourceKeys(script, { decisions }, requiredKeys);
+    if (missing.length > 0) {
+        stateCurationBlocked("State curation plan is missing required state decisions.", missing.slice(0, 80));
+    }
+    return {
+        ...plan,
+        decisions,
+    };
+}
+function mapStateForCuration(kind, assetId, stateId, replacements, removed) {
+    const id = strOf(stateId);
+    if (!id)
+        return null;
+    const key = stateCurationSourceKey(kind, assetId, id);
+    const replacement = replacements.get(key);
+    if (replacement)
+        return replacement;
+    if (removed.has(key))
+        return null;
+    return id;
+}
+function rewriteRefsAfterStateCuration(script, replacements, removed) {
+    let sceneRefsCleared = 0;
+    let sceneRefsMerged = 0;
+    let stateChangesRemoved = 0;
+    let stateChangesRewritten = 0;
+    for (const ep of asList(script["episodes"])) {
+        for (const scene of asList(ep["scenes"])) {
+            const ctx = sceneContext(scene);
+            for (const kind of ["actor", "location", "prop"]) {
+                const idKey = assetIdKey(kind);
+                const refKey = assetListKey(kind);
+                for (const ref of asList(ctx[refKey])) {
+                    if (!isDict(ref))
+                        continue;
+                    const assetId = strOf(ref[idKey]);
+                    const prior = strOf(ref["state_id"]);
+                    const next = mapStateForCuration(kind, assetId, prior, replacements, removed);
+                    if (!next && prior) {
+                        ref["state_id"] = null;
+                        sceneRefsCleared += 1;
+                    }
+                    else if (next && next !== prior) {
+                        ref["state_id"] = next;
+                        sceneRefsMerged += 1;
+                    }
+                }
+            }
+            setSceneContext(scene, ctx);
+            for (const action of asList(scene["actions"])) {
+                if (!isDict(action) || action["state_changes"] === undefined || action["state_changes"] === null)
+                    continue;
+                const nextChanges = [];
+                for (const change of asList(action["state_changes"])) {
+                    if (!isDict(change))
+                        continue;
+                    const kind = strOf(change["target_kind"]);
+                    if (!isAssetKindValue(kind))
+                        continue;
+                    const assetId = strOf(change["target_id"]);
+                    const toState = mapStateForCuration(kind, assetId, change["to_state_id"], replacements, removed);
+                    if (!toState) {
+                        stateChangesRemoved += 1;
+                        continue;
+                    }
+                    const fromState = mapStateForCuration(kind, assetId, change["from_state_id"], replacements, removed);
+                    if (fromState && fromState === toState) {
+                        stateChangesRemoved += 1;
+                        continue;
+                    }
+                    const next = { ...change, to_state_id: toState };
+                    if (fromState)
+                        next["from_state_id"] = fromState;
+                    else
+                        delete next["from_state_id"];
+                    if (toState !== strOf(change["to_state_id"]) || fromState !== strOf(change["from_state_id"]))
+                        stateChangesRewritten += 1;
+                    nextChanges.push(next);
+                }
+                if (nextChanges.length > 0)
+                    action["state_changes"] = nextChanges;
+                else
+                    delete action["state_changes"];
+            }
+        }
+    }
+    return {
+        scene_refs_cleared: sceneRefsCleared,
+        scene_refs_merged: sceneRefsMerged,
+        state_changes_removed: stateChangesRemoved,
+        state_changes_rewritten: stateChangesRewritten,
+    };
+}
+export function applyStateCurationPlan(script, rawPlan) {
+    const plan = assertStateCurationPlan(script, rawPlan);
+    const decisions = asList(plan["decisions"]).filter(isDict);
+    const beforeByKind = { actor: 0, location: 0, prop: 0 };
+    const afterByKind = { actor: 0, location: 0, prop: 0 };
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)]))
+            beforeByKind[kind] += asList(asset["states"]).filter(isDict).length;
+    }
+    const replacements = new Map();
+    const removed = new Set();
+    const decisionSummary = {
+        keep: 0,
+        merge: 0,
+        drop: 0,
+        action_desc: 0,
+        rename: 0,
+    };
+    for (const decision of decisions) {
+        const kind = strOf(decision["kind"]);
+        const assetId = strOf(decision["asset_id"]);
+        const stateId = strOf(decision["state_id"]);
+        const key = stateCurationSourceKey(kind, assetId, stateId);
+        const action = strOf(decision["decision"]);
+        decisionSummary[action] = Number(decisionSummary[action] ?? 0) + 1;
+        if (action === "rename") {
+            const state = assertStateExistsForCuration(script, kind, assetId, stateId);
+            state["state_name"] = strOf(decision["new_name"]).trim();
+        }
+        else if (action === "merge") {
+            replacements.set(key, strOf(decision["target_state_id"]));
+            removed.add(key);
+        }
+        else if (action === "drop" || action === "action_desc") {
+            removed.add(key);
+        }
+    }
+    const rewriteSummary = rewriteRefsAfterStateCuration(script, replacements, removed);
+    for (const kind of ["actor", "location", "prop"]) {
+        for (const asset of asList(script[assetListKey(kind)])) {
+            if (!isDict(asset))
+                continue;
+            const assetId = strOf(asset[assetIdKey(kind)]);
+            asset["states"] = asList(asset["states"]).filter((state) => {
+                if (!isDict(state))
+                    return false;
+                const key = stateCurationSourceKey(kind, assetId, strOf(state["state_id"]));
+                return !removed.has(key);
+            });
+            afterByKind[kind] += asList(asset["states"]).filter(isDict).length;
+        }
+    }
+    const statesBefore = beforeByKind.actor + beforeByKind.location + beforeByKind.prop;
+    const statesAfter = afterByKind.actor + afterByKind.location + afterByKind.prop;
+    return {
+        version: 1,
+        format: "state-curation-exp-v1",
+        summary: {
+            states_before: statesBefore,
+            states_after: statesAfter,
+            states_removed: statesBefore - statesAfter,
+            actor_states_before: beforeByKind.actor,
+            actor_states_after: afterByKind.actor,
+            location_states_before: beforeByKind.location,
+            location_states_after: afterByKind.location,
+            prop_states_before: beforeByKind.prop,
+            prop_states_after: afterByKind.prop,
+            decisions: decisionSummary,
+            ...rewriteSummary,
+        },
+        decisions,
+    };
+}
+// ---------------------------------------------------------------------------
 // State binding
 // ---------------------------------------------------------------------------
 function stateBindingBlocked(message, received) {