team 0.0.1 → 0.1.1

package/dist/file/validate.js

@@ -0,0 +1,702 @@
+import { CLIS } from "../clis.js";
+import { ALWAYS_ON, CHECK_NAMES } from "../watch/check.js";
+import { YamlError, parseYaml } from "../yaml.js";
+import { findSecrets } from "./secrets.js";
+import { DEFAULT_COMMIT_TEMPLATE, DEFAULT_FORBIDDEN, DEFAULT_PR_TEMPLATE, hasVersionToken, isTrailerTemplate, templateProblem, } from "./signature.js";
+import { insideProject, insideTrust, normalize, trustProblem } from "./paths.js";
+const POSITIONS = ['last-line', 'trailer', 'anywhere'];
+const MODES = ['worktree', 'shared'];
+// Validates the text of a team file. Every problem is collected, each with its line.
+export function validateTeamFile(text) {
+    let root;
+    try {
+        root = parseYaml(text);
+    }
+    catch (error) {
+        if (error instanceof YamlError)
+            return { ok: false, errors: [{ line: error.line, message: error.message }] };
+        throw error;
+    }
+    const check = new Check();
+    const secrets = findSecrets(root);
+    check.problems.push(...secrets.refused);
+    check.warnings.push(...secrets.warned);
+    const team = readTeam(root, check);
+    if (check.problems.length || !team) {
+        return { ok: false, errors: check.problems.sort((a, b) => a.line - b.line) };
+    }
+    return { ok: true, team, warnings: check.warnings };
+}
+class Check {
+    problems = [];
+    warnings = [];
+    fail(line, message) {
+        this.problems.push({ line, message });
+    }
+    // The fields of a map, with every field outside `known` reported.
+    fields(node, where, known) {
+        const fields = new Map();
+        if (!node)
+            return fields;
+        if (node.kind !== 'map') {
+            if (!(node.kind === 'scalar' && node.value === null))
+                this.fail(node.line, `${where} must be a map of fields`);
+            return fields;
+        }
+        for (const entry of node.entries) {
+            if (known.includes(entry.key))
+                fields.set(entry.key, entry);
+            else
+                this.fail(entry.line, `unknown field "${entry.key}" in ${where}`);
+        }
+        return fields;
+    }
+    text(entry, name) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'string' && node.value !== '')
+            return node.value;
+        this.fail(node.line, `${name} must be text${node.kind === 'scalar' && node.value !== null && node.value !== '' ? ': quote it' : ''}`);
+        return undefined;
+    }
+    required(entry, name, line) {
+        if (!entry)
+            this.fail(line, `${name} is required`);
+        return this.text(entry, name);
+    }
+    oneOf(entry, name, values) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'string' && values.includes(node.value)) {
+            return node.value;
+        }
+        this.fail(node.line, `${name} must be one of: ${values.join(', ')}`);
+        return undefined;
+    }
+    flag(entry, name) {
+        if (!entry)
+            return false;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'boolean' && !node.quoted)
+            return node.value;
+        this.fail(node.line, `${name} must be true or false`);
+        return false;
+    }
+    whole(entry, name, least) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'number' && Number.isInteger(node.value) && node.value >= least) {
+            return node.value;
+        }
+        this.fail(node.line, `${name} must be a whole number, ${least} or more`);
+        return undefined;
+    }
+    number(entry, name) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'number' && Number.isFinite(node.value) && node.value > 0) {
+            return node.value;
+        }
+        this.fail(node.line, `${name} must be a number above 0`);
+        return undefined;
+    }
+    // A value with its unit, such as 120s, 25% or 10GB.
+    measure(entry, name, units, example) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        const raw = node.kind === 'scalar' ? node.raw : '';
+        const match = /^([0-9]+(?:\.[0-9]+)?)([A-Za-z%]+)$/.exec(raw);
+        const unit = match?.[2];
+        if (match && unit !== undefined && unit in units && node.kind === 'scalar' && !node.quoted) {
+            return Number(match[1]) * units[unit];
+        }
+        this.fail(node.line, `${name} needs a value with its unit (${Object.keys(units).join(', ')}), such as ${example}`);
+        return undefined;
+    }
+    list(entry, name) {
+        if (!entry)
+            return [];
+        const node = entry.value;
+        if (node.kind !== 'seq') {
+            if (!(node.kind === 'scalar' && node.value === null))
+                this.fail(node.line, `${name} must be a list`);
+            return [];
+        }
+        const out = [];
+        for (const item of node.items) {
+            if (item.kind === 'scalar' && typeof item.value === 'string' && item.value !== '') {
+                out.push({ value: item.value, line: item.line });
+            }
+            else {
+                this.fail(item.line, `each item of ${name} must be text${item.kind === 'map' ? ': quote a line that contains ": "' : ''}`);
+            }
+        }
+        return out;
+    }
+}
+const DURATION = { s: 1, m: 60, h: 3600 };
+const PERCENT = { '%': 1 };
+const SIZE = { MB: 1e6, GB: 1e9, TB: 1e12 };
+function readTeam(root, check) {
+    if (root.kind !== 'map') {
+        check.fail(root.line, 'the file must be a map of fields, starting with "format: 1"');
+        return null;
+    }
+    const top = check.fields(root, 'the file', [
+        'format', 'project', 'visibility', 'session', 'coordinator', 'operator', 'tools', 'identity', 'rules',
+        'trust', 'workspace', 'watch', 'machine', 'limits', 'seats', 'budgets',
+    ]);
+    const format = top.get('format');
+    if (!format)
+        check.fail(1, 'format is required: "format: 1"');
+    else if (!(format.value.kind === 'scalar' && format.value.value === 1 && !format.value.quoted)) {
+        check.fail(format.line, 'format must be 1: this version of team reads no other');
+    }
+    const project = check.required(top.get('project'), 'project', 1) ?? '';
+    if (project && !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(project)) {
+        check.fail(top.get('project')?.line ?? 1, 'project must be a short name: letters, digits, ".", "_" and "-"');
+    }
+    const session = check.text(top.get('session'), 'session') ?? project;
+    if (session === 'default') {
+        check.fail(top.get('session')?.line ?? top.get('project')?.line ?? 1, 'session can\'t be "default", herdr\'s own session: give the team a session of its own');
+    }
+    const identity = readIdentity(top.get('identity'), check);
+    const declaredVisibility = check.oneOf(top.get('visibility'), 'visibility', ['public', 'private']);
+    const visibility = declaredVisibility ?? (identity.forbiddenPublic.length ? 'public' : 'private');
+    const trustItems = check.list(top.get('trust'), 'trust');
+    for (const item of trustItems) {
+        const problem = trustProblem(item.value);
+        if (problem)
+            check.fail(item.line, `trust: "${item.value}" ${problem}`);
+    }
+    const trust = trustItems.map((item) => item.value);
+    const broken = new Set();
+    const seats = readSeats(top.get('seats'), check, trust, root.line, broken);
+    const workspace = readWorkspace(top.get('workspace'), check, project, trust, seats, root.line);
+    for (const seat of seats)
+        seat.mode ??= workspace.mode;
+    const coordinator = readLead(top.get('coordinator'), 'coordinator', seats, broken, check);
+    const operator = readLead(top.get('operator'), 'operator', seats, broken, check);
+    const limits = readLimits(top.get('limits'), check, seats.length);
+    const watched = readWatch(top.get('watch'), check);
+    return {
+        format: 1,
+        project,
+        visibility,
+        session,
+        coordinator,
+        operator,
+        tools: readTools(top.get('tools'), check),
+        identity,
+        rules: check.list(top.get('rules'), 'rules').map((item) => item.value),
+        trust,
+        workspace,
+        watch: watched.watch,
+        budgets: readBudgets(top.get('budgets'), check, watched.watch.quotaMarks, watched.legacyMarks),
+        machine: readMachine(top.get('machine'), check),
+        limits,
+        seats: seats,
+    };
+}
+function readTools(entry, check) {
+    const tools = {};
+    if (!entry)
+        return tools;
+    if (entry.value.kind !== 'map') {
+        check.fail(entry.value.line, 'tools must be a map: a name, then its kind and where it is');
+        return tools;
+    }
+    for (const tool of entry.value.entries) {
+        const fields = {};
+        if (tool.value.kind !== 'map') {
+            check.fail(tool.value.line, `tools.${tool.key} must be a map with a kind`);
+            continue;
+        }
+        for (const field of tool.value.entries) {
+            const value = check.text(field, `tools.${tool.key}.${field.key}`);
+            if (value !== undefined)
+                fields[field.key] = value;
+        }
+        if (!('kind' in fields))
+            check.fail(tool.line, `tools.${tool.key} needs a kind`);
+        tools[tool.key] = fields;
+    }
+    return tools;
+}
+function readIdentity(entry, check) {
+    const identity = check.fields(entry?.value, 'identity', ['signature', 'humans', 'since', 'forbidden', 'forbidden_public']);
+    const signature = check.fields(identity.get('signature')?.value, 'identity.signature', ['template', 'commits', 'pull_requests']);
+    const commits = check.fields(signature.get('commits')?.value, 'identity.signature.commits', ['template', 'position', 'exempt']);
+    const prs = check.fields(signature.get('pull_requests')?.value, 'identity.signature.pull_requests', ['template', 'position', 'exempt']);
+    const base = readTemplate(signature.get('template'), 'identity.signature.template', check) ?? DEFAULT_COMMIT_TEMPLATE;
+    const commitTemplate = readTemplate(commits.get('template'), 'identity.signature.commits.template', check) ?? base;
+    const prTemplate = readTemplate(prs.get('template'), 'identity.signature.pull_requests.template', check) ?? DEFAULT_PR_TEMPLATE;
+    const commitPosition = check.oneOf(commits.get('position'), 'identity.signature.commits.position', POSITIONS) ?? 'trailer';
+    const prPosition = check.oneOf(prs.get('position'), 'identity.signature.pull_requests.position', POSITIONS) ?? 'last-line';
+    if (commitPosition === 'trailer' && !isTrailerTemplate(commitTemplate)) {
+        const line = commits.get('position')?.line ?? commits.get('template')?.line ?? signature.get('template')?.line ?? entry?.line ?? 1;
+        check.fail(line, 'position "trailer" needs a template git reads as a trailer: "<token>: <value>", the token without spaces');
+    }
+    const exemptEntry = commits.get('exempt');
+    const exempt = exemptEntry ? check.list(exemptEntry, 'identity.signature.commits.exempt') : [{ value: 'merge', line: 0 }];
+    for (const item of exempt) {
+        if (item.value !== 'merge')
+            check.fail(item.line, `exempt takes only "merge" in this version, found "${item.value}"`);
+    }
+    const prExempt = prs.get('exempt');
+    if (prExempt)
+        check.fail(prExempt.line, 'pull_requests has no exempt: it applies to commits only');
+    const forbidden = readPatterns(identity.get('forbidden'), 'identity.forbidden', check);
+    const forbiddenPublic = readPatterns(identity.get('forbidden_public'), 'identity.forbidden_public', check);
+    return {
+        signature: {
+            commits: { template: commitTemplate, position: commitPosition, exempt: exempt.some((item) => item.value === 'merge') ? ['merge'] : [] },
+            pullRequests: { template: prTemplate, position: prPosition },
+        },
+        humans: check.list(identity.get('humans'), 'identity.humans').map((item) => item.value),
+        since: check.text(identity.get('since'), 'identity.since') ?? null,
+        forbidden: [...DEFAULT_FORBIDDEN, ...forbidden.filter((pattern) => !DEFAULT_FORBIDDEN.includes(pattern))],
+        forbiddenPublic,
+    };
+}
+function readTemplate(entry, name, check) {
+    const template = check.text(entry, name);
+    if (template === undefined || !entry)
+        return undefined;
+    const problem = templateProblem(template);
+    if (problem)
+        check.fail(entry.value.line, `${name}: ${problem}`);
+    return template;
+}
+function readPatterns(entry, name, check) {
+    const out = [];
+    for (const item of check.list(entry, name)) {
+        try {
+            new RegExp(item.value);
+            out.push(item.value);
+        }
+        catch (error) {
+            check.fail(item.line, `${name}: not a regular expression (${error.message})`);
+        }
+    }
+    return out;
+}
+// `broken` collects the names of seats left out for their own problems, so that a reference to
+// one is not reported a second time.
+function readSeats(entry, check, trust, topLine, broken) {
+    if (!entry) {
+        check.fail(topLine, 'seats is required: at least the coordinator\'s and the operator\'s seat');
+        return [];
+    }
+    if (entry.value.kind !== 'seq' || !entry.value.items.length) {
+        check.fail(entry.value.line, 'seats must be a list with at least one seat');
+        return [];
+    }
+    const seats = [];
+    for (const item of entry.value.items) {
+        const fields = check.fields(item, 'a seat', [
+            'role', 'name', 'cli', 'vendor', 'model', 'version', 'display', 'launch', 'cwd', 'label', 'mode',
+            'parked', 'stopped', 'count',
+        ]);
+        if (item.kind !== 'map')
+            continue;
+        const line = item.line;
+        const role = check.required(fields.get('role'), 'a seat\'s role', line);
+        const name = check.required(fields.get('name'), 'a seat\'s name', line);
+        const at = name ? `seat "${name}"` : 'a seat';
+        if (name && !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) {
+            check.fail(fields.get('name')?.line ?? line, `${at}: the name takes letters, digits, ".", "_" and "-"`);
+        }
+        if (!fields.get('cli'))
+            check.fail(line, `${at}: cli is required`);
+        const cli = check.oneOf(fields.get('cli'), `${at}: cli`, CLIS);
+        const vendor = check.required(fields.get('vendor'), `${at}: vendor`, line);
+        const model = check.required(fields.get('model'), `${at}: model`, line);
+        const version = readVersion(fields.get('version'), at, line, check);
+        const launch = check.required(fields.get('launch'), `${at}: launch`, line);
+        const display = check.text(fields.get('display'), `${at}: display`) ?? (model && version ? `${model} ${version}` : undefined);
+        if (display && version && fields.get('display') && !hasVersionToken(display, version)) {
+            check.fail(fields.get('display')?.line ?? line, `${at}: display must contain the version "${version}" as a token of its own`);
+        }
+        const cwd = readCwd(fields.get('cwd'), at, trust, check);
+        const mode = check.oneOf(fields.get('mode'), `${at}: mode`, MODES);
+        const parked = check.flag(fields.get('parked'), `${at}: parked`);
+        const stopped = check.flag(fields.get('stopped'), `${at}: stopped`);
+        const count = check.whole(fields.get('count'), `${at}: count`, 1) ?? 1;
+        const label = check.text(fields.get('label'), `${at}: label`);
+        if (!role || !name || !cli || !vendor || !model || !version || !launch || !display) {
+            if (name)
+                broken.add(name);
+            continue;
+        }
+        for (let instance = 1; instance <= count; instance++) {
+            const suffix = instance === 1 ? '' : `-${instance}`;
+            seats.push({
+                role, cli, vendor, model, version, display, launch, cwd, parked, stopped, line,
+                name: name + suffix,
+                label: (label ?? name) + suffix,
+                declared: name,
+                count,
+                instance,
+                ...(mode ? { mode } : {}),
+            });
+        }
+    }
+    reportCollisions(seats, 'name', check);
+    reportCollisions(seats, 'label', check);
+    return seats;
+}
+function readVersion(entry, at, line, check) {
+    if (!entry) {
+        check.fail(line, `${at}: version is required`);
+        return undefined;
+    }
+    const node = entry.value;
+    if (node.kind === 'scalar' && typeof node.value === 'string' && node.value !== '')
+        return node.value;
+    if (node.kind === 'scalar' && typeof node.value === 'number') {
+        check.fail(node.line, `${at}: version must be quoted ("${node.raw}"): unquoted, YAML reads it as a number and 4.10 becomes 4.1`);
+    }
+    else
+        check.fail(node.line, `${at}: version must be quoted text`);
+    return undefined;
+}
+function readCwd(entry, at, trust, check) {
+    const cwd = check.text(entry, `${at}: cwd`);
+    if (cwd === undefined || !entry)
+        return '.';
+    if (cwd.startsWith('/') || cwd.startsWith('~') || /^[A-Za-z]:[\\/]/.test(cwd)) {
+        check.fail(entry.value.line, `${at}: cwd must be relative to the project, never absolute and never "~"`);
+        return '.';
+    }
+    const path = normalize(cwd);
+    if (!insideProject(path) && !insideTrust(path, trust)) {
+        check.fail(entry.value.line, `${at}: cwd "${cwd}" is outside the project and matches no trust path`);
+    }
+    return path;
+}
+function reportCollisions(seats, field, check) {
+    const seen = new Map();
+    for (const seat of seats) {
+        const first = seen.get(seat[field]);
+        if (!first)
+            seen.set(seat[field], seat);
+        else if (first.line !== seat.line || first.instance === seat.instance) {
+            check.fail(seat.line, `two seats have the ${field} "${seat[field]}" (the other is on line ${first.line}${first.count > 1 || seat.count > 1 ? ', after count is expanded' : ''})`);
+        }
+    }
+}
+function readLead(entry, field, seats, broken, check) {
+    const name = check.required(entry, field, 1);
+    if (!name || !entry)
+        return '';
+    const seat = seats.find((candidate) => candidate.name === name);
+    const line = entry.value.line;
+    if (!seat) {
+        if (!broken.has(name))
+            check.fail(line, `${field} "${name}" names no declared seat`);
+    }
+    else if (seat.count > 1)
+        check.fail(line, `${field} "${name}" can't be a seat with count`);
+    else if (seat.parked)
+        check.fail(line, `${field} "${name}" can't be a parked seat`);
+    else if (seat.stopped)
+        check.fail(line, `${field} "${name}" can't be a stopped seat`);
+    return name;
+}
+function readWorkspace(entry, check, project, trust, seats, topLine) {
+    const fields = check.fields(entry?.value, 'workspace', ['mode', 'path', 'branch', 'base', 'setup', 'remove', 'protected', 'limit']);
+    const mode = check.oneOf(fields.get('mode'), 'workspace.mode', MODES) ?? 'worktree';
+    const usesWorktrees = seats.some((seat) => (seat.mode ?? mode) === 'worktree');
+    const line = entry?.line ?? topLine;
+    const path = check.text(fields.get('path'), 'workspace.path') ?? null;
+    const base = check.text(fields.get('base'), 'workspace.base') ?? null;
+    if (usesWorktrees && !base)
+        check.fail(line, 'workspace.base is required when a seat works in worktrees');
+    if (usesWorktrees && !path)
+        check.fail(line, 'workspace.path is required when a seat works in worktrees');
+    if (path) {
+        const at = fields.get('path')?.value.line ?? line;
+        const problem = worktreePathProblem(path, project, trust);
+        if (problem)
+            check.fail(at, `workspace.path ${problem}`);
+    }
+    const protectedPaths = fields.get('protected') ? check.list(fields.get('protected'), 'workspace.protected').map((item) => item.value) : ['.'];
+    return {
+        mode,
+        path,
+        branch: check.text(fields.get('branch'), 'workspace.branch') ?? '{task}',
+        base,
+        setup: check.list(fields.get('setup'), 'workspace.setup').map((item) => item.value),
+        remove: check.oneOf(fields.get('remove'), 'workspace.remove', ['on-merge', 'manual']) ?? 'on-merge',
+        protected: protectedPaths,
+        limit: check.whole(fields.get('limit'), 'workspace.limit', 1) ?? 8,
+    };
+}
+// A worktree goes under a fixed folder of its own, and inside a trust path.
+function worktreePathProblem(path, project, trust) {
+    if (path.startsWith('/') || path.startsWith('~'))
+        return 'must be relative to the project';
+    const segments = path.split('/').filter((segment) => segment && segment !== '.');
+    const last = segments[segments.length - 1];
+    if (last !== '{task}')
+        return 'must end with the segment {task}';
+    if (segments.slice(0, -1).some((segment) => segment.includes('{task}')))
+        return 'takes {task} only as its last segment';
+    const folder = segments.slice(0, -1).map((segment) => segment.replaceAll('{repo}', project || 'project'));
+    if (folder.every((segment) => segment === '..')) {
+        return 'needs a fixed folder of its own before {task}: this one puts worktrees straight into the project or one of its parents';
+    }
+    const sample = normalize([...folder, 'task'].join('/'));
+    if (!insideTrust(sample, trust))
+        return 'matches no trust pattern';
+    return null;
+}
+/**
+ * The watch values a file that sets none runs with — and, since the section is the owner's, the
+ * values a file runs with until the owner approves what it sets instead.
+ */
+export function defaultWatch() {
+    return {
+        interval: 120,
+        idleFirst: 600,
+        idleRepeat: 1200,
+        teamIdle: 600,
+        nudgeWait: 600,
+        unsentAfter: 60,
+        quotaMarks: [50, 75, 90],
+        checks: [],
+    };
+}
+function readWatch(entry, check) {
+    const fields = check.fields(entry?.value, 'watch', [
+        'interval', 'idle_first', 'idle_repeat', 'team_idle', 'nudge_wait', 'unsent_after', 'quota_marks', 'checks',
+    ]);
+    const time = (name, fallback) => check.measure(fields.get(name), `watch.${name}`, DURATION, '120s or 10m') ?? fallback;
+    const base = defaultWatch();
+    let quotaMarks = base.quotaMarks;
+    const marks = fields.get('quota_marks');
+    if (marks) {
+        const node = marks.value;
+        const numbers = node.kind === 'seq' ? node.items.map((item) => (item.kind === 'scalar' ? item.value : null)) : null;
+        if (numbers && numbers.every((n) => typeof n === 'number' && n > 0 && n <= 100))
+            quotaMarks = numbers;
+        else
+            check.fail(node.line, 'watch.quota_marks must be a list of percentages, such as [50, 75, 90]');
+        check.warnings.push({ line: node.line, message: 'watch.quota_marks is now budgets.marks, and is still read' });
+    }
+    return {
+        legacyMarks: Boolean(marks),
+        watch: {
+            interval: time('interval', base.interval),
+            idleFirst: time('idle_first', base.idleFirst),
+            idleRepeat: time('idle_repeat', base.idleRepeat),
+            teamIdle: time('team_idle', base.teamIdle),
+            nudgeWait: time('nudge_wait', base.nudgeWait),
+            unsentAfter: time('unsent_after', base.unsentAfter),
+            quotaMarks,
+            checks: readChecks(fields.get('checks'), check),
+        },
+    };
+}
+// The checks a file turns off: a map of check name to `off`. A name that doesn't exist is refused
+// with its line, and so is one of the four that always run (RFC 0002 § 4.2) — the schema refuses
+// them, and `team approve` validates before it fingerprints, so neither can approve them either.
+function readChecks(entry, check) {
+    const off = [];
+    if (!entry)
+        return off;
+    const node = entry.value;
+    if (node.kind !== 'map') {
+        if (!(node.kind === 'scalar' && node.value === null)) {
+            check.fail(node.line, 'watch.checks must be a map: a check named, and set off');
+        }
+        return off;
+    }
+    for (const item of node.entries) {
+        if (!CHECK_NAMES.includes(item.key)) {
+            check.fail(item.line, `unknown check "${item.key}" in watch.checks: the checks are ${CHECK_NAMES.join(', ')}`);
+            continue;
+        }
+        if (ALWAYS_ON.includes(item.key)) {
+            check.fail(item.line, `watch.checks can't turn off ${item.key}: ${ALWAYS_ON.join(', ')} always run`);
+            continue;
+        }
+        if (item.value.kind === 'scalar' && item.value.value === 'off')
+            off.push(item.key);
+        else
+            check.fail(item.line, `watch.checks.${item.key} must be off: the only setting is off`);
+    }
+    return off;
+}
+/**
+ * The budget values a file that sets none runs with — and, since the section is the owner's, the
+ * values a file runs with until the owner approves what it sets instead. No accounts: nothing is
+ * budgeted until the owner names one.
+ */
+export function defaultBudgets() {
+    return { staleAfter: 30 * 60, checkEvery: 10 * 60, marks: defaultWatch().quotaMarks, accounts: {} };
+}
+function readBudgets(entry, check, fallbackMarks, legacyMarks) {
+    const base = { ...defaultBudgets(), marks: fallbackMarks };
+    if (!entry)
+        return base;
+    const fields = check.fields(entry.value, 'budgets', ['stale_after', 'check_every', 'marks', 'accounts']);
+    const marks = percentList(fields.get('marks'), 'budgets.marks', check);
+    if (marks && legacyMarks) {
+        check.warnings.push({ line: fields.get('marks')?.line ?? entry.line, message: 'budgets.marks replaces watch.quota_marks' });
+    }
+    return {
+        staleAfter: check.measure(fields.get('stale_after'), 'budgets.stale_after', DURATION, '30m') ?? base.staleAfter,
+        checkEvery: check.measure(fields.get('check_every'), 'budgets.check_every', DURATION, '10m') ?? base.checkEvery,
+        marks: marks ?? fallbackMarks,
+        accounts: readAccounts(fields.get('accounts'), check),
+    };
+}
+function percentList(entry, name, check) {
+    if (!entry)
+        return null;
+    const node = entry.value;
+    const numbers = node.kind === 'seq' ? node.items.map((item) => (item.kind === 'scalar' ? item.value : null)) : null;
+    if (numbers && numbers.length > 0 && numbers.every((n) => typeof n === 'number' && n > 0 && n <= 100))
+        return numbers;
+    check.fail(node.line, `${name} must be a list of percentages, such as [50, 75, 90]`);
+    return null;
+}
+function readAccounts(entry, check) {
+    const accounts = {};
+    if (!entry)
+        return accounts;
+    if (entry.value.kind !== 'map') {
+        check.fail(entry.value.line, 'budgets.accounts must be a map');
+        return accounts;
+    }
+    for (const account of entry.value.entries) {
+        const fields = check.fields(account.value, `budgets.accounts.${account.key}`, ['kind', 'shared', 'reserve', 'floor', 'sources', 'check']);
+        const kind = check.oneOf(fields.get('kind'), `budgets.accounts.${account.key}.kind`, ['subscription', 'spend']);
+        if (!kind) {
+            check.fail(account.line, `budgets.accounts.${account.key} needs kind`);
+            continue;
+        }
+        const command = check.text(fields.get('check'), `budgets.accounts.${account.key}.check`) ?? null;
+        if (command && /\s/.test(command)) {
+            check.fail(fields.get('check')?.line ?? account.line, `budgets.accounts.${account.key}.check names one command, with no arguments; use a wrapper`);
+        }
+        const sources = sourcesOf(fields.get('sources'), account.key, kind, Boolean(command) && !/\s/.test(command ?? ''), check, account.line);
+        if (sources.includes('check') && !command)
+            check.fail(account.line, `budgets.accounts.${account.key} needs check`);
+        if (command && !/\s/.test(command) && !sources.includes('check')) {
+            check.fail(fields.get('check')?.line ?? account.line, `budgets.accounts.${account.key}.check needs sources to list check`);
+        }
+        const measured = kind === 'subscription'
+            ? check.measure(fields.get('reserve'), `budgets.accounts.${account.key}.reserve`, PERCENT, '20%')
+            : undefined;
+        const reserve = measured !== undefined && measured > 0 && measured <= 100 ? measured : null;
+        if (kind === 'subscription' && measured !== undefined && (measured <= 0 || measured > 100)) {
+            check.fail(fields.get('reserve')?.line ?? account.line, `budgets.accounts.${account.key}.reserve must be a percentage above 0 and at most 100, such as 20%`);
+        }
+        if (kind === 'subscription' && !fields.get('reserve'))
+            check.fail(account.line, `budgets.accounts.${account.key} needs reserve`);
+        if (kind === 'spend' && fields.get('reserve'))
+            check.fail(fields.get('reserve')?.line ?? account.line, 'a spend account has a floor, not a reserve');
+        const floor = kind === 'spend' ? money(fields.get('floor'), account.key, check) : null;
+        if (kind === 'spend' && !fields.get('floor'))
+            check.fail(account.line, `budgets.accounts.${account.key} needs floor`);
+        if (kind === 'subscription' && fields.get('floor'))
+            check.fail(fields.get('floor')?.line ?? account.line, 'a subscription has a reserve, not a floor');
+        accounts[account.key] = {
+            kind,
+            shared: check.flag(fields.get('shared'), `budgets.accounts.${account.key}.shared`),
+            reserve,
+            floor,
+            sources,
+            check: command,
+        };
+    }
+    return accounts;
+}
+function sourcesOf(entry, account, kind, hasCheck, check, line) {
+    if (!entry) {
+        if (hasCheck)
+            return ['check'];
+        if (kind === 'subscription')
+            return ['status_line'];
+        check.fail(line, `budgets.accounts.${account} needs check`);
+        return [];
+    }
+    const items = check.list(entry, `budgets.accounts.${account}.sources`);
+    if (items.length === 0) {
+        check.fail(entry.line, `budgets.accounts.${account} needs a source`);
+        return [];
+    }
+    const sources = [];
+    for (const item of items) {
+        if (item.value !== 'check' && item.value !== 'status_line') {
+            check.fail(item.line, `budgets.accounts.${account}.sources must be check or status_line`);
+            continue;
+        }
+        if (kind === 'spend' && item.value === 'status_line') {
+            check.fail(item.line, 'a spend account never reads a screen');
+            continue;
+        }
+        if (sources.includes(item.value))
+            check.fail(item.line, `budgets.accounts.${account}.sources lists ${item.value} twice`);
+        else
+            sources.push(item.value);
+    }
+    return sources;
+}
+function money(entry, account, check) {
+    if (!entry)
+        return null;
+    const raw = entry.value.kind === 'scalar' ? entry.value.raw : '';
+    const match = /^([0-9]+(?:\.[0-9]{1,4})?) ([A-Z]{3})$/.exec(raw);
+    if (!match || match[1] === undefined || match[2] === undefined) {
+        check.fail(entry.line, `budgets.accounts.${account}.floor is an amount and a currency, such as 5 USD`);
+        return null;
+    }
+    return { amount: Number(match[1]), currency: match[2] };
+}
+function readMachine(entry, check) {
+    const fields = check.fields(entry?.value, 'machine', [
+        'load_start', 'load_max', 'memory_start', 'memory_min', 'disk_min', 'swap_free_min', 'swap_growth_max', 'swap_growth_window',
+    ]);
+    return {
+        loadStart: check.number(fields.get('load_start'), 'machine.load_start') ?? 3,
+        loadMax: check.number(fields.get('load_max'), 'machine.load_max') ?? 6,
+        memoryStart: check.measure(fields.get('memory_start'), 'machine.memory_start', PERCENT, '25%') ?? 25,
+        memoryMin: check.measure(fields.get('memory_min'), 'machine.memory_min', PERCENT, '15%') ?? 15,
+        diskMin: check.measure(fields.get('disk_min'), 'machine.disk_min', SIZE, '10GB') ?? 10e9,
+        swapFreeMin: check.measure(fields.get('swap_free_min'), 'machine.swap_free_min', SIZE, '2GB') ?? 2e9,
+        swapGrowthMax: check.measure(fields.get('swap_growth_max'), 'machine.swap_growth_max', SIZE, '1GB') ?? 1e9,
+        swapGrowthWindow: check.measure(fields.get('swap_growth_window'), 'machine.swap_growth_window', DURATION, '10m') ?? 600,
+    };
+}
+function readLimits(entry, check, declared) {
+    const fields = check.fields(entry?.value, 'limits', ['seats', 'temporary', 'vendors']);
+    const temporary = check.whole(fields.get('temporary'), 'limits.temporary', 0) ?? 2;
+    const vendors = {};
+    const vendorsEntry = fields.get('vendors');
+    if (vendorsEntry) {
+        const node = vendorsEntry.value;
+        if (node.kind !== 'map')
+            check.fail(node.line, 'limits.vendors must be a map: a vendor, then its ceiling');
+        else {
+            for (const vendor of node.entries) {
+                const ceiling = check.whole(vendor, `limits.vendors.${vendor.key}`, 0);
+                if (ceiling !== undefined)
+                    vendors[vendor.key] = ceiling;
+            }
+        }
+    }
+    return {
+        seats: check.whole(fields.get('seats'), 'limits.seats', 1) ?? declared + temporary,
+        temporary,
+        vendors,
+    };
+}