@lingjingai/scriptctl 0.49.16 → 0.51.0

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

@@ -0,0 +1,823 @@
+import { ACTION_TYPE_SET, IMPORTANCE_TIER_SET, NON_ACTOR_SPEAKER_KIND_SET, ROLE_TYPE_SET, } from "../../script/v3/types.js";
+import { authoringError, parseBracketRecord, } from "../shared/bracket.js";
+export { parseBracketRecord } from "../shared/bracket.js";
+function emptyModifiers() {
+    return { extend: {}, extendPresent: false, aliases: [], aliasesPresent: false, phase: "extend" };
+}
+function hasModifiers(modifiers) {
+    return modifiers.extendPresent
+        || modifiers.aliasesPresent
+        || modifiers.prompt !== undefined;
+}
+function extensionOrUndefined(modifiers) {
+    return modifiers.extendPresent ? modifiers.extend : undefined;
+}
+function isJsonValue(value) {
+    if (value === null)
+        return true;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return true;
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (typeof value !== "object")
+        return false;
+    return Object.values(value).every(isJsonValue);
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalJson);
+    if (value !== null && typeof value === "object") {
+        const result = {};
+        for (const key of Object.keys(value).sort())
+            result[key] = canonicalJson(value[key]);
+        return result;
+    }
+    return value;
+}
+function isImportance(value) {
+    return value === "featured" || value === "background";
+}
+function isRoleType(value) {
+    return value === "主角" || value === "配角";
+}
+function isNonActorSpeakerKind(value) {
+    return value === "system" || value === "broadcast" || value === "offscreen" || value === "group";
+}
+function isAssetKind(value) {
+    return value === "actor" || value === "location" || value === "prop";
+}
+function parsePositiveInteger(raw, source, label, allowZero) {
+    if (!/^\d+$/.test(raw)) {
+        throw authoringError(`${label} must be an integer.`, source, raw || "<empty>", `Use ${allowZero ? "a non-negative" : "a positive"} integer.`);
+    }
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || (allowZero ? value < 0 : value < 1)) {
+        throw authoringError(`${label} is out of range.`, source, raw, `Use ${allowZero ? "a non-negative" : "a positive"} safe integer.`);
+    }
+    return value;
+}
+function parseTag(raw, line) {
+    const text = raw.trim();
+    if (!text.startsWith("<"))
+        return null;
+    const source = { line, column: raw.indexOf("<") + 1 };
+    const closingMatch = /^<\/([a-z-]+)>$/.exec(text);
+    if (closingMatch)
+        return { name: closingMatch[1], closing: true, attrs: new Map(), source };
+    const openMatch = /^<([a-z-]+)(?: ([^>]+))?>$/.exec(text);
+    if (!openMatch) {
+        throw authoringError("Block tag syntax is invalid.", source, raw, "Use <name key=value> or </name> on its own line.");
+    }
+    const attrs = new Map();
+    const attrText = openMatch[2] ?? "";
+    if (attrText) {
+        for (const token of attrText.split(" ")) {
+            if (!token) {
+                throw authoringError("Block attributes must use one space separators.", source, raw, "Use canonical key=value attributes separated by one space.");
+            }
+            const match = /^([a-z]+)=([A-Za-z0-9_./#:-]+)$/.exec(token);
+            if (!match) {
+                throw authoringError("Block attribute syntax is invalid.", source, token, "Use unquoted canonical key=value attributes.");
+            }
+            if (attrs.has(match[1])) {
+                throw authoringError("Block attribute is duplicated.", source, match[1], "Keep exactly one value for each attribute.");
+            }
+            attrs.set(match[1], match[2]);
+        }
+    }
+    return { name: openMatch[1], closing: false, attrs, source };
+}
+function assertAttributes(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) {
+        throw authoringError(`Attributes for <${tag.name}> are invalid.`, tag.source, `missing=${missing.join(",") || "-"} unknown=${unknown.join(",") || "-"}`, `Use ${[...required, ...optional].map((key) => `${key}=...`).join(" ")}.`);
+    }
+}
+function speakerFromSlot(raw, source) {
+    if (!raw) {
+        throw authoringError("Speaker is required.", source, "<empty>", "Use act_ID[/state_ID] or system|broadcast|offscreen|group[:label].");
+    }
+    const slash = raw.indexOf("/");
+    const actorId = slash >= 0 ? raw.slice(0, slash) : raw;
+    if (/^act_[A-Za-z0-9_-]+$/.test(actorId)) {
+        if (slash < 0)
+            return { actor_id: actorId };
+        const stateId = raw.slice(slash + 1);
+        if (!stateId || stateId.includes("/")) {
+            throw authoringError("Actor speaker state is invalid.", source, raw, "Use act_ID/state_ID.");
+        }
+        return { actor_id: actorId, state_id: stateId };
+    }
+    const colon = raw.indexOf(":");
+    const kind = colon >= 0 ? raw.slice(0, colon) : raw;
+    if (!NON_ACTOR_SPEAKER_KIND_SET.has(kind) || !isNonActorSpeakerKind(kind)) {
+        throw authoringError("Speaker kind is invalid.", source, raw, "Use an actor ID or system, broadcast, offscreen, or group.");
+    }
+    if (colon < 0)
+        return { kind };
+    return { kind, label: raw.slice(colon + 1) };
+}
+function actionFromRecord(record, modifiers) {
+    const map = {
+        act: "action",
+        dlg: "dialogue",
+        think: "inner_thought",
+        trans: "transition",
+    };
+    const type = map[record.type];
+    if (type === undefined || !ACTION_TYPE_SET.has(type)) {
+        throw authoringError("Body record type is invalid.", record.source, record.type, "Use [act], [dlg], [think], or [trans].");
+    }
+    const action = { type, content: record.content };
+    if (type === "dialogue" || type === "inner_thought") {
+        if (record.slots.length < 1 || record.slots.length > 2) {
+            throw authoringError("Speaker record slots are invalid.", record.source, record.slots.join("|"), `Use [${record.type}|speaker|emotion?].`);
+        }
+        action.speaker = speakerFromSlot(record.slots[0], record.source);
+        if (record.slots.length === 2)
+            action.emotion = record.slots[1];
+    }
+    else {
+        if (record.slots.length > 1) {
+            throw authoringError("Body record slots are invalid.", record.source, record.slots.join("|"), `Use [${record.type}|emotion?].`);
+        }
+        if (record.slots.length === 1)
+            action.emotion = record.slots[0];
+    }
+    const extend = extensionOrUndefined(modifiers);
+    if (extend !== undefined)
+        action.extend = extend;
+    if (modifiers.aliasesPresent) {
+        throw authoringError("Alias cannot modify an action.", modifiers.source ?? record.source, modifiers.aliases.join(","), "Use [alias] only before an asset declaration.");
+    }
+    if (modifiers.prompt !== undefined)
+        action.transition_prompt = modifiers.prompt;
+    return action;
+}
+class Parser {
+    lines;
+    index = 0;
+    constructor(text) {
+        this.lines = text.replace(/\r\n?/g, "\n").split("\n");
+    }
+    parse() {
+        this.skipBlank();
+        const root = this.takeOpen("authoring");
+        assertAttributes(root, ["version"]);
+        if (root.attrs.get("version") !== "1") {
+            throw authoringError("Authoring version is unsupported.", root.source, root.attrs.get("version") ?? "<missing>", "Use <authoring version=1>.");
+        }
+        const declarations = [];
+        const targets = [];
+        let seenTarget = false;
+        let pending = emptyModifiers();
+        while (true) {
+            this.skipBlank();
+            if (this.peekClose("authoring")) {
+                if (hasModifiers(pending))
+                    this.throwDangling(pending);
+                this.takeClose("authoring");
+                break;
+            }
+            const next = this.peekSemantic();
+            if (next === null)
+                throw this.eofError("authoring");
+            if (next.record?.type === "extensions" || next.record?.type === "extend") {
+                pending = this.addModifier(pending, this.takeRecord());
+                continue;
+            }
+            if (next.tag?.name === "create" && !next.tag.closing) {
+                if (seenTarget)
+                    throw authoringError("<create> must precede every target.", next.tag.source, "<create>", "Move the single <create> block before the targets.");
+                if (hasModifiers(pending))
+                    this.throwUnsupportedModifiers(pending, "create");
+                declarations.push(...this.parseCreate());
+                seenTarget = true;
+                continue;
+            }
+            seenTarget = true;
+            targets.push(this.parseTarget(pending));
+            pending = emptyModifiers();
+        }
+        this.skipBlank();
+        if (this.index < this.lines.length) {
+            const source = { line: this.index + 1, column: 1 };
+            throw authoringError("Content exists after </authoring>.", source, this.lines[this.index], "Remove content outside the root block.");
+        }
+        if (targets.length === 0) {
+            throw authoringError("Authoring file has no target.", root.source, "<authoring>", "Add one or more homogeneous target blocks.");
+        }
+        const targetKind = targets[0].kind;
+        const mixed = targets.find((target) => target.kind !== targetKind);
+        if (mixed !== undefined) {
+            throw authoringError("Authoring targets are not homogeneous.", mixed.source, mixed.kind, `Keep only ${targetKind} targets in this file.`);
+        }
+        if (targetKind === "script" && targets.length !== 1) {
+            throw authoringError("A script authoring file has exactly one target.", targets[1].source, "second <script>", "Keep one <script> target.");
+        }
+        return { version: 1, declarations, targets, targetKind };
+    }
+    parseCreate() {
+        const tag = this.takeOpen("create");
+        assertAttributes(tag, []);
+        const declarations = [];
+        let pending = emptyModifiers();
+        while (true) {
+            this.skipBlank();
+            if (this.peekClose("create")) {
+                if (hasModifiers(pending))
+                    this.throwDangling(pending);
+                this.takeClose("create");
+                return declarations;
+            }
+            const record = this.takeRecord();
+            if (record.type === "extensions" || record.type === "extend" || record.type === "aliases" || record.type === "alias" || record.type === "prompt") {
+                pending = this.addModifier(pending, record);
+                continue;
+            }
+            if (record.type === "actor") {
+                if (record.slots.length < 3 || record.slots.length > 4) {
+                    throw authoringError("Actor declaration slots are invalid.", record.source, record.slots.join("|"), "Use [actor|id|name|importance|role?] description.");
+                }
+                const [actorId, actorName, importance, role] = record.slots;
+                if (!actorId || !actorName || !importance || !IMPORTANCE_TIER_SET.has(importance) || !isImportance(importance)) {
+                    throw authoringError("Actor declaration is invalid.", record.source, record.slots.join("|"), "Provide id, name, and featured|background importance.");
+                }
+                if (role !== undefined && (!ROLE_TYPE_SET.has(role) || !isRoleType(role))) {
+                    throw authoringError("Actor role is invalid.", record.source, role, "Use 主角 or 配角, or omit the slot.");
+                }
+                const value = {
+                    actor_id: actorId,
+                    actor_name: actorName,
+                    importance,
+                    description: record.content,
+                    states: [],
+                };
+                if (role !== undefined)
+                    value.role_type = role;
+                if (pending.aliasesPresent)
+                    value.aliases = [...pending.aliases];
+                const extend = extensionOrUndefined(pending);
+                if (extend !== undefined)
+                    value.extend = extend;
+                if (pending.prompt !== undefined)
+                    this.throwUnsupportedModifiers(pending, "actor");
+                declarations.push({ declarationKind: "actor", value, source: record.source });
+                pending = emptyModifiers();
+                continue;
+            }
+            if (record.type === "location" || record.type === "prop") {
+                if (record.slots.length !== 3) {
+                    throw authoringError(`${record.type} declaration slots are invalid.`, record.source, record.slots.join("|"), `Use [${record.type}|id|name|importance] description.`);
+                }
+                const [id, name, importance] = record.slots;
+                if (!id || !name || !importance || !IMPORTANCE_TIER_SET.has(importance) || !isImportance(importance)) {
+                    throw authoringError(`${record.type} declaration is invalid.`, record.source, record.slots.join("|"), "Provide id, name, and featured|background importance.");
+                }
+                if (pending.prompt !== undefined)
+                    this.throwUnsupportedModifiers(pending, record.type);
+                const extend = extensionOrUndefined(pending);
+                if (record.type === "location") {
+                    const value = {
+                        location_id: id,
+                        location_name: name,
+                        importance,
+                        description: record.content,
+                        states: [],
+                    };
+                    if (pending.aliasesPresent)
+                        value.aliases = [...pending.aliases];
+                    if (extend !== undefined)
+                        value.extend = extend;
+                    declarations.push({ declarationKind: "location", value, source: record.source });
+                }
+                else {
+                    const value = {
+                        prop_id: id,
+                        prop_name: name,
+                        importance,
+                        description: record.content,
+                        states: [],
+                    };
+                    if (pending.aliasesPresent)
+                        value.aliases = [...pending.aliases];
+                    if (extend !== undefined)
+                        value.extend = extend;
+                    declarations.push({ declarationKind: "prop", value, source: record.source });
+                }
+                pending = emptyModifiers();
+                continue;
+            }
+            if (record.type === "state") {
+                if (record.slots.length !== 3) {
+                    throw authoringError("State declaration slots are invalid.", record.source, record.slots.join("|"), "Use [state|kind:asset_id|state_id|state_name] description.");
+                }
+                if (pending.aliasesPresent || pending.prompt !== undefined)
+                    this.throwUnsupportedModifiers(pending, "state");
+                const [owner, stateId, stateName] = record.slots;
+                const ownerMatch = /^(actor|location|prop):(.+)$/.exec(owner ?? "");
+                const ownerKind = ownerMatch?.[1] ?? "";
+                if (!ownerMatch || !isAssetKind(ownerKind) || !stateId || !stateName) {
+                    throw authoringError("State declaration is invalid.", record.source, record.slots.join("|"), "Use a typed owner and non-empty state ID/name.");
+                }
+                const value = { state_id: stateId, state_name: stateName, description: record.content };
+                const extend = extensionOrUndefined(pending);
+                if (extend !== undefined)
+                    value.extend = extend;
+                declarations.push({
+                    declarationKind: "state",
+                    ownerKind,
+                    ownerId: ownerMatch[2],
+                    value,
+                    source: record.source,
+                });
+                pending = emptyModifiers();
+                continue;
+            }
+            throw authoringError("Record is not allowed in <create>.", record.source, record.type, "Use actor, location, prop, state, or a supported prefix modifier.");
+        }
+    }
+    parseTarget(modifiers) {
+        const tag = this.peekTag();
+        if (tag === null || tag.closing) {
+            const source = tag?.source ?? { line: this.index + 1, column: 1 };
+            throw authoringError("Expected a target block.", source, this.lines[this.index] ?? "<eof>", "Add a supported target block.");
+        }
+        if (modifiers.aliasesPresent || modifiers.prompt !== undefined)
+            this.throwUnsupportedModifiers(modifiers, tag.name);
+        switch (tag.name) {
+            case "script": return this.parseScript(modifiers);
+            case "episode": return { kind: "episode", value: this.parseEpisode(modifiers), source: tag.source, ...(extensionOrUndefined(modifiers) ? { extend: extensionOrUndefined(modifiers) } : {}) };
+            case "episode-span": return this.parseEpisodeSpan(modifiers);
+            case "scene": {
+                assertAttributes(tag, ["id", "parent"]);
+                const parent = tag.attrs.get("parent");
+                return { kind: "scene", parent, value: this.parseScene(modifiers, true), source: tag.source, ...(extensionOrUndefined(modifiers) ? { extend: extensionOrUndefined(modifiers) } : {}) };
+            }
+            case "scene-span": return this.parseSceneSpan(modifiers);
+            case "action-span": return this.parseActionSpan(modifiers);
+            default:
+                throw authoringError("Unknown target block.", tag.source, tag.name, "Use script, episode, episode-span, scene, scene-span, or action-span.");
+        }
+    }
+    parseScript(modifiers) {
+        const tag = this.takeOpen("script");
+        assertAttributes(tag, []);
+        const recordOrder = ["title", "worldview", "worldview-raw", "style", "synopsis", "logline", "theme", "main-characters", "main-character"];
+        const values = new Map();
+        const mainCharacters = [];
+        const episodes = [];
+        let lastRecord = -1;
+        let episodesStarted = false;
+        let pending = emptyModifiers();
+        while (true) {
+            this.skipBlank();
+            if (this.peekClose("script")) {
+                if (hasModifiers(pending))
+                    this.throwDangling(pending);
+                this.takeClose("script");
+                break;
+            }
+            const next = this.peekSemantic();
+            if (next?.record !== undefined) {
+                const record = this.takeRecord();
+                if (record.type === "extensions" || record.type === "extend" || record.type === "aliases" || record.type === "alias" || record.type === "prompt") {
+                    pending = this.addModifier(pending, record);
+                    continue;
+                }
+                if (hasModifiers(pending))
+                    this.throwUnsupportedModifiers(pending, record.type);
+                const order = recordOrder.indexOf(record.type);
+                const repeatedMainCharacter = record.type === "main-character";
+                if (episodesStarted || order < 0 || order < lastRecord || (!repeatedMainCharacter && values.has(record.type))) {
+                    throw authoringError("Metadata record in <script> is invalid or out of order.", record.source, record.type, `Use ${recordOrder.join(", ")} in canonical order before episode blocks.`);
+                }
+                lastRecord = order;
+                if (record.type === "main-characters") {
+                    if (record.slots.length !== 0 || record.content !== "") {
+                        throw authoringError("Main characters marker is invalid.", record.source, record.content, "Use [main-characters] with no slots or content.");
+                    }
+                    values.set(record.type, "");
+                }
+                else if (repeatedMainCharacter) {
+                    if (record.slots.length !== 2 || !record.slots[0] || !record.slots[1] || record.content !== "") {
+                        throw authoringError("Main character record is invalid.", record.source, record.slots.join("|"), "Use [main-character|name|role] with no content.");
+                    }
+                    mainCharacters.push({ name: record.slots[0], role: record.slots[1] });
+                }
+                else {
+                    if (record.slots.length !== 0) {
+                        throw authoringError("Script metadata record has unexpected slots.", record.source, record.slots.join("|"), `Use [${record.type}] content.`);
+                    }
+                    values.set(record.type, record.content);
+                }
+                continue;
+            }
+            if (next?.tag === undefined || next.tag.closing || next.tag.name !== "episode") {
+                const source = next?.tag?.source ?? { line: this.index + 1, column: 1 };
+                throw authoringError("Unexpected member in <script>.", source, this.lines[this.index] ?? "<eof>", "Use metadata records followed by <episode> blocks.");
+            }
+            episodesStarted = true;
+            episodes.push(this.parseEpisode(pending));
+            pending = emptyModifiers();
+        }
+        const title = this.requiredMetadata(values, "title", tag.source);
+        const worldview = this.requiredMetadata(values, "worldview", tag.source);
+        const style = this.requiredMetadata(values, "style", tag.source);
+        const extend = extensionOrUndefined(modifiers);
+        return {
+            kind: "script",
+            title,
+            worldview,
+            style,
+            ...(values.get("worldview-raw") !== undefined ? { worldviewRaw: values.get("worldview-raw") } : {}),
+            ...(values.get("synopsis") !== undefined ? { synopsis: values.get("synopsis") } : {}),
+            ...(values.get("logline") !== undefined ? { logline: values.get("logline") } : {}),
+            ...(values.get("theme") !== undefined ? { theme: values.get("theme") } : {}),
+            ...(values.has("main-characters") || mainCharacters.length > 0 ? { mainCharacters } : {}),
+            episodes,
+            source: tag.source,
+            ...(extend !== undefined ? { extend } : {}),
+        };
+    }
+    parseEpisode(modifiers) {
+        const tag = this.takeOpen("episode");
+        assertAttributes(tag, ["id"]);
+        if (modifiers.aliasesPresent || modifiers.prompt !== undefined)
+            this.throwUnsupportedModifiers(modifiers, "episode");
+        const metadata = this.parseMetadataAndChildren("episode", ["title", "synopsis"], "scene", (childModifiers) => this.parseScene(childModifiers, false));
+        const episode = { episode_id: tag.attrs.get("id"), scenes: metadata.children };
+        if (metadata.values.has("title"))
+            episode.title = metadata.values.get("title");
+        if (metadata.values.has("synopsis"))
+            episode.synopsis = metadata.values.get("synopsis");
+        const extend = extensionOrUndefined(modifiers);
+        if (extend !== undefined)
+            episode.extend = extend;
+        return episode;
+    }
+    parseScene(modifiers, root) {
+        const tag = this.takeOpen("scene");
+        assertAttributes(tag, root ? ["id", "parent"] : ["id"]);
+        if (modifiers.aliasesPresent || modifiers.prompt !== undefined)
+            this.throwUnsupportedModifiers(modifiers, "scene");
+        let environment;
+        let location;
+        const actors = [];
+        const props = [];
+        let phase = "environment";
+        let actions;
+        while (true) {
+            this.skipBlank();
+            if (this.peekClose("scene")) {
+                this.takeClose("scene");
+                break;
+            }
+            const next = this.peekSemantic();
+            if (next?.tag?.name === "body" && !next.tag.closing) {
+                if (phase === "body")
+                    throw authoringError("Scene has more than one body.", next.tag.source, "<body>", "Keep exactly one <body>.");
+                phase = "body";
+                actions = this.parseBody();
+                continue;
+            }
+            if (next?.record === undefined) {
+                const source = next?.tag?.source ?? { line: this.index + 1, column: 1 };
+                throw authoringError("Only scene records and <body> are allowed here.", source, this.lines[this.index] ?? "<eof>", "Use environment, location, cast, prop, then body.");
+            }
+            const record = this.takeRecord();
+            if (record.type === "extensions" || record.type === "extend" || record.type === "aliases" || record.type === "alias" || record.type === "prompt") {
+                throw authoringError("Scene prefix modifier must directly precede <scene>.", record.source, record.type, "Move the modifier before the <scene> opening tag.");
+            }
+            if (record.type === "environment") {
+                if (phase !== "environment" || environment !== undefined || record.slots.length > 2) {
+                    throw authoringError("Environment record is out of order or invalid.", record.source, record.slots.join("|"), "Place at most one [environment|space?|time?] first.");
+                }
+                environment = {};
+                if (record.slots.length >= 1 && record.slots[0] !== "")
+                    environment.space = record.slots[0];
+                if (record.slots.length >= 2 && record.slots[1] !== "")
+                    environment.time = record.slots[1];
+                continue;
+            }
+            if (record.type === "location") {
+                if (phase === "cast" || phase === "prop" || phase === "body" || location !== undefined || record.slots.length > 2) {
+                    throw authoringError("Location record is out of order or invalid.", record.source, record.slots.join("|"), "Place exactly one [location|id?|state?] before cast.");
+                }
+                phase = "location";
+                const id = record.slots[0];
+                if (id === undefined || id === "")
+                    location = null;
+                else
+                    location = record.slots.length === 2 ? { location_id: id, state_id: record.slots[1] } : { location_id: id };
+                continue;
+            }
+            if (record.type === "cast") {
+                if (location === undefined || phase === "prop" || phase === "body" || record.slots.length < 1 || record.slots.length > 2 || !record.slots[0]) {
+                    throw authoringError("Cast record is out of order or invalid.", record.source, record.slots.join("|"), "Place [cast|actor_id|state_id?] after location and before props.");
+                }
+                phase = "cast";
+                actors.push(record.slots.length === 2 ? { actor_id: record.slots[0], state_id: record.slots[1] } : { actor_id: record.slots[0] });
+                continue;
+            }
+            if (record.type === "prop") {
+                if (location === undefined || phase === "body" || record.slots.length < 1 || record.slots.length > 2 || !record.slots[0]) {
+                    throw authoringError("Prop record is out of order or invalid.", record.source, record.slots.join("|"), "Place [prop|prop_id|state_id?] after cast and before body.");
+                }
+                phase = "prop";
+                props.push(record.slots.length === 2 ? { prop_id: record.slots[0], state_id: record.slots[1] } : { prop_id: record.slots[0] });
+                continue;
+            }
+            throw authoringError("Record is not allowed in a scene header.", record.source, record.type, "Use environment, location, cast, prop, or body records.");
+        }
+        if (location === undefined)
+            throw authoringError("Scene location record is missing.", tag.source, `<scene id=${tag.attrs.get("id")}>`, "Add [location] or [location|loc_ID|state_ID].");
+        if (actions === undefined)
+            throw authoringError("Scene body is missing.", tag.source, `<scene id=${tag.attrs.get("id")}>`, "Add one <body> block.");
+        const scene = { scene_id: tag.attrs.get("id"), location, actors, props, actions };
+        if (environment !== undefined)
+            scene.environment = environment;
+        const extend = extensionOrUndefined(modifiers);
+        if (extend !== undefined)
+            scene.extend = extend;
+        return scene;
+    }
+    parseBody() {
+        const tag = this.takeOpen("body");
+        assertAttributes(tag, []);
+        const actions = [];
+        let pending = emptyModifiers();
+        while (true) {
+            this.skipBlank();
+            if (this.peekClose("body")) {
+                if (hasModifiers(pending))
+                    this.throwDangling(pending);
+                this.takeClose("body");
+                return actions;
+            }
+            const record = this.takeRecord();
+            if (record.type === "extensions" || record.type === "extend" || record.type === "aliases" || record.type === "prompt" || record.type === "alias") {
+                pending = this.addModifier(pending, record);
+                continue;
+            }
+            actions.push(actionFromRecord(record, pending));
+            pending = emptyModifiers();
+        }
+    }
+    parseEpisodeSpan(modifiers) {
+        const tag = this.takeOpen("episode-span");
+        assertAttributes(tag, ["from", "through"]);
+        const episodes = this.parseOnlyChildren("episode-span", "episode", (childModifiers) => this.parseEpisode(childModifiers));
+        const extend = extensionOrUndefined(modifiers);
+        return {
+            kind: "episode-span",
+            from: tag.attrs.get("from"),
+            through: tag.attrs.get("through"),
+            episodes,
+            source: tag.source,
+            ...(extend !== undefined ? { extend } : {}),
+        };
+    }
+    parseSceneSpan(modifiers) {
+        const tag = this.takeOpen("scene-span");
+        assertAttributes(tag, ["parent", "from", "through"]);
+        const scenes = this.parseOnlyChildren("scene-span", "scene", (childModifiers) => this.parseScene(childModifiers, false));
+        const extend = extensionOrUndefined(modifiers);
+        return {
+            kind: "scene-span",
+            parent: tag.attrs.get("parent"),
+            from: tag.attrs.get("from"),
+            through: tag.attrs.get("through"),
+            scenes,
+            source: tag.source,
+            ...(extend !== undefined ? { extend } : {}),
+        };
+    }
+    parseActionSpan(modifiers) {
+        const tag = this.takeOpen("action-span");
+        assertAttributes(tag, ["parent", "from", "through"]);
+        this.skipBlank();
+        const actions = this.parseBody();
+        this.skipBlank();
+        this.takeClose("action-span");
+        const extend = extensionOrUndefined(modifiers);
+        return {
+            kind: "action-span",
+            parent: tag.attrs.get("parent"),
+            from: parsePositiveInteger(tag.attrs.get("from"), tag.source, "action-span from", true),
+            through: parsePositiveInteger(tag.attrs.get("through"), tag.source, "action-span through", true),
+            actions,
+            source: tag.source,
+            ...(extend !== undefined ? { extend } : {}),
+        };
+    }
+    parseMetadataAndChildren(block, recordOrder, childName, parseChild) {
+        const values = new Map();
+        const children = [];
+        let lastRecord = -1;
+        let childrenStarted = false;
+        let pending = emptyModifiers();
+        while (true) {
+            this.skipBlank();
+            if (this.peekClose(block)) {
+                if (hasModifiers(pending))
+                    this.throwDangling(pending);
+                this.takeClose(block);
+                return { values, children };
+            }
+            const next = this.peekSemantic();
+            if (next?.record !== undefined) {
+                const record = this.takeRecord();
+                if (record.type === "extensions" || record.type === "extend" || record.type === "aliases" || record.type === "alias" || record.type === "prompt") {
+                    pending = this.addModifier(pending, record);
+                    continue;
+                }
+                if (hasModifiers(pending))
+                    this.throwUnsupportedModifiers(pending, record.type);
+                const order = recordOrder.indexOf(record.type);
+                if (childrenStarted || order < 0 || order < lastRecord || values.has(record.type) || record.slots.length !== 0) {
+                    throw authoringError(`Metadata record in <${block}> is invalid or out of order.`, record.source, record.type, `Use each of ${recordOrder.join(", ")} at most once in canonical order before child blocks.`);
+                }
+                lastRecord = order;
+                values.set(record.type, record.content);
+                continue;
+            }
+            const tag = next?.tag;
+            if (tag === undefined || tag.closing || tag.name !== childName) {
+                const source = tag?.source ?? { line: this.index + 1, column: 1 };
+                throw authoringError(`Unexpected member in <${block}>.`, source, this.lines[this.index] ?? "<eof>", `Use metadata records followed by <${childName}> blocks.`);
+            }
+            childrenStarted = true;
+            children.push(parseChild(pending));
+            pending = emptyModifiers();
+        }
+    }
+    parseOnlyChildren(block, childName, parseChild) {
+        const children = [];
+        let pending = emptyModifiers();
+        while (true) {
+            this.skipBlank();
+            if (this.peekClose(block)) {
+                if (hasModifiers(pending))
+                    this.throwDangling(pending);
+                this.takeClose(block);
+                return children;
+            }
+            const next = this.peekSemantic();
+            if (next?.record?.type === "extensions" || next?.record?.type === "extend") {
+                pending = this.addModifier(pending, this.takeRecord());
+                continue;
+            }
+            if (next?.tag === undefined || next.tag.closing || next.tag.name !== childName) {
+                const source = next?.tag?.source ?? next?.record?.source ?? { line: this.index + 1, column: 1 };
+                throw authoringError(`Only <${childName}> children are allowed in <${block}>.`, source, this.lines[this.index] ?? "<eof>", `Add complete <${childName}> blocks.`);
+            }
+            children.push(parseChild(pending));
+            pending = emptyModifiers();
+        }
+    }
+    addModifier(modifiers, record) {
+        const next = {
+            extend: { ...modifiers.extend },
+            extendPresent: modifiers.extendPresent,
+            aliases: [...modifiers.aliases],
+            aliasesPresent: modifiers.aliasesPresent,
+            phase: modifiers.phase,
+            ...(modifiers.prompt !== undefined ? { prompt: modifiers.prompt } : {}),
+            source: modifiers.source ?? record.source,
+        };
+        if (record.type === "extensions") {
+            if (next.phase !== "extend" || next.extendPresent || record.slots.length !== 0 || record.content !== "") {
+                throw authoringError("Extensions marker is invalid or out of order.", record.source, record.content || "<empty>", "Use one [extensions] marker before extension records.");
+            }
+            next.extendPresent = true;
+            return next;
+        }
+        if (record.type === "extend") {
+            if (next.phase !== "extend" || record.slots.length !== 1 || !record.slots[0]) {
+                throw authoringError("Extend modifier is invalid or out of order.", record.source, record.slots.join("|"), "Place unique [extend|key] records first.");
+            }
+            const key = record.slots[0];
+            if (Object.hasOwn(next.extend, key)) {
+                throw authoringError("Extend key is duplicated.", record.source, key, "Keep one value for each extension key.");
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(record.content);
+            }
+            catch {
+                throw authoringError("Extension value is not valid JSON.", record.source, record.content, "Use one canonical JSON value.");
+            }
+            if (!isJsonValue(parsed)) {
+                throw authoringError("Extension value is not JSON-compatible.", record.source, record.content, "Use string, number, boolean, null, array, or object.");
+            }
+            next.extendPresent = true;
+            next.extend[key] = canonicalJson(parsed);
+            return next;
+        }
+        if (record.type === "aliases") {
+            if (next.phase !== "extend" || next.aliasesPresent || record.slots.length !== 0 || record.content !== "") {
+                throw authoringError("Aliases marker is invalid or out of order.", record.source, record.content || "<empty>", "Use one [aliases] marker after extensions and before alias records.");
+            }
+            next.phase = "alias";
+            next.aliasesPresent = true;
+            return next;
+        }
+        if (record.type === "alias") {
+            if (next.phase === "prompt" || record.slots.length !== 0 || !record.content) {
+                throw authoringError("Alias modifier is invalid or out of order.", record.source, record.content || "<empty>", "Place non-empty [alias] records after extensions and before prompt.");
+            }
+            next.phase = "alias";
+            next.aliasesPresent = true;
+            if (next.aliases.includes(record.content)) {
+                throw authoringError("Alias is duplicated.", record.source, record.content, "Keep each alias once.");
+            }
+            next.aliases.push(record.content);
+            return next;
+        }
+        if (record.type === "prompt") {
+            if (next.prompt !== undefined || record.slots.length !== 3 || record.slots.some((slot) => !slot)) {
+                throw authoringError("Prompt modifier is invalid.", record.source, record.slots.join("|"), "Use one [prompt|target|process|contrast] after extensions and aliases.");
+            }
+            if (!/^(?:actor:act_|location:loc_|prop:prp_)[A-Za-z0-9_-]+$/.test(record.slots[0])) {
+                throw authoringError("Prompt target is invalid.", record.source, record.slots[0], "Use actor:act_ID, location:loc_ID, or prop:prp_ID.");
+            }
+            next.phase = "prompt";
+            next.prompt = { target: record.slots[0], process: record.slots[1], contrast: record.slots[2] };
+            return next;
+        }
+        throw authoringError("Unknown prefix modifier.", record.source, record.type, "Use extend, alias, or prompt.");
+    }
+    requiredMetadata(values, key, source) {
+        const value = values.get(key);
+        if (value === undefined)
+            throw authoringError(`Script ${key} record is missing.`, source, `<script>`, `Add [${key}] in canonical metadata order.`);
+        return value;
+    }
+    peekSemantic() {
+        this.skipBlank();
+        if (this.index >= this.lines.length)
+            return null;
+        const raw = this.lines[this.index];
+        const tag = parseTag(raw, this.index + 1);
+        if (tag !== null)
+            return { tag };
+        if (raw.trimStart().startsWith("["))
+            return { record: parseBracketRecord(raw, this.index + 1) };
+        const source = { line: this.index + 1, column: Math.max(1, raw.search(/\S/) + 1) };
+        throw authoringError("Semantic line is neither a tag nor a bracket record.", source, raw, "Use only known tags, bracket records, or blank lines.");
+    }
+    peekTag() {
+        return this.peekSemantic()?.tag ?? null;
+    }
+    takeRecord() {
+        const item = this.peekSemantic();
+        if (item?.record === undefined) {
+            const source = item?.tag?.source ?? { line: this.index + 1, column: 1 };
+            throw authoringError("Expected a bracket record.", source, this.lines[this.index] ?? "<eof>", "Use the record required at this position.");
+        }
+        this.index += 1;
+        return item.record;
+    }
+    takeOpen(name) {
+        const tag = this.peekTag();
+        if (tag === null || tag.closing || tag.name !== name) {
+            const source = tag?.source ?? { line: this.index + 1, column: 1 };
+            throw authoringError(`Expected <${name}>.`, source, this.lines[this.index] ?? "<eof>", `Open <${name}> here.`);
+        }
+        this.index += 1;
+        return tag;
+    }
+    takeClose(name) {
+        const tag = this.peekTag();
+        if (tag === null || !tag.closing || tag.name !== name) {
+            const source = tag?.source ?? { line: this.index + 1, column: 1 };
+            throw authoringError(`Expected </${name}>.`, source, this.lines[this.index] ?? "<eof>", `Close the current <${name}> block.`);
+        }
+        this.index += 1;
+        return tag;
+    }
+    peekClose(name) {
+        const tag = this.peekTag();
+        return tag !== null && tag.closing && tag.name === name;
+    }
+    skipBlank() {
+        while (this.index < this.lines.length && this.lines[this.index].trim() === "")
+            this.index += 1;
+    }
+    eofError(block) {
+        return authoringError(`Unexpected end of file inside <${block}>.`, { line: this.lines.length, column: 1 }, "<eof>", `Add </${block}>.`);
+    }
+    throwDangling(modifiers) {
+        throw authoringError("Prefix modifier has no following node.", modifiers.source ?? { line: this.index + 1, column: 1 }, "dangling modifier", "Move it directly before a supported node.");
+    }
+    throwUnsupportedModifiers(modifiers, node) {
+        throw authoringError("Prefix modifier does not apply to this node.", modifiers.source ?? { line: this.index + 1, column: 1 }, node, "Remove the unsupported modifier or move it before a supported node.");
+    }
+}
+export function parseAuthoring(text) {
+    return new Parser(text).parse();
+}
+//# sourceMappingURL=parser.js.map