@lingjingai/scriptctl 0.49.16 → 0.50.0

package/dist/domain/script/v4/patch/ops-asset.js

@@ -0,0 +1,617 @@
+import { strOf } from "../../shared.js";
+import { IMPORTANCE_TIER_SET, ROLE_TYPE_SET, } from "../../shared/types.js";
+import { generateV4Id, isV4Id } from "../ids.js";
+import { sortDeep } from "../../text-util.js";
+import { opUsage, requireAsset, requireState, stringField } from "./helpers.js";
+function aliasesFrom(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw) || !raw.every((value) => typeof value === "string")) {
+        return opUsage("ASSET BLOCKED: aliases invalid", "aliases must be an array of strings.", {
+            code: "ALIASES_INVALID",
+            received: [JSON.stringify(raw)],
+        });
+    }
+    if (raw.some((value) => value === "") || new Set(raw).size !== raw.length) {
+        return opUsage("ASSET BLOCKED: aliases invalid", "aliases must be non-empty and unique.", {
+            code: "ALIASES_INVALID",
+            received: raw,
+        });
+    }
+    return raw;
+}
+function importanceFrom(raw) {
+    const value = strOf(raw).trim() || "featured";
+    if (!IMPORTANCE_TIER_SET.has(value)) {
+        return opUsage("ASSET BLOCKED: importance invalid", "importance must be featured or background.", {
+            code: "IMPORTANCE_INVALID",
+            received: [value],
+        });
+    }
+    return value;
+}
+function requestedId(ctx, kind, key, existing) {
+    const raw = strOf(ctx.op[key] ?? ctx.op.id).trim();
+    if (!raw)
+        return generateV4Id(kind, existing);
+    if (!isV4Id(kind, raw)) {
+        return opUsage("ASSET BLOCKED: ID invalid", `New ${kind} ID has the wrong format.`, {
+            code: "V4_ID_INVALID",
+            received: [raw],
+        });
+    }
+    if (existing.has(raw)) {
+        return opUsage("ASSET BLOCKED: ID exists", `New ${kind} ID already exists.`, {
+            code: "ASSET_ID_EXISTS",
+            received: [raw],
+        });
+    }
+    return raw;
+}
+function defaultState() {
+    return { state_id: "default", state_name: "default", description: "" };
+}
+export const op_actor_add = (ctx) => {
+    const name = strOf(ctx.op.name ?? ctx.op.actor_name).trim();
+    if (!name) {
+        return opUsage("ASSET BLOCKED: actor name empty", "Actor name is required.", {
+            code: "ASSET_NAME_EMPTY",
+        });
+    }
+    if (ctx.script.actors.some((actor) => actor.actor_name.trim().toLocaleLowerCase() === name.toLocaleLowerCase())) {
+        return opUsage("ASSET BLOCKED: actor name exists", "Actor names must be unique.", {
+            code: "ACTOR_NAME_EXISTS",
+            received: [name],
+        });
+    }
+    const existing = new Set(ctx.script.actors.map((actor) => actor.actor_id));
+    const actorId = requestedId(ctx, "actor", "actor_id", existing);
+    const role = strOf(ctx.op.role_type ?? ctx.op.role).trim();
+    if (role && !ROLE_TYPE_SET.has(role)) {
+        return opUsage("ASSET BLOCKED: role invalid", "role_type must be 主角 or 配角.", {
+            code: "ROLE_TYPE_INVALID",
+            received: [role],
+        });
+    }
+    const aliases = aliasesFrom(ctx.op.aliases);
+    if (aliases?.includes(name)) {
+        return opUsage("ASSET BLOCKED: alias equals name", "An alias must differ from the asset name.", {
+            code: "ALIAS_EQUALS_NAME",
+            received: [name],
+        });
+    }
+    ctx.script.actors.push({
+        actor_id: actorId,
+        actor_name: name,
+        importance: importanceFrom(ctx.op.importance),
+        description: strOf(ctx.op.description).trim(),
+        states: [defaultState()],
+        ...(role ? { role_type: role } : {}),
+        ...(aliases && aliases.length > 0 ? { aliases } : {}),
+    });
+    ctx.applied.push(ctx.kind);
+};
+export const op_location_add = (ctx) => {
+    const name = strOf(ctx.op.name ?? ctx.op.location_name).trim();
+    if (!name) {
+        return opUsage("ASSET BLOCKED: location name empty", "Location name is required.", {
+            code: "ASSET_NAME_EMPTY",
+        });
+    }
+    const existing = new Set(ctx.script.locations.map((asset) => asset.location_id));
+    ctx.script.locations.push({
+        location_id: requestedId(ctx, "location", "location_id", existing),
+        location_name: name,
+        importance: importanceFrom(ctx.op.importance),
+        description: strOf(ctx.op.description).trim(),
+        states: [defaultState()],
+    });
+    ctx.applied.push(ctx.kind);
+};
+export const op_prop_add = (ctx) => {
+    const name = strOf(ctx.op.name ?? ctx.op.prop_name).trim();
+    if (!name) {
+        return opUsage("ASSET BLOCKED: prop name empty", "Prop name is required.", {
+            code: "ASSET_NAME_EMPTY",
+        });
+    }
+    const existing = new Set(ctx.script.props.map((asset) => asset.prop_id));
+    ctx.script.props.push({
+        prop_id: requestedId(ctx, "prop", "prop_id", existing),
+        prop_name: name,
+        importance: importanceFrom(ctx.op.importance),
+        description: strOf(ctx.op.description).trim(),
+        states: [defaultState()],
+    });
+    ctx.applied.push(ctx.kind);
+};
+export const op_state_add = (ctx) => {
+    const target = requireAsset(ctx.script, ctx.op.target);
+    const name = strOf(ctx.op.name ?? ctx.op.state_name).trim();
+    if (!name) {
+        return opUsage("STATE BLOCKED: name empty", "State name is required.", {
+            code: "STATE_NAME_EMPTY",
+        });
+    }
+    if (target.asset.states.some((state) => state.state_name === name)) {
+        return opUsage("STATE BLOCKED: name exists", "State name already exists on this asset.", {
+            code: "STATE_NAME_EXISTS",
+            received: [name],
+        });
+    }
+    const existing = new Set(target.asset.states.map((state) => state.state_id));
+    const raw = strOf(ctx.op.state_id ?? ctx.op.id).trim();
+    const stateId = raw || generateV4Id("state", existing);
+    if (stateId === "default" || !isV4Id("state", stateId)) {
+        return opUsage("STATE BLOCKED: ID invalid", "New state ID must use the v4 random state format.", {
+            code: "STATE_ID_INVALID",
+            received: [stateId],
+        });
+    }
+    if (existing.has(stateId)) {
+        return opUsage("STATE BLOCKED: ID exists", "State ID already exists on this asset.", {
+            code: "STATE_ID_EXISTS",
+            received: [stateId],
+        });
+    }
+    target.asset.states.push({
+        state_id: stateId,
+        state_name: name,
+        description: strOf(ctx.op.description).trim(),
+    });
+    ctx.applied.push(ctx.kind);
+};
+export const op_asset_rename = (ctx) => {
+    const target = requireAsset(ctx.script, ctx.op.target);
+    const name = stringField(ctx.op, "name").trim();
+    if (!name) {
+        return opUsage("ASSET BLOCKED: name empty", "Name must not be empty.", {
+            code: "ASSET_NAME_EMPTY",
+        });
+    }
+    if (target.asset.aliases?.includes(name)) {
+        return opUsage("ASSET BLOCKED: name equals alias", "The new name must differ from every alias.", {
+            code: "ASSET_NAME_EQUALS_ALIAS",
+            received: [name],
+        });
+    }
+    if (target.kind === "actor"
+        && ctx.script.actors.some((actor) => actor.actor_id !== target.id
+            && actor.actor_name.trim().toLocaleLowerCase() === name.toLocaleLowerCase())) {
+        return opUsage("ASSET BLOCKED: actor name exists", "Actor names must be unique.", {
+            code: "ACTOR_NAME_EXISTS",
+            received: [name],
+        });
+    }
+    if (target.kind === "actor")
+        target.asset.actor_name = name;
+    else if (target.kind === "location")
+        target.asset.location_name = name;
+    else
+        target.asset.prop_name = name;
+    ctx.applied.push(ctx.kind);
+};
+export const op_asset_describe = (ctx) => {
+    requireAsset(ctx.script, ctx.op.target).asset.description = stringField(ctx.op, "description");
+    ctx.applied.push(ctx.kind);
+};
+export const op_importance_set = (ctx) => {
+    requireAsset(ctx.script, ctx.op.target).asset.importance = importanceFrom(ctx.op.importance);
+    ctx.applied.push(ctx.kind);
+};
+export const op_asset_role_set = (ctx) => {
+    const target = requireAsset(ctx.script, ctx.op.target);
+    if (target.kind !== "actor") {
+        return opUsage("ROLE BLOCKED: target is not an actor", "Role only belongs to actor assets.", {
+            code: "ROLE_TARGET_INVALID",
+            received: [target.id],
+        });
+    }
+    const role = strOf(ctx.op.role_type ?? ctx.op.role).trim();
+    if (!ROLE_TYPE_SET.has(role)) {
+        return opUsage("ROLE BLOCKED: role invalid", "role_type must be 主角 or 配角.", {
+            code: "ROLE_TYPE_INVALID",
+            received: [role || "<empty>"],
+        });
+    }
+    target.asset.role_type = role;
+    ctx.applied.push(ctx.kind);
+};
+function aliasesFromOp(ctx) {
+    const raw = ctx.op.alias ?? ctx.op.aliases;
+    const values = Array.isArray(raw) ? raw : [raw];
+    if (!values.every((value) => typeof value === "string" && value.trim() !== "")) {
+        return opUsage("ALIAS BLOCKED: alias invalid", "Aliases must be non-empty strings.", {
+            code: "ALIAS_INVALID",
+            received: [JSON.stringify(raw)],
+        });
+    }
+    const aliases = values.map((value) => value.trim());
+    if (new Set(aliases).size !== aliases.length) {
+        return opUsage("ALIAS BLOCKED: alias duplicated", "Aliases in one operation must be unique.", {
+            code: "ALIAS_DUPLICATE",
+            received: aliases,
+        });
+    }
+    return aliases;
+}
+function assetName(asset) {
+    if ("actor_name" in asset)
+        return asset.actor_name;
+    if ("location_name" in asset)
+        return asset.location_name;
+    return asset.prop_name;
+}
+function assertAliasesDifferFromName(target, aliases) {
+    const name = assetName(target);
+    if (aliases.includes(name)) {
+        opUsage("ALIAS BLOCKED: alias equals name", "An alias must differ from the asset name.", {
+            code: "ALIAS_EQUALS_NAME",
+            received: [name],
+        });
+    }
+}
+export const op_asset_alias_set = (ctx) => {
+    const target = requireAsset(ctx.script, ctx.op.target).asset;
+    const aliases = aliasesFromOp(ctx);
+    assertAliasesDifferFromName(target, aliases);
+    target.aliases = aliases;
+    if (target.aliases.length === 0)
+        delete target.aliases;
+    ctx.applied.push(ctx.kind);
+};
+export const op_asset_alias_add = (ctx) => {
+    const target = requireAsset(ctx.script, ctx.op.target).asset;
+    const added = aliasesFromOp(ctx);
+    assertAliasesDifferFromName(target, added);
+    const duplicates = added.filter((alias) => target.aliases?.includes(alias));
+    if (duplicates.length > 0) {
+        return opUsage("ALIAS BLOCKED: alias exists", "The asset already has this alias.", {
+            code: "ALIAS_EXISTS",
+            received: duplicates,
+        });
+    }
+    const aliases = [...(target.aliases ?? []), ...added];
+    target.aliases = aliases;
+    ctx.applied.push(ctx.kind);
+};
+export const op_asset_alias_remove = (ctx) => {
+    const target = requireAsset(ctx.script, ctx.op.target).asset;
+    const removing = new Set(aliasesFromOp(ctx));
+    const aliases = (target.aliases ?? []).filter((alias) => !removing.has(alias));
+    if (aliases.length > 0)
+        target.aliases = aliases;
+    else
+        delete target.aliases;
+    ctx.applied.push(ctx.kind);
+};
+export const op_state_rename = (ctx) => {
+    const target = requireState(ctx.script, ctx.op.target);
+    const name = stringField(ctx.op, "name").trim();
+    if (!name) {
+        return opUsage("STATE BLOCKED: name empty", "State name must not be empty.", {
+            code: "STATE_NAME_EMPTY",
+        });
+    }
+    if (target.owner.asset.states.some((state) => state !== target.state && state.state_name === name)) {
+        return opUsage("STATE BLOCKED: name exists", "State name already exists on this asset.", {
+            code: "STATE_NAME_EXISTS",
+            received: [name],
+        });
+    }
+    target.state.state_name = name;
+    ctx.applied.push(ctx.kind);
+};
+export const op_state_describe = (ctx) => {
+    requireState(ctx.script, ctx.op.target).state.description = stringField(ctx.op, "description");
+    ctx.applied.push(ctx.kind);
+};
+function replaceStateId(ids, from, replacement) {
+    const next = ids.flatMap((id) => id === from ? (replacement ? [replacement] : []) : [id]);
+    return [...new Set(next)].sort();
+}
+export const op_state_delete = (ctx) => {
+    const target = requireState(ctx.script, ctx.op.target);
+    if (target.state.state_id === "default") {
+        return opUsage("STATE DELETE BLOCKED: default is protected", "Every asset must retain its default state.", {
+            code: "STATE_DEFAULT_PROTECTED",
+        });
+    }
+    const strategy = strOf(ctx.op.strategy).trim();
+    if (strategy !== "replace" && strategy !== "remove") {
+        return opUsage("STATE DELETE BLOCKED: strategy invalid", "Choose replace or remove.", {
+            code: "DELETE_STRATEGY_INVALID",
+            received: [strategy || "<empty>"],
+        });
+    }
+    if (strategy === "remove" && ctx.op.replacement !== undefined) {
+        return opUsage("STATE DELETE BLOCKED: replacement conflicts with remove", "replacement only belongs to the replace strategy.", {
+            code: "DELETE_REPLACEMENT_UNEXPECTED",
+            received: [strOf(ctx.op.replacement)],
+        });
+    }
+    const replacementRaw = strOf(ctx.op.replacement).trim();
+    const replacement = strategy === "replace"
+        ? target.owner.asset.states.find((state) => state.state_id === replacementRaw && state.state_id !== target.state.state_id)
+        : undefined;
+    if (strategy === "replace" && !replacement) {
+        return opUsage("STATE DELETE BLOCKED: replacement invalid", "Replacement must be another state on the same asset.", {
+            code: "REPLACEMENT_INVALID",
+            received: [replacementRaw || "<empty>"],
+        });
+    }
+    const fromId = target.state.state_id;
+    const replacementId = replacement?.state_id ?? null;
+    const stateRefUpdates = [];
+    const queueStateRefUpdate = (sceneId, stateIds, write) => {
+        const next = replaceStateId(stateIds, fromId, replacementId);
+        if (next.length === 0) {
+            return opUsage("STATE DELETE BLOCKED: scene state set would be empty", "Replace the state or add another state to the scene first.", {
+                code: "SCENE_REF_STATES_EMPTY",
+                received: [sceneId, fromId],
+            });
+        }
+        stateRefUpdates.push(() => write(next));
+    };
+    for (const episode of ctx.script.episodes) {
+        for (const scene of episode.scenes) {
+            if (target.owner.kind === "location" && scene.location?.location_id === target.owner.id) {
+                const ref = scene.location;
+                queueStateRefUpdate(scene.scene_id, ref.state_ids, (next) => {
+                    ref.state_ids = next;
+                });
+            }
+            else if (target.owner.kind === "actor") {
+                const ref = scene.actors.find((candidate) => candidate.actor_id === target.owner.id);
+                if (ref) {
+                    queueStateRefUpdate(scene.scene_id, ref.state_ids, (next) => {
+                        ref.state_ids = next;
+                    });
+                }
+            }
+            else if (target.owner.kind === "prop") {
+                const ref = scene.props.find((candidate) => candidate.prop_id === target.owner.id);
+                if (ref) {
+                    queueStateRefUpdate(scene.scene_id, ref.state_ids, (next) => {
+                        ref.state_ids = next;
+                    });
+                }
+            }
+        }
+    }
+    for (const update of stateRefUpdates)
+        update();
+    if (target.owner.kind === "actor") {
+        for (const episode of ctx.script.episodes) {
+            for (const scene of episode.scenes) {
+                for (const action of scene.actions) {
+                    if ((action.type === "dialogue" || action.type === "inner_thought")
+                        && "actor_id" in action.speaker
+                        && action.speaker.actor_id === target.owner.id
+                        && action.speaker.state_id === fromId) {
+                        if (replacementId)
+                            action.speaker.state_id = replacementId;
+                        else
+                            delete action.speaker.state_id;
+                    }
+                }
+            }
+        }
+    }
+    target.owner.asset.states.splice(target.stateIndex, 1);
+    ctx.applied.push(ctx.kind);
+};
+function assetRefCount(ctx, kind, id) {
+    let count = 0;
+    for (const episode of ctx.script.episodes) {
+        for (const scene of episode.scenes) {
+            if (kind === "actor") {
+                if (scene.actors.some((ref) => ref.actor_id === id))
+                    count++;
+                count += scene.actions.filter((action) => (action.type === "dialogue" || action.type === "inner_thought")
+                    && "actor_id" in action.speaker
+                    && action.speaker.actor_id === id).length;
+            }
+            else if (kind === "location" && scene.location?.location_id === id) {
+                count++;
+            }
+            else if (kind === "prop" && scene.props.some((ref) => ref.prop_id === id)) {
+                count++;
+            }
+            count += scene.actions.filter((action) => action.transition_prompt?.target === id).length;
+        }
+    }
+    return count;
+}
+export const op_asset_merge = (ctx) => {
+    const from = requireAsset(ctx.script, ctx.op.from ?? ctx.op.source);
+    const into = requireAsset(ctx.script, ctx.op.into ?? ctx.op.target);
+    if (from.kind !== into.kind) {
+        return opUsage("ASSET MERGE BLOCKED: kind mismatch", "Both assets must have the same kind.", {
+            code: "MERGE_KIND_MISMATCH",
+            received: [from.kind, into.kind],
+        });
+    }
+    if (from.id === into.id) {
+        return opUsage("ASSET MERGE BLOCKED: same asset", "An asset cannot be merged into itself.", {
+            code: "MERGE_SELF",
+            received: [from.id],
+        });
+    }
+    const fromStates = new Map(from.asset.states.map((state) => [state.state_id, state]));
+    const intoStates = new Map(into.asset.states.map((state) => [state.state_id, state]));
+    const referencedStates = new Set();
+    for (const episode of ctx.script.episodes) {
+        for (const scene of episode.scenes) {
+            if (from.kind === "location" && scene.location?.location_id === from.id) {
+                scene.location.state_ids.forEach((id) => referencedStates.add(id));
+            }
+            else if (from.kind === "actor") {
+                scene.actors.find((ref) => ref.actor_id === from.id)?.state_ids.forEach((id) => referencedStates.add(id));
+            }
+            else if (from.kind === "prop") {
+                scene.props.find((ref) => ref.prop_id === from.id)?.state_ids.forEach((id) => referencedStates.add(id));
+            }
+            if (from.kind === "actor") {
+                for (const action of scene.actions) {
+                    if ((action.type === "dialogue" || action.type === "inner_thought")
+                        && "actor_id" in action.speaker
+                        && action.speaker.actor_id === from.id
+                        && action.speaker.state_id)
+                        referencedStates.add(action.speaker.state_id);
+                }
+            }
+        }
+    }
+    const missing = [...referencedStates].filter((id) => !intoStates.has(id));
+    const conflicting = [...referencedStates].filter((id) => {
+        if (id === "default")
+            return false;
+        const sourceState = fromStates.get(id);
+        const survivorState = intoStates.get(id);
+        return sourceState !== undefined
+            && survivorState !== undefined
+            && JSON.stringify(sortDeep(sourceState)) !== JSON.stringify(sortDeep(survivorState));
+    });
+    if (missing.length > 0 || conflicting.length > 0) {
+        return opUsage("ASSET MERGE BLOCKED: state mismatch", "The survivor lacks a referenced source state or uses the same owner-local ID for a different state.", {
+            code: "MERGE_STATE_CONFLICT",
+            received: [
+                ...missing.map((id) => `missing:${id}`),
+                ...conflicting.map((id) => `different:${id}`),
+            ],
+        });
+    }
+    for (const episode of ctx.script.episodes) {
+        for (const scene of episode.scenes) {
+            if (from.kind === "location" && into.kind === "location" && scene.location?.location_id === from.id) {
+                scene.location.location_id = into.id;
+            }
+            else if (from.kind === "actor" && into.kind === "actor") {
+                const sourceIndex = scene.actors.findIndex((ref) => ref.actor_id === from.id);
+                if (sourceIndex >= 0) {
+                    const sourceRef = scene.actors[sourceIndex];
+                    const targetRef = scene.actors.find((ref) => ref.actor_id === into.id);
+                    if (targetRef) {
+                        targetRef.state_ids = [...new Set([...targetRef.state_ids, ...sourceRef.state_ids])].sort();
+                        scene.actors.splice(sourceIndex, 1);
+                    }
+                    else {
+                        sourceRef.actor_id = into.id;
+                    }
+                }
+            }
+            else if (from.kind === "prop" && into.kind === "prop") {
+                const sourceIndex = scene.props.findIndex((ref) => ref.prop_id === from.id);
+                if (sourceIndex >= 0) {
+                    const sourceRef = scene.props[sourceIndex];
+                    const targetRef = scene.props.find((ref) => ref.prop_id === into.id);
+                    if (targetRef) {
+                        targetRef.state_ids = [...new Set([...targetRef.state_ids, ...sourceRef.state_ids])].sort();
+                        scene.props.splice(sourceIndex, 1);
+                    }
+                    else {
+                        sourceRef.prop_id = into.id;
+                    }
+                }
+            }
+            for (const action of scene.actions) {
+                if (from.kind === "actor"
+                    && into.kind === "actor"
+                    && (action.type === "dialogue" || action.type === "inner_thought")
+                    && "actor_id" in action.speaker
+                    && action.speaker.actor_id === from.id)
+                    action.speaker.actor_id = into.id;
+                if (action.transition_prompt?.target === from.id)
+                    action.transition_prompt.target = into.id;
+            }
+        }
+    }
+    const survivorName = assetName(into.asset);
+    const mergedAliases = [...new Set([
+            ...(into.asset.aliases ?? []),
+            assetName(from.asset),
+            ...(from.asset.aliases ?? []),
+        ])].filter((alias) => alias !== survivorName);
+    assertAliasesDifferFromName(into.asset, mergedAliases);
+    into.asset.aliases = mergedAliases;
+    if (into.asset.aliases.length === 0)
+        delete into.asset.aliases;
+    if (from.asset.extend)
+        into.asset.extend = { ...from.asset.extend, ...(into.asset.extend ?? {}) };
+    if (from.kind === "actor")
+        ctx.script.actors = ctx.script.actors.filter((asset) => asset.actor_id !== from.id);
+    else if (from.kind === "location")
+        ctx.script.locations = ctx.script.locations.filter((asset) => asset.location_id !== from.id);
+    else
+        ctx.script.props = ctx.script.props.filter((asset) => asset.prop_id !== from.id);
+    ctx.applied.push(ctx.kind);
+};
+export const op_asset_delete = (ctx) => {
+    const target = requireAsset(ctx.script, ctx.op.target);
+    const count = assetRefCount(ctx, target.kind, target.id);
+    const strategy = strOf(ctx.op.strategy).trim();
+    if (strategy !== "" && strategy !== "replace" && strategy !== "remove") {
+        return opUsage("ASSET DELETE BLOCKED: strategy invalid", "Choose replace or remove.", {
+            code: "DELETE_STRATEGY_INVALID",
+            received: [strategy],
+        });
+    }
+    if (strategy === "replace") {
+        const replacement = strOf(ctx.op.replacement).trim();
+        if (!replacement) {
+            return opUsage("ASSET DELETE BLOCKED: replacement missing", "The replace strategy requires a replacement asset.", {
+                code: "REPLACEMENT_INVALID",
+                received: ["<empty>"],
+            });
+        }
+        ctx.runOps([{ op: "asset.merge", from: target.id, into: replacement }]);
+        ctx.applied.push(ctx.kind);
+        return;
+    }
+    if (ctx.op.replacement !== undefined) {
+        return opUsage("ASSET DELETE BLOCKED: replacement conflicts with remove", "replacement only belongs to the replace strategy.", {
+            code: "DELETE_REPLACEMENT_UNEXPECTED",
+            received: [strOf(ctx.op.replacement)],
+        });
+    }
+    if (count > 0 && !strategy) {
+        return opUsage("ASSET DELETE BLOCKED: asset is referenced", "Choose replace or remove.", {
+            code: "ASSET_HAS_REFS",
+            received: [`refs=${count}`],
+        });
+    }
+    if (target.kind === "actor") {
+        const speaking = ctx.script.episodes.flatMap((episode) => episode.scenes).some((scene) => scene.actions.some((action) => (action.type === "dialogue" || action.type === "inner_thought")
+            && "actor_id" in action.speaker
+            && action.speaker.actor_id === target.id));
+        if (speaking) {
+            return opUsage("ASSET DELETE BLOCKED: actor still speaks", "Reassign or delete the actor's speaking actions first.", {
+                code: "ACTOR_SPEAKER_IN_USE",
+                received: [target.id],
+            });
+        }
+    }
+    for (const episode of ctx.script.episodes) {
+        for (const scene of episode.scenes) {
+            if (target.kind === "actor")
+                scene.actors = scene.actors.filter((ref) => ref.actor_id !== target.id);
+            else if (target.kind === "location" && scene.location?.location_id === target.id)
+                scene.location = null;
+            else if (target.kind === "prop")
+                scene.props = scene.props.filter((ref) => ref.prop_id !== target.id);
+            for (const action of scene.actions) {
+                if (action.transition_prompt?.target === target.id)
+                    delete action.transition_prompt;
+            }
+        }
+    }
+    if (target.kind === "actor")
+        ctx.script.actors = ctx.script.actors.filter((asset) => asset.actor_id !== target.id);
+    else if (target.kind === "location")
+        ctx.script.locations = ctx.script.locations.filter((asset) => asset.location_id !== target.id);
+    else
+        ctx.script.props = ctx.script.props.filter((asset) => asset.prop_id !== target.id);
+    ctx.applied.push(ctx.kind);
+};
+//# sourceMappingURL=ops-asset.js.map