@alisio/plugin-thesis 0.1.0

package/dist/schemas.js

@@ -0,0 +1,1020 @@
+import { stringify as stringifyYaml } from "yaml";
+import { approaches, claimKinds, evidenceStatuses, evidenceTypes, permittedUses, reviewCategories, reviewRoutes, routeOfCategory, } from "./types.js";
+// biome-ignore lint/suspicious/noControlCharactersInRegex: control characters are what is stripped
+const controlPattern = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g;
+/** Child output is untrusted: remove control characters before any further use. */
+export function stripControl(text) {
+    return text.replace(controlPattern, "");
+}
+/**
+ * Parse a child's reply: a strict JSON document, or exactly one fenced `json` block. Anything else
+ * (prose around the JSON, several blocks) is rejected so the coordinator can retry with the error.
+ */
+export function parseChildJson(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        throw new Error("The child returned no output");
+    const fences = [...trimmed.matchAll(/```json\s*\n([\s\S]*?)\n```/g)];
+    let candidate = trimmed;
+    if (fences.length > 1)
+        throw new Error("The child returned more than one JSON block");
+    if (fences.length === 1) {
+        const [block, inner] = fences[0];
+        if (trimmed.replace(block, "").trim())
+            throw new Error("The child wrapped its JSON in extra prose");
+        candidate = inner.trim();
+    }
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        throw new Error("The child output is not valid JSON");
+    }
+}
+const domainPattern = /^[a-z][a-z0-9_]{1,40}$/;
+export function validateIntakeDraft(value) {
+    const errors = [];
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return { errors: ["IntakeDraft must be a JSON object"] };
+    }
+    const record = value;
+    for (const key of Object.keys(record)) {
+        if (!["titles", "domain", "approach", "notes"].includes(key))
+            errors.push(`Unknown field: ${key}`);
+    }
+    const titles = record.titles;
+    const cleanTitles = [];
+    if (!Array.isArray(titles) || titles.length < 1 || titles.length > 3) {
+        errors.push("titles must hold 1 to 3 working titles");
+    }
+    else {
+        for (const title of titles) {
+            const clean = typeof title === "string" ? stripControl(title).trim() : "";
+            if (!clean || clean.length > 200)
+                errors.push("each title must be 1 to 200 characters");
+            else
+                cleanTitles.push(clean);
+        }
+    }
+    const draft = { titles: cleanTitles };
+    if (record.domain !== undefined) {
+        if (typeof record.domain === "string" && domainPattern.test(record.domain))
+            draft.domain = record.domain;
+        else
+            errors.push("domain must be a snake_case id");
+    }
+    if (record.approach !== undefined) {
+        if (typeof record.approach === "string" &&
+            approaches.includes(record.approach)) {
+            draft.approach = record.approach;
+        }
+        else
+            errors.push(`approach must be one of: ${approaches.join(", ")}`);
+    }
+    if (record.notes !== undefined) {
+        if (typeof record.notes === "string" && record.notes.length <= 1000)
+            draft.notes = stripControl(record.notes);
+        else
+            errors.push("notes must be a string of at most 1000 characters");
+    }
+    return errors.length > 0 ? { errors } : { value: draft, errors };
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function record(value, path, allowed, errors) {
+    if (!isObject(value)) {
+        errors.push(`${path} must be a JSON object`);
+        return undefined;
+    }
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key))
+            errors.push(`${path}: unknown field ${key}`);
+    }
+    return value;
+}
+function text(source, key, path, errors, max, options = {}) {
+    const raw = source[key];
+    if (raw === undefined || raw === null) {
+        if (!options.optional)
+            errors.push(`${path}.${key} is required`);
+        return undefined;
+    }
+    if (typeof raw !== "string") {
+        errors.push(`${path}.${key} must be a string`);
+        return undefined;
+    }
+    const clean = stripControl(raw).trim();
+    if (clean.length < (options.min ?? 1) || clean.length > max) {
+        errors.push(`${path}.${key} must be ${options.min ?? 1} to ${max} characters (got ${clean.length})`);
+        return undefined;
+    }
+    return clean;
+}
+function list(source, key, path, errors, options) {
+    const raw = source[key];
+    if (raw === undefined && options.optional)
+        return [];
+    if (!Array.isArray(raw)) {
+        errors.push(`${path}.${key} must be a list`);
+        return undefined;
+    }
+    if (raw.length < (options.min ?? 0) || raw.length > options.max) {
+        errors.push(`${path}.${key} must hold ${options.min ?? 0} to ${options.max} items (got ${raw.length})`);
+        return undefined;
+    }
+    const out = [];
+    raw.forEach((entry, index) => {
+        const clean = typeof entry === "string" ? stripControl(entry).trim() : "";
+        if (!clean || clean.length > options.item) {
+            errors.push(`${path}.${key}[${index}] must be 1 to ${options.item} characters`);
+        }
+        else
+            out.push(clean);
+    });
+    return out;
+}
+function oneOf(source, key, path, errors, values, optional = false) {
+    const raw = source[key];
+    if (raw === undefined && optional)
+        return undefined;
+    if (typeof raw !== "string" || !values.includes(raw)) {
+        errors.push(`${path}.${key} must be one of: ${values.join(", ")}`);
+        return undefined;
+    }
+    return raw;
+}
+function integer(source, key, path, errors, min, max, optional = false) {
+    const raw = source[key];
+    if (raw === undefined && optional)
+        return undefined;
+    if (!Number.isInteger(raw) || raw < min || raw > max) {
+        errors.push(`${path}.${key} must be an integer from ${min} to ${max}`);
+        return undefined;
+    }
+    return raw;
+}
+const fold = (value) => value
+    .normalize("NFD")
+    .replace(/[̀-ͯ]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim();
+function finish(errors, value) {
+    return errors.length > 0 ? { errors } : { value, errors: [] };
+}
+const ethicsIds = [
+    "human_participants",
+    "minors",
+    "identifiable_personal_data",
+    "sensitive_data",
+    "intervention",
+    "risk_above_minimal",
+    "biological_samples",
+    "animals",
+    "communities",
+    "clinical_research",
+    "additional_institutional_rules",
+];
+export function validateProtocolDraft(value, context) {
+    const errors = [];
+    const top = record(value, "ProtocolDraft", [
+        "problem",
+        "researchQuestions",
+        "generalObjective",
+        "specificObjectives",
+        "justification",
+        "scope",
+        "limitations",
+        "hypotheses",
+        "methodology",
+        "ethics",
+        "openQuestions",
+    ], errors);
+    if (!top)
+        return { errors };
+    const problem = text(top, "problem", "ProtocolDraft", errors, 2000);
+    const researchQuestions = list(top, "researchQuestions", "ProtocolDraft", errors, {
+        min: 1,
+        max: 5,
+        item: 400,
+    });
+    const generalObjective = text(top, "generalObjective", "ProtocolDraft", errors, 400);
+    const specificObjectives = [];
+    if (!Array.isArray(top.specificObjectives) ||
+        top.specificObjectives.length < 2 ||
+        top.specificObjectives.length > 6) {
+        errors.push("ProtocolDraft.specificObjectives must hold 2 to 6 objectives");
+    }
+    else {
+        top.specificObjectives.forEach((entry, index) => {
+            const path = `specificObjectives[${index}]`;
+            const item = record(entry, path, ["verb", "object", "deliverable"], errors);
+            if (!item)
+                return;
+            const verb = text(item, "verb", path, errors, 40);
+            const object = text(item, "object", path, errors, 300);
+            const deliverable = text(item, "deliverable", path, errors, 300);
+            if (verb && /\s/.test(verb))
+                errors.push(`${path}.verb must be a single action verb`);
+            if (verb && object && deliverable)
+                specificObjectives.push({ verb, object, deliverable });
+        });
+    }
+    const justificationInput = record(top.justification, "justification", ["relevance", "novelty", "feasibility", "beneficiaries"], errors);
+    const justification = justificationInput
+        ? {
+            relevance: text(justificationInput, "relevance", "justification", errors, 1200) ?? "",
+            novelty: text(justificationInput, "novelty", "justification", errors, 1200) ?? "",
+            feasibility: text(justificationInput, "feasibility", "justification", errors, 1200) ?? "",
+            beneficiaries: text(justificationInput, "beneficiaries", "justification", errors, 1200) ?? "",
+        }
+        : undefined;
+    const scope = text(top, "scope", "ProtocolDraft", errors, 1500);
+    const limitations = list(top, "limitations", "ProtocolDraft", errors, {
+        max: 10,
+        item: 400,
+        optional: true,
+    });
+    const hypotheses = list(top, "hypotheses", "ProtocolDraft", errors, {
+        max: 6,
+        item: 400,
+        optional: true,
+    });
+    if (context.approach === "quantitative" && hypotheses && hypotheses.length === 0) {
+        errors.push("ProtocolDraft.hypotheses is required for a quantitative approach");
+    }
+    const methodInput = record(top.methodology, "methodology", ["design", "population", "instruments", "analysisPlan", "reportingGuideline"], errors);
+    let methodology;
+    if (methodInput) {
+        const design = text(methodInput, "design", "methodology", errors, 600);
+        const population = text(methodInput, "population", "methodology", errors, 600);
+        const instruments = list(methodInput, "instruments", "methodology", errors, {
+            max: 8,
+            item: 300,
+            optional: true,
+        });
+        const analysisPlan = text(methodInput, "analysisPlan", "methodology", errors, 1200);
+        let reportingGuideline = null;
+        if (methodInput.reportingGuideline !== undefined && methodInput.reportingGuideline !== null) {
+            reportingGuideline =
+                text(methodInput, "reportingGuideline", "methodology", errors, 100) ?? null;
+        }
+        if (design && population && instruments && analysisPlan) {
+            methodology = { design, population, instruments, analysisPlan, reportingGuideline };
+        }
+    }
+    const ethics = {};
+    const ethicsInput = record(top.ethics, "ethics", ethicsIds, errors);
+    if (ethicsInput) {
+        for (const id of ethicsIds) {
+            if (typeof ethicsInput[id] !== "boolean")
+                errors.push(`ethics.${id} must be true or false`);
+            else
+                ethics[id] = ethicsInput[id];
+        }
+    }
+    const openQuestions = list(top, "openQuestions", "ProtocolDraft", errors, {
+        max: 10,
+        item: 400,
+        optional: true,
+    });
+    if (!problem ||
+        !researchQuestions ||
+        !generalObjective ||
+        !justification ||
+        !scope ||
+        !limitations ||
+        !hypotheses ||
+        !methodology ||
+        !openQuestions) {
+        return { errors: errors.length ? errors : ["ProtocolDraft is incomplete"] };
+    }
+    return finish(errors, {
+        problem,
+        researchQuestions,
+        generalObjective,
+        specificObjectives,
+        justification,
+        scope,
+        limitations,
+        hypotheses,
+        methodology,
+        ethics,
+        openQuestions,
+    });
+}
+// ---------------------------------------------------------------------------------------------
+// OutlineDraft (structure only; coverage, order and cycles are the OUT checks)
+// ---------------------------------------------------------------------------------------------
+export const evidenceNeeds = [
+    "empirical",
+    "theoretical",
+    "normative",
+    "statistical",
+    "methodological",
+];
+const nodeKeys = [
+    "key",
+    "title",
+    "requiredKey",
+    "purpose",
+    "objectives",
+    "researchTopics",
+    "questionsToAnswer",
+    "evidenceNeeds",
+    "targetWords",
+    "dependsOn",
+    "children",
+];
+const keyPattern = /^[a-z][a-z0-9-]{0,40}$/;
+const requiredKeyPattern = /^[a-z][a-z0-9_]{0,40}$/;
+export const maxOutlineNodes = 150;
+export function validateOutlineDraft(value, context) {
+    const errors = [];
+    const top = record(value, "OutlineDraft", ["sections"], errors);
+    if (!top)
+        return { errors };
+    const seen = new Set();
+    const dependencies = [];
+    let count = 0;
+    const readNode = (entry, path, depth) => {
+        count += 1;
+        const node = record(entry, path, nodeKeys, errors);
+        if (!node)
+            return undefined;
+        const key = text(node, "key", path, errors, 41);
+        if (key) {
+            if (!keyPattern.test(key))
+                errors.push(`${path}.key must match ${keyPattern}`);
+            else if (seen.has(key))
+                errors.push(`${path}.key "${key}" is used twice`);
+            else
+                seen.add(key);
+        }
+        const title = text(node, "title", path, errors, 200);
+        const purpose = text(node, "purpose", path, errors, 300);
+        const requiredKey = text(node, "requiredKey", path, errors, 41, { optional: true });
+        if (requiredKey && !requiredKeyPattern.test(requiredKey))
+            errors.push(`${path}.requiredKey must be snake_case`);
+        const objectives = list(node, "objectives", path, errors, { max: 7, item: 10 });
+        for (const objective of objectives ?? []) {
+            if (!context.objectiveIds.includes(objective)) {
+                errors.push(`${path}.objectives lists unknown objective ${objective} (known: ${context.objectiveIds.join(", ")})`);
+            }
+        }
+        const researchTopics = list(node, "researchTopics", path, errors, {
+            min: 1,
+            max: 8,
+            item: 200,
+        });
+        const questionsToAnswer = list(node, "questionsToAnswer", path, errors, { max: 8, item: 300 });
+        const needs = list(node, "evidenceNeeds", path, errors, { max: 5, item: 20 });
+        for (const need of needs ?? []) {
+            if (!evidenceNeeds.includes(need)) {
+                errors.push(`${path}.evidenceNeeds: "${need}" is not one of ${evidenceNeeds.join(", ")}`);
+            }
+        }
+        const targetWords = integer(node, "targetWords", path, errors, 1, 100000);
+        const dependsOn = list(node, "dependsOn", path, errors, { max: 20, item: 41, optional: true });
+        if (dependsOn)
+            dependencies.push({ path, keys: dependsOn });
+        const children = [];
+        if (node.children !== undefined) {
+            if (!Array.isArray(node.children) || node.children.length > 99) {
+                errors.push(`${path}.children must be a list of at most 99 sections`);
+            }
+            else if (node.children.length > 0 && depth >= 3) {
+                errors.push(`${path}: sections nest at most three levels (SEC-01.01.01)`);
+            }
+            else {
+                node.children.forEach((child, index) => {
+                    const read = readNode(child, `${path}.children[${index}]`, depth + 1);
+                    if (read)
+                        children.push(read);
+                });
+            }
+        }
+        if (!key ||
+            !title ||
+            !purpose ||
+            !objectives ||
+            !researchTopics ||
+            !questionsToAnswer ||
+            !needs ||
+            targetWords === undefined ||
+            !dependsOn) {
+            return undefined;
+        }
+        return {
+            key,
+            title,
+            ...(requiredKey ? { requiredKey } : {}),
+            purpose,
+            objectives,
+            researchTopics,
+            questionsToAnswer,
+            evidenceNeeds: needs,
+            targetWords,
+            dependsOn,
+            children,
+        };
+    };
+    const sections = [];
+    if (!Array.isArray(top.sections) || top.sections.length < 1 || top.sections.length > 99) {
+        errors.push("OutlineDraft.sections must hold 1 to 99 sections");
+    }
+    else {
+        top.sections.forEach((entry, index) => {
+            const read = readNode(entry, `sections[${index}]`, 1);
+            if (read)
+                sections.push(read);
+        });
+    }
+    if (count > maxOutlineNodes)
+        errors.push(`The outline has ${count} sections; the limit is ${maxOutlineNodes}`);
+    for (const { path, keys } of dependencies) {
+        for (const key of keys) {
+            if (!seen.has(key))
+                errors.push(`${path}.dependsOn names unknown section key "${key}"`);
+        }
+    }
+    return finish(errors, { sections });
+}
+export function validateSearchPlan(value) {
+    const errors = [];
+    const top = record(value, "SearchPlan", ["queries", "yearRangeReason", "webToolsAvailable", "gaps"], errors);
+    if (!top)
+        return { errors };
+    const queries = [];
+    if (!Array.isArray(top.queries) || top.queries.length < 1 || top.queries.length > 24) {
+        errors.push("SearchPlan.queries must hold 1 to 24 queries");
+    }
+    else {
+        top.queries.forEach((entry, index) => {
+            const path = `queries[${index}]`;
+            const item = record(entry, path, ["topic", "query", "source", "language", "fromYear", "toYear", "limit"], errors);
+            if (!item)
+                return;
+            const topic = text(item, "topic", path, errors, 200);
+            const query = text(item, "query", path, errors, 512);
+            const source = oneOf(item, "source", path, errors, [
+                "openalex",
+                "crossref",
+                "arxiv",
+            ]);
+            const language = text(item, "language", path, errors, 3, { optional: true, min: 2 });
+            const fromYear = integer(item, "fromYear", path, errors, 1600, 2200, true);
+            const toYear = integer(item, "toYear", path, errors, 1600, 2200, true);
+            const limit = integer(item, "limit", path, errors, 1, 25, true) ?? 10;
+            if (fromYear !== undefined && toYear !== undefined && fromYear > toYear)
+                errors.push(`${path}: fromYear is after toYear`);
+            if (topic && query && source) {
+                queries.push({
+                    topic,
+                    query,
+                    source,
+                    ...(language ? { language: language.toLowerCase() } : {}),
+                    ...(fromYear !== undefined ? { fromYear } : {}),
+                    ...(toYear !== undefined ? { toYear } : {}),
+                    limit,
+                });
+            }
+        });
+    }
+    const reason = text(top, "yearRangeReason", "SearchPlan", errors, 300, { optional: true });
+    const gaps = list(top, "gaps", "SearchPlan", errors, { max: 10, item: 400, optional: true });
+    if (top.webToolsAvailable !== undefined && typeof top.webToolsAvailable !== "boolean") {
+        errors.push("SearchPlan.webToolsAvailable must be true or false");
+    }
+    return finish(errors, {
+        queries,
+        ...(reason ? { yearRangeReason: reason } : {}),
+        webToolsAvailable: top.webToolsAvailable === true,
+        gaps: gaps ?? [],
+    });
+}
+export function validateCandidateSet(value) {
+    const errors = [];
+    const top = record(value, "CandidateSet", ["candidates", "gaps", "webToolsUsed"], errors);
+    if (!top)
+        return { errors };
+    const candidates = [];
+    if (!Array.isArray(top.candidates) || top.candidates.length > 40) {
+        errors.push("CandidateSet.candidates must be a list of at most 40 candidates (it may be empty)");
+    }
+    else {
+        top.candidates.forEach((entry, index) => {
+            const path = `candidates[${index}]`;
+            const item = record(entry, path, [
+                "identifier",
+                "topic",
+                "reason",
+                "title",
+                "firstAuthor",
+                "year",
+                "type",
+                "url",
+                "language",
+            ], errors);
+            if (!item)
+                return;
+            const identifier = text(item, "identifier", path, errors, 2048);
+            const topic = text(item, "topic", path, errors, 200);
+            const reason = text(item, "reason", path, errors, 300);
+            const title = text(item, "title", path, errors, 500);
+            const firstAuthor = text(item, "firstAuthor", path, errors, 120, { optional: true });
+            const year = integer(item, "year", path, errors, 1000, 2200);
+            const type = oneOf(item, "type", path, errors, evidenceTypes, true);
+            const url = text(item, "url", path, errors, 500, { optional: true });
+            const language = text(item, "language", path, errors, 12, { optional: true });
+            if (identifier && topic && reason && title && year !== undefined) {
+                candidates.push({
+                    identifier,
+                    topic,
+                    reason,
+                    title,
+                    firstAuthor: firstAuthor ?? null,
+                    year,
+                    ...(type ? { type } : {}),
+                    ...(url ? { url } : {}),
+                    ...(language ? { language } : {}),
+                });
+            }
+        });
+    }
+    const gaps = list(top, "gaps", "CandidateSet", errors, { max: 10, item: 400, optional: true });
+    if (top.webToolsUsed !== undefined && typeof top.webToolsUsed !== "boolean") {
+        errors.push("CandidateSet.webToolsUsed must be true or false");
+    }
+    return finish(errors, { candidates, gaps: gaps ?? [], webToolsUsed: top.webToolsUsed === true });
+}
+/** `assigned` maps each candidate handle to the status code gave it; every handle must be appraised. */
+export function validateAppraisalSet(value, context) {
+    const errors = [];
+    const top = record(value, "AppraisalSet", ["appraisals"], errors);
+    if (!top)
+        return { errors };
+    const appraisals = [];
+    const seen = new Set();
+    if (!Array.isArray(top.appraisals) || top.appraisals.length > 60) {
+        errors.push("AppraisalSet.appraisals must be a list of at most 60 entries");
+    }
+    else {
+        top.appraisals.forEach((entry, index) => {
+            const path = `appraisals[${index}]`;
+            const item = record(entry, path, [
+                "handle",
+                "relevance",
+                "evidenceType",
+                "limitations",
+                "supports",
+                "location",
+                "permittedUse",
+                "status",
+            ], errors);
+            if (!item)
+                return;
+            const handle = text(item, "handle", path, errors, 20);
+            if (handle) {
+                if (!context.assigned.has(handle))
+                    errors.push(`${path}.handle "${handle}" is not one of: ${[...context.assigned.keys()].join(", ")}`);
+                else if (seen.has(handle))
+                    errors.push(`${path}.handle "${handle}" is appraised twice`);
+                else
+                    seen.add(handle);
+            }
+            const relevance = oneOf(item, "relevance", path, errors, ["high", "medium", "low"]);
+            const evidenceType = text(item, "evidenceType", path, errors, 80);
+            const limitations = list(item, "limitations", path, errors, { min: 1, max: 5, item: 300 });
+            const supports = list(item, "supports", path, errors, { max: 8, item: 200 });
+            const location = text(item, "location", path, errors, 200, { optional: true });
+            const uses = list(item, "permittedUse", path, errors, { min: 1, max: 4, item: 30 });
+            for (const use of uses ?? []) {
+                if (!permittedUses.includes(use))
+                    errors.push(`${path}.permittedUse: "${use}" is not one of ${permittedUses.join(", ")}`);
+            }
+            const status = oneOf(item, "status", path, errors, evidenceStatuses, true);
+            if (handle && status) {
+                const assigned = context.assigned.get(handle);
+                if (assigned && evidenceStatuses.indexOf(status) < evidenceStatuses.indexOf(assigned)) {
+                    errors.push(`${path}.status ${status} would upgrade ${assigned}; an appraisal may only downgrade a status`);
+                }
+            }
+            if (handle && relevance && evidenceType && limitations && supports && uses) {
+                appraisals.push({
+                    handle,
+                    relevance,
+                    evidenceType,
+                    limitations,
+                    supports,
+                    ...(location ? { location } : {}),
+                    permittedUse: uses,
+                    ...(status ? { status } : {}),
+                });
+            }
+        });
+    }
+    for (const handle of context.assigned.keys()) {
+        if (!seen.has(handle))
+            errors.push(`AppraisalSet is missing an appraisal for ${handle}`);
+    }
+    return finish(errors, { appraisals });
+}
+export function validateDossier(value, context) {
+    const errors = [];
+    const top = record(value, "Dossier", ["synthesis", "claims", "gaps"], errors);
+    if (!top)
+        return { errors };
+    const knownIds = new Set(context.evidenceIds);
+    const knownKeys = new Set(context.citeKeys);
+    const checkKeys = (path, content) => {
+        for (const match of content.matchAll(/@([a-z][a-z0-9]*\d{4}[a-z]?)\b/g)) {
+            if (!knownKeys.has(match[1]))
+                errors.push(`${path} cites unknown key @${match[1]}`);
+        }
+    };
+    const evidence = (item, path) => {
+        const ids = list(item, "evidence", path, errors, { max: 20, item: 20 });
+        for (const id of ids ?? [])
+            if (!knownIds.has(id))
+                errors.push(`${path}.evidence names unknown evidence id ${id}`);
+        return ids ?? [];
+    };
+    const synthesis = [];
+    if (!Array.isArray(top.synthesis) || top.synthesis.length > 12)
+        errors.push("Dossier.synthesis must be a list of at most 12 entries");
+    else {
+        top.synthesis.forEach((entry, index) => {
+            const path = `synthesis[${index}]`;
+            const item = record(entry, path, ["topic", "summary", "evidence"], errors);
+            if (!item)
+                return;
+            const topic = text(item, "topic", path, errors, 200);
+            const summary = text(item, "summary", path, errors, 1500);
+            const ids = evidence(item, path);
+            if (summary)
+                checkKeys(path, summary);
+            if (topic && summary)
+                synthesis.push({ topic, summary, evidence: ids });
+        });
+    }
+    const claims = [];
+    if (!Array.isArray(top.claims) || top.claims.length > 30)
+        errors.push("Dossier.claims must be a list of at most 30 entries");
+    else {
+        top.claims.forEach((entry, index) => {
+            const path = `claims[${index}]`;
+            const item = record(entry, path, ["text", "kind", "evidence", "topic"], errors);
+            if (!item)
+                return;
+            const claim = text(item, "text", path, errors, 400);
+            const kind = oneOf(item, "kind", path, errors, claimKinds);
+            const ids = evidence(item, path);
+            const topic = text(item, "topic", path, errors, 200, { optional: true });
+            if (claim)
+                checkKeys(path, claim);
+            if (claim && kind)
+                claims.push({ text: claim, kind, evidence: ids, ...(topic ? { topic } : {}) });
+        });
+    }
+    const gaps = [];
+    if (!Array.isArray(top.gaps) || top.gaps.length > 20)
+        errors.push("Dossier.gaps must be a list of at most 20 entries");
+    else {
+        top.gaps.forEach((entry, index) => {
+            const path = `gaps[${index}]`;
+            const item = record(entry, path, ["topic", "description", "critical"], errors);
+            if (!item)
+                return;
+            const topic = text(item, "topic", path, errors, 200);
+            const description = text(item, "description", path, errors, 400);
+            if (typeof item.critical !== "boolean")
+                errors.push(`${path}.critical must be true or false`);
+            if (topic && description && typeof item.critical === "boolean")
+                gaps.push({ topic, description, critical: item.critical });
+        });
+    }
+    const covered = new Set([...synthesis, ...gaps].map((entry) => fold(entry.topic)));
+    for (const topic of context.topics) {
+        if (!covered.has(fold(topic)))
+            errors.push(`Dossier does not cover the research topic "${topic}" in synthesis or gaps; copy each topic exactly`);
+    }
+    return finish(errors, { synthesis, claims, gaps });
+}
+const figureLabel = /^(fig|tbl)-[a-z0-9-]{1,48}$/;
+const widthText = /^\d{1,3}(?:\.\d+)?%$|^\d{1,3}(?:\.\d+)?(?:cm|mm|in|pt)$/;
+const anchorText = /^[A-Za-z0-9_-]{1,40}$/;
+export function validateFigureDraft(value, path = "FigureDraft") {
+    const errors = [];
+    const item = record(value, path, ["label", "kind", "spec", "source", "table", "caption", "width", "supports"], errors);
+    if (!item)
+        return { errors };
+    const label = text(item, "label", path, errors, 60);
+    if (label !== undefined && !figureLabel.test(label))
+        errors.push(`${path}.label must look like fig-adoption-rate or tbl-results`);
+    const kind = oneOf(item, "kind", path, errors, ["chart", "diagram", "table"]);
+    const caption = text(item, "caption", path, errors, 600);
+    if (caption !== undefined && /[\n[\]]/.test(caption))
+        errors.push(`${path}.caption must be one line without [ or ] (cite sources as @key)`);
+    const supports = text(item, "supports", path, errors, 300, { optional: true }) ?? "";
+    const width = text(item, "width", path, errors, 12, { optional: true });
+    if (width !== undefined && !widthText.test(width))
+        errors.push(`${path}.width must look like 80% or 12cm`);
+    let spec;
+    let source;
+    let table;
+    if (kind === "chart") {
+        if (!isObject(item.spec) || JSON.stringify(item.spec).length > 200_000)
+            errors.push(`${path}.spec must be a Vega-Lite object of at most 200 KB`);
+        else
+            spec = item.spec;
+        if (label && !label.startsWith("fig-"))
+            errors.push(`${path}.label of a chart must start with fig-`);
+    }
+    else if (kind === "diagram") {
+        source = text(item, "source", path, errors, 20_000);
+        if (label && !label.startsWith("fig-"))
+            errors.push(`${path}.label of a diagram must start with fig-`);
+    }
+    else if (kind === "table") {
+        table = text(item, "table", path, errors, 20_000);
+        if (label && !label.startsWith("tbl-"))
+            errors.push(`${path}.label of a table must start with tbl-`);
+    }
+    if (errors.length > 0 || !label || !kind || !caption)
+        return { errors };
+    return {
+        value: {
+            label,
+            kind,
+            ...(spec ? { spec } : {}),
+            ...(source ? { source } : {}),
+            ...(table ? { table } : {}),
+            caption,
+            ...(width ? { width } : {}),
+            supports,
+        },
+        errors: [],
+    };
+}
+export function validateSectionDraft(value, context) {
+    const errors = [];
+    const top = record(value, "SectionDraft", ["markdown", "keywords", "claims", "figures", "gaps"], errors);
+    if (!top)
+        return { errors };
+    const markdown = text(top, "markdown", "SectionDraft", errors, 80_000);
+    const keywords = list(top, "keywords", "SectionDraft", errors, {
+        max: 12,
+        item: 80,
+        optional: true,
+    });
+    const gaps = list(top, "gaps", "SectionDraft", errors, { max: 20, item: 400, optional: true });
+    const evidenceIds = new Set(context.evidenceIds);
+    const objectiveIds = new Set(context.objectiveIds);
+    const claims = [];
+    const anchors = new Set();
+    const rawClaims = top.claims ?? [];
+    if (!Array.isArray(rawClaims) || rawClaims.length > 60)
+        errors.push("SectionDraft.claims must be a list of at most 60 entries");
+    else {
+        rawClaims.forEach((entry, index) => {
+            const path = `claims[${index}]`;
+            const item = record(entry, path, ["anchor", "text", "kind", "evidence", "results", "objectives"], errors);
+            if (!item)
+                return;
+            const anchor = text(item, "anchor", path, errors, 40);
+            if (anchor !== undefined) {
+                if (!anchorText.test(anchor))
+                    errors.push(`${path}.anchor must use letters, digits, _ and -`);
+                else if (anchors.has(anchor))
+                    errors.push(`${path}.anchor ${anchor} is used twice`);
+                else
+                    anchors.add(anchor);
+            }
+            const claim = text(item, "text", path, errors, 400);
+            const kind = oneOf(item, "kind", path, errors, claimKinds);
+            const evidence = list(item, "evidence", path, errors, { max: 20, item: 20, optional: true }) ?? [];
+            for (const id of evidence)
+                if (!evidenceIds.has(id))
+                    errors.push(`${path}.evidence names evidence ${id} that is not in the packet`);
+            const results = list(item, "results", path, errors, { max: 20, item: 40, optional: true }) ?? [];
+            const objectives = list(item, "objectives", path, errors, { max: 12, item: 10, optional: true }) ?? [];
+            for (const id of objectives)
+                if (!objectiveIds.has(id))
+                    errors.push(`${path}.objectives names unknown objective ${id}`);
+            if (anchor && claim && kind)
+                claims.push({ anchor, text: claim, kind, evidence, results, objectives });
+        });
+    }
+    const figures = [];
+    const rawFigures = top.figures ?? [];
+    if (!Array.isArray(rawFigures) || rawFigures.length > 8)
+        errors.push("SectionDraft.figures must be a list of at most 8 entries");
+    else {
+        const labels = new Set();
+        rawFigures.forEach((entry, index) => {
+            const checked = validateFigureDraft(entry, `figures[${index}]`);
+            if (checked.value === undefined)
+                errors.push(...checked.errors);
+            else if (labels.has(checked.value.label))
+                errors.push(`figures[${index}].label ${checked.value.label} is used twice`);
+            else {
+                labels.add(checked.value.label);
+                figures.push(checked.value);
+            }
+        });
+    }
+    if (errors.length > 0 || !markdown)
+        return { errors };
+    return {
+        value: { markdown, keywords: keywords ?? [], claims, figures, gaps: gaps ?? [] },
+        errors: [],
+    };
+}
+export function validateEditPass(value) {
+    const errors = [];
+    const top = record(value, "EditPass", ["markdown", "changes", "queries"], errors);
+    if (!top)
+        return { errors };
+    const markdown = text(top, "markdown", "EditPass", errors, 80_000);
+    const changes = list(top, "changes", "EditPass", errors, { max: 30, item: 300, optional: true });
+    const queries = list(top, "queries", "EditPass", errors, { max: 20, item: 400, optional: true });
+    if (errors.length > 0 || !markdown)
+        return { errors };
+    return { value: { markdown, changes: changes ?? [], queries: queries ?? [] }, errors: [] };
+}
+const squash = (value) => value.replace(/\s+/g, " ").trim();
+/**
+ * `texts` maps each reviewable section id to the text the reviewer saw; a finding must quote that
+ * text (a finding without a location is not a finding) and its route must follow the category.
+ */
+export function validateReviewReport(value, context) {
+    const errors = [];
+    const top = record(value, "ReviewReport", ["summary", "findings"], errors);
+    if (!top)
+        return { errors };
+    const summary = text(top, "summary", "ReviewReport", errors, 1500);
+    const findings = [];
+    if (!Array.isArray(top.findings) || top.findings.length > 60)
+        errors.push("ReviewReport.findings must be a list of at most 60 entries");
+    else {
+        top.findings.forEach((entry, index) => {
+            const path = `findings[${index}]`;
+            const item = record(entry, path, ["severity", "category", "target", "evidence", "description", "routeTo"], errors);
+            if (!item)
+                return;
+            const severity = oneOf(item, "severity", path, errors, [
+                "critical",
+                "major",
+                "minor",
+            ]);
+            const category = oneOf(item, "category", path, errors, reviewCategories);
+            const routeTo = oneOf(item, "routeTo", path, errors, reviewRoutes);
+            const target = text(item, "target", path, errors, 20);
+            const evidence = text(item, "evidence", path, errors, 400, { min: 8 });
+            const description = text(item, "description", path, errors, 800);
+            if (category && routeTo && routeOfCategory[category] !== routeTo)
+                errors.push(`${path}.routeTo for category ${category} must be ${routeOfCategory[category]}`);
+            if (target !== undefined) {
+                const source = context.texts.get(target);
+                if (source === undefined)
+                    errors.push(`${path}.target ${target} is not one of the reviewed sections`);
+                else if (evidence !== undefined && !squash(source).includes(squash(evidence)))
+                    errors.push(`${path}.evidence is not a verbatim quote of ${target}`);
+            }
+            if (severity && category && routeTo && target && evidence && description)
+                findings.push({ severity, category, target, evidence, description, routeTo });
+        });
+    }
+    if (errors.length > 0 || !summary)
+        return { errors };
+    return { value: { summary, findings }, errors: [] };
+}
+export function validateRevisionAdvice(value) {
+    const errors = [];
+    const top = record(value, "RevisionAdvice", ["guidance", "protocolChange"], errors);
+    if (!top)
+        return { errors };
+    const guidance = text(top, "guidance", "RevisionAdvice", errors, 2000);
+    if (typeof top.protocolChange !== "boolean")
+        errors.push("RevisionAdvice.protocolChange must be true or false");
+    if (errors.length > 0 || !guidance)
+        return { errors };
+    return { value: { guidance, protocolChange: top.protocolChange }, errors: [] };
+}
+function profileText(top, path, errors) {
+    const raw = top.profile;
+    if (raw === undefined || raw === null)
+        return undefined;
+    if (typeof raw === "string") {
+        const clean = stripControl(raw).trim();
+        if (!clean || clean.length > 60_000)
+            errors.push(`${path}.profile must be 1 to 60000 characters`);
+        return clean;
+    }
+    if (isObject(raw))
+        return stringifyYaml(raw, { lineWidth: 0 });
+    errors.push(`${path}.profile must be YAML text or an object`);
+    return undefined;
+}
+function trace(top, key, path, errors, fields) {
+    const raw = top[key] ?? [];
+    const out = [];
+    if (!Array.isArray(raw) || raw.length > 80) {
+        errors.push(`${path}.${key} must be a list of at most 80 entries`);
+        return out;
+    }
+    raw.forEach((entry, index) => {
+        const where = `${key}[${index}]`;
+        const item = record(entry, where, [...fields], errors);
+        if (!item)
+            return;
+        const first = text(item, fields[0], where, errors, 300);
+        const second = text(item, fields[1], where, errors, 600);
+        const third = item[fields[2]] === ""
+            ? ""
+            : (text(item, fields[2], where, errors, 600, { optional: true }) ?? "");
+        if (first && second)
+            out.push({ rule: first, guide: second, effect: third });
+    });
+    return out;
+}
+export function validateStyleDraft(value) {
+    const errors = [];
+    const top = record(value, "StyleDraft", ["csl", "profile", "questions", "ruleTrace"], errors);
+    if (!top)
+        return { errors };
+    const csl = text(top, "csl", "StyleDraft", errors, 400_000);
+    const profile = profileText(top, "StyleDraft", errors);
+    const questions = list(top, "questions", "StyleDraft", errors, {
+        max: 8,
+        item: 400,
+        optional: true,
+    });
+    const ruleTrace = trace(top, "ruleTrace", "StyleDraft", errors, ["rule", "guide", "effect"]);
+    if (errors.length > 0 || !csl)
+        return { errors };
+    return {
+        value: { csl, ...(profile ? { profile } : {}), questions: questions ?? [], ruleTrace },
+        errors: [],
+    };
+}
+export const normsScopes = [
+    "institution",
+    "faculty",
+    "program",
+    "writing",
+    "international",
+];
+export function validateNormsDraft(value) {
+    const errors = [];
+    const top = record(value, "NormsDraft", ["pack", "rules", "profile", "questions", "sourceTrace"], errors);
+    if (!top)
+        return { errors };
+    const packSource = record(top.pack, "NormsDraft.pack", ["scope", "id", "description", "appliesWhen"], errors);
+    let pack;
+    if (packSource) {
+        const scope = oneOf(packSource, "scope", "NormsDraft.pack", errors, normsScopes);
+        const id = text(packSource, "id", "NormsDraft.pack", errors, 60);
+        const description = text(packSource, "description", "NormsDraft.pack", errors, 300);
+        if (packSource.appliesWhen !== undefined && !isObject(packSource.appliesWhen))
+            errors.push("NormsDraft.pack.appliesWhen must be a mapping");
+        if (scope && id && description)
+            pack = {
+                scope,
+                id,
+                description,
+                appliesWhen: isObject(packSource.appliesWhen) ? packSource.appliesWhen : {},
+            };
+    }
+    const rules = [];
+    if (!Array.isArray(top.rules) || top.rules.length < 1 || top.rules.length > 80)
+        errors.push("NormsDraft.rules must hold 1 to 80 rules");
+    else {
+        top.rules.forEach((entry, index) => {
+            if (!isObject(entry))
+                errors.push(`rules[${index}] must be a mapping`);
+            else
+                rules.push(entry);
+        });
+    }
+    const profile = profileText(top, "NormsDraft", errors);
+    const questions = list(top, "questions", "NormsDraft", errors, {
+        max: 8,
+        item: 400,
+        optional: true,
+    });
+    const sourceTrace = trace(top, "sourceTrace", "NormsDraft", errors, ["rule", "guide", "effect"]);
+    if (errors.length > 0 || !pack)
+        return { errors };
+    return {
+        value: {
+            pack,
+            rules,
+            ...(profile ? { profile } : {}),
+            questions: questions ?? [],
+            sourceTrace,
+        },
+        errors: [],
+    };
+}
+//# sourceMappingURL=schemas.js.map