presubmit 0.1.0

package/dist/packages/protocol/src/memory.js

@@ -0,0 +1,46 @@
+function text(value, max, empty = false) {
+    if (typeof value !== 'string' || value.length > max || (!empty && !value.trim()))
+        throw new Error('Invalid memory text.');
+    return value.trim();
+}
+export function parseMemoryRequest(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('Invalid memory request.');
+    const v = value;
+    if (v.action === 'search') {
+        const limit = v.limit ?? 10;
+        if (!Number.isInteger(limit) ||
+            Number(limit) < 1 ||
+            Number(limit) > 50 ||
+            (v.includeRetired !== undefined && typeof v.includeRetired !== 'boolean'))
+            throw new Error('Invalid memory search.');
+        return {
+            action: 'search',
+            query: text(v.query, 200, true),
+            limit: Number(limit),
+            includeRetired: v.includeRetired === true,
+        };
+    }
+    const id = () => text(v.id, 128);
+    if (v.action === 'read')
+        return { action: 'read', id: id() };
+    if (!['save', 'update', 'retire'].includes(String(v.action)))
+        throw new Error('Invalid memory action.');
+    const requestId = text(v.requestId, 128);
+    if (v.action !== 'save' && (!Number.isSafeInteger(v.revision) || Number(v.revision) < 1))
+        throw new Error('Invalid memory revision.');
+    if (v.action === 'retire')
+        return { action: 'retire', requestId, id: id(), revision: Number(v.revision) };
+    if (!v.text || typeof v.text !== 'object')
+        throw new Error('Invalid lesson.');
+    const t = v.text;
+    const fields = {
+        title: text(t.title, 120),
+        lesson: text(t.lesson, 1600),
+        context: text(t.context, 800),
+        evidence: text(t.evidence, 1200),
+    };
+    return v.action === 'save'
+        ? { action: 'save', requestId, text: fields }
+        : { action: 'update', requestId, id: id(), revision: Number(v.revision), text: fields };
+}

package/dist/packages/protocol/src/metrics.js

@@ -0,0 +1,70 @@
+// Fixed buckets and bounded labels keep diagnostics from growing with session history.
+const bounds = [
+    0.1,
+    0.25,
+    0.5,
+    1,
+    2,
+    4,
+    8,
+    16,
+    32,
+    64,
+    128,
+    256,
+    512,
+    1000,
+    2000,
+    4000,
+    8000,
+    16000,
+    30000,
+    Infinity,
+];
+const round = (value) => Math.round(value * 100) / 100;
+export class PerformanceMetrics {
+    timings = new Map();
+    counters = new Map();
+    observe(name, milliseconds) {
+        if (!Number.isFinite(milliseconds) || milliseconds < 0)
+            return;
+        let value = this.timings.get(name);
+        if (!value) {
+            if (this.timings.size >= 32)
+                return;
+            value = { count: 0, total: 0, max: 0, buckets: bounds.map(() => 0) };
+            this.timings.set(name, value);
+        }
+        value.count++;
+        value.total += milliseconds;
+        value.max = Math.max(value.max, milliseconds);
+        value.buckets[bounds.findIndex((bound) => milliseconds <= bound)]++;
+    }
+    count(name, amount = 1) {
+        if (!Number.isFinite(amount) || amount < 0)
+            return;
+        if (!this.counters.has(name) && this.counters.size >= 32)
+            return;
+        this.counters.set(name, (this.counters.get(name) ?? 0) + amount);
+    }
+    drain() {
+        const timings = Object.fromEntries([...this.timings].map(([name, value]) => {
+            let count = 0;
+            const index = value.buckets.findIndex((bucket) => (count += bucket) >= Math.ceil(value.count * 0.95));
+            return [
+                name,
+                {
+                    count: value.count,
+                    totalMs: round(value.total),
+                    meanMs: round(value.total / value.count),
+                    p95UpperMs: round(Math.min(bounds[index], value.max)),
+                    maxMs: round(value.max),
+                },
+            ];
+        }));
+        const counters = Object.fromEntries(this.counters);
+        this.timings.clear();
+        this.counters.clear();
+        return { timings, counters };
+    }
+}

package/dist/packages/protocol/src/planning.js

@@ -0,0 +1,138 @@
+export const emptyPlanningBoard = () => ({
+    revision: 0,
+    summary: '',
+    ideas: [],
+    tasks: [],
+    questions: [],
+});
+/** Compact conversation/UI label in the task list's persisted order; tool references still use IDs. */
+export function taskDisplayId(taskId, tasks) {
+    const index = tasks.findIndex((task) => task.id === taskId);
+    return index < 0 ? undefined : `T${tasks[index].displayNumber ?? index + 1}`;
+}
+/** Shared structural limits for HTTP, IPC, and persisted planning proposals. */
+export function parsePlanningBoard(value) {
+    const object = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+    const text = (v, max, required = true) => typeof v === 'string' && v.length <= max && (!required || !!v.trim());
+    const id = (v) => text(v, 80) && /^[a-zA-Z0-9_-]+$/.test(v);
+    const refs = (v) => Array.isArray(v) &&
+        v.length > 0 &&
+        v.length <= 100 &&
+        v.every(id) &&
+        new Set(v).size === v.length;
+    const list = (v, max) => Array.isArray(v) &&
+        v.length <= max &&
+        v.every((x) => object(x) && id(x.id)) &&
+        new Set(v.map((x) => x.id)).size === v.length;
+    if (!object(value) ||
+        !Number.isSafeInteger(value.revision) ||
+        Number(value.revision) < 0 ||
+        Number(value.revision) >= Number.MAX_SAFE_INTEGER ||
+        !text(value.summary, 8000, false) ||
+        !list(value.ideas, 100) ||
+        !list(value.tasks, 50) ||
+        !list(value.questions, 50))
+        throw new Error('Invalid planning board or limits exceeded.');
+    const ideas = value.ideas.map((idea) => {
+        if (!text(idea.text, 4000) ||
+            !refs(idea.sourceRunIds) ||
+            !['active', 'deferred', 'rejected'].includes(String(idea.disposition)))
+            throw new Error('Invalid idea. Include its source message IDs.');
+        return {
+            id: String(idea.id),
+            text: idea.text,
+            sourceRunIds: idea.sourceRunIds,
+            disposition: idea.disposition,
+        };
+    });
+    const ideaIds = new Set(ideas.map((idea) => idea.id));
+    const tasks = value.tasks.map((task) => {
+        if (!text(task.title, 120) ||
+            !text(task.scope, 8000) ||
+            !text(task.criteria, 4000, false) ||
+            !Array.isArray(task.sourceIdeaIds) ||
+            (task.sourceIdeaIds.length > 0 && !refs(task.sourceIdeaIds)) ||
+            !task.sourceIdeaIds.every((ref) => ideaIds.has(ref)) ||
+            (task.sourceRunIds !== undefined && !refs(task.sourceRunIds)) ||
+            (!task.sourceIdeaIds.length && !refs(task.sourceRunIds)) ||
+            !['draft', 'needs_clarification', 'ready', 'deferred'].includes(String(task.status)))
+            throw new Error('Invalid task. Include source message IDs or existing idea references.');
+        if (task.status === 'ready' && !task.criteria.trim())
+            throw new Error('Ready tasks need acceptance criteria.');
+        if (task.dependencies !== undefined &&
+            (!Array.isArray(task.dependencies) ||
+                task.dependencies.length > 50 ||
+                !task.dependencies.every(id) ||
+                new Set(task.dependencies).size !== task.dependencies.length))
+            throw new Error('Invalid task dependencies.');
+        if (task.execution !== undefined && !['session', 'subagent'].includes(String(task.execution)))
+            throw new Error('Invalid execution kind.');
+        if (task.kind !== undefined && !['research', 'implementation'].includes(String(task.kind)))
+            throw new Error('Invalid task kind.');
+        if (task.affectedAreas !== undefined && !text(task.affectedAreas, 2000, false))
+            throw new Error('Invalid affected areas.');
+        return {
+            ...(task.sourceRunIds !== undefined ? { sourceRunIds: task.sourceRunIds } : {}),
+            ...(task.dependencies !== undefined ? { dependencies: task.dependencies } : {}),
+            ...(task.execution !== undefined
+                ? { execution: task.execution }
+                : {}),
+            ...(task.kind !== undefined ? { kind: task.kind } : {}),
+            ...(task.affectedAreas !== undefined ? { affectedAreas: task.affectedAreas } : {}),
+            id: String(task.id),
+            title: task.title,
+            scope: task.scope,
+            criteria: task.criteria,
+            sourceIdeaIds: task.sourceIdeaIds,
+            status: task.status,
+        };
+    });
+    const taskMap = new Map(tasks.map((task) => [task.id, task]));
+    const visiting = new Set(), visited = new Set();
+    const visit = (id) => {
+        if (visiting.has(id))
+            throw new Error('Task dependencies contain a cycle.');
+        if (visited.has(id))
+            return;
+        const task = taskMap.get(id);
+        if (!task)
+            throw new Error('Unknown dependency task.');
+        visiting.add(id);
+        for (const dependency of task.dependencies ?? [])
+            visit(dependency);
+        visiting.delete(id);
+        visited.add(id);
+    };
+    for (const task of tasks)
+        visit(task.id);
+    const questions = value.questions.map((question) => {
+        if (!text(question.text, 2000) ||
+            !text(question.answer, 4000, false) ||
+            typeof question.blocking !== 'boolean' ||
+            !refs(question.sourceRunIds))
+            throw new Error('Invalid clarification question.');
+        if (question.taskIds !== undefined &&
+            (!Array.isArray(question.taskIds) ||
+                question.taskIds.length > 50 ||
+                !question.taskIds.every((id) => typeof id === 'string' && taskMap.has(id))))
+            throw new Error('Invalid question task references.');
+        return {
+            ...(question.taskIds !== undefined ? { taskIds: question.taskIds } : {}),
+            id: String(question.id),
+            text: question.text,
+            answer: question.answer,
+            blocking: question.blocking,
+            sourceRunIds: question.sourceRunIds,
+        };
+    });
+    const board = {
+        revision: Number(value.revision),
+        summary: value.summary,
+        ideas,
+        tasks,
+        questions,
+    };
+    if (JSON.stringify(board).length > 100000)
+        throw new Error('Planning board exceeds 100,000 characters.');
+    return board;
+}

package/dist/packages/protocol/src/retrieval.js

@@ -0,0 +1,36 @@
+/** Only turn features off; keep the embedding provider and any remaining access unchanged. */
+export function isSearchSettingsReduction(previous, next) {
+    return (next.model === previous.model &&
+        next.endpoint === previous.endpoint &&
+        (!next.enabled || previous.enabled) &&
+        (!next.agentRetrieval || previous.agentRetrieval) &&
+        ((previous.enabled && !next.enabled) || (previous.agentRetrieval && !next.agentRetrieval)));
+}
+export function isAgentRetrievalChange(previous, next) {
+    return (previous.enabled &&
+        next.enabled &&
+        next.model === previous.model &&
+        next.endpoint === previous.endpoint &&
+        next.agentRetrieval !== previous.agentRetrieval);
+}
+export function parseHistoryHits(value) {
+    if (!Array.isArray(value) || value.length > 10)
+        throw new Error('Invalid history response');
+    for (const hit of value) {
+        if (!hit ||
+            typeof hit !== 'object' ||
+            !['sourceId', 'sessionId', 'sessionTitle', 'runId', 'createdAt', 'text'].every((key) => typeof hit[key] === 'string') ||
+            hit.sourceId.length > 128 ||
+            hit.sessionId.length > 128 ||
+            hit.runId.length > 128 ||
+            hit.sessionTitle.length > 500 ||
+            hit.createdAt.length > 100 ||
+            hit.text.length > 1600 ||
+            !['prompt', 'reply'].includes(hit.kind) ||
+            !Number.isFinite(hit.score) ||
+            hit.score < 0 ||
+            hit.score > 1)
+            throw new Error('Invalid history response');
+    }
+    return value;
+}

package/dist/packages/protocol/src/reviewers.js

@@ -0,0 +1,17 @@
+export function parseReviewRequest(value) {
+    const v = value;
+    if (!v ||
+        !['working', 'branch'].includes(String(v.scope)) ||
+        typeof v.base !== 'string' ||
+        !v.base.trim() ||
+        v.base.length > 200 ||
+        (v.target !== undefined &&
+            (typeof v.target !== 'string' || !v.target.trim() || v.target.length > 200)) ||
+        (v.scope === 'working' && v.target !== undefined))
+        throw new Error('Supply working or branch scope and explicit local comparison refs.');
+    return {
+        scope: v.scope,
+        base: v.base.trim(),
+        ...(v.scope === 'branch' ? { target: v.target?.trim() ?? 'HEAD' } : {}),
+    };
+}

package/dist/packages/protocol/src/search.js

@@ -0,0 +1,16 @@
+/** Literal, case-insensitive matching, including punctuation and non-ASCII text. */
+export function searchPattern(query) {
+    return new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'iu');
+}
+export function searchExcerpt(text, pattern) {
+    const match = pattern.exec(text);
+    if (!match)
+        return;
+    const start = Math.max(0, match.index - 80);
+    const end = Math.min(text.length, match.index + match[0].length + 160);
+    return {
+        before: (start ? '…' : '') + text.slice(start, match.index),
+        match: match[0],
+        after: text.slice(match.index + match[0].length, end) + (end < text.length ? '…' : ''),
+    };
+}

package/dist/packages/protocol/src/session-changes.js

@@ -0,0 +1,29 @@
+export const MAX_RECORDED_FILE_BYTES = 1024 * 1024;
+export function isRecordedFileChange(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const item = value;
+    if (typeof item.toolCallId !== 'string' ||
+        !item.toolCallId ||
+        item.toolCallId.length > 200 ||
+        !Number.isSafeInteger(item.index) ||
+        Number(item.index) < 0 ||
+        typeof item.file !== 'string' ||
+        !item.file ||
+        item.file.length > 4096 ||
+        item.file.startsWith('/') ||
+        item.file.includes('\\') ||
+        item.file.includes('\0') ||
+        item.file
+            .split('/')
+            .some((part) => !part || part === '.' || part === '..' || part.toLowerCase() === '.git'))
+        return false;
+    if (item.omitted !== undefined)
+        return (['size', 'non-text'].includes(String(item.omitted)) &&
+            item.before === undefined &&
+            item.after === undefined);
+    return [item.before, item.after].every((text) => text === null ||
+        (typeof text === 'string' &&
+            !text.includes('\0') &&
+            new TextEncoder().encode(text).length <= MAX_RECORDED_FILE_BYTES));
+}

package/dist/packages/protocol/src/session-router.js

@@ -0,0 +1,123 @@
+export const defaultSessionRouterSettings = {
+    enabled: false,
+    model: 'jev-latest',
+    routeConfidence: { code: 0.8, plan: 0.7 },
+    taskRoutingEnabled: false,
+    taskMinConfidence: 0.7,
+    agentConsultEnabled: false,
+    agentConsultMinConfidence: 0.7,
+    shellSafetyShadowEnabled: false,
+};
+function boundedText(value, label, maxLength) {
+    if (typeof value !== 'string' ||
+        !value.trim() ||
+        value.length > maxLength ||
+        /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(value))
+        throw new Error(`Enter valid ${label}.`);
+    return value.trim();
+}
+export function parseJevConsultRequest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid Jev consultation.');
+    const input = value;
+    if (Object.keys(input).some((key) => !['question', 'choices', 'context', 'criterion'].includes(key)))
+        throw new Error('Unknown Jev consultation field.');
+    if (!Array.isArray(input.choices) || input.choices.length < 2 || input.choices.length > 5)
+        throw new Error('Provide between two and five Jev choices.');
+    const choices = input.choices.map((value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('Invalid Jev choice.');
+        const choice = value;
+        if (Object.keys(choice).some((key) => !['id', 'description'].includes(key)))
+            throw new Error('Unknown Jev choice field.');
+        const id = boundedText(choice.id, 'choice ID', 64);
+        if (!/^[a-zA-Z0-9_-]+$/.test(id))
+            throw new Error('Choice IDs may contain only letters, numbers, underscores, and hyphens.');
+        return { id, description: boundedText(choice.description, 'choice description', 1000) };
+    });
+    if (new Set(choices.map((choice) => choice.id)).size !== choices.length)
+        throw new Error('Jev choice IDs must be unique.');
+    return {
+        question: boundedText(input.question, 'consultation question', 1000),
+        choices,
+        context: boundedText(input.context, 'consultation context', 8000),
+        ...(input.criterion === undefined
+            ? {}
+            : { criterion: boundedText(input.criterion, 'decision criterion', 1000) }),
+    };
+}
+export function parseJevConsultDecision(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid Jev consultation result.');
+    const decision = value;
+    if (decision.provider !== 'typesafe' ||
+        typeof decision.requestedModel !== 'string' ||
+        typeof decision.accepted !== 'boolean' ||
+        (decision.choice !== undefined && typeof decision.choice !== 'string') ||
+        (decision.confidence !== undefined &&
+            (typeof decision.confidence !== 'number' ||
+                !Number.isFinite(decision.confidence) ||
+                decision.confidence < 0 ||
+                decision.confidence > 1)) ||
+        (decision.accepted && (!decision.choice || decision.confidence === undefined)) ||
+        (decision.fallback !== undefined &&
+            !['confidence', 'invalid_selection', 'timeout', 'provider_error'].includes(decision.fallback)))
+        throw new Error('Invalid Jev consultation result.');
+    return decision;
+}
+function confidence(value, label) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0.5 || value > 1)
+        throw new Error(`${label} must be between 0.5 and 1.`);
+    return value;
+}
+export function parseSessionRouterSettings(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid session routing settings.');
+    const input = value;
+    if (Object.keys(input).some((key) => ![
+        'enabled',
+        'model',
+        'minConfidence',
+        'routeConfidence',
+        'taskRoutingEnabled',
+        'taskMinConfidence',
+        'agentConsultEnabled',
+        'agentConsultMinConfidence',
+        'shellSafetyShadowEnabled',
+    ].includes(key)))
+        throw new Error('Unknown session routing setting.');
+    if (typeof input.enabled !== 'boolean')
+        throw new Error('Choose whether Jev routing is enabled.');
+    if (typeof input.model !== 'string' ||
+        !input.model.trim() ||
+        input.model.length > 200 ||
+        /[\x00-\x1f\x7f]/.test(input.model))
+        throw new Error('Enter a valid Jev model ID.');
+    const legacy = input.minConfidence;
+    const route = input.routeConfidence;
+    if (route !== undefined &&
+        (!route ||
+            typeof route !== 'object' ||
+            Array.isArray(route) ||
+            Object.keys(route).some((key) => !['code', 'plan'].includes(key))))
+        throw new Error('Invalid route confidence settings.');
+    const code = confidence(route ? route.code : (legacy ?? 0.8), 'Code route confidence');
+    const plan = confidence(route ? route.plan : (legacy ?? 0.7), 'Plan route confidence');
+    if (input.taskRoutingEnabled !== undefined && typeof input.taskRoutingEnabled !== 'boolean')
+        throw new Error('Choose whether Jev routes subtask models.');
+    if (input.agentConsultEnabled !== undefined && typeof input.agentConsultEnabled !== 'boolean')
+        throw new Error('Choose whether agents can consult Jev.');
+    if (input.shellSafetyShadowEnabled !== undefined &&
+        typeof input.shellSafetyShadowEnabled !== 'boolean')
+        throw new Error('Choose whether Jev shadows shell safety.');
+    return {
+        enabled: input.enabled,
+        model: input.model.trim(),
+        routeConfidence: { code, plan },
+        taskRoutingEnabled: input.taskRoutingEnabled === true,
+        taskMinConfidence: confidence(input.taskMinConfidence ?? legacy ?? 0.7, 'Task confidence'),
+        agentConsultEnabled: input.agentConsultEnabled === true,
+        agentConsultMinConfidence: confidence(input.agentConsultMinConfidence ?? legacy ?? 0.7, 'Agent consultation confidence'),
+        shellSafetyShadowEnabled: input.shellSafetyShadowEnabled === true,
+    };
+}

package/dist/packages/protocol/src/shell-evaluator.js

@@ -0,0 +1,43 @@
+export const defaultSafetyMaxTokens = 4096;
+export const minSafetyMaxTokens = 256;
+export const maxSafetyMaxTokens = 32768;
+export function validSafetyMaxTokens(value) {
+    return (typeof value === 'number' &&
+        Number.isInteger(value) &&
+        value >= minSafetyMaxTokens &&
+        value <= maxSafetyMaxTokens);
+}
+export function parseShellEvaluatorSettings(value, models) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid evaluator settings.');
+    const input = value;
+    if (Object.keys(input).some((key) => !['model', 'reasoning', 'maxTokens', 'prompt'].includes(key)))
+        throw new Error('Unknown evaluator setting.');
+    const result = {};
+    if (input.maxTokens !== undefined) {
+        if (!validSafetyMaxTokens(input.maxTokens))
+            throw new Error(`Maximum output tokens must be an integer from ${minSafetyMaxTokens} to ${maxSafetyMaxTokens}.`);
+        result.maxTokens = input.maxTokens;
+    }
+    if (input.model !== undefined) {
+        const model = models.find((model) => model.id === input.model);
+        if (!model)
+            throw new Error('Evaluator model is unavailable on the connected provider.');
+        result.model = model.id;
+    }
+    if (input.reasoning !== undefined) {
+        const model = models.find((model) => model.id === result.model);
+        if (!model || !(model.reasoningLevels ?? ['off']).includes(input.reasoning))
+            throw new Error('Select a model and a supported reasoning level.');
+        result.reasoning = input.reasoning;
+    }
+    if (input.prompt !== undefined) {
+        if (typeof input.prompt !== 'string' ||
+            !input.prompt.trim() ||
+            input.prompt.length > 16000 ||
+            input.prompt.includes('\0'))
+            throw new Error('Evaluator prompt must contain 1–16000 characters and no NUL.');
+        result.prompt = input.prompt;
+    }
+    return result;
+}

package/dist/packages/protocol/src/task-graph.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/protocol/src/token-usage.js

@@ -0,0 +1,17 @@
+/** Sum reported runs, preserving the distinction between missing usage and zero. */
+export function sumTokenUsage(runs) {
+    let total;
+    for (const { usage } of runs) {
+        if (!usage)
+            continue;
+        total ??= { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+        total.input += usage.input;
+        total.output += usage.output;
+        total.cacheRead += usage.cacheRead;
+        total.cacheWrite += usage.cacheWrite;
+    }
+    return total;
+}
+export function totalTokens(usage) {
+    return usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}

package/dist/packages/protocol/src/user-questions.js

@@ -0,0 +1,106 @@
+export function userQuestionItems(request) {
+    return 'questions' in request ? request.questions : [request];
+}
+export function userAnswerItems(response) {
+    return 'answers' in response ? response.answers : [response];
+}
+function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid question or answer.');
+    return value;
+}
+function text(value, name, limit) {
+    if (typeof value !== 'string' || !value.trim() || value.length > limit)
+        throw new Error(`Invalid ${name}.`);
+    return value.trim();
+}
+export function parseUserQuestion(value) {
+    const input = object(value);
+    if (input.questions !== undefined)
+        throw new Error('Nested question batches are not supported.');
+    const question = text(input.question, 'question', 2000);
+    const context = input.context === undefined ? undefined : text(input.context, 'context', 2000);
+    if (input.allowMultiple !== undefined && typeof input.allowMultiple !== 'boolean')
+        throw new Error('Invalid multiple-selection setting.');
+    let options;
+    if (input.options !== undefined) {
+        if (!Array.isArray(input.options) || input.options.length < 2 || input.options.length > 4)
+            throw new Error('Provide two to four choices, or omit choices for a written answer.');
+        options = input.options.map((raw) => {
+            const option = object(raw);
+            return {
+                label: text(option.label, 'choice', 120),
+                ...(option.description === undefined
+                    ? {}
+                    : { description: text(option.description, 'choice description', 400) }),
+            };
+        });
+        if (new Set(options.map((option) => option.label.toLowerCase())).size !== options.length)
+            throw new Error('Choices must be distinct.');
+    }
+    if (input.allowMultiple && !options)
+        throw new Error('Multiple selection requires choices.');
+    return {
+        question,
+        ...(context ? { context } : {}),
+        ...(options ? { options } : {}),
+        ...(input.allowMultiple !== undefined ? { allowMultiple: input.allowMultiple } : {}),
+    };
+}
+export function parseUserAnswer(value, question) {
+    const input = object(value);
+    if (input.answers !== undefined)
+        throw new Error('This question needs one answer.');
+    if (input.skipped !== undefined) {
+        if (input.skipped !== true)
+            throw new Error('A skipped answer must explicitly set skipped to true.');
+        if (['option', 'options', 'text'].some((key) => input[key] !== undefined))
+            throw new Error('A skipped question cannot include an answer.');
+        return { skipped: true };
+    }
+    const option = input.option === undefined ? undefined : text(input.option, 'selected choice', 120);
+    const answerText = input.text === undefined ? undefined : text(input.text, 'answer', 4000);
+    if (input.option !== undefined && question.allowMultiple)
+        throw new Error('Return selected choices as an array for a multiple-selection question.');
+    let options;
+    if (input.options !== undefined) {
+        if (!question.allowMultiple || !Array.isArray(input.options) || input.options.length > 4)
+            throw new Error('Invalid selected choices.');
+        options = input.options.map((option) => text(option, 'selected choice', 120));
+        if (new Set(options).size !== options.length)
+            throw new Error('Selected choices must be distinct.');
+        if (options.some((option) => !question.options?.some((choice) => choice.label === option)))
+            throw new Error('A selected choice does not belong to this question.');
+    }
+    if (option && !question.options?.some((choice) => choice.label === option))
+        throw new Error('The selected choice does not belong to this question.');
+    if (!option && !options?.length && !answerText)
+        throw new Error('Choose an option or write an answer.');
+    return {
+        ...(option ? { option } : {}),
+        ...(options?.length ? { options } : {}),
+        ...(answerText ? { text: answerText } : {}),
+    };
+}
+export function parseUserQuestionRequest(value) {
+    const input = object(value);
+    if (input.questions === undefined)
+        return parseUserQuestion(input);
+    if (['question', 'context', 'options', 'allowMultiple'].some((key) => input[key] !== undefined))
+        throw new Error('Provide either a single question or a questions array.');
+    if (!Array.isArray(input.questions) || input.questions.length < 1 || input.questions.length > 5)
+        throw new Error('Provide one to five questions per batch.');
+    return { questions: input.questions.map(parseUserQuestion) };
+}
+export function parseUserResponse(value, request) {
+    if (!('questions' in request))
+        return parseUserAnswer(value, request);
+    const input = object(value);
+    if (['option', 'options', 'text', 'skipped'].some((key) => input[key] !== undefined) ||
+        !Array.isArray(input.answers) ||
+        input.answers.length !== request.questions.length)
+        throw new Error('Provide one answer for every question, in the original order.');
+    return {
+        answers: input.answers.map((answer, index) => parseUserAnswer(answer, request.questions[index])),
+    };
+}