@lingjingai/scriptctl 0.49.11 → 0.49.13

package/dist/domain/authoring/apply.js

@@ -0,0 +1,717 @@
+import { CliError, EXIT_INPUT, EXIT_USAGE } from "../../common.js";
+import { validateScriptV3 } from "../ingest/validation.js";
+function fail(code, message, received, nextSteps, exitCode = EXIT_INPUT) {
+    throw new CliError("AUTHORING BLOCKED", message, {
+        exitCode,
+        errorCode: code,
+        received,
+        nextSteps,
+    });
+}
+function sourceLabel(source) {
+    return `line ${source.line}, column ${source.column}`;
+}
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value !== null && typeof value === "object") {
+        const result = {};
+        for (const [key, item] of Object.entries(value).sort(([left], [right]) => left.localeCompare(right))) {
+            result[key] = canonicalize(item);
+        }
+        return result;
+    }
+    return value;
+}
+function semanticEqual(left, right) {
+    return JSON.stringify(canonicalize(left)) === JSON.stringify(canonicalize(right));
+}
+function assetId(_kind, value) {
+    if ("actor_id" in value)
+        return value.actor_id;
+    if ("location_id" in value)
+        return value.location_id;
+    return value.prop_id;
+}
+function assetName(_kind, value) {
+    if ("actor_name" in value)
+        return value.actor_name;
+    if ("location_name" in value)
+        return value.location_name;
+    return value.prop_name;
+}
+function assetsFor(script, kind) {
+    if (kind === "actor")
+        return script.actors;
+    if (kind === "location")
+        return script.locations;
+    return script.props;
+}
+function pushAsset(script, asset) {
+    if ("actor_id" in asset.value)
+        script.actors.push(asset.value);
+    else if ("location_id" in asset.value)
+        script.locations.push(asset.value);
+    else
+        script.props.push(asset.value);
+}
+function findAsset(script, kind, id) {
+    return assetsFor(script, kind).find((asset) => assetId(kind, asset) === id);
+}
+function findAssetByAnyId(script, id) {
+    for (const kind of ["actor", "location", "prop"]) {
+        const value = findAsset(script, kind, id);
+        if (value !== undefined)
+            return { kind, value };
+    }
+    return undefined;
+}
+function prepareDeclarations(declarations) {
+    const assets = [];
+    const states = [];
+    const groupOrder = { actor: 0, location: 1, prop: 2 };
+    let lastGroup = -1;
+    let currentAsset;
+    let standaloneStarted = false;
+    const seenOwners = new Set();
+    for (const declaration of declarations) {
+        if (declaration.declarationKind !== "state") {
+            if (standaloneStarted) {
+                fail("AUTHORING_DECLARATION_ORDER", "Asset declarations must precede standalone state declarations.", [sourceLabel(declaration.source)], ["Move standalone states to the end of <create>."]);
+            }
+            const kind = declaration.declarationKind;
+            if (groupOrder[kind] < lastGroup) {
+                fail("AUTHORING_DECLARATION_ORDER", "Asset declaration groups are out of canonical order.", [sourceLabel(declaration.source), kind], ["Order asset declarations as actor, location, then prop."]);
+            }
+            lastGroup = groupOrder[kind];
+            const value = structuredClone(declaration.value);
+            value.states = [];
+            const prepared = { kind, value, source: declaration.source };
+            const ownerKey = `${kind}:${assetId(kind, value)}`;
+            if (seenOwners.has(ownerKey)) {
+                fail("AUTHORING_DECLARATION_DUPLICATE", "Asset declaration is duplicated.", [sourceLabel(declaration.source), ownerKey], ["Keep one declaration per asset."]);
+            }
+            seenOwners.add(ownerKey);
+            assets.push(prepared);
+            currentAsset = prepared;
+            continue;
+        }
+        const ownerKey = `${declaration.ownerKind}:${declaration.ownerId}`;
+        if (currentAsset !== undefined
+            && currentAsset.kind === declaration.ownerKind
+            && assetId(currentAsset.kind, currentAsset.value) === declaration.ownerId) {
+            currentAsset.value.states.push(structuredClone(declaration.value));
+            continue;
+        }
+        standaloneStarted = true;
+        currentAsset = undefined;
+        states.push({
+            kind: declaration.ownerKind,
+            ownerId: declaration.ownerId,
+            value: structuredClone(declaration.value),
+            source: declaration.source,
+        });
+    }
+    for (const asset of assets) {
+        const id = assetId(asset.kind, asset.value);
+        if (asset.value.states.length === 0 || asset.value.states[0].state_id !== "default") {
+            fail("AUTHORING_DEFAULT_STATE_REQUIRED", "Every declared asset must be immediately followed by its states, beginning with default.", [sourceLabel(asset.source), `${asset.kind}:${id}`], [`Add [state|${asset.kind}:${id}|default|...] directly after the asset declaration.`]);
+        }
+        if (asset.value.states.filter((state) => state.state_id === "default").length !== 1) {
+            fail("AUTHORING_DEFAULT_STATE_DUPLICATE", "Every declared asset must contain exactly one default state.", [sourceLabel(asset.source), `${asset.kind}:${id}`], ["Keep exactly one default state."]);
+        }
+        const aliases = asset.value.aliases ?? [];
+        if (new Set(aliases).size !== aliases.length || aliases.includes(assetName(asset.kind, asset.value))) {
+            fail("AUTHORING_ALIAS_INVALID", "Asset aliases must be unique and must differ from the canonical name.", [sourceLabel(asset.source), `${asset.kind}:${id}`], ["Remove duplicate aliases and the canonical name from aliases."]);
+        }
+    }
+    return { assets, states };
+}
+function emptyDeclarationPlan() {
+    return {
+        createdAssets: [],
+        existingAssets: [],
+        createdStates: [],
+        existingStates: [],
+    };
+}
+function applyDeclarations(script, declarations) {
+    const prepared = prepareDeclarations(declarations);
+    const plan = emptyDeclarationPlan();
+    for (const asset of prepared.assets) {
+        const id = assetId(asset.kind, asset.value);
+        const address = `${asset.kind}:${id}`;
+        const anyExisting = findAssetByAnyId(script, id);
+        if (anyExisting !== undefined) {
+            if (anyExisting.kind === asset.kind && semanticEqual(anyExisting.value, asset.value)) {
+                plan.existingAssets.push(address);
+                plan.existingStates.push(...asset.value.states.map((state) => `${address}/${state.state_id}`));
+                continue;
+            }
+            fail("AUTHORING_ASSET_CONFLICT", "Create-only asset declaration conflicts with an existing asset.", [sourceLabel(asset.source), `${asset.kind}:${id}`], ["Use the existing identical definition or change it with an explicit mutation verb."]);
+        }
+        pushAsset(script, asset);
+        plan.createdAssets.push(address);
+        plan.createdStates.push(...asset.value.states.map((state) => `${address}/${state.state_id}`));
+    }
+    for (const state of prepared.states) {
+        const owner = findAsset(script, state.kind, state.ownerId);
+        if (owner === undefined) {
+            fail("AUTHORING_STATE_OWNER_NOT_FOUND", "Standalone state owner does not exist.", [sourceLabel(state.source), `${state.kind}:${state.ownerId}`], ["Declare the asset before its states or use an existing asset ID."]);
+        }
+        for (const kind of ["actor", "location", "prop"]) {
+            for (const asset of assetsFor(script, kind)) {
+                const existing = asset.states.find((candidate) => candidate.state_id === state.value.state_id);
+                if (existing === undefined)
+                    continue;
+                const sameOwner = kind === state.kind && assetId(kind, asset) === state.ownerId;
+                if (sameOwner && semanticEqual(existing, state.value))
+                    continue;
+                if (state.value.state_id === "default" && !sameOwner)
+                    continue;
+                fail("AUTHORING_STATE_CONFLICT", "Create-only state declaration conflicts with an existing state ID.", [sourceLabel(state.source), `${state.kind}:${state.ownerId}/${state.value.state_id}`], ["Use an unused globally unique state ID, or reuse the identical existing state."]);
+            }
+        }
+        const stateAddress = `${state.kind}:${state.ownerId}/${state.value.state_id}`;
+        if (!owner.states.some((candidate) => candidate.state_id === state.value.state_id)) {
+            owner.states.push(state.value);
+            plan.createdStates.push(stateAddress);
+        }
+        else
+            plan.existingStates.push(stateAddress);
+    }
+    return plan;
+}
+function sceneCounts(scene) {
+    return { episodes: 0, scenes: scene === undefined ? 0 : 1, actions: scene?.actions.length ?? 0 };
+}
+function episodeCounts(episode) {
+    return {
+        episodes: episode === undefined ? 0 : 1,
+        scenes: episode?.scenes.length ?? 0,
+        actions: episode?.scenes.reduce((total, scene) => total + scene.actions.length, 0) ?? 0,
+    };
+}
+function episodesCounts(episodes) {
+    return episodes.reduce((counts, episode) => ({
+        episodes: counts.episodes + 1,
+        scenes: counts.scenes + episode.scenes.length,
+        actions: counts.actions + episode.scenes.reduce((total, scene) => total + scene.actions.length, 0),
+    }), { episodes: 0, scenes: 0, actions: 0 });
+}
+function scenesCounts(scenes) {
+    return {
+        episodes: 0,
+        scenes: scenes.length,
+        actions: scenes.reduce((total, scene) => total + scene.actions.length, 0),
+    };
+}
+function idDiff(before, after) {
+    const beforeSet = new Set(before);
+    const afterSet = new Set(after);
+    return {
+        retainedIds: after.filter((id) => beforeSet.has(id)),
+        createdIds: after.filter((id) => !beforeSet.has(id)),
+        removedIds: before.filter((id) => !afterSet.has(id)),
+    };
+}
+function assertSceneComplete(scene, source) {
+    if (scene.actions.length === 0) {
+        fail("AUTHORING_EMPTY_SCENE", "A production scene must contain at least one action.", [sourceLabel(source), scene.scene_id], ["Add at least one body record."]);
+    }
+    const unmaterialized = [];
+    if (scene.location !== null && !scene.location.state_id)
+        unmaterialized.push(`location:${scene.location.location_id}`);
+    for (const actor of scene.actors)
+        if (!actor.state_id)
+            unmaterialized.push(`actor:${actor.actor_id}`);
+    for (const prop of scene.props)
+        if (!prop.state_id)
+            unmaterialized.push(`prop:${prop.prop_id}`);
+    if (unmaterialized.length > 0) {
+        fail("AUTHORING_SCENE_REF_UNMATERIALIZED", "Every scene asset reference in an authored production block must bind a state.", [sourceLabel(source), ...unmaterialized], ["Add the concrete state ID to every location, cast, and prop record."]);
+    }
+}
+function assertEpisodeComplete(episode, source) {
+    if (episode.scenes.length === 0) {
+        fail("AUTHORING_EMPTY_EPISODE", "A production episode must contain at least one scene.", [sourceLabel(source), episode.episode_id], ["Add at least one complete scene."]);
+    }
+    for (const scene of episode.scenes)
+        assertSceneComplete(scene, source);
+}
+function episodeIndex(script, episodeId) {
+    return script.episodes.findIndex((episode) => episode.episode_id === episodeId);
+}
+function sceneIndex(episode, sceneId) {
+    return episode.scenes.findIndex((scene) => scene.scene_id === sceneId);
+}
+function sceneCoordinate(script, parent, sceneId) {
+    const epIndex = episodeIndex(script, parent);
+    if (epIndex < 0)
+        fail("AUTHORING_EPISODE_NOT_FOUND", "Episode target does not exist.", [parent], ["Inspect episodes and use an existing parent."]);
+    const index = sceneIndex(script.episodes[epIndex], sceneId);
+    if (index < 0)
+        fail("AUTHORING_SCENE_NOT_FOUND", "Scene target does not exist.", [`${parent}/${sceneId}`], ["Inspect scenes and use an existing target."]);
+    return [epIndex, index];
+}
+function compareCoordinate(left, right) {
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const diff = (left[index] ?? 0) - (right[index] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+function assertStrictOrder(coords, message) {
+    for (let index = 1; index < coords.length; index += 1) {
+        if (compareCoordinate(coords[index - 1].coord, coords[index].coord) >= 0) {
+            fail("AUTHORING_TARGET_ORDER", message, [sourceLabel(coords[index].source)], ["List replace targets in current document order without duplicates."], EXIT_USAGE);
+        }
+    }
+}
+function applyEpisodeTargets(baseline, script, targets, mode) {
+    const plans = [];
+    if (mode === "replace") {
+        const coords = targets.map((target) => {
+            const index = episodeIndex(baseline, target.value.episode_id);
+            if (index < 0)
+                fail("AUTHORING_EPISODE_NOT_FOUND", "Episode replace target does not exist.", [sourceLabel(target.source), target.value.episode_id], ["Use --create for a new episode or choose an existing ID."]);
+            return { coord: [index], source: target.source };
+        });
+        assertStrictOrder(coords, "Episode replace targets are not in document order.");
+    }
+    for (const target of targets) {
+        assertEpisodeComplete(target.value, target.source);
+        const existingIndex = episodeIndex(baseline, target.value.episode_id);
+        const existing = existingIndex < 0 ? undefined : baseline.episodes[existingIndex];
+        if (mode === "create") {
+            if (existing !== undefined) {
+                if (!semanticEqual(existing, target.value)) {
+                    fail("AUTHORING_CREATE_CONFLICT", "Episode create target already exists with different content.", [sourceLabel(target.source), target.value.episode_id], ["Use --replace to replace it, or make the create block identical for a no-op retry."]);
+                }
+            }
+            else {
+                script.episodes.push(structuredClone(target.value));
+            }
+        }
+        else {
+            script.episodes[existingIndex] = structuredClone(target.value);
+        }
+        plans.push({
+            kind: "episode",
+            address: target.value.episode_id,
+            before: episodeCounts(existing),
+            after: episodeCounts(target.value),
+            ...idDiff(existing?.scenes.map((scene) => scene.scene_id) ?? [], target.value.scenes.map((scene) => scene.scene_id)),
+            untouchedSiblings: Math.max(0, baseline.episodes.length - (existing === undefined ? 0 : 1)),
+        });
+    }
+    return plans;
+}
+function applySceneTargets(baseline, script, targets, mode) {
+    const plans = [];
+    if (mode === "replace") {
+        const coords = targets.map((target) => ({ coord: sceneCoordinate(baseline, target.parent, target.value.scene_id), source: target.source }));
+        assertStrictOrder(coords, "Scene replace targets are not in document order.");
+    }
+    for (const target of targets) {
+        assertSceneComplete(target.value, target.source);
+        const epIndex = episodeIndex(baseline, target.parent);
+        if (epIndex < 0)
+            fail("AUTHORING_EPISODE_NOT_FOUND", "Scene parent episode does not exist.", [sourceLabel(target.source), target.parent], ["Use an existing episode parent."]);
+        const baseEpisode = baseline.episodes[epIndex];
+        const outputEpisode = script.episodes[epIndex];
+        const existingIndex = sceneIndex(baseEpisode, target.value.scene_id);
+        const existing = existingIndex < 0 ? undefined : baseEpisode.scenes[existingIndex];
+        if (mode === "create") {
+            if (existing !== undefined) {
+                if (!semanticEqual(existing, target.value)) {
+                    fail("AUTHORING_CREATE_CONFLICT", "Scene create target already exists with different content.", [sourceLabel(target.source), `${target.parent}/${target.value.scene_id}`], ["Use --replace or make the create block identical for a no-op retry."]);
+                }
+            }
+            else {
+                outputEpisode.scenes.push(structuredClone(target.value));
+            }
+        }
+        else {
+            if (existingIndex < 0)
+                fail("AUTHORING_SCENE_NOT_FOUND", "Scene replace target does not exist.", [sourceLabel(target.source), `${target.parent}/${target.value.scene_id}`], ["Use --create for a new scene or choose an existing scene."]);
+            outputEpisode.scenes[existingIndex] = structuredClone(target.value);
+        }
+        plans.push({
+            kind: "scene",
+            address: `${target.parent}/${target.value.scene_id}`,
+            before: sceneCounts(existing),
+            after: sceneCounts(target.value),
+            ...idDiff(existing === undefined ? [] : [existing.scene_id], [target.value.scene_id]),
+            untouchedSiblings: Math.max(0, baseEpisode.scenes.length - (existing === undefined ? 0 : 1)),
+        });
+    }
+    return plans;
+}
+function applyEpisodeSpans(baseline, script, targets) {
+    const resolved = targets.map((target) => {
+        const from = episodeIndex(baseline, target.from);
+        const through = episodeIndex(baseline, target.through);
+        if (from < 0 || through < 0)
+            fail("AUTHORING_SPAN_ENDPOINT_NOT_FOUND", "Episode-span endpoint does not exist.", [sourceLabel(target.source), `${target.from}..${target.through}`], ["Use existing episode IDs as span endpoints."]);
+        if (from > through)
+            fail("AUTHORING_SPAN_REVERSED", "Episode-span endpoints are reversed in current document order.", [sourceLabel(target.source), `${target.from}..${target.through}`], ["Swap from and through."]);
+        if (target.episodes.length === 0)
+            fail("AUTHORING_EMPTY_SPAN", "Episode-span replacement cannot be empty.", [sourceLabel(target.source)], ["Include at least one complete episode."]);
+        for (const episode of target.episodes)
+            assertEpisodeComplete(episode, target.source);
+        return { target, from, through };
+    });
+    assertStrictOrder(resolved.map((item) => ({ coord: [item.from], source: item.target.source })), "Episode spans are not in document order.");
+    for (let index = 1; index < resolved.length; index += 1) {
+        if (resolved[index].from <= resolved[index - 1].through)
+            fail("AUTHORING_SPAN_OVERLAP", "Episode spans overlap.", [sourceLabel(resolved[index].target.source)], ["Use disjoint episode spans."]);
+    }
+    const plans = resolved.map(({ target, from, through }) => {
+        const before = baseline.episodes.slice(from, through + 1);
+        return {
+            kind: "episode-span",
+            address: `${target.from}..${target.through}`,
+            before: episodesCounts(before),
+            after: episodesCounts(target.episodes),
+            ...idDiff(before.map((episode) => episode.episode_id), target.episodes.map((episode) => episode.episode_id)),
+            untouchedSiblings: baseline.episodes.length - before.length,
+        };
+    });
+    for (const { target, from, through } of [...resolved].reverse()) {
+        script.episodes.splice(from, through - from + 1, ...structuredClone(target.episodes));
+    }
+    return plans;
+}
+function applySceneSpans(baseline, script, targets) {
+    const resolved = targets.map((target) => {
+        const epIndex = episodeIndex(baseline, target.parent);
+        if (epIndex < 0)
+            fail("AUTHORING_EPISODE_NOT_FOUND", "Scene-span parent does not exist.", [sourceLabel(target.source), target.parent], ["Use an existing parent episode."]);
+        const episode = baseline.episodes[epIndex];
+        const from = sceneIndex(episode, target.from);
+        const through = sceneIndex(episode, target.through);
+        if (from < 0 || through < 0)
+            fail("AUTHORING_SPAN_ENDPOINT_NOT_FOUND", "Scene-span endpoint does not exist in its parent.", [sourceLabel(target.source), `${target.parent}:${target.from}..${target.through}`], ["Use scene IDs from the same existing episode."]);
+        if (from > through)
+            fail("AUTHORING_SPAN_REVERSED", "Scene-span endpoints are reversed in current document order.", [sourceLabel(target.source), `${target.from}..${target.through}`], ["Swap from and through."]);
+        if (target.scenes.length === 0)
+            fail("AUTHORING_EMPTY_SPAN", "Scene-span replacement cannot be empty.", [sourceLabel(target.source)], ["Include at least one complete scene."]);
+        for (const scene of target.scenes)
+            assertSceneComplete(scene, target.source);
+        return { target, epIndex, from, through };
+    });
+    assertStrictOrder(resolved.map((item) => ({ coord: [item.epIndex, item.from], source: item.target.source })), "Scene spans are not in document order.");
+    for (let index = 1; index < resolved.length; index += 1) {
+        const previous = resolved[index - 1];
+        const current = resolved[index];
+        if (current.epIndex === previous.epIndex && current.from <= previous.through)
+            fail("AUTHORING_SPAN_OVERLAP", "Scene spans overlap.", [sourceLabel(current.target.source)], ["Use disjoint scene spans."]);
+    }
+    const plans = resolved.map(({ target, epIndex, from, through }) => {
+        const before = baseline.episodes[epIndex].scenes.slice(from, through + 1);
+        return {
+            kind: "scene-span",
+            address: `${target.parent}/${target.from}..${target.parent}/${target.through}`,
+            before: scenesCounts(before),
+            after: scenesCounts(target.scenes),
+            ...idDiff(before.map((scene) => scene.scene_id), target.scenes.map((scene) => scene.scene_id)),
+            untouchedSiblings: baseline.episodes[epIndex].scenes.length - before.length,
+        };
+    });
+    const grouped = new Map();
+    for (const item of resolved)
+        grouped.set(item.epIndex, [...(grouped.get(item.epIndex) ?? []), item]);
+    for (const [epIndex, spans] of grouped) {
+        for (const { target, from, through } of [...spans].reverse()) {
+            script.episodes[epIndex].scenes.splice(from, through - from + 1, ...structuredClone(target.scenes));
+        }
+    }
+    return plans;
+}
+function applyActionSpans(baseline, script, targets) {
+    const resolved = targets.map((target) => {
+        const slash = target.parent.indexOf("/");
+        if (slash < 1 || slash === target.parent.length - 1)
+            fail("AUTHORING_SCENE_ADDRESS_INVALID", "Action-span parent is not a complete scene address.", [sourceLabel(target.source), target.parent], ["Use parent=ep_ID/scn_ID."]);
+        const parent = target.parent.slice(0, slash);
+        const sceneId = target.parent.slice(slash + 1);
+        const [epIndex, scIndex] = sceneCoordinate(baseline, parent, sceneId);
+        const scene = baseline.episodes[epIndex].scenes[scIndex];
+        if (target.from > target.through)
+            fail("AUTHORING_SPAN_REVERSED", "Action-span endpoints are reversed.", [sourceLabel(target.source), `${target.from}..${target.through}`], ["Swap from and through."]);
+        if (target.through >= scene.actions.length)
+            fail("AUTHORING_SPAN_ENDPOINT_NOT_FOUND", "Action-span endpoint is outside the current scene body.", [sourceLabel(target.source), `${target.from}..${target.through}`, `actions=${scene.actions.length}`], ["Use zero-based endpoints within the current body."]);
+        if (target.actions.length === 0)
+            fail("AUTHORING_EMPTY_SPAN", "Action-span replacement cannot be empty.", [sourceLabel(target.source)], ["Include at least one action."]);
+        return { target, epIndex, scIndex, scene, from: target.from, through: target.through };
+    });
+    assertStrictOrder(resolved.map((item) => ({ coord: [item.epIndex, item.scIndex, item.from], source: item.target.source })), "Action spans are not in document order.");
+    for (let index = 1; index < resolved.length; index += 1) {
+        const previous = resolved[index - 1];
+        const current = resolved[index];
+        if (current.epIndex === previous.epIndex && current.scIndex === previous.scIndex && current.from <= previous.through) {
+            fail("AUTHORING_SPAN_OVERLAP", "Action spans overlap.", [sourceLabel(current.target.source)], ["Use disjoint action spans."]);
+        }
+    }
+    const plans = resolved.map(({ target, scene, from, through }) => ({
+        kind: "action-span",
+        address: `${target.parent}#${from}..${target.parent}#${through}`,
+        before: { episodes: 0, scenes: 0, actions: through - from + 1 },
+        after: { episodes: 0, scenes: 0, actions: target.actions.length },
+        retainedIds: [],
+        createdIds: [],
+        removedIds: [],
+        untouchedSiblings: scene.actions.length - (through - from + 1),
+    }));
+    const grouped = new Map();
+    for (const item of resolved) {
+        const key = `${item.epIndex}/${item.scIndex}`;
+        grouped.set(key, [...(grouped.get(key) ?? []), item]);
+    }
+    for (const spans of grouped.values()) {
+        for (const { target, epIndex, scIndex, from, through } of [...spans].reverse()) {
+            script.episodes[epIndex].scenes[scIndex].actions.splice(from, through - from + 1, ...structuredClone(target.actions));
+        }
+    }
+    return plans;
+}
+function assertUniqueStructureIds(script) {
+    const episodeIds = new Set();
+    const sceneIds = new Set();
+    for (const episode of script.episodes) {
+        if (episodeIds.has(episode.episode_id))
+            fail("AUTHORING_EPISODE_ID_CONFLICT", "Episode ID occurs more than once.", [episode.episode_id], ["Use globally unique episode IDs."]);
+        episodeIds.add(episode.episode_id);
+        for (const scene of episode.scenes) {
+            if (sceneIds.has(scene.scene_id))
+                fail("AUTHORING_SCENE_ID_CONFLICT", "Scene ID occurs more than once.", [scene.scene_id], ["Use globally unique stable scene IDs."]);
+            sceneIds.add(scene.scene_id);
+        }
+    }
+}
+function stableValidationPath(path, script) {
+    const episodeMatch = /^\$\.episodes\[(\d+)]/.exec(path);
+    if (episodeMatch === null)
+        return path;
+    const episode = script.episodes[Number(episodeMatch[1])];
+    if (episode === undefined)
+        return path;
+    let stable = path.replace(episodeMatch[0], `$.episodes[${episode.episode_id}]`);
+    const sceneMatch = /^(\$\.episodes\[\d+]\.scenes)\[(\d+)]/.exec(path);
+    if (sceneMatch !== null) {
+        const scene = episode.scenes[Number(sceneMatch[2])];
+        if (scene !== undefined) {
+            const oldPrefix = `${episodeMatch[0]}.scenes[${sceneMatch[2]}]`;
+            stable = path.replace(oldPrefix, `$.episodes[${episode.episode_id}].scenes[${scene.scene_id}]`);
+        }
+    }
+    return stable;
+}
+function validationKey(issue, script) {
+    return `${issue.code}\u0000${stableValidationPath(issue.path, script)}\u0000${issue.message}`;
+}
+function assertValidationAllowed(before, after, authored) {
+    const result = validateScriptV3(after);
+    if (result.ok)
+        return result;
+    const beforeKeys = new Set(before === null
+        ? []
+        : validateScriptV3(before).errors.map((issue) => validationKey(issue, before)));
+    const authoredEpisodeIds = new Set();
+    const authoredSceneIds = new Set();
+    for (const target of authored) {
+        if (target.kind === "script") {
+            for (const episode of target.episodes) {
+                authoredEpisodeIds.add(episode.episode_id);
+                for (const scene of episode.scenes)
+                    authoredSceneIds.add(scene.scene_id);
+            }
+        }
+        else if (target.kind === "episode") {
+            authoredEpisodeIds.add(target.value.episode_id);
+            for (const scene of target.value.scenes)
+                authoredSceneIds.add(scene.scene_id);
+        }
+        else if (target.kind === "episode-span") {
+            for (const episode of target.episodes) {
+                authoredEpisodeIds.add(episode.episode_id);
+                for (const scene of episode.scenes)
+                    authoredSceneIds.add(scene.scene_id);
+            }
+        }
+        else if (target.kind === "scene")
+            authoredSceneIds.add(target.value.scene_id);
+        else if (target.kind === "scene-span")
+            for (const scene of target.scenes)
+                authoredSceneIds.add(scene.scene_id);
+        else if (target.kind === "action-span")
+            authoredSceneIds.add(target.parent.split("/")[1] ?? "");
+    }
+    const blocking = result.errors.filter((issue) => {
+        if (!beforeKeys.has(validationKey(issue, after)))
+            return true;
+        const episodeMatch = /^\$\.episodes\[(\d+)]/.exec(issue.path);
+        if (!episodeMatch)
+            return false;
+        const episode = after.episodes[Number(episodeMatch[1])];
+        if (episode === undefined)
+            return true;
+        if (authoredEpisodeIds.has(episode.episode_id))
+            return true;
+        const sceneMatch = /^\$\.episodes\[\d+]\.scenes\[(\d+)]/.exec(issue.path);
+        const scene = sceneMatch === null ? undefined : episode.scenes[Number(sceneMatch[1])];
+        return scene !== undefined && authoredSceneIds.has(scene.scene_id);
+    });
+    if (blocking.length > 0) {
+        fail("AUTHORING_VALIDATION_FAILED", "The proposed script has blocking validation errors.", blocking.map((issue) => `${issue.path}: ${issue.code} ${issue.message}`), ["Repair the authoring source and rerun the plan."]);
+    }
+    return result;
+}
+function orphanAssets(script) {
+    const referenced = new Set();
+    for (const episode of script.episodes) {
+        for (const scene of episode.scenes) {
+            if (scene.location !== null)
+                referenced.add(scene.location.location_id);
+            for (const actor of scene.actors)
+                referenced.add(actor.actor_id);
+            for (const prop of scene.props)
+                referenced.add(prop.prop_id);
+        }
+    }
+    return [
+        ...script.actors.map((asset) => asset.actor_id),
+        ...script.locations.map((asset) => asset.location_id),
+        ...script.props.map((asset) => asset.prop_id),
+    ].filter((id) => !referenced.has(id));
+}
+function buildScriptTarget(document) {
+    const target = document.targets[0];
+    if (target?.kind !== "script")
+        fail("AUTHORING_TARGET_MODE", "Script create requires exactly one script target.", [], ["Use a single <script> block."], EXIT_USAGE);
+    for (const episode of target.episodes)
+        assertEpisodeComplete(episode, target.source);
+    const script = {
+        version: 3,
+        title: target.title,
+        worldview: target.worldview,
+        style: target.style,
+        actors: [],
+        locations: [],
+        props: [],
+        episodes: structuredClone(target.episodes),
+    };
+    if (target.worldviewRaw !== undefined)
+        script.worldview_raw = target.worldviewRaw;
+    if (target.synopsis !== undefined)
+        script.synopsis = target.synopsis;
+    if (target.logline !== undefined)
+        script.logline = target.logline;
+    if (target.theme !== undefined)
+        script.theme = target.theme;
+    if (target.mainCharacters !== undefined)
+        script.main_characters = structuredClone(target.mainCharacters);
+    if (target.extend !== undefined)
+        script.extend = structuredClone(target.extend);
+    const declarations = applyDeclarations(script, document.declarations);
+    assertUniqueStructureIds(script);
+    return { script, declarations };
+}
+export function applyAuthoring(current, document, mode) {
+    if (document.targetKind === "script") {
+        if (mode !== "create")
+            fail("AUTHORING_TARGET_MODE", "Script targets support create only.", [mode], ["Use --create."], EXIT_USAGE);
+        const built = buildScriptTarget(document);
+        const script = built.script;
+        if (current !== null && !semanticEqual(current, script)) {
+            fail("AUTHORING_CREATE_CONFLICT", "The script target already exists with different content.", ["script"], ["Use episode replacement for an existing script, or write an identical script for a no-op retry."]);
+        }
+        const declarations = current === null
+            ? built.declarations
+            : {
+                createdAssets: [],
+                existingAssets: [...built.declarations.existingAssets, ...built.declarations.createdAssets],
+                createdStates: [],
+                existingStates: [...built.declarations.existingStates, ...built.declarations.createdStates],
+            };
+        const validation = assertValidationAllowed(current, script, document.targets);
+        return {
+            script,
+            changed: current === null || !semanticEqual(current, script),
+            declarations,
+            targets: [{
+                    kind: "script",
+                    address: "global",
+                    before: current === null ? { episodes: 0, scenes: 0, actions: 0 } : episodesCounts(current.episodes),
+                    after: episodesCounts(script.episodes),
+                    ...idDiff(current?.episodes.map((episode) => episode.episode_id) ?? [], script.episodes.map((episode) => episode.episode_id)),
+                    untouchedSiblings: 0,
+                }],
+            retainedOrphanAssets: orphanAssets(script),
+            validation,
+        };
+    }
+    if (current === null) {
+        fail("AUTHORING_SCRIPT_NOT_FOUND", "A local Script v3 file is required for this target kind.", ["<missing>"], ["Create a script first or select an existing --script-path."]);
+    }
+    if ((document.targetKind === "episode-span" || document.targetKind === "scene-span" || document.targetKind === "action-span") && mode !== "replace") {
+        fail("AUTHORING_TARGET_MODE", `${document.targetKind} supports replace only.`, [mode], ["Use --replace."], EXIT_USAGE);
+    }
+    const baseline = structuredClone(current);
+    const script = structuredClone(current);
+    const declarations = applyDeclarations(script, document.declarations);
+    let targets;
+    switch (document.targetKind) {
+        case "episode": {
+            const selected = document.targets.flatMap((target) => target.kind === "episode" ? [target] : []);
+            if (selected.length !== document.targets.length)
+                fail("AUTHORING_TARGET_MODE", "Authoring targets are not homogeneous.", [], ["Keep one target kind per file."], EXIT_USAGE);
+            targets = applyEpisodeTargets(baseline, script, selected, mode);
+            break;
+        }
+        case "scene": {
+            const selected = document.targets.flatMap((target) => target.kind === "scene" ? [target] : []);
+            if (selected.length !== document.targets.length)
+                fail("AUTHORING_TARGET_MODE", "Authoring targets are not homogeneous.", [], ["Keep one target kind per file."], EXIT_USAGE);
+            targets = applySceneTargets(baseline, script, selected, mode);
+            break;
+        }
+        case "episode-span": {
+            const selected = document.targets.flatMap((target) => target.kind === "episode-span" ? [target] : []);
+            if (selected.length !== document.targets.length)
+                fail("AUTHORING_TARGET_MODE", "Authoring targets are not homogeneous.", [], ["Keep one target kind per file."], EXIT_USAGE);
+            targets = applyEpisodeSpans(baseline, script, selected);
+            break;
+        }
+        case "scene-span": {
+            const selected = document.targets.flatMap((target) => target.kind === "scene-span" ? [target] : []);
+            if (selected.length !== document.targets.length)
+                fail("AUTHORING_TARGET_MODE", "Authoring targets are not homogeneous.", [], ["Keep one target kind per file."], EXIT_USAGE);
+            targets = applySceneSpans(baseline, script, selected);
+            break;
+        }
+        case "action-span": {
+            const selected = document.targets.flatMap((target) => target.kind === "action-span" ? [target] : []);
+            if (selected.length !== document.targets.length)
+                fail("AUTHORING_TARGET_MODE", "Authoring targets are not homogeneous.", [], ["Keep one target kind per file."], EXIT_USAGE);
+            targets = applyActionSpans(baseline, script, selected);
+            break;
+        }
+        default:
+            fail("AUTHORING_TARGET_MODE", "Unsupported authoring target.", [document.targetKind], ["Use a supported homogeneous target kind."]);
+    }
+    assertUniqueStructureIds(script);
+    const validation = assertValidationAllowed(current, script, document.targets);
+    return {
+        script,
+        changed: !semanticEqual(current, script),
+        declarations,
+        targets,
+        retainedOrphanAssets: orphanAssets(script),
+        validation,
+    };
+}
+//# sourceMappingURL=apply.js.map