bareloop 0.8.0 → 0.9.0

package/types/authorflow.d.ts

@@ -0,0 +1,720 @@
+/** The frozen question set for a picked class. Throws on a locked or unknown
+ * one: reaching here with either means admission did not refuse, which is a
+ * bareloop bug, and failing loudly beats interviewing for a class we cannot run.
+ * @param {string} verdictType */
+export function questionsFor(verdictType: string): any;
+/** The question numbers whose answer must be present for that class's interview
+ * to be finished. @param {string} verdictType @returns {number[]} */
+export function requiredAnswersFor(verdictType: string): number[];
+/**
+ * The mechanical seam between the catalogue and the schema, read BOTH ways: a
+ * catalogue parameter with no schema would be silently undeclarable, and a schema
+ * entry the catalogue does not have is a second catalogue.
+ * @param {Record<string, any>} [catalogue]
+ * @returns {{ok: boolean, missing: string[], orphan: string[]}}
+ */
+export function schemaCoverage(catalogue?: Record<string, any>): {
+    ok: boolean;
+    missing: string[];
+    orphan: string[];
+};
+/**
+ * THE DECLARATION SCHEMA — the tool's input schema, and therefore the whole
+ * shape a model can express.
+ *
+ * One `oneOf` branch per LIVE kind, each pinning its own `kind` as a const so a
+ * parameter set cannot drift onto the wrong kind. A LOCKED kind gets no branch at
+ * all: declaring one is inexpressible here rather than rejected afterwards (see
+ * the header for what that costs).
+ *
+ * It enforces STRUCTURE, not LAW. The stage-name slug rule, the one-population
+ * law, the listing rule, F49's regex reject and the D5 guard equality are M2's,
+ * and they arrive as validation reds through the revise loop — a schema that
+ * tried to restate them would be a second validator.
+ *
+ * THROWS on a catalogue it cannot cover: a malformed catalogue is a bareloop bug,
+ * and failing loudly beats emitting a schema that quietly cannot say something
+ * the validator will then demand.
+ * @param {Record<string, any>} [catalogue]
+ */
+export function declarationSchema(catalogue?: Record<string, any>): {
+    type: string;
+    properties: {
+        stages: {
+            type: string;
+            minItems: number;
+            maxItems: number;
+            description: string;
+            items: {
+                oneOf: {
+                    title: string;
+                    description: any;
+                    type: string;
+                    properties: {
+                        name: {
+                            type: string;
+                            description: string;
+                        };
+                        kind: {
+                            const: string;
+                        };
+                        params: {
+                            type: string;
+                            properties: Record<string, any>;
+                            required: any[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                }[];
+            };
+        };
+        notes: {
+            type: string;
+            items: {
+                type: string;
+                minLength: number;
+            };
+            description: string;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+/**
+ * The output channel. It records and acknowledges; it takes no action, which is
+ * why handing it to a toolless authoring call does not reopen D3.
+ * @param {{calls: any[]}} box
+ * @param {{catalogue?: Record<string, any>}} [o]
+ */
+export function declarationTool(box: {
+    calls: any[];
+}, { catalogue }?: {
+    catalogue?: Record<string, any>;
+}): {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            stages: {
+                type: string;
+                minItems: number;
+                maxItems: number;
+                description: string;
+                items: {
+                    oneOf: {
+                        title: string;
+                        description: any;
+                        type: string;
+                        properties: {
+                            name: {
+                                type: string;
+                                description: string;
+                            };
+                            kind: {
+                                const: string;
+                            };
+                            params: {
+                                type: string;
+                                properties: Record<string, any>;
+                                required: any[];
+                                additionalProperties: boolean;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    }[];
+                };
+            };
+            notes: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    execute: (args: any) => Promise<string>;
+};
+/**
+ * The catalogue, as the authoring call sees it — rendered FROM the catalogue, so
+ * the prompt and the validator judge one set of facts. `shape` and `asserts` are
+ * M2's own strings.
+ * @param {Record<string, any>} [catalogue]
+ */
+export function catalogueBlock(catalogue?: Record<string, any>): string;
+/** The three laws. Stated to the author; enforced, where checkable, by M2. */
+export function lawsBlock(): string;
+/**
+ * The whole authoring prompt, as one string.
+ *
+ * Two people fed this brief and neither of them is the model: a person who is not
+ * a software engineer answered an interview, and a read-only survey produced the
+ * facts. The prompt says so, because round 1 measured what happens when a model
+ * treats a lay answer as a specification.
+ *
+ * `verdictType` is REQUIRED and has no default. It is the user's own answer and
+ * the one thing that tells the composer what DONE is allowed to mean here; a
+ * defaulted class would be the prompt answering a question the user was asked.
+ *
+ * @param {{answers: Record<string|number, string>, questions?: Record<string|number, string>,
+ *   facts: any, listingBlock: string, lang: string, verdictType: string,
+ *   guards: {name: string, kind: string, params: Record<string, any>, fill: string[]}[],
+ *   ownedEnvNames?: string[], mode?: 'tool'|'text', catalogue?: Record<string, any>}} o
+ */
+export function authorPrompt({ answers, questions, facts, listingBlock, lang, verdictType, guards, ownedEnvNames, mode, catalogue }: {
+    answers: Record<string | number, string>;
+    questions?: Record<string | number, string>;
+    facts: any;
+    listingBlock: string;
+    lang: string;
+    verdictType: string;
+    guards: {
+        name: string;
+        kind: string;
+        params: Record<string, any>;
+        fill: string[];
+    }[];
+    ownedEnvNames?: string[];
+    mode?: "tool" | "text";
+    catalogue?: Record<string, any>;
+}): string;
+/**
+ * The seed read, as the model sees it: mechanical labels, no editorial. Per-stage
+ * gap capped with the trim ANNOUNCED (F28 — a bound that eats the failure names
+ * deletes exactly the mechanical detail that converts).
+ *
+ * SCRUBBED at the emission boundary. What this block renders is raw subprocess
+ * output (gap lines, an instrument stop carrying a command's stderr) and it
+ * becomes the next USER TURN sent to the provider — the surface most likely to
+ * carry a real credential, crossing the network. It goes through the ONE shared
+ * redactor, the same one `askDeclaration` puts the model's own text through and
+ * the same one `declaredclose`/`authorjob` put these very fields through; never
+ * a second inventory. Applied to the whole rendered block rather than one field,
+ * so a line added here is scrubbed by construction.
+ * @param {any[]} rows M1 `StageResult[]`
+ * @param {{gapCap?: number}} [o]
+ */
+export function renderSeedReadBlock(rows: any[], { gapCap }?: {
+    gapCap?: number;
+}): string;
+/**
+ * The measured block when the declaration never reached execution. Both cases are
+ * machine outputs of the pipeline, never editorial prose about the model's work.
+ *
+ * SCRUBBED at the emission boundary, for the SAME reason `renderSeedReadBlock`
+ * is and through the SAME one redactor. The channel here is different and just
+ * as real: a validation red QUOTES WHAT THE MODEL DECLARED, verbatim — the
+ * genre-env branch echoes the expected and the declared value, the deny floor
+ * echoes the whole `cmd`, the listing rule echoes the path — and this block
+ * becomes the next USER TURN sent to the provider. A declared value shaped like
+ * a credential crossed unmasked before this line existed. Applied to the whole
+ * rendered block rather than one field, so a red added to the validator is
+ * scrubbed by construction rather than by remembering.
+ * @param {{kind: 'validation'|'artifact', reds: (Red|string)[], cap?: number}} o
+ */
+export function renderRejectBlock({ kind, reds, cap }: {
+    kind: "validation" | "artifact";
+    reds: (Red | string)[];
+    cap?: number;
+}): string;
+/** A revise turn is EXACTLY the measured block, a blank line, and the instruction. */
+export function buildReviseTurn(measuredBlock: string): string;
+/**
+ * The structural guarantee that no other prose can enter a revise turn. Without
+ * it "the feedback is measurement only" is a promise; with it, it is a fact that
+ * fails the build the day someone appends a helpful sentence.
+ * @param {string} turn @param {string} measuredBlock
+ */
+export function assertReviseTurn(turn: string, measuredBlock: string): {
+    ok: boolean;
+    bytes: number;
+};
+/**
+ * Apply the genre's environment to a declaration, mechanically.
+ *
+ * Three rules, and each one is a finding:
+ *   - it lands on every stage that SPAWNS something (env-capable by the
+ *     catalogue) and nowhere else — a stage that runs no process has no
+ *     environment to set;
+ *   - a model-authored copy of a genre-owned name is DROPPED and ANNOUNCED. M2's
+ *     validator already reds that, so this is defence in depth — but the failure
+ *     direction matters: silently keeping the model's guess is how round 2's arm
+ *     B graded an unedited checkout;
+ *   - a genre variable this patient cannot supply is a RED, not an omission. It
+ *     moves no seed number, so no seed-verdict read can ever see it missing, and
+ *     the artefact it would be missing from is SIGNED.
+ *
+ * The input declaration is never mutated: the model's own copy has to stay what
+ * the model wrote, or the next turn's validator reds it for our injection.
+ * @param {any} declaration
+ * @param {string} lang
+ * @param {{sourcePrefixes?: string[], catalogue?: Record<string, any>}} [o]
+ * @returns {{declaration: any, applied: Record<string, string>, dropped: {stage: string, name: string}[],
+ *   missing: string[], reds: Red[]}}
+ */
+export function applyGenreEnv(declaration: any, lang: string, { sourcePrefixes, catalogue }?: {
+    sourcePrefixes?: string[];
+    catalogue?: Record<string, any>;
+}): {
+    declaration: any;
+    applied: Record<string, string>;
+    dropped: {
+        stage: string;
+        name: string;
+    }[];
+    missing: string[];
+    reds: Red[];
+};
+/**
+ * The prefixes `genreEnv` JOINS into the genre's variable, resolved against the
+ * real tree. Two filters, and the second one was paid for on a live patient.
+ *
+ * EXISTENCE (unchanged): a prefix that names nothing at the seed would build a
+ * variable pointing at nothing, and the grounded validator refuses it anyway
+ * (`ungroundedGenreEnv` checks every ELEMENT against the seed listing).
+ *
+ * IDENTITY (new): existence alone reads a SYMLINK and the directory behind it as
+ * two prefixes. On aurora, 11 entries under `src` resolve into the per-package
+ * `packages/<pkg>/src` trees, so the joined `MYPYPATH` named one tree twice
+ * under two spellings and mypy died FATALLY — exit 2, "shadows library module",
+ * zero output — which the close reads as a broken instrument on a perfectly
+ * healthy patient. The realpath-deduped control produced the identical clean
+ * reading as the known-good invocation.
+ *
+ * WHICH SPELLING SURVIVES is not cosmetic. The REAL path wins, because that is
+ * the one the checker itself resolves to; the symlink spelling is kept only when
+ * the real one cannot be used. And a spelling is only ever emitted when it
+ * SELECTS from the seed listing, because the arbiter records this value in a
+ * SIGNED envelope and re-validates it GROUNDED — a value the grounded validator
+ * cannot select is one the arbiter must never build. So a link out of the
+ * repository, or into a path git does not track, keeps its declared spelling
+ * rather than becoming an absolute path nothing can ground.
+ *
+ * An unreadable candidate (a dangling link, a race) is NOT dropped: it passed the
+ * existence filter against the listing, and silently losing a real prefix is the
+ * Result-5 hazard in the other direction.
+ * @param {{workdir: string, sourcePaths: any, seedFiles: string[]}} o
+ * @returns {string[]}
+ */
+export function resolveSourcePrefixes({ workdir, sourcePaths, seedFiles }: {
+    workdir: string;
+    sourcePaths: any;
+    seedFiles: string[];
+}): string[];
+/**
+ * F6's shape: an unpriced call or round makes the TOTAL unknown, and unknown is
+ * reported as null — never as the sum of the priced half wearing a complete coat.
+ * `knownUsd` carries the priced half explicitly so nothing is hidden either way.
+ *
+ * IT IS ALSO THE RUN'S AUDIT OF WHAT WAS SAID, not only of what was spent. Every
+ * `add` records the call's RAW output beside its price, through the one
+ * scrubbed-persist helper — one list of calls, read two ways. That pairing is
+ * structural rather than remembered: run mslhn707 metered a $0.053 scout call
+ * and kept not one byte of what it returned, so the malformation that killed the
+ * run could not be read afterwards. A cost entry with no raw beside it is that
+ * run again.
+ */
+export function makeCostBook(): {
+    /** @param {string} label @param {any} r a bare-agent run result @param {number} [attempt] */
+    add(label: string, r: any, attempt?: number): {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    } | undefined;
+    /** @param {{label: string, costUsd: number|null, unpricedRounds: number}[]} calls
+     * @param {ReturnType<typeof scrubRaw>[]} [callRaws] */
+    absorb(calls: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }[], callRaws?: ReturnType<typeof scrubRaw>[]): void;
+    /** the persisted raws, in call order — the same order and the same labels as
+     * `report().calls`, because both are readings of one list */
+    raws(): {
+        label: string;
+        attempt: number;
+        bytes: number;
+        trimmed: boolean;
+        text: string;
+        cause: string | null;
+        reason: string | null;
+    }[];
+    report(): {
+        costUsd: number | null;
+        knownUsd: number;
+        spendComplete: boolean;
+        nullCostCalls: number;
+        unpricedRounds: number;
+        calls: {
+            label: string;
+            costUsd: number | null;
+            unpricedRounds: number;
+        }[];
+    };
+};
+/**
+ * The default model boundary: one bare-agent Loop per call, with the declaration
+ * tool wired to END the call the moment it is used. The tool is an OUTPUT
+ * CHANNEL, not a step in a conversation, so the round that would acknowledge its
+ * result has nothing left to say.
+ *
+ * MEASURED against the real Loop with a counting provider, both arms: stop-wired
+ * = 1 provider round, $0.001; unwired = 2 rounds, $0.002. So the wiring halves
+ * the round count of every authoring and revise call — that is the number, not
+ * an estimate, and it is why tool mode does not cost double what text mode did.
+ *
+ * `cacheMessages` (F18) and `maxTokens` (F30) are not optional on this stack.
+ * @param {any} provider @param {{system?: string, maxTokens?: number}} [o]
+ * @returns {(messages: any[], tools: any[], opts?: any) => Promise<any>}
+ */
+export function makeLoopGenerate(provider: any, { system, maxTokens }?: {
+    system?: string;
+    maxTokens?: number;
+}): (messages: any[], tools: any[], opts?: any) => Promise<any>;
+/**
+ * THE AUTHORING FLOW.
+ *
+ * Everything cheap happens BEFORE any token is spent: an ABSENT survey, an
+ * unreadable listing, an unsupported genre and a genre variable that cannot be
+ * built are all $0 refusals, because a paid call that was always going to be
+ * thrown away is a paid call nobody needed.
+ *
+ * The return is deliberately complete rather than tidy:
+ *   - `ok` is true iff a declaration passed validation and was measured;
+ *   - `declaration` is the LAST ACCEPTED one, genre-env injected — the exact form
+ *     that will run and that the signature will cover;
+ *   - `reds` is what the LAST validated iteration said. `ok:true` with a non-empty
+ *     `reds` means the final revision was rejected and the previous close stands:
+ *     the rejection is reported, never hidden, and never silently shipped either;
+ *   - `iterations` carries every intermediate declaration, validation, seed read
+ *     and attempt count, because M4 emits them and a human signs against them;
+ *   - `raws` carries what every model call actually SAID — the scout's attempts
+ *     and the declaration's, scrubbed and bounded through the one persist
+ *     helper, in the cost book's own order and under its own labels. It is
+ *     present on EVERY path including the $0 preflight refusals, because the
+ *     path that spends nothing more is exactly the one whose evidence used to
+ *     vanish with the process.
+ *
+ * No spine emission here (M4 wires events).
+ *
+ * @param {{workdir: string, seedRef: string, lang: string, verdictType: string,
+ *   answers: Record<string|number, string>, questions?: Record<string|number, string>,
+ *   scout: {state: string, facts: any, reason?: string|null, calls?: any[], raws?: any[]},
+ *   listing?: {stop: string|null, files: string[]|null, block: string|null, meta: any}|null,
+ *   generate: Function, seedReadFn?: Function, closeCtx?: any,
+ *   maxRevisions?: number, structureRetries?: number,
+ *   structuredMode?: 'tool'|'text', catalogue?: Record<string, any>}} o
+ */
+export function authorClose({ workdir, seedRef, lang, verdictType, answers, questions, scout, listing, generate, seedReadFn, closeCtx, maxRevisions, structureRetries, structuredMode, catalogue, }: {
+    workdir: string;
+    seedRef: string;
+    lang: string;
+    verdictType: string;
+    answers: Record<string | number, string>;
+    questions?: Record<string | number, string>;
+    scout: {
+        state: string;
+        facts: any;
+        reason?: string | null;
+        calls?: any[];
+        raws?: any[];
+    };
+    listing?: {
+        stop: string | null;
+        files: string[] | null;
+        block: string | null;
+        meta: any;
+    } | null;
+    generate: Function;
+    seedReadFn?: Function;
+    closeCtx?: any;
+    maxRevisions?: number;
+    structureRetries?: number;
+    structuredMode?: "tool" | "text";
+    catalogue?: Record<string, any>;
+}): Promise<any>;
+/** @typedef {{code: string, path: string, detail: string, [k: string]: any}} Red */
+/** the output channel's name. It takes no action; it carries the answer. */
+export const DECLARATION_TOOL_NAME: "declare_close";
+/** what the tool returns. The loop stops on delivery, so the model never reads it. */
+export const DECLARATION_ACK: "declaration received";
+/** addendum 5: unlimited revising launders thrash as adaptation (v1.12's rule). */
+export const MAX_REVISIONS: 2;
+/** a malformed EMISSION is a transport fault, bounded on its own axis */
+export const MAX_STRUCTURE_RETRIES: 2;
+/** per-stage gap lines carried into a revise turn, trim announced (F28) */
+export const REVISE_GAP_CAP: 15;
+/** validator reds carried into a revise turn, trim announced (F28) */
+export const REVISE_RED_CAP: 20;
+/** F18 / F30 — caching on, and the 4096 provider default cannot hold a declaration */
+export const AUTHOR_MAX_TOKENS: 32000;
+/** the one slot the model fills on an injected guard */
+export const FILL_MARKER: "<FILL IN>";
+/**
+ * THE FROZEN REVISE INSTRUCTION — gate-2 round 3's own text, byte for byte
+ * (`scratch-gate2/author.mjs:63`, the turn that PASSED both arms). It is the only
+ * prose a revise turn may carry, this constant is its only source, and the suite
+ * asserts its bytes: an edit reds the suite and forces a decision rather than
+ * quietly changing what every future close is corrected against.
+ */
+export const REVISE_INSTRUCTION: string;
+/**
+ * The structure re-ask, per mode. DELIBERATELY NOT `REVISE_INSTRUCTION`: nothing
+ * has been measured, there is no declaration to judge, and reusing the revise
+ * text would tell a model to "judge its own declaration against them" when there
+ * is no them.
+ */
+export const STRUCTURE_INSTRUCTION_TOOL: string;
+export const STRUCTURE_INSTRUCTION_TEXT: string;
+/**
+ * THE INTERVIEW, KEYED BY VERDICT CLASS (hamr's ruling, PRD v1.57 §2).
+ *
+ * One question set per GENRE has no terminating shape — genres are a fat long
+ * tail that cannot be enumerated, and TYPES was the first specimen rather than
+ * the pattern. One set per verdict CLASS has exactly three. Genre understanding
+ * does not disappear: it moves into the COMPOSITION over the kind catalogue
+ * (`CLASS_STATEMENTS` below, rendered into the authoring prompt), which is the
+ * layer already built to hold it — the authoring call composes owned kinds and
+ * cannot emit anything else (D2/D3), so a genre it has never seen is a
+ * composition problem, not a catalogue problem.
+ *
+ * The GREEN set is questions 1–6 of the frozen TYPES set (prereg §5) BYTE FOR
+ * BYTE. What is gone is the seventh slot — D13's genre CONFIRM ("this looks like
+ * a type-fixing job, correct?") — superseded in full: the interview never asks
+ * about a genre again. The refusal it carried did not disappear; it MOVED to the
+ * composer, on the same counted `request-red` path (see `authorCloseForJob`).
+ * The remaining six are already genre-neutral, which is why generalising them
+ * required deleting a slot rather than rewording one.
+ */
+export const GREEN_QUESTIONS: Readonly<{
+    1: "What do you want done?";
+    2: "Which files or folders should change?";
+    3: "Is there anything that must not change?";
+    4: "How do you check today whether it's working?";
+    5: "What would make you say this came back worse than before?";
+    6: "Is there a code repo I can look at? Where?";
+}>;
+/**
+ * The three sets. `questions: null` on a locked class is ABSENT, never `{}`:
+ * an empty set would read as "this class needs no questions", which is a
+ * different and false statement (F59's distinction, at the interview layer).
+ * Nothing ever reads them — a locked class refuses at ADMISSION, before its
+ * questions run — and the two readers below throw rather than hand back nothing.
+ * @type {Record<string, {locked: boolean, questions: Record<string|number, string>|null, required: readonly number[]|null}>}
+ */
+export const QUESTION_SETS: Record<string, {
+    locked: boolean;
+    questions: Record<string | number, string> | null;
+    required: readonly number[] | null;
+}>;
+/**
+ * WHERE GENRE UNDERSTANDING NOW LIVES: the plain statement the composer is fed —
+ * *the user has this problem and declared it green/deterministic*. It is the
+ * user's own answer travelling into the composition call, and the composer is
+ * what turns it into stages over owned kinds.
+ *
+ * A locked class states NOTHING rather than something bland: a sentence here
+ * would be a class this build can compose for, and it cannot.
+ * @type {Record<string, string|null>}
+ */
+export const CLASS_STATEMENTS: Record<string, string | null>;
+export const AUTHOR_SYSTEM: string;
+/**
+ * ONE schema per PARAMETER NAME, composed into kinds by the catalogue's own
+ * `required`/`optional` lists. Keyed by name rather than by kind on purpose: the
+ * catalogue already decides which kind takes which parameter, and a per-kind
+ * table would be a second place for that fact to live.
+ *
+ * What is genuinely NEW here is only the JSON TYPE of each leaf — the catalogue
+ * states it as prose (`shape`) for the prompt, and nothing in the tree states it
+ * as a schema. Everything a schema could DRIFT on — which kinds exist, which are
+ * locked, which parameters each takes, which values an enum admits — is read
+ * from M2 and M1, and {@link schemaCoverage} makes the remaining seam mechanical:
+ * a catalogue that grows a parameter this table does not know about fails LOUDLY
+ * at schema-build time rather than silently omitting it from what the model can
+ * say.
+ */
+export const PARAM_SCHEMAS: Readonly<{
+    cmd: {
+        type: string;
+        description: string;
+    };
+    args: {
+        type: string;
+        items: {
+            type: string;
+        };
+    };
+    expectExit: {
+        type: string;
+    };
+    timeoutMs: {
+        type: string;
+        minimum: number;
+    };
+    env: {
+        type: string;
+        additionalProperties: {
+            type: string;
+        };
+    };
+    parser: Readonly<{
+        description: string;
+        oneOf: ({
+            title: string;
+            type: string;
+            properties: {
+                terms: {
+                    type: string;
+                    minItems: number;
+                    maxItems: number;
+                    items: {
+                        type: string;
+                        properties: {
+                            lineMatch: {
+                                type: string;
+                                description: string;
+                            };
+                            capture: {
+                                type: string;
+                                minimum: number;
+                                description: string;
+                            };
+                            sign: {
+                                enum: number[];
+                                description: string;
+                            };
+                            aggregate: {
+                                enum: string[];
+                                description: string;
+                            };
+                            region: {
+                                oneOf: ({
+                                    const: string;
+                                    type?: undefined;
+                                    properties?: undefined;
+                                    required?: undefined;
+                                    additionalProperties?: undefined;
+                                } | {
+                                    type: string;
+                                    properties: {
+                                        anchor: {
+                                            type: string;
+                                        };
+                                        capture: {
+                                            type: string;
+                                            minimum: number;
+                                            description: string;
+                                        };
+                                    };
+                                    required: string[];
+                                    additionalProperties: boolean;
+                                    const?: undefined;
+                                })[];
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                };
+                lineMatch?: undefined;
+                capture?: undefined;
+            };
+            required: string[];
+            additionalProperties: boolean;
+            description?: undefined;
+        } | {
+            title: string;
+            type: string;
+            description: string;
+            properties: {
+                lineMatch: {
+                    type: string;
+                };
+                capture: {
+                    type: string;
+                    minimum: number;
+                };
+                terms?: undefined;
+            };
+            required: string[];
+            additionalProperties: boolean;
+        })[];
+    }>;
+    scope: Readonly<{
+        type: "object";
+        description: "which population this stage counts. A path prefix, read off the seed listing.";
+        properties: {
+            includePrefixes: {
+                type: string;
+                minItems: number;
+                items: {
+                    type: string;
+                };
+            };
+            excludePrefixes: {
+                type: string;
+                minItems: number;
+                items: {
+                    type: string;
+                };
+            };
+        };
+        additionalProperties: false;
+    }>;
+    direction: {
+        enum: string[];
+    };
+    baseline: {
+        enum: (string | number)[];
+        description: string;
+    };
+    patterns: {
+        type: string;
+        minItems: number;
+        items: {
+            type: string;
+            properties: {
+                id: {
+                    type: string;
+                };
+                regex: {
+                    type: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+    extensions: {
+        type: string;
+        minItems: number;
+        items: {
+            type: string;
+        };
+    };
+    allowPrefixes: {
+        type: string;
+        minItems: number;
+        items: {
+            type: string;
+        };
+    };
+    requireNonEmpty: {
+        const: boolean;
+    };
+}>;
+export type Red = {
+    code: string;
+    path: string;
+    detail: string;
+    [k: string]: any;
+};
+import { scrubRaw } from './text.js';