@zenera/cli 1.1.24 → 1.1.26

package/dist/meta/finetune/dataset/drift.d.ts

@@ -0,0 +1,33 @@
+import type { DatasetStore } from './store.ts';
+import { type Anchor } from './types.ts';
+export type CaseDrift = 'changed' | 'gone';
+export interface DriftedCase {
+    id: string;
+    file: string;
+    anchor?: Anchor;
+    state: CaseDrift;
+    why?: string;
+}
+export interface DriftReport {
+    revision: number;
+    /** `unsettled`: never recorded, because a section in it is still uncovered */
+    files: {
+        file: string;
+        state: 'changed' | 'missing' | 'unsettled';
+    }[];
+    cases: DriftedCase[];
+    /** active cases checked and found where they were */
+    unchanged: number;
+    /** active cases with no source to drift from */
+    untracked: number;
+    uncovered: {
+        file: string;
+        anchor: Anchor;
+    }[];
+    clean: boolean;
+}
+/** `all` re-reads unchanged files too, to list their uncovered sections. */
+export declare function drift(store: DatasetStore, options?: {
+    all?: boolean;
+}): DriftReport;
+//# sourceMappingURL=drift.d.ts.map

package/dist/meta/finetune/dataset/drift.js

@@ -0,0 +1,71 @@
+import { Sources } from "./anchors.js";
+import { sameAnchor } from "./types.js";
+/** `all` re-reads unchanged files too, to list their uncovered sections. */
+export function drift(store, options = {}) {
+    const sources = new Sources(store.root);
+    const active = store.all().filter((c) => c.status === 'active');
+    const byFile = new Map();
+    let untracked = 0;
+    for (const c of active) {
+        if (!c.source) {
+            untracked++;
+            continue;
+        }
+        byFile.set(c.source.file, [...(byFile.get(c.source.file) ?? []), c]);
+    }
+    for (const ignored of store.manifest.ignored) {
+        if (!byFile.has(ignored.file)) {
+            byFile.set(ignored.file, []);
+        }
+    }
+    const report = {
+        revision: store.manifest.revision,
+        files: [],
+        cases: [],
+        unchanged: 0,
+        untracked,
+        uncovered: [],
+        clean: true,
+    };
+    for (const [file, cases] of [...byFile].sort(([a], [b]) => a.localeCompare(b))) {
+        const now = sources.hash(file);
+        const was = store.manifest.sources[file]?.sha256;
+        const moved = now !== was;
+        if (now === undefined) {
+            report.files.push({ file, state: 'missing' });
+        }
+        else if (moved) {
+            report.files.push({ file, state: was ? 'changed' : 'unsettled' });
+        }
+        if (!moved && !options.all) {
+            report.unchanged += cases.length;
+            continue;
+        }
+        for (const c of cases) {
+            const found = sources.section(file, c.source.anchor);
+            const anchor = c.source.anchor ? { anchor: c.source.anchor } : {};
+            if (!found.found) {
+                report.cases.push({ id: c.id, file, ...anchor, state: 'gone', why: found.why });
+            }
+            else if (found.sha256 !== c.source.sha256) {
+                report.cases.push({ id: c.id, file, ...anchor, state: 'changed' });
+            }
+            else {
+                report.unchanged++;
+            }
+        }
+        if (now === undefined) {
+            continue;
+        }
+        const ignored = store.manifest.ignored.filter((i) => i.file === file).map((i) => i.anchor);
+        const covered = [...cases.map((c) => c.source.anchor), ...ignored];
+        for (const anchor of sources.uncovered(file, covered)) {
+            if (!ignored.some((i) => sameAnchor(i, anchor))) {
+                report.uncovered.push({ file, anchor });
+            }
+        }
+    }
+    report.clean = report.cases.length === 0 && report.uncovered.length === 0;
+    return report;
+}
+//# sourceMappingURL=drift.js.map

package/dist/meta/finetune/dataset/export.d.ts

@@ -0,0 +1,26 @@
+import { type Case, type Input } from './types.ts';
+export declare function batchInput(cases: readonly Case[], root: string, out?: string): {
+    batch: {
+        id: string;
+        input: Input;
+    }[];
+};
+export declare function dump(cases: readonly Case[], root: string, revision: number, out?: string): {
+    version: number;
+    revision: number;
+    cases: {
+        input: Input;
+        id: string;
+        rev: number;
+        status: import("./types.ts").Status;
+        class?: string;
+        complexity?: import("./types.ts").Complexity;
+        tags?: string[];
+        rubric: import("./types.ts").RubricItem[];
+        expected?: string;
+        notes?: string;
+        source?: import("./types.ts").Source;
+        overrides?: string[];
+    }[];
+};
+//# sourceMappingURL=export.d.ts.map

package/dist/meta/finetune/dataset/export.js

@@ -0,0 +1,51 @@
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { MEDIA_KINDS } from "./types.js";
+// ---------------------------------------------------------------------------
+// Cases leaving the store
+//
+// Two shapes. A batch input is exactly what `zen run batch` accepts — an id and
+// an input, never a rubric, because whatever reaches the agent under test must
+// not include the answer key. A dump is the whole case, rubric and all, for a
+// grader or for another machine, and it reads back in through `apply`.
+//
+// Media paths are stored relative to the project. On the way out they are made
+// relative to the file being written, which is how both `zen run batch` and
+// `apply` read them back; written to stdout, they are absolute.
+// ---------------------------------------------------------------------------
+const URL_LIKE = /^[a-z][a-z0-9+.-]*:/i;
+function rebase(input, root, out) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    return input.map((part) => {
+        if (typeof part === 'string' || 'text' in part) {
+            return part;
+        }
+        const kind = MEDIA_KINDS.find((k) => typeof part[k] === 'string');
+        const ref = kind ? part[kind] : undefined;
+        if (!kind || !ref || URL_LIKE.test(ref)) {
+            return part;
+        }
+        const absolute = isAbsolute(ref) ? ref : resolve(root, ref);
+        const written = out
+            ? relative(dirname(resolve(out)), absolute)
+                .split(sep)
+                .join('/')
+            : absolute;
+        return {
+            ...part,
+            [kind]: written.startsWith('.') || isAbsolute(written) ? written : `./${written}`,
+        };
+    });
+}
+export function batchInput(cases, root, out) {
+    return { batch: cases.map((c) => ({ id: c.id, input: rebase(c.input, root, out) })) };
+}
+export function dump(cases, root, revision, out) {
+    return {
+        version: 1,
+        revision,
+        cases: cases.map((c) => ({ ...c, input: rebase(c.input, root, out) })),
+    };
+}
+//# sourceMappingURL=export.js.map

package/dist/meta/finetune/dataset/index.d.ts

@@ -0,0 +1,2 @@
+export { DATASET_DETAILS, DATASET_HELP, DATASET_SUMMARY, DATASET_USAGE, datasetProjectFlag, runDataset, } from './command.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/meta/finetune/dataset/index.js

@@ -0,0 +1,2 @@
+export { DATASET_DETAILS, DATASET_HELP, DATASET_SUMMARY, DATASET_USAGE, datasetProjectFlag, runDataset, } from "./command.js";
+//# sourceMappingURL=index.js.map

package/dist/meta/finetune/dataset/sample.d.ts

@@ -0,0 +1,50 @@
+import type { Matcher } from '@zenera/neo';
+import { type Case, type NoteKind, type NoteRow, type Verdict } from './types.ts';
+export interface Criteria {
+    status: 'active' | 'retired' | 'all';
+    classes?: string[];
+    complexities?: string[];
+    tags?: string[];
+    rubric?: boolean;
+    expected?: boolean;
+    ids?: Matcher;
+    exclude?: Matcher;
+    idsFrom?: ReadonlySet<string>;
+    changedSince?: number;
+    restarted?: ReadonlySet<string>;
+    verdicts?: Verdict[];
+    neverGraded?: boolean;
+    noteKinds?: NoteKind[];
+    gradedIn?: string[];
+    source?: Matcher;
+    anchor?: Matcher;
+    grep?: Matcher;
+}
+export declare const STRATA_FIELDS: readonly ["class", "complexity", "tag", "source", "rubric", "verdict"];
+export type StratumField = (typeof STRATA_FIELDS)[number];
+export declare const ORDER_KEYS: readonly ["rubric", "complexity", "verdict", "rev", "id"];
+export type OrderKey = (typeof ORDER_KEYS)[number];
+export interface Draw {
+    by: StratumField[];
+    weights: ReadonlyMap<string, number>;
+    order: OrderKey[];
+    count?: number;
+    seed: number;
+}
+export interface Stratum {
+    key: string;
+    weight: number;
+    available: number;
+    chosen: number;
+}
+export interface Sampled {
+    ids: string[];
+    strata: Stratum[];
+    /** cases that passed the filters */
+    matched: number;
+}
+export type NotesOf = (c: Case) => readonly NoteRow[];
+export declare function lastVerdict(c: Case, notes: NotesOf): Verdict | undefined;
+export declare function matches(c: Case, k: Criteria, notes: NotesOf): boolean;
+export declare function sample(cases: readonly Case[], criteria: Criteria, draw: Draw, notes: NotesOf): Sampled;
+//# sourceMappingURL=sample.d.ts.map

package/dist/meta/finetune/dataset/sample.js

@@ -0,0 +1,197 @@
+import { usageError } from "../../host.js";
+import { anchorText, COMPLEXITIES, } from "./types.js";
+export const STRATA_FIELDS = ['class', 'complexity', 'tag', 'source', 'rubric', 'verdict'];
+export const ORDER_KEYS = ['rubric', 'complexity', 'verdict', 'rev', 'id'];
+/** Notes about this revision of the case, oldest first. */
+const current = (c, notes) => notes(c).filter((n) => n.caseRev === c.rev);
+export function lastVerdict(c, notes) {
+    return current(c, notes).findLast((n) => n.verdict)?.verdict;
+}
+const textOf = (c) => [
+    typeof c.input === 'string'
+        ? c.input
+        : c.input
+            .map((p) => (typeof p === 'string' ? p : 'text' in p ? p.text : ''))
+            .join('\n'),
+    ...c.rubric.map((r) => r.text),
+].join('\n');
+export function matches(c, k, notes) {
+    if (k.status !== 'all' && c.status !== k.status) {
+        return false;
+    }
+    if (k.classes && !k.classes.includes(c.class ?? 'unclassified')) {
+        return false;
+    }
+    if (k.complexities && !k.complexities.includes(c.complexity ?? 'unrated')) {
+        return false;
+    }
+    if (k.tags && !(c.tags ?? []).some((t) => k.tags.includes(t))) {
+        return false;
+    }
+    if (k.rubric !== undefined && k.rubric !== c.rubric.length > 0) {
+        return false;
+    }
+    if (k.expected !== undefined && k.expected !== (c.expected !== undefined)) {
+        return false;
+    }
+    if (k.ids && !k.ids(c.id)) {
+        return false;
+    }
+    if (k.exclude?.(c.id)) {
+        return false;
+    }
+    if (k.idsFrom && !k.idsFrom.has(c.id)) {
+        return false;
+    }
+    if (k.changedSince !== undefined && c.rev <= k.changedSince) {
+        return false;
+    }
+    if (k.restarted && !k.restarted.has(c.id)) {
+        return false;
+    }
+    if (k.source && !(c.source && k.source(c.source.file))) {
+        return false;
+    }
+    if (k.anchor && !(c.source && k.anchor(anchorText(c.source.anchor)))) {
+        return false;
+    }
+    if (k.grep && !k.grep(textOf(c))) {
+        return false;
+    }
+    if (k.verdicts || k.neverGraded || k.noteKinds || k.gradedIn) {
+        const mine = current(c, notes);
+        const verdict = mine.findLast((n) => n.verdict)?.verdict;
+        if (k.verdicts && !(verdict && k.verdicts.includes(verdict))) {
+            return false;
+        }
+        if (k.neverGraded && mine.some((n) => n.kind === 'graded' || n.verdict)) {
+            return false;
+        }
+        if (k.noteKinds && !mine.some((n) => k.noteKinds.includes(n.kind))) {
+            return false;
+        }
+        if (k.gradedIn && !mine.some((n) => n.run !== undefined && k.gradedIn.includes(n.run))) {
+            return false;
+        }
+    }
+    return true;
+}
+function stratumValue(c, field, notes) {
+    switch (field) {
+        case 'class':
+            return c.class ?? 'unclassified';
+        case 'complexity':
+            return c.complexity ?? 'unrated';
+        case 'tag':
+            return c.tags?.length ? [...c.tags].sort().join(',') : 'untagged';
+        case 'source':
+            return c.source?.file ?? 'no source';
+        case 'rubric':
+            return c.rubric.length > 0 ? 'rubric' : 'no rubric';
+        case 'verdict':
+            return lastVerdict(c, notes) ?? 'ungraded';
+    }
+}
+const COMPLEX_RANK = { complex: 0, medium: 1, simple: 2 };
+const VERDICT_RANK = { wrong: 0, void: 1, right: 3 };
+function rank(c, key, notes) {
+    switch (key) {
+        case 'rubric':
+            return c.rubric.length > 0 ? 0 : 1;
+        case 'complexity':
+            return COMPLEX_RANK[c.complexity ?? ''] ?? COMPLEXITIES.length;
+        case 'verdict':
+            return VERDICT_RANK[lastVerdict(c, notes) ?? ''] ?? 2;
+        case 'rev':
+            return -c.rev;
+        case 'id':
+            return c.id;
+    }
+}
+/** Lehmer / Park-Miller: exact in a double, so the same on every machine. */
+function lehmer(seed) {
+    let s = seed % 2147483647;
+    if (s <= 0) {
+        s += 2147483646;
+    }
+    return () => {
+        s = (s * 48271) % 2147483647;
+        return s;
+    };
+}
+/** FNV-1a, so each stratum shuffles on its own and a new case elsewhere moves nothing here. */
+function hash(text) {
+    let h = 2166136261;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 16777619) >>> 0;
+    }
+    return h;
+}
+function ordered(cases, key, draw, notes) {
+    const next = lehmer(draw.seed + hash(key));
+    const shuffled = [...cases].sort((a, b) => a.id.localeCompare(b.id));
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = next() % (i + 1);
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    const position = new Map(shuffled.map((c, i) => [c.id, i]));
+    return shuffled.sort((a, b) => {
+        for (const k of draw.order) {
+            const x = rank(a, k, notes);
+            const y = rank(b, k, notes);
+            if (x !== y) {
+                return x < y ? -1 : 1;
+            }
+        }
+        return position.get(a.id) - position.get(b.id);
+    });
+}
+export function sample(cases, criteria, draw, notes) {
+    const eligible = cases.filter((c) => matches(c, criteria, notes));
+    const groups = new Map();
+    for (const c of eligible) {
+        const key = draw.by.length === 0
+            ? 'all'
+            : draw.by.map((f) => stratumValue(c, f, notes)).join(' · ');
+        groups.set(key, [...(groups.get(key) ?? []), c]);
+    }
+    const unknown = [...draw.weights.keys()].filter((k) => !groups.has(k));
+    if (unknown.length > 0 && eligible.length > 0) {
+        throw usageError(`no stratum ${unknown.map((k) => `"${k}"`).join(', ')}`, `the strata are: ${[...groups.keys()].sort().join(', ')}`);
+    }
+    const lanes = [...groups.keys()].sort().map((key) => ({
+        key,
+        weight: draw.weights.get(key) ?? 1,
+        queue: ordered(groups.get(key), key, draw, notes),
+        taken: 0,
+        current: 0,
+    }));
+    const ids = [];
+    let live = lanes.filter((l) => l.weight > 0 && l.queue.length > 0);
+    const limit = draw.count ?? Infinity;
+    while (live.length > 0 && ids.length < limit) {
+        const total = live.reduce((sum, l) => sum + l.weight, 0);
+        let best = live[0];
+        for (const lane of live) {
+            lane.current += lane.weight;
+            if (lane.current > best.current) {
+                best = lane;
+            }
+        }
+        best.current -= total;
+        ids.push(best.queue[best.taken++].id);
+        live = live.filter((l) => l.taken < l.queue.length);
+    }
+    return {
+        ids,
+        matched: eligible.length,
+        strata: lanes.map((l) => ({
+            key: l.key,
+            weight: l.weight,
+            available: l.queue.length,
+            chosen: l.taken,
+        })),
+    };
+}
+//# sourceMappingURL=sample.js.map

package/dist/meta/finetune/dataset/schema.d.ts

@@ -0,0 +1,33 @@
+import { type Anchor, type Complexity, type Input } from './types.ts';
+export interface ProposedRubric {
+    id?: string;
+    text: string;
+}
+export interface Proposed {
+    id: string;
+    class?: string;
+    complexity?: Complexity;
+    tags?: string[];
+    input: Input;
+    rubric: ProposedRubric[];
+    expected?: string;
+    notes?: string;
+    source?: {
+        file: string;
+        anchor?: Anchor;
+    };
+}
+/**
+ * `{ heading: "A > B" }`, `{ heading: ["A", "B"] }`, `{ pointer: "/x/0" }`, or
+ * nothing for the whole file.
+ */
+export declare function readAnchor(raw: unknown, where: string, issues: string[]): Anchor | undefined;
+/** Inside the project: relative to it. Outside: absolute. */
+export declare function projectPath(root: string, absolute: string): string;
+/**
+ * Every case in a proposal, or a thrown list of what is wrong with it. Media
+ * paths resolve against the proposal file, the way `zen run batch` resolves
+ * them against its input, and are kept relative to the project from then on.
+ */
+export declare function readProposal(doc: unknown, file: string, root: string): Proposed[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/meta/finetune/dataset/schema.js

@@ -0,0 +1,216 @@
+import { existsSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { invalidError } from "../../host.js";
+import { CASE_ID, COMPLEXITIES, MEDIA_KINDS, } from "./types.js";
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** A url, a data uri: anything with a scheme is not a path to rebase. */
+const URL_LIKE = /^[a-z][a-z0-9+.-]*:/i;
+/**
+ * `{ heading: "A > B" }`, `{ heading: ["A", "B"] }`, `{ pointer: "/x/0" }`, or
+ * nothing for the whole file.
+ */
+export function readAnchor(raw, where, issues) {
+    if (raw === undefined || raw === null) {
+        return undefined;
+    }
+    if (!isObject(raw)) {
+        issues.push(`${where}: anchor must be an object`);
+        return undefined;
+    }
+    if (raw.heading !== undefined && raw.pointer !== undefined) {
+        issues.push(`${where}: anchor names both a heading and a pointer`);
+        return undefined;
+    }
+    if (raw.heading !== undefined) {
+        const path = typeof raw.heading === 'string'
+            ? raw.heading.split(' > ')
+            : Array.isArray(raw.heading) && raw.heading.every((h) => typeof h === 'string')
+                ? raw.heading
+                : undefined;
+        const clean = path?.map((h) => h.trim()).filter(Boolean);
+        if (!clean || clean.length === 0) {
+            issues.push(`${where}: anchor.heading must be a heading or a list of them`);
+            return undefined;
+        }
+        return { heading: clean };
+    }
+    if (raw.pointer !== undefined) {
+        if (typeof raw.pointer !== 'string' ||
+            !(raw.pointer === '' || raw.pointer.startsWith('/'))) {
+            issues.push(`${where}: anchor.pointer must be a JSON pointer like /cases/0`);
+            return undefined;
+        }
+        return { pointer: raw.pointer };
+    }
+    return undefined;
+}
+/** Inside the project: relative to it. Outside: absolute. */
+export function projectPath(root, absolute) {
+    const rel = relative(root, absolute);
+    return rel.startsWith('..') || isAbsolute(rel) ? absolute : rel.split(sep).join('/');
+}
+function readInput(raw, where, base, root, issues) {
+    if (typeof raw === 'string') {
+        return raw.trim() ? raw : (issues.push(`${where}: input is empty`), undefined);
+    }
+    if (!Array.isArray(raw) || raw.length === 0) {
+        issues.push(`${where}: input must be a string or a non-empty list of parts`);
+        return undefined;
+    }
+    const parts = [];
+    raw.forEach((part, i) => {
+        if (typeof part === 'string') {
+            parts.push(part);
+            return;
+        }
+        if (isObject(part) && typeof part.text === 'string') {
+            parts.push({ text: part.text });
+            return;
+        }
+        const kind = MEDIA_KINDS.find((k) => isObject(part) && typeof part[k] === 'string');
+        if (!kind || !isObject(part)) {
+            issues.push(`${where}: input[${i}] is neither text nor ${MEDIA_KINDS.join('/')}`);
+            return;
+        }
+        const ref = part[kind];
+        let stored = ref;
+        if (!URL_LIKE.test(ref)) {
+            const at = resolve(base, ref);
+            if (!existsSync(at)) {
+                issues.push(`${where}: input[${i}] ${kind} ${ref} does not exist`);
+            }
+            stored = projectPath(root, at);
+        }
+        parts.push({
+            [kind]: stored,
+            ...(typeof part.mimeType === 'string' ? { mimeType: part.mimeType } : {}),
+        });
+    });
+    return parts;
+}
+function readOne(raw, index, base, root, issues) {
+    if (!isObject(raw)) {
+        issues.push(`case ${index}: not an object`);
+        return undefined;
+    }
+    const id = raw.id;
+    if (typeof id !== 'string' || !CASE_ID.test(id) || id === '.' || id === '..') {
+        issues.push(`case ${index}: id must be letters, digits, dot, dash or underscore`);
+        return undefined;
+    }
+    const where = id;
+    const input = readInput(raw.input, where, base, root, issues);
+    const rubric = [];
+    if (raw.rubric !== undefined) {
+        if (!Array.isArray(raw.rubric)) {
+            issues.push(`${where}: rubric must be a list`);
+        }
+        else {
+            raw.rubric.forEach((item, i) => {
+                if (typeof item === 'string' && item.trim()) {
+                    rubric.push({ text: item });
+                }
+                else if (isObject(item) && typeof item.text === 'string' && item.text.trim()) {
+                    rubric.push({
+                        text: item.text,
+                        ...(typeof item.id === 'string' ? { id: item.id } : {}),
+                    });
+                }
+                else {
+                    issues.push(`${where}: rubric[${i}] is not a line of text`);
+                }
+            });
+        }
+    }
+    let complexity;
+    if (raw.complexity !== undefined) {
+        if (COMPLEXITIES.includes(raw.complexity)) {
+            complexity = raw.complexity;
+        }
+        else {
+            issues.push(`${where}: complexity must be one of ${COMPLEXITIES.join(', ')}`);
+        }
+    }
+    const text = (key) => {
+        const v = raw[key];
+        if (v === undefined || v === null) {
+            return undefined;
+        }
+        if (typeof v !== 'string') {
+            issues.push(`${where}: ${key} must be a string`);
+            return undefined;
+        }
+        return v;
+    };
+    let tags;
+    if (raw.tags !== undefined) {
+        if (Array.isArray(raw.tags) && raw.tags.every((t) => typeof t === 'string' && t.trim())) {
+            tags = [...new Set(raw.tags.map((t) => t.trim()))];
+        }
+        else {
+            issues.push(`${where}: tags must be a list of words`);
+        }
+    }
+    let source;
+    const rawSource = typeof raw.source === 'string' ? { file: raw.source } : raw.source;
+    if (rawSource !== undefined) {
+        if (!isObject(rawSource) || typeof rawSource.file !== 'string' || !rawSource.file) {
+            issues.push(`${where}: source must name a file`);
+        }
+        else {
+            const at = resolve(root, rawSource.file);
+            if (!existsSync(at)) {
+                issues.push(`${where}: source ${rawSource.file} does not exist`);
+            }
+            source = {
+                file: projectPath(root, at),
+                ...(rawSource.anchor !== undefined
+                    ? { anchor: readAnchor(rawSource.anchor, where, issues) }
+                    : {}),
+            };
+        }
+    }
+    if (!input) {
+        return undefined;
+    }
+    const cls = text('class');
+    const expected = text('expected');
+    const notes = text('notes');
+    return {
+        id,
+        ...(cls ? { class: cls } : {}),
+        ...(complexity ? { complexity } : {}),
+        ...(tags && tags.length > 0 ? { tags } : {}),
+        input,
+        rubric,
+        ...(expected ? { expected } : {}),
+        ...(notes ? { notes } : {}),
+        ...(source ? { source } : {}),
+    };
+}
+/**
+ * Every case in a proposal, or a thrown list of what is wrong with it. Media
+ * paths resolve against the proposal file, the way `zen run batch` resolves
+ * them against its input, and are kept relative to the project from then on.
+ */
+export function readProposal(doc, file, root) {
+    const list = Array.isArray(doc) ? doc : isObject(doc) ? (doc.cases ?? doc.samples) : undefined;
+    if (!Array.isArray(list)) {
+        throw invalidError(`${file} holds no cases`, 'write { "cases": [ … ] } — or a bare list of cases');
+    }
+    const issues = [];
+    const base = dirname(resolve(file));
+    const cases = list.flatMap((raw, i) => readOne(raw, i, base, root, issues) ?? []);
+    const seen = new Set();
+    for (const c of cases) {
+        if (seen.has(c.id)) {
+            issues.push(`${c.id}: the id appears more than once`);
+        }
+        seen.add(c.id);
+    }
+    if (issues.length > 0) {
+        throw invalidError(`${file}: ${issues.length} problem${issues.length === 1 ? '' : 's'}\n  ${issues.join('\n  ')}`, 'fix the proposal and apply it again; nothing was written');
+    }
+    return cases;
+}
+//# sourceMappingURL=schema.js.map