@open-tomato/rafa 0.44.0 → 0.46.0

package/dist/core/config/config-sections.d.ts

@@ -0,0 +1,493 @@
+/**
+ * The value readers behind `config.ts`: one per shape a setting takes,
+ * and the closed lists of values a setting accepts. The two item shapes
+ * the schema's lists hold, a prerequisite item and a module source, are
+ * read in `config-items.ts`, through the reading helpers exported here.
+ *
+ * `config.ts` owns the file: its sections, its keys, the layers and how
+ * they rank. For each setting it asks this module one question: is this
+ * raw value one the setting accepts, and if so, what is it? Every rule
+ * about a VALUE lives here, apart from the rules about KEYS, and
+ * `config.ts` stays under the size cap.
+ *
+ * The file is `config-sections.ts` and not `config/index.ts` on purpose.
+ * While both sat in `src/`, `./config.js` resolved to `src/config.ts`
+ * (now `packages/rafa/src/core/config/config.ts`), and a `src/config/` directory
+ * beside it would have set the trap `context/source.md` records for
+ * `./plan`.
+ *
+ * ## What a reader answers
+ *
+ * A {@link Reader} takes the raw value, as the YAML parser returned it
+ * or as a command line passed it, and a {@link ValueAt} saying where
+ * that value sits. It answers a {@link Reading}: the value, or undefined
+ * with every problem named, plus any unknown key an item carried. A
+ * reader never throws and never prints, because `config.ts` collects the
+ * problems of every setting before it refuses, so one run names all of
+ * them.
+ *
+ * A problem is one sentence opening with the label it was handed, so
+ * one reader serves the file (`/repo/.rafa/config.yaml: tracker.default`)
+ * and the command line (`command line: trackerDefault`). A list item's
+ * label and key gain its index: `prerequisites.required[1]`.
+ *
+ * ## Rules every reader keeps
+ *
+ *   - Nothing is coerced. `tracker.fallback: local` is not read as
+ *     `[local]`, and `tracking.all: "true"` is not read as `true`.
+ *     Guessing what the operator meant is the silent choice `config.ts`
+ *     refuses.
+ *   - A string names something only when it holds a character other
+ *     than whitespace. It is kept as written, never trimmed.
+ *   - A key an item carries is matched against a list with `===`,
+ *     never with `in` or an object index. The parser keeps a key spelled
+ *     `toString`, `constructor` or `__proto__` as an ordinary own key,
+ *     and `'toString' in item` is true for every mapping. Measured on
+ *     bun 1.3.14: an item carrying `__proto__: x` beside `tool: bun`
+ *     holds both as own keys, and its prototype stays `Object.prototype`.
+ *   - Every list a reader answers is frozen, and so is every item in
+ *     it. A value one caller holds cannot be edited for the next.
+ *   - A null optional key in an item (`probe:` above a commented-out
+ *     command) says nothing, as a null setting says nothing in
+ *     `config.ts`. A null kind key (`- tool:`) names no tool and is
+ *     refused.
+ *   - A key an item does not read is retained as a {@link ConfigExtra}
+ *     under its path (`prerequisites.optional[0].timeout`), for
+ *     `config.ts` to warn about, never refused. That is the rule
+ *     `config.ts` keeps for unknown keys, applied one level down.
+ *
+ * ## The `dangerous` section
+ *
+ * A setting under `dangerous:` turns a refusal off on every run, so it
+ * is read as strictly as any: `dangerous.acceptStaleRefs` and
+ * `dangerous.selfUpdateDuringLoop` go through {@link flag}, the reader every `tracking` key takes, and no reader of
+ * its own. That is on purpose. A reader that took `yes`, `"true"` or
+ * `1` as true would let a spelling nobody meant as an answer switch
+ * check 4 of the readiness gate off, which is the one reading this
+ * section must never make by guessing. The section holds no closed
+ * list and no item shape, so nothing else here names it.
+ *
+ * ## The `tiers` section
+ *
+ * `.rafa/specs/rafa-26-skill-tiers.md` spells `tiers.rafa` as `on` or
+ * `off`, and `tiers.skills` and `tiers.agents` as maps of a name to
+ * `false` or a tier. {@link tierSwitch} reads the first and
+ * {@link tierPin} one value of the other two; the map around it is
+ * `config-readers.ts`'s `mapOf`, because what that reader rules on is a
+ * key. Three readings are this module's:
+ *
+ *   - `tiers.rafa` takes the WORDS `on` and `off`, as the spec writes
+ *     them, and not the booleans. `Bun.YAML.parse` answers both words
+ *     as strings (see {@link ReleaseEnabled}), so a file spelling
+ *     `rafa: off` reaches the reader as `off`, and `rafa: false` is
+ *     refused and told what to write, since nothing is coerced.
+ *   - A pin is the boolean `false`, which turns the item off in every
+ *     tier, or one of the three tiers, which names the holder that
+ *     serves it. `true` is refused: an item is on unless something
+ *     turns it off, so `true` would say nothing, and a value that says
+ *     nothing is not one a person meant to write.
+ *   - A null pin, a name written with nothing after it, is refused and
+ *     not read as silence. It is the `- tool:` of a map: a name that
+ *     pins nothing, where silence is the name left out.
+ *
+ * ## The `routing` setting
+ *
+ * The spec spells `routing` as a map of a task shape to an agent.
+ * {@link routeTarget} reads one value; the map around it is `mapOf`
+ * again, and the defaults are `default-routing.ts`'s. Two readings are
+ * this module's:
+ *
+ *   - A value is an agent name, any non-empty string, or `false`, a
+ *     shape routed nowhere, as `false` turns an item off in
+ *     `tiers.skills`. Whether the name is an agent anything defines is
+ *     a question for the tier resolver the spec plans, never for a
+ *     reader. So a quoted `"false"` is read as a name and not coerced
+ *     to `false`.
+ *   - `true` and null are refused, as for a pin: `true` names no agent,
+ *     and a shape with nothing after it routes nothing, where silence
+ *     is the shape left out.
+ *
+ * ## The `task` section
+ *
+ * `task.skills` names the resolver that picks a task's skills at
+ * dispatch, and `task.lessons` whether blessed lessons join its prompt.
+ * {@link skillResolverName} reads the first and {@link lessonSwitch}
+ * the second, each a closed list declared here. Two readings are this
+ * module's:
+ *
+ *   - `task.skills` takes `planner`, `tag` or `none` and nothing else.
+ *     Which resolver runs under each name is `task/resolve-skills.ts`'s
+ *     to say. A name outside the list, `model` included, is refused
+ *     here, where a person can still fix the file, and not left for
+ *     dispatch to find.
+ *   - `task.lessons` takes the WORDS `on` and `off`, as `tiers.rafa`
+ *     does and for the same reason: `Bun.YAML.parse` answers both as
+ *     strings, so `lessons: false` is refused and told what to write.
+ *     It has a list of its own rather than {@link TIER_SWITCHES},
+ *     since the two settings share a spelling and not a meaning.
+ *
+ * ## The `claims` section
+ *
+ * `claims.staleAfter` is how long a `rafa:claimed` claim stands before
+ * another device may take it over; `claims.ahead` whether a claim may
+ * reach one issue ahead. {@link claimsStaleAfter} reads the first and
+ * {@link claimsAhead} the second. Three readings are this module's:
+ *
+ *   - A duration is whole digits then `h` or `d`, and nothing else:
+ *     `1.5d`, `3w`, `3D` and ` 3d` are refused, and so is the bare
+ *     number `3`, which names no unit. It is kept as written, and
+ *     {@link claimDurationHours} answers the hours it spells.
+ *   - `0h`, `0d` and anything below are refused and not read as "off":
+ *     a claim stale at once is one any device takes over, and `disabled`
+ *     is already the word for off.
+ *   - `claims.ahead` takes the WORDS `off` and `allow`, so
+ *     `ahead: false` is refused and told what to write.
+ *
+ * ## The lists this module does not own
+ *
+ * Every other closed list here is declared here. Two are not, because
+ * another module is already their authority and a second spelling could
+ * disagree with it:
+ *
+ *   - The three tiers a pin names are `schema/tiers.ts`'s
+ *     {@link SKILL_TIERS}, the order a listing reads them in. That
+ *     module imports `node:fs` and `node:path` alone, so reaching it
+ *     here is no cycle.
+ *   - The shape {@link usdAmount} accepts is `parseBudgetUsd`'s
+ *     (`core/plan/declaration.ts`), which is what a plan's `budget=` goes
+ *     through and therefore what `--max-budget-usd` has been measured
+ *     against. The reader asks it about `String(raw)`, so a config
+ *     value is accepted only when the number the loop would pass on
+ *     survives that round trip: `.inf`, `.nan`, `1e21` and `1e-7` are
+ *     each a number the parser returns and `String` writes as something
+ *     the flag never takes.
+ *
+ * `core/plan/declaration.ts` imports only the store's `effort-levels.ts`,
+ * which imports nothing, so this module reaches it without its reaching
+ * back.
+ *
+ * The range {@link confidence} accepts, {@link CONFIDENCE_MIN} to
+ * {@link CONFIDENCE_MAX}, is declared here and not read from the
+ * learning library: core imports nothing above it, and `src/learning/`
+ * imports nothing from the rest of `src/`, so each declares the pair the
+ * library clamps every lesson's confidence to, and
+ * `src/tests/learning-contract.test.ts` holds the two equal.
+ *
+ * The reader of `pr.mergeMethod`, over the pull request port's three
+ * methods, is not here: it sits with the setting it reads, in
+ * `config-schema-release.ts`, so no core file imports `pr/types.ts`.
+ */
+import type { SkillTier } from '../../schema/tiers.js';
+/** One key a file carried that names nothing this version reads. */
+export interface ConfigExtra {
+    /**
+     * Its path from the top of the file: `nonesuch`, `plan.depth`,
+     * `prerequisites.required[0].timeout`.
+     */
+    key: string;
+    /**
+     * The value exactly as the parser returned it. Never serialised
+     * here: a YAML alias can make it cyclic.
+     */
+    value: unknown;
+}
+/** Where a value sits, as a problem and an extra name it. */
+export interface ValueAt {
+    /** What a problem opens with: `<file>: tracker.default`. */
+    label: string;
+    /** The path an unknown key inside the value is retained under. */
+    key: string;
+}
+/** What a reader made of one raw value. */
+export interface Reading<T> {
+    /** The value read, or undefined when a problem refused it. */
+    value: T | undefined;
+    /** One sentence per problem, each opening with the label. */
+    problems: readonly string[];
+    /** Keys inside the value that name nothing, retained. */
+    extras: readonly ConfigExtra[];
+}
+/** Reads one raw value; see the module note. */
+export type Reader<T> = (raw: unknown, at: ValueAt) => Reading<T>;
+/** A plain mapping, as the parser returns one. */
+export type Mapping = Readonly<Record<string, unknown>>;
+/** True for a mapping; false for a list, a scalar or null. */
+export declare function isMapping(value: unknown): value is Mapping;
+/** A value as a refusal quotes it. Never serialises a collection. */
+export declare function describeValue(value: unknown): string;
+/** The message of whatever was thrown, for a refusal to quote. */
+export declare function messageOf(error: unknown): string;
+/** The schema versions `config.ts` reads. */
+export declare const CONFIG_VERSIONS: readonly [1];
+/** One schema version `config.ts` reads. */
+export type ConfigVersion = (typeof CONFIG_VERSIONS)[number];
+/** Backends the effort store can be selected as. */
+export declare const STORE_BACKENDS: readonly ["sqlite", "ndjson"];
+/** One of the two effort-store backends. */
+export type StoreBackend = (typeof STORE_BACKENDS)[number];
+/**
+ * How a project's effort store travels between devices, as
+ * `effort.sync` names it. Closed: `git`, `service` and `p2p` are named
+ * here though modules bring their adapters, so a value outside the five
+ * is refused at load rather than when a sync is attempted.
+ */
+export declare const SYNC_STRATEGIES: readonly ["local", "file", "git", "service", "p2p"];
+/** One of the five effort-store sync strategies. */
+export type SyncStrategy = (typeof SYNC_STRATEGIES)[number];
+/** How the board records epics and blockers: labels, or GitHub's own links. */
+export declare const BOARD_RELATIONSHIP_MODES: readonly ["labels", "native"];
+/** One of the two board relationship modes, as `board.relationships` names it. */
+export type BoardRelationshipMode = (typeof BOARD_RELATIONSHIP_MODES)[number];
+/** How much of the plan a task session is handed, widest first. */
+export declare const INJECT_MODES: readonly ["full", "stage", "task"];
+/** One of the three injection modes. */
+export type InjectMode = (typeof INJECT_MODES)[number];
+/** How a command writes what it has to say. */
+export declare const OUTPUT_MODES: readonly ["text", "json", "events"];
+/** One of the three output modes. */
+export type OutputMode = (typeof OUTPUT_MODES)[number];
+/** The sources Claude Code's `--setting-sources` takes a subset of. */
+export declare const CLAUDE_SETTING_SOURCES: readonly ["user", "project", "local"];
+/** One of Claude Code's three setting sources. */
+export type ClaudeSettingSource = (typeof CLAUDE_SETTING_SOURCES)[number];
+/**
+ * The pull request providers a file may name: the GitHub CLI, and none.
+ *
+ * `none` is a provider and not an absence: under it the loop pushes the
+ * branch, prints the compare URL and skips the CI wait, which is a
+ * behaviour an operator chooses, where a setting left unnamed is one
+ * `pr/provider.ts` resolves off the `origin` remote.
+ */
+export declare const PR_PROVIDERS: readonly ["gh", "none"];
+/** One of the two pull request providers. */
+export type PrProvider = (typeof PR_PROVIDERS)[number];
+/**
+ * What `release.enabled` takes: a YAML boolean, or `auto`.
+ *
+ * `auto` is a third value and not a spelling of either boolean. It
+ * means "on when both configured files exist", a reading only
+ * `release/enabled.ts` can make, because only it looks at a disk.
+ *
+ * The two explicit answers are the BOOLEANS `true` and `false`, and
+ * not the words `on` and `off`: nothing here is coerced, so a file
+ * spelling `enabled: on` is refused and told what to write instead.
+ * Measured on bun 1.3.14, `Bun.YAML.parse` reads `on`, `off`, `yes`
+ * and `no` as strings and `true`, `True` and `TRUE` as the boolean, so
+ * `on` reaches the reader as the string and never as true.
+ */
+export type ReleaseEnabled = boolean | 'auto';
+/** The value of `release.enabled` that defers to the two files. */
+export declare const RELEASE_AUTO = "auto";
+/**
+ * What `merge.duplicates` takes: how two entries of one config file
+ * setting one key are reported. `warn` prints each, `error` refuses the
+ * load with every one, `allow` drops them.
+ */
+export declare const DUPLICATE_LEVELS: readonly ["warn", "error", "allow"];
+/** One of {@link DUPLICATE_LEVELS}. */
+export type DuplicatesLevel = (typeof DUPLICATE_LEVELS)[number];
+/** What `tiers.rafa` takes: the words, not the booleans. */
+export declare const TIER_SWITCHES: readonly ["on", "off"];
+/** One of {@link TIER_SWITCHES}. */
+export type TierSwitch = (typeof TIER_SWITCHES)[number];
+/**
+ * One value of `tiers.skills` or `tiers.agents`: `false` to turn the
+ * item off in every tier, or the tier whose holder serves it.
+ */
+export type TierPin = false | SkillTier;
+/**
+ * One value of `routing`: the agent a task of that shape goes to, or
+ * `false` for a shape routed nowhere.
+ */
+export type RouteTarget = false | string;
+/** The skill resolvers `task.skills` may name; see "The `task` section". */
+export declare const SKILL_RESOLVERS: readonly ["planner", "tag", "none"];
+/** One of {@link SKILL_RESOLVERS}. */
+export type SkillResolverName = (typeof SKILL_RESOLVERS)[number];
+/** What `task.lessons` takes: the words, not the booleans. */
+export declare const LESSON_SWITCHES: readonly ["on", "off"];
+/** One of {@link LESSON_SWITCHES}. */
+export type LessonSwitch = (typeof LESSON_SWITCHES)[number];
+/** The value of `claims.staleAfter` that turns stale takeover off. */
+export declare const CLAIMS_STALE_DISABLED = "disabled";
+/**
+ * What `claims.staleAfter` takes: a whole number of hours or days above
+ * zero, spelled as written (`36h`, `3d`), or `disabled`.
+ */
+export type ClaimsStaleAfter = `${number}h` | `${number}d` | typeof CLAIMS_STALE_DISABLED;
+/** What `claims.ahead` takes; see "The `claims` section". */
+export declare const CLAIMS_AHEAD: readonly ["off", "allow"];
+/** One of {@link CLAIMS_AHEAD}. */
+export type ClaimsAhead = (typeof CLAIMS_AHEAD)[number];
+/** A reading refusing `raw`, saying what was expected instead. */
+export declare function refused<T>(at: ValueAt, raw: unknown, expected: string): Reading<T>;
+/** A reading carrying `problems` alone. */
+export declare function refusedWith<T>(problems: readonly string[]): Reading<T>;
+/** `reading` with its value, when it has one, passed through `map`. */
+export declare function mapReading<T, U>(reading: Reading<T>, map: (value: T) => U): Reading<U>;
+/** `at` one step down: an index (`[1]`) or a key (`.probe`). */
+export declare function below(at: ValueAt, step: string): ValueAt;
+/** Accepts exactly one of `values`, compared with `===`. */
+export declare function oneOf<T>(values: readonly T[]): Reader<T>;
+/**
+ * Accepts a string holding a character other than whitespace, kept as
+ * written. `expected` names what the string is for, in a refusal.
+ */
+export declare function text(expected: string): Reader<string>;
+/** Accepts a YAML boolean, and nothing spelled like one. */
+export declare const flag: Reader<boolean>;
+/**
+ * Accepts a number of US dollars a session can be handed as a budget:
+ * above zero, at most six digits either side of the point, and no
+ * string spelled like one. What it accepts is `parseBudgetUsd`'s shape,
+ * asked about `String(raw)`; the module note says why.
+ */
+export declare const usdAmount: Reader<number>;
+/**
+ * Accepts an issue number as the board spells one: a whole number above
+ * zero, and no string spelled like one.
+ *
+ * The bound matches `src/board/naming.ts`, which refuses anything else
+ * with a `RangeError` rather than spelling `rafa-0` into a path. A
+ * setting read here is handed straight to `gh issue view <n>`, so `0`,
+ * `-1` and `2.5` are refused where the person can still fix the file,
+ * and not where a command has already been sent.
+ *
+ * `Bun.YAML.parse` reads `31`, `0x1f` and `3.1e1` all as the number 31,
+ * so the three spellings are one value here. A QUOTED `"31"` is refused,
+ * as every other reader refuses a string spelled like its type.
+ */
+export declare const issueNumber: Reader<number>;
+/**
+ * Accepts a number of days as the `cleanup` thresholds take one: a
+ * whole number above zero, and no string spelled like one.
+ *
+ * Zero is refused and not read as "off": a zero-day threshold would put
+ * every branch under Stale and every worktree under idle, which is a
+ * listing nobody asks for by writing a number. A fraction is refused
+ * as `issueNumber` refuses one: the setting counts whole days, and
+ * `2.5` would be a precision nobody has said the reading keeps.
+ */
+export declare const dayCount: Reader<number>;
+/** The shortest lock wait `effort.busyTimeoutMs` accepts, in milliseconds. */
+export declare const BUSY_TIMEOUT_MIN_MS = 1;
+/** The longest lock wait `effort.busyTimeoutMs` accepts: one minute. */
+export declare const BUSY_TIMEOUT_MAX_MS = 60000;
+/**
+ * True for a lock wait the effort store accepts: a whole number of
+ * milliseconds from {@link BUSY_TIMEOUT_MIN_MS} to
+ * {@link BUSY_TIMEOUT_MAX_MS}, both included.
+ */
+export declare function isBusyTimeoutMs(raw: unknown): raw is number;
+/**
+ * Accepts how long an effort store open waits for another process's
+ * write lock, as `effort.busyTimeoutMs` takes it.
+ *
+ * Zero is refused and not read as "no wait": SQLite reads a zero busy
+ * timeout as none, so an open would throw `SQLITE_BUSY` at once, the
+ * failure the key exists to prevent. There is no unlimited value, since
+ * a lock wait with no end can hang a loop. A fraction, a quoted number
+ * and `false` are refused as every reader here refuses them.
+ */
+export declare const busyTimeoutMs: Reader<number>;
+/**
+ * The lowest confidence a lesson may carry, and the lowest
+ * {@link confidence} accepts: the learning library's `CONFIDENCE_MIN`.
+ */
+export declare const CONFIDENCE_MIN = 0.3;
+/**
+ * The highest confidence a lesson may carry, and the highest
+ * {@link confidence} accepts: the learning library's `CONFIDENCE_MAX`.
+ */
+export declare const CONFIDENCE_MAX = 0.9;
+/**
+ * Accepts a lesson confidence as the `learning` thresholds take one: a
+ * number from {@link CONFIDENCE_MIN} to {@link CONFIDENCE_MAX}, both
+ * included, and no string spelled like one.
+ *
+ * A bound is compared after rounding to two decimals, as the library
+ * compares confidences, so `0.9000000000000001` reads as 0.9. The value
+ * is kept as written. A quoted `"0.5"` is refused, as every reader here
+ * refuses a string spelled like its type.
+ */
+export declare const confidence: Reader<number>;
+/**
+ * Accepts how many times a lesson must recur as `learning.promote.after`
+ * counts it: a whole number of 1 or more, and no string spelled like one.
+ *
+ * Zero is refused and not read as "off": every held lesson was
+ * confirmed by at least one source, so 0 would promote exactly what 1
+ * does, and a second spelling of one threshold is a value nobody can
+ * tell was meant. A fraction is refused as {@link dayCount} refuses one:
+ * the setting counts distinct sources, which come whole.
+ */
+export declare const recurrenceCount: Reader<number>;
+/**
+ * Accepts `true`, `false` or `auto`, each as itself. A string spelled
+ * like a boolean is refused; see {@link ReleaseEnabled}.
+ */
+export declare const releaseEnabled: Reader<ReleaseEnabled>;
+/** Accepts one of {@link DUPLICATE_LEVELS}, as words. */
+export declare const duplicatesLevel: Reader<DuplicatesLevel>;
+/** Accepts `on` or `off`, as words; see "The `tiers` section". */
+export declare const tierSwitch: Reader<TierSwitch>;
+/**
+ * Accepts `false` or one of the three tiers, each as itself; see "The
+ * `tiers` section" for why `true` and null are refused.
+ */
+export declare const tierPin: Reader<TierPin>;
+/**
+ * Accepts `false` or an agent name, each as itself; see "The `routing`
+ * setting" for why `true` and null are refused.
+ */
+export declare const routeTarget: Reader<RouteTarget>;
+/** Accepts one of {@link SKILL_RESOLVERS}; see "The `task` section". */
+export declare const skillResolverName: Reader<SkillResolverName>;
+/** Accepts `on` or `off`, as words; see "The `task` section". */
+export declare const lessonSwitch: Reader<LessonSwitch>;
+/**
+ * The hours a `claims.staleAfter` duration spells (`36h` → 36, `3d` →
+ * 72), or null for anything else, `disabled` and `0d` included.
+ */
+export declare function claimDurationHours(raw: unknown): number | null;
+/**
+ * Accepts a duration of whole hours or days above zero, or `disabled`,
+ * each kept as written; see "The `claims` section".
+ */
+export declare const claimsStaleAfter: Reader<ClaimsStaleAfter>;
+/** Accepts `off` or `allow`; see "The `claims` section". */
+export declare const claimsAhead: Reader<ClaimsAhead>;
+/** True for a string shaped like a GitHub login; see {@link GITHUB_LOGIN}. */
+export declare function isGitHubLogin(value: unknown): value is string;
+/** Accepts a GitHub account login, kept as written; see {@link GITHUB_LOGIN}. */
+export declare const githubLogin: Reader<string>;
+/**
+ * The URL `board.project.template` names when no layer does: open-tomato's
+ * public "rafa board template", with the five fields, the three saved
+ * views and every automation off.
+ */
+export declare const BOARD_PROJECT_TEMPLATE_DEFAULT = "https://github.com/orgs/open-tomato/projects/6";
+/** Accepts a GitHub project URL, kept as written; see {@link PROJECT_URL}. */
+export declare const projectUrl: Reader<string>;
+/**
+ * Accepts a GitHub project number: a whole number above zero, and no
+ * string spelled like one, for the reasons {@link issueNumber} gives.
+ * It is read apart from `issueNumber` only so a refusal names a
+ * project and not an issue.
+ */
+export declare const projectNumber: Reader<number>;
+/**
+ * Accepts a list whose every entry `item` accepts, answered frozen.
+ * Every entry is read, so a list with two unusable entries names both.
+ * `expected` names the entries, in the refusal of a value that is not a
+ * list.
+ */
+export declare function listOf<T>(item: Reader<T>, expected: string): Reader<readonly T[]>;
+/**
+ * Accepts a comma-separated subset of `values`, answered as a frozen
+ * list in the order written. Space around a comma is allowed, since the
+ * list, not the string, is what a caller acts on. An empty value, an
+ * empty entry, an entry naming nothing in `values` and an entry given
+ * twice are each refused: none of them is a subset spelled out.
+ */
+export declare function subsetOf<T extends string>(values: readonly T[]): Reader<readonly T[]>;