@lingjingai/scriptctl 0.63.14 → 0.63.16

package/dist/domain/authoring/v3/apply.js

@@ -1,784 +0,0 @@
-import { CliError, EXIT_INPUT, EXIT_USAGE } from "../../../common.js";
-import { validateScriptV3 } from "../../script/v3/validation.js";
-function fail(code, message, received, nextSteps, exitCode = EXIT_INPUT) {
-    throw new CliError(message, {
-        exitCode,
-        errorCode: code,
-        hint: nextSteps[0],
-        data: { actual: received },
-    });
-}
-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."]);
-        }
-        const existing = owner.states.find((candidate) => candidate.state_id === state.value.state_id);
-        if (existing !== undefined && !semanticEqual(existing, state.value)) {
-            fail("AUTHORING_STATE_CONFLICT", "Create-only state declaration conflicts with an existing state on the same asset.", [sourceLabel(state.source), `${state.kind}:${state.ownerId}/${state.value.state_id}`], ["Use an unused state ID for this asset, or reuse the identical existing state."]);
-        }
-        const stateAddress = `${state.kind}:${state.ownerId}/${state.value.state_id}`;
-        if (existing === undefined) {
-            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 assertSceneReferencesMaterialized(scene, source) {
-    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 block must bind a state.", [sourceLabel(source), ...unmaterialized], ["Add the concrete state ID to every location, cast, and prop record."]);
-    }
-}
-function assertEpisodeReferencesMaterialized(episode, source) {
-    for (const scene of episode.scenes)
-        assertSceneReferencesMaterialized(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) {
-        assertEpisodeReferencesMaterialized(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) {
-        assertSceneReferencesMaterialized(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)
-            assertEpisodeReferencesMaterialized(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)
-            assertSceneReferencesMaterialized(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 authoredScope(authored) {
-    const scope = {
-        episodeIds: new Set(),
-        sceneIds: new Set(),
-        fullEpisodeIds: new Set(),
-        fullSceneIds: new Set(),
-        actionSpans: [],
-    };
-    const includeScene = (scene) => {
-        scope.sceneIds.add(scene.scene_id);
-        scope.fullSceneIds.add(scene.scene_id);
-    };
-    const includeEpisode = (episode) => {
-        scope.episodeIds.add(episode.episode_id);
-        scope.fullEpisodeIds.add(episode.episode_id);
-        for (const scene of episode.scenes)
-            includeScene(scene);
-    };
-    for (const target of authored) {
-        if (target.kind === "script") {
-            for (const episode of target.episodes)
-                includeEpisode(episode);
-        }
-        else if (target.kind === "episode")
-            includeEpisode(target.value);
-        else if (target.kind === "episode-span") {
-            for (const episode of target.episodes)
-                includeEpisode(episode);
-        }
-        else if (target.kind === "scene")
-            includeScene(target.value);
-        else if (target.kind === "scene-span") {
-            for (const scene of target.scenes)
-                includeScene(scene);
-        }
-        else {
-            scope.sceneIds.add(target.parent.split("/")[1] ?? "");
-            scope.actionSpans.push(target);
-        }
-    }
-    return scope;
-}
-function authoredCompletenessWarnings(before, after, scope) {
-    const warnings = [];
-    const beforeEpisodes = new Map(before?.episodes.map((episode) => [episode.episode_id, episode]) ?? []);
-    const beforeScenes = new Map();
-    for (const episode of before?.episodes ?? []) {
-        for (const scene of episode.scenes)
-            beforeScenes.set(scene.scene_id, scene);
-    }
-    const afterEpisodes = new Map(after.episodes.map((episode) => [episode.episode_id, episode]));
-    const afterScenes = new Map();
-    for (const episode of after.episodes) {
-        for (const scene of episode.scenes)
-            afterScenes.set(scene.scene_id, { episodeId: episode.episode_id, scene });
-    }
-    for (const episodeId of scope.fullEpisodeIds) {
-        const episode = afterEpisodes.get(episodeId);
-        if (episode === undefined || episode.scenes.length > 0)
-            continue;
-        const cleared = (beforeEpisodes.get(episodeId)?.scenes.length ?? 0) > 0;
-        warnings.push({
-            code: cleared ? "authoring_episode_cleared" : "authoring_empty_episode",
-            path: `$.episodes[${episodeId}]`,
-            message: cleared
-                ? `authoring replaced episode ${episodeId} with an empty scene list`
-                : `authored episode ${episodeId} has no scenes`,
-        });
-    }
-    for (const sceneId of scope.fullSceneIds) {
-        const located = afterScenes.get(sceneId);
-        if (located === undefined)
-            continue;
-        const scenePath = `$.episodes[${located.episodeId}].scenes[${sceneId}]`;
-        if (located.scene.actions.length === 0) {
-            const cleared = (beforeScenes.get(sceneId)?.actions.length ?? 0) > 0;
-            warnings.push({
-                code: cleared ? "authoring_scene_cleared" : "authoring_empty_scene",
-                path: scenePath,
-                message: cleared
-                    ? `authoring replaced scene ${sceneId} with an empty body`
-                    : `authored scene ${sceneId} has an empty body`,
-            });
-        }
-        located.scene.actions.forEach((action, index) => {
-            if (action.content.trim() !== "")
-                return;
-            warnings.push({
-                code: "authoring_empty_action_content",
-                path: `${scenePath}.actions[${index}]`,
-                message: "authored action content is empty",
-            });
-        });
-    }
-    for (const target of scope.actionSpans) {
-        target.actions.forEach((action, index) => {
-            if (action.content.trim() !== "")
-                return;
-            warnings.push({
-                code: "authoring_empty_action_content",
-                path: `${target.parent}#replacement[${index}]`,
-                message: "authored action-span replacement contains an action with empty content",
-            });
-        });
-    }
-    return warnings;
-}
-function assertValidationAllowed(before, after, authored) {
-    const result = validateScriptV3(after);
-    const scope = authoredScope(authored);
-    const withWarnings = () => ({
-        ...result,
-        warnings: [...result.warnings, ...authoredCompletenessWarnings(before, after, scope)],
-    });
-    if (result.ok || (before !== null && semanticEqual(before, after)))
-        return withWarnings();
-    const beforeKeys = new Set(before === null
-        ? []
-        : validateScriptV3(before).errors.map((issue) => validationKey(issue, before)));
-    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 (scope.episodeIds.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 && scope.sceneIds.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 withWarnings();
-}
-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)
-        assertEpisodeReferencesMaterialized(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