@lingjingai/scriptctl 0.49.15 → 0.50.0

package/dist/domain/authoring/v4/parser.js

@@ -0,0 +1,729 @@
+import { CliError, EXIT_INPUT } from "../../../common.js";
+import { parseBracketRecord } from "../shared/bracket.js";
+import { isV4Id } from "../../script/v4/ids.js";
+function invalid(message, line, received) {
+    throw new CliError("AUTHORING BLOCKED: Script v4 source invalid", message, {
+        exitCode: EXIT_INPUT,
+        errorCode: "AUTHORING_SOURCE_INVALID",
+        received: [`line ${line}: ${received}`],
+    });
+}
+function parseTag(raw, line) {
+    const text = raw.trim();
+    const close = /^<\/([a-z-]+)>$/.exec(text);
+    if (close)
+        return { name: close[1], closing: true, attrs: new Map(), line };
+    const open = /^<([a-z-]+)(?: ([^>]+))?>$/.exec(text);
+    if (!open)
+        return null;
+    const attrs = new Map();
+    const attrText = open[2] ?? "";
+    const tokens = attrText === "" ? [] : attrText.split(" ");
+    if (tokens.some((token) => token === ""))
+        invalid("Tag attributes need one-space separators.", line, text);
+    for (const token of tokens) {
+        const match = /^([a-z]+)=([A-Za-z0-9_./#:-]+)$/.exec(token);
+        if (!match || attrs.has(match[1]))
+            invalid("Tag attributes are invalid.", line, token);
+        attrs.set(match[1], match[2]);
+    }
+    return { name: open[1], closing: false, attrs, line };
+}
+function assertAttrs(tag, required, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    const unknown = [...tag.attrs.keys()].filter((key) => !allowed.has(key));
+    const missing = required.filter((key) => !tag.attrs.has(key));
+    if (unknown.length > 0 || missing.length > 0) {
+        invalid("Tag attributes do not match the canonical grammar.", tag.line, [
+            ...missing.map((key) => `missing:${key}`),
+            ...unknown.map((key) => `unknown:${key}`),
+        ].join(","));
+    }
+}
+class Cursor {
+    lines;
+    index = 0;
+    constructor(text) {
+        this.lines = text.split(/\r?\n/)
+            .map((raw, index) => ({
+            raw: raw.replace(/^\s+/, ""),
+            line: index + 1,
+        }))
+            .filter((item) => item.raw.trim() !== "");
+    }
+    peek() {
+        const item = this.lines[this.index];
+        if (!item)
+            invalid("Unexpected end of authoring file.", this.lines.at(-1)?.line ?? 1, "<eof>");
+        return item;
+    }
+    take() {
+        const item = this.peek();
+        this.index++;
+        return item;
+    }
+    tag(name, closing) {
+        const item = this.take();
+        const tag = parseTag(item.raw, item.line);
+        if (!tag || tag.name !== name || tag.closing !== closing) {
+            invalid(`Expected ${closing ? "</" : "<"}${name}>.`, item.line, item.raw);
+        }
+        return tag;
+    }
+    record() {
+        const item = this.take();
+        return parseBracketRecord(item.raw, item.line);
+    }
+    nextTag() {
+        const item = this.peek();
+        return parseTag(item.raw, item.line);
+    }
+    nextRecord() {
+        const item = this.peek();
+        return item.raw.startsWith("[") ? parseBracketRecord(item.raw, item.line) : null;
+    }
+}
+function jsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return true;
+    if (Array.isArray(value))
+        return value.every(jsonValue);
+    return typeof value === "object" && Object.values(value).every(jsonValue);
+}
+function modifiers(cursor) {
+    const result = {};
+    let next = cursor.nextRecord();
+    if (next?.type === "extensions") {
+        cursor.record();
+        const extend = {};
+        let previousKey = null;
+        while ((next = cursor.nextRecord())?.type === "extend") {
+            const record = cursor.record();
+            if (record.slots.length !== 1 || Object.hasOwn(extend, record.slots[0])) {
+                invalid("extend record is invalid or duplicated.", record.source.line, record.type);
+            }
+            const key = record.slots[0];
+            if (previousKey !== null && previousKey >= key) {
+                invalid("extend keys must use ascending canonical order.", record.source.line, key);
+            }
+            let value;
+            try {
+                value = JSON.parse(record.content);
+            }
+            catch {
+                invalid("extend content must be JSON.", record.source.line, record.content);
+            }
+            if (!jsonValue(value))
+                invalid("extend value must be JSON-compatible.", record.source.line, record.content);
+            extend[key] = value;
+            previousKey = key;
+        }
+        result.extend = extend;
+    }
+    next = cursor.nextRecord();
+    if (next?.type === "aliases") {
+        cursor.record();
+        const aliases = [];
+        while ((next = cursor.nextRecord())?.type === "alias") {
+            const record = cursor.record();
+            if (record.slots.length !== 0)
+                invalid("alias takes no slots.", record.source.line, record.type);
+            if (record.content === "")
+                invalid("alias must not be empty.", record.source.line, record.type);
+            if (aliases.includes(record.content))
+                invalid("alias must not be duplicated.", record.source.line, record.content);
+            aliases.push(record.content);
+        }
+        result.aliases = aliases;
+    }
+    next = cursor.nextRecord();
+    if (next?.type === "prompt") {
+        const record = cursor.record();
+        if (record.slots.length !== 3 || record.slots.some((slot) => slot === "")) {
+            invalid("prompt requires non-empty target, process, and contrast.", record.source.line, record.type);
+        }
+        const target = record.slots[0];
+        if (!isV4Id("actor", target) && !isV4Id("location", target) && !isV4Id("prop", target)) {
+            invalid("prompt target must be an asset ID.", record.source.line, target);
+        }
+        result.prompt = {
+            target,
+            process: record.slots[1],
+            contrast: record.slots[2],
+        };
+    }
+    return result;
+}
+function importance(raw, line) {
+    if (raw !== "featured" && raw !== "background")
+        invalid("Importance is invalid.", line, raw);
+    return raw;
+}
+function role(raw, line) {
+    if (raw === undefined)
+        return undefined;
+    if (raw !== "主角" && raw !== "配角")
+        invalid("Role type is invalid.", line, raw);
+    return raw;
+}
+function stateId(raw, line) {
+    if (raw === "default" || isV4Id("state", raw))
+        return raw;
+    return invalid("State ID is invalid.", line, raw);
+}
+function parseCreate(cursor) {
+    const opening = cursor.tag("create", false);
+    assertAttrs(opening, []);
+    const declarations = [];
+    const declaredAssets = new Map();
+    let activeNewAssetId = null;
+    let declarationPhase = 0;
+    const finishActiveAsset = (line) => {
+        if (activeNewAssetId === null)
+            return;
+        const asset = declaredAssets.get(activeNewAssetId);
+        if (!asset || asset.states.length === 0 || asset.states[0].state_id !== "default") {
+            invalid("A new asset must be followed immediately by its default state.", line, activeNewAssetId);
+        }
+        activeNewAssetId = null;
+    };
+    while (cursor.nextTag()?.name !== "create" || cursor.nextTag()?.closing !== true) {
+        const mod = modifiers(cursor);
+        const record = cursor.record();
+        if (record.type === "actor") {
+            if (declarationPhase > 0)
+                invalid("Create declarations are not in canonical order.", record.source.line, record.type);
+            finishActiveAsset(record.source.line);
+            if (mod.prompt !== undefined)
+                invalid("prompt cannot modify an asset.", record.source.line, record.type);
+            if (record.slots.length < 3 || record.slots.length > 4 || !isV4Id("actor", record.slots[0])) {
+                invalid("actor declaration is invalid.", record.source.line, record.type);
+            }
+            const roleType = role(record.slots[3], record.source.line);
+            const value = {
+                actor_id: record.slots[0],
+                actor_name: record.slots[1],
+                importance: importance(record.slots[2], record.source.line),
+                description: record.content,
+                states: [],
+                ...(roleType === undefined ? {} : { role_type: roleType }),
+                ...(mod.aliases === undefined ? {} : { aliases: mod.aliases }),
+                ...(mod.extend === undefined ? {} : { extend: mod.extend }),
+            };
+            if (value.aliases?.includes(value.actor_name)) {
+                invalid("An alias must differ from the asset name.", record.source.line, value.actor_name);
+            }
+            declarations.push({ kind: "actor", value });
+            declaredAssets.set(value.actor_id, value);
+            activeNewAssetId = value.actor_id;
+        }
+        else if (record.type === "location" || record.type === "prop") {
+            const nextPhase = record.type === "location" ? 1 : 2;
+            if (nextPhase < declarationPhase) {
+                invalid("Create declarations are not in canonical order.", record.source.line, record.type);
+            }
+            declarationPhase = nextPhase;
+            finishActiveAsset(record.source.line);
+            if (mod.prompt !== undefined)
+                invalid("prompt cannot modify an asset.", record.source.line, record.type);
+            const kind = record.type;
+            if (record.slots.length !== 3
+                || (kind === "location"
+                    ? !isV4Id("location", record.slots[0])
+                    : !isV4Id("prop", record.slots[0]))) {
+                invalid(`${kind} declaration is invalid.`, record.source.line, record.type);
+            }
+            if (kind === "location") {
+                const locationId = record.slots[0];
+                if (!isV4Id("location", locationId))
+                    invalid("location ID is invalid.", record.source.line, locationId);
+                const value = {
+                    location_id: locationId,
+                    location_name: record.slots[1],
+                    importance: importance(record.slots[2], record.source.line),
+                    description: record.content,
+                    states: [],
+                    ...(mod.aliases === undefined ? {} : { aliases: mod.aliases }),
+                    ...(mod.extend === undefined ? {} : { extend: mod.extend }),
+                };
+                if (value.aliases?.includes(value.location_name)) {
+                    invalid("An alias must differ from the asset name.", record.source.line, value.location_name);
+                }
+                declarations.push({ kind, value });
+                declaredAssets.set(value.location_id, value);
+                activeNewAssetId = value.location_id;
+            }
+            else {
+                const propId = record.slots[0];
+                if (!isV4Id("prop", propId))
+                    invalid("prop ID is invalid.", record.source.line, propId);
+                const value = {
+                    prop_id: propId,
+                    prop_name: record.slots[1],
+                    importance: importance(record.slots[2], record.source.line),
+                    description: record.content,
+                    states: [],
+                    ...(mod.aliases === undefined ? {} : { aliases: mod.aliases }),
+                    ...(mod.extend === undefined ? {} : { extend: mod.extend }),
+                };
+                if (value.aliases?.includes(value.prop_name)) {
+                    invalid("An alias must differ from the asset name.", record.source.line, value.prop_name);
+                }
+                declarations.push({ kind, value });
+                declaredAssets.set(value.prop_id, value);
+                activeNewAssetId = value.prop_id;
+            }
+        }
+        else if (record.type === "state") {
+            if (record.slots.length !== 3 || mod.aliases !== undefined || mod.prompt !== undefined) {
+                invalid("state declaration is invalid.", record.source.line, record.type);
+            }
+            const ownerId = record.slots[0];
+            const owner = declaredAssets.get(ownerId);
+            if (owner && activeNewAssetId !== ownerId) {
+                invalid("States for a new asset must immediately follow that asset.", record.source.line, ownerId);
+            }
+            if (!owner) {
+                finishActiveAsset(record.source.line);
+                declarationPhase = 3;
+            }
+            const value = {
+                state_id: stateId(record.slots[1], record.source.line),
+                state_name: record.slots[2],
+                description: record.content,
+                ...(mod.extend === undefined ? {} : { extend: mod.extend }),
+            };
+            if (owner) {
+                if (owner.states.length === 0 && value.state_id !== "default") {
+                    invalid("The first state of a new asset must be default.", record.source.line, value.state_id);
+                }
+                owner.states.push(value);
+            }
+            else
+                declarations.push({ kind: "state", ownerId, value });
+        }
+        else {
+            finishActiveAsset(record.source.line);
+            invalid("Unknown create declaration.", record.source.line, record.type);
+        }
+    }
+    finishActiveAsset(cursor.peek().line);
+    const closing = cursor.tag("create", true);
+    assertAttrs(closing, []);
+    return declarations;
+}
+function speaker(raw, line) {
+    const slash = raw.indexOf("/");
+    const actor = slash < 0 ? raw : raw.slice(0, slash);
+    if (isV4Id("actor", actor)) {
+        return slash < 0
+            ? { actor_id: actor }
+            : { actor_id: actor, state_id: stateId(raw.slice(slash + 1), line) };
+    }
+    const colon = raw.indexOf(":");
+    const kind = (colon < 0 ? raw : raw.slice(0, colon));
+    if (!["system", "broadcast", "offscreen", "group"].includes(kind)) {
+        return invalid("Speaker is invalid.", line, raw);
+    }
+    return colon < 0 ? { kind } : { kind, label: raw.slice(colon + 1) };
+}
+function parseAction(cursor) {
+    const mod = modifiers(cursor);
+    if (mod.aliases !== undefined)
+        invalid("aliases cannot modify an Action.", cursor.peek().line, "aliases");
+    const record = cursor.record();
+    if (record.type === "act" || record.type === "trans") {
+        if (record.slots.length !== 1 || !isV4Id("action", record.slots[0])) {
+            invalid("Narrative Action record is invalid.", record.source.line, record.type);
+        }
+        return {
+            action_id: record.slots[0],
+            type: record.type === "act" ? "action" : "transition",
+            content: record.content,
+            ...(mod.extend === undefined ? {} : { extend: mod.extend }),
+            ...(mod.prompt === undefined ? {} : { transition_prompt: mod.prompt }),
+        };
+    }
+    if (record.type !== "dlg" && record.type !== "think") {
+        return invalid("Unknown Action record.", record.source.line, record.type);
+    }
+    if ((record.slots.length !== 2 && record.slots.length !== 3) || !isV4Id("action", record.slots[0])) {
+        invalid("Speaking Action record is invalid.", record.source.line, record.type);
+    }
+    return {
+        action_id: record.slots[0],
+        type: record.type === "dlg" ? "dialogue" : "inner_thought",
+        speaker: speaker(record.slots[1], record.source.line),
+        content: record.content,
+        ...(record.slots.length === 3 ? { parenthetical: record.slots[2] } : {}),
+        ...(mod.extend === undefined ? {} : { extend: mod.extend }),
+        ...(mod.prompt === undefined ? {} : { transition_prompt: mod.prompt }),
+    };
+}
+function stateSet(slots, line) {
+    if (slots.length === 0)
+        invalid("Scene reference needs at least one state.", line, "<empty>");
+    const values = slots.map((value) => stateId(value, line));
+    if (new Set(values).size !== values.length)
+        invalid("Scene reference repeats a state.", line, values.join(","));
+    return values.sort();
+}
+function parseScene(cursor, opening, outerParent, extend) {
+    assertAttrs(opening, outerParent === undefined ? ["id", "parent"] : ["id"]);
+    const id = opening.attrs.get("id") ?? "";
+    if (!isV4Id("scene", id))
+        invalid("Scene ID is invalid.", opening.line, id);
+    const parent = opening.attrs.get("parent") ?? outerParent;
+    if (parent !== undefined && !isV4Id("episode", parent)) {
+        invalid("Scene parent must be an Episode ID.", opening.line, parent);
+    }
+    let environment;
+    let location;
+    const actors = [];
+    const props = [];
+    const actorIds = new Set();
+    const propIds = new Set();
+    let phase = 0;
+    while (cursor.nextTag()?.name !== "body") {
+        const record = cursor.record();
+        const nextPhase = record.type === "environment" ? 0
+            : record.type === "location" ? 1
+                : record.type === "cast" ? 2
+                    : record.type === "prop" ? 3
+                        : -1;
+        if (nextPhase < phase) {
+            invalid("Scene records are not in canonical order.", record.source.line, record.type);
+        }
+        phase = nextPhase;
+        if (record.type === "environment") {
+            if (environment !== undefined)
+                invalid("Scene environment is duplicated.", record.source.line, record.type);
+            if (record.slots.length > 2)
+                invalid("environment has too many slots.", record.source.line, record.type);
+            environment = {
+                ...(record.slots[0] === undefined ? {} : { space: record.slots[0] }),
+                ...(record.slots[1] === undefined ? {} : { time: record.slots[1] }),
+            };
+        }
+        else if (record.type === "location") {
+            if (location !== undefined)
+                invalid("Scene location is duplicated.", record.source.line, record.type);
+            if (record.slots.length === 0)
+                location = null;
+            else {
+                if (!isV4Id("location", record.slots[0]))
+                    invalid("Location ref ID is invalid.", record.source.line, record.slots[0]);
+                location = { location_id: record.slots[0], state_ids: stateSet(record.slots.slice(1), record.source.line) };
+            }
+        }
+        else if (record.type === "cast") {
+            if (!isV4Id("actor", record.slots[0]))
+                invalid("Cast ref ID is invalid.", record.source.line, record.slots[0] ?? "");
+            if (actorIds.has(record.slots[0]))
+                invalid("Scene repeats an actor reference.", record.source.line, record.slots[0]);
+            actorIds.add(record.slots[0]);
+            actors.push({ actor_id: record.slots[0], state_ids: stateSet(record.slots.slice(1), record.source.line) });
+        }
+        else if (record.type === "prop") {
+            if (!isV4Id("prop", record.slots[0]))
+                invalid("Prop ref ID is invalid.", record.source.line, record.slots[0] ?? "");
+            if (propIds.has(record.slots[0]))
+                invalid("Scene repeats a prop reference.", record.source.line, record.slots[0]);
+            propIds.add(record.slots[0]);
+            props.push({ prop_id: record.slots[0], state_ids: stateSet(record.slots.slice(1), record.source.line) });
+        }
+        else
+            invalid("Unknown scene header record.", record.source.line, record.type);
+    }
+    if (location === undefined)
+        invalid("Scene must declare location or [location].", cursor.peek().line, id);
+    const bodyOpening = cursor.tag("body", false);
+    assertAttrs(bodyOpening, []);
+    const actions = [];
+    while (cursor.nextTag()?.name !== "body" || cursor.nextTag()?.closing !== true)
+        actions.push(parseAction(cursor));
+    assertAttrs(cursor.tag("body", true), []);
+    assertAttrs(cursor.tag("scene", true), []);
+    return {
+        ...(parent === undefined ? {} : { parent }),
+        value: {
+            scene_id: id,
+            ...(environment === undefined ? {} : { environment }),
+            location,
+            actors,
+            props,
+            actions,
+            ...(extend === undefined ? {} : { extend }),
+        },
+    };
+}
+function parseEpisode(cursor, opening, extend) {
+    assertAttrs(opening, ["id"]);
+    const id = opening.attrs.get("id") ?? "";
+    if (!isV4Id("episode", id))
+        invalid("Episode ID is invalid.", opening.line, id);
+    let title;
+    let synopsis;
+    const scenes = [];
+    let phase = 0;
+    while (cursor.nextTag()?.name !== "episode" || cursor.nextTag()?.closing !== true) {
+        const mod = modifiers(cursor);
+        if (mod.aliases !== undefined || mod.prompt !== undefined) {
+            invalid("Invalid episode child modifier.", cursor.peek().line, "modifier");
+        }
+        const next = cursor.nextTag();
+        if (next?.name === "scene" && !next.closing) {
+            phase = 2;
+            cursor.take();
+            scenes.push(parseScene(cursor, next, id, mod.extend).value);
+            continue;
+        }
+        if (mod.extend !== undefined)
+            invalid("extend must precede a scene here.", cursor.peek().line, "extend");
+        const record = cursor.record();
+        const nextPhase = record.type === "title" ? 0 : record.type === "synopsis" ? 1 : -1;
+        if (nextPhase < phase)
+            invalid("Episode records are not in canonical order.", record.source.line, record.type);
+        phase = nextPhase;
+        if (record.type === "title") {
+            if (title !== undefined)
+                invalid("Episode title is duplicated.", record.source.line, record.type);
+            if (record.slots.length !== 0)
+                invalid("Episode title takes no slots.", record.source.line, record.type);
+            title = record.content;
+        }
+        else if (record.type === "synopsis") {
+            if (synopsis !== undefined)
+                invalid("Episode synopsis is duplicated.", record.source.line, record.type);
+            if (record.slots.length !== 0)
+                invalid("Episode synopsis takes no slots.", record.source.line, record.type);
+            synopsis = record.content;
+        }
+        else
+            invalid("Unknown episode record.", record.source.line, record.type);
+    }
+    assertAttrs(cursor.tag("episode", true), []);
+    return {
+        episode_id: id,
+        ...(title === undefined ? {} : { title }),
+        ...(synopsis === undefined ? {} : { synopsis }),
+        scenes,
+        ...(extend === undefined ? {} : { extend }),
+    };
+}
+function range(tag, kind) {
+    const value = tag.attrs.get("range") ?? "";
+    const pieces = value.split("..");
+    if (pieces.length !== 2
+        || !pieces[0]
+        || !pieces[1]
+        || !isV4Id(kind, pieces[0])
+        || !isV4Id(kind, pieces[1])) {
+        invalid(`Span range must contain two ${kind} IDs.`, tag.line, value);
+    }
+    return [pieces[0], pieces[1]];
+}
+function parseScriptTarget(cursor, opening, extend) {
+    assertAttrs(opening, []);
+    let title;
+    let worldview;
+    let worldview_raw;
+    let style;
+    let synopsis;
+    let logline;
+    let theme;
+    let main_characters;
+    const episodes = [];
+    let phase = 0;
+    while (cursor.nextTag()?.name !== "script" || cursor.nextTag()?.closing !== true) {
+        const mod = modifiers(cursor);
+        if (mod.aliases !== undefined || mod.prompt !== undefined) {
+            invalid("Invalid script child modifier.", cursor.peek().line, "modifier");
+        }
+        const next = cursor.nextTag();
+        if (next?.name === "episode" && !next.closing) {
+            phase = 8;
+            cursor.take();
+            episodes.push(parseEpisode(cursor, next, mod.extend));
+            continue;
+        }
+        if (mod.extend !== undefined)
+            invalid("extend must precede an episode here.", cursor.peek().line, "extend");
+        const record = cursor.record();
+        const nextPhase = record.type === "title" ? 0
+            : record.type === "worldview" ? 1
+                : record.type === "worldview-raw" ? 2
+                    : record.type === "style" ? 3
+                        : record.type === "synopsis" ? 4
+                            : record.type === "logline" ? 5
+                                : record.type === "theme" ? 6
+                                    : record.type === "main-characters" || record.type === "main-character" ? 7
+                                        : -1;
+        if (nextPhase < phase)
+            invalid("Script records are not in canonical order.", record.source.line, record.type);
+        phase = nextPhase;
+        if (record.type !== "main-character"
+            && record.slots.length !== 0) {
+            invalid("Script metadata record takes no slots.", record.source.line, record.type);
+        }
+        if (record.type === "title") {
+            if (title !== undefined)
+                invalid("Script title is duplicated.", record.source.line, record.type);
+            title = record.content;
+        }
+        else if (record.type === "worldview") {
+            if (worldview !== undefined)
+                invalid("Script worldview is duplicated.", record.source.line, record.type);
+            worldview = record.content;
+        }
+        else if (record.type === "worldview-raw") {
+            if (worldview_raw !== undefined)
+                invalid("Script worldview-raw is duplicated.", record.source.line, record.type);
+            worldview_raw = record.content;
+        }
+        else if (record.type === "style") {
+            if (style !== undefined)
+                invalid("Script style is duplicated.", record.source.line, record.type);
+            style = record.content;
+        }
+        else if (record.type === "synopsis") {
+            if (synopsis !== undefined)
+                invalid("Script synopsis is duplicated.", record.source.line, record.type);
+            synopsis = record.content;
+        }
+        else if (record.type === "logline") {
+            if (logline !== undefined)
+                invalid("Script logline is duplicated.", record.source.line, record.type);
+            logline = record.content;
+        }
+        else if (record.type === "theme") {
+            if (theme !== undefined)
+                invalid("Script theme is duplicated.", record.source.line, record.type);
+            theme = record.content;
+        }
+        else if (record.type === "main-characters") {
+            if (main_characters !== undefined)
+                invalid("Script main-characters is duplicated.", record.source.line, record.type);
+            main_characters = [];
+        }
+        else if (record.type === "main-character"
+            && main_characters !== undefined
+            && record.slots.length === 2
+            && record.content === "") {
+            main_characters.push({ name: record.slots[0], role: record.slots[1] });
+        }
+        else
+            invalid("Unknown script record.", record.source.line, record.type);
+    }
+    assertAttrs(cursor.tag("script", true), []);
+    if (title === undefined || worldview === undefined || style === undefined) {
+        invalid("Script target needs title, worldview, and style.", cursor.peek().line, "script");
+    }
+    return {
+        kind: "script",
+        value: {
+            title,
+            worldview,
+            style,
+            episodes,
+            ...(worldview_raw === undefined ? {} : { worldview_raw }),
+            ...(synopsis === undefined ? {} : { synopsis }),
+            ...(logline === undefined ? {} : { logline }),
+            ...(theme === undefined ? {} : { theme }),
+            ...(main_characters === undefined ? {} : { main_characters }),
+            ...(extend === undefined ? {} : { extend }),
+        },
+    };
+}
+export function parseAuthoringV4(text) {
+    const cursor = new Cursor(text);
+    const root = cursor.tag("authoring", false);
+    assertAttrs(root, ["version"]);
+    if (root.attrs.get("version") !== "1")
+        invalid("authoring version must be 1.", 1, root.attrs.get("version") ?? "<missing>");
+    const declarations = cursor.nextTag()?.name === "create" ? parseCreate(cursor) : [];
+    const targets = [];
+    while (cursor.nextTag()?.name !== "authoring" || cursor.nextTag()?.closing !== true) {
+        const mod = modifiers(cursor);
+        if (mod.aliases !== undefined || mod.prompt !== undefined) {
+            invalid("Invalid target modifier.", cursor.peek().line, "modifier");
+        }
+        const item = cursor.take();
+        const tag = parseTag(item.raw, item.line);
+        if (!tag || tag.closing)
+            invalid("Expected an authoring target.", item.line, item.raw);
+        if (tag.name === "script")
+            targets.push(parseScriptTarget(cursor, tag, mod.extend));
+        else if (tag.name === "episode")
+            targets.push({ kind: "episode", value: parseEpisode(cursor, tag, mod.extend) });
+        else if (tag.name === "scene") {
+            const parsed = parseScene(cursor, tag, undefined, mod.extend);
+            if (!parsed.parent)
+                invalid("Top-level scene needs parent.", item.line, item.raw);
+            targets.push({ kind: "scene", parent: parsed.parent, value: parsed.value });
+        }
+        else if (tag.name === "episode-span") {
+            if (mod.extend !== undefined)
+                invalid("A span cannot carry node extensions.", item.line, item.raw);
+            assertAttrs(tag, ["range"]);
+            const [from, through] = range(tag, "episode");
+            const values = [];
+            while (cursor.nextTag()?.name !== "episode-span" || cursor.nextTag()?.closing !== true) {
+                const childMod = modifiers(cursor);
+                if (childMod.aliases !== undefined || childMod.prompt !== undefined) {
+                    invalid("Invalid episode child modifier.", cursor.peek().line, "modifier");
+                }
+                const open = cursor.tag("episode", false);
+                values.push(parseEpisode(cursor, open, childMod.extend));
+            }
+            assertAttrs(cursor.tag("episode-span", true), []);
+            targets.push({ kind: "episode-span", from, through, values });
+        }
+        else if (tag.name === "scene-span") {
+            if (mod.extend !== undefined)
+                invalid("A span cannot carry node extensions.", item.line, item.raw);
+            assertAttrs(tag, ["parent", "range"]);
+            const [from, through] = range(tag, "scene");
+            const parent = tag.attrs.get("parent") ?? invalid("scene-span needs parent.", item.line, item.raw);
+            if (!isV4Id("episode", parent))
+                invalid("scene-span parent must be an Episode ID.", item.line, parent);
+            const values = [];
+            while (cursor.nextTag()?.name !== "scene-span" || cursor.nextTag()?.closing !== true) {
+                const childMod = modifiers(cursor);
+                if (childMod.aliases !== undefined || childMod.prompt !== undefined) {
+                    invalid("Invalid scene child modifier.", cursor.peek().line, "modifier");
+                }
+                const open = cursor.tag("scene", false);
+                values.push(parseScene(cursor, open, parent, childMod.extend).value);
+            }
+            assertAttrs(cursor.tag("scene-span", true), []);
+            targets.push({ kind: "scene-span", parent, from, through, values });
+        }
+        else if (tag.name === "action-span") {
+            if (mod.extend !== undefined)
+                invalid("A span cannot carry node extensions.", item.line, item.raw);
+            assertAttrs(tag, ["parent", "range"]);
+            const [from, through] = range(tag, "action");
+            const parent = tag.attrs.get("parent") ?? invalid("action-span needs parent.", item.line, item.raw);
+            if (!isV4Id("scene", parent))
+                invalid("action-span parent must be a Scene ID.", item.line, parent);
+            assertAttrs(cursor.tag("body", false), []);
+            const values = [];
+            while (cursor.nextTag()?.name !== "body" || cursor.nextTag()?.closing !== true)
+                values.push(parseAction(cursor));
+            assertAttrs(cursor.tag("body", true), []);
+            assertAttrs(cursor.tag("action-span", true), []);
+            targets.push({ kind: "action-span", parent, from, through, values });
+        }
+        else
+            invalid("Unknown authoring target.", item.line, tag.name);
+    }
+    assertAttrs(cursor.tag("authoring", true), []);
+    if (cursor.index !== cursor.lines.length || targets.length === 0)
+        invalid("Authoring file has trailing content or no targets.", cursor.peek().line, "<root>");
+    const targetKind = targets[0].kind;
+    if (!targets.every((target) => target.kind === targetKind))
+        invalid("All targets must have the same kind.", 1, targetKind);
+    return { declarations, targets, targetKind };
+}
+//# sourceMappingURL=parser.js.map