balladeer 1.0.14 → 1.0.16

package/dist/risk/symbols.js

@@ -0,0 +1,348 @@
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { extensionOf, languageOf } from "./paths.js";
+const loadedTypeScript = new Map();
+/**
+ * The TypeScript compiler of the repository being read, resolved from its root
+ * the way its own tools resolve it. The published command ships no compiler and
+ * never imports one: a TypeScript repository nearly always has its own, and one
+ * without it has its script files read by the declaration pattern instead.
+ * Looked up once per repository.
+ */
+export function loadTypeScript(root) {
+    if (root === undefined)
+        return undefined;
+    if (loadedTypeScript.has(root))
+        return loadedTypeScript.get(root) ?? undefined;
+    let found = null;
+    try {
+        const loaded = createRequire(join(root, "package.json"))("typescript");
+        if (typeof loaded.createSourceFile === "function")
+            found = loaded;
+    }
+    catch {
+        // No compiler in reach of this repository.
+    }
+    loadedTypeScript.set(root, found);
+    return found ?? undefined;
+}
+function scriptKind(typescript, path) {
+    switch (extensionOf(path)) {
+        case "tsx":
+            return typescript.ScriptKind.TSX;
+        case "jsx":
+            return typescript.ScriptKind.JSX;
+        case "js":
+        case "mjs":
+        case "cjs":
+            return typescript.ScriptKind.JS;
+        default:
+            return typescript.ScriptKind.TS;
+    }
+}
+function scriptSymbols(typescript, path, text) {
+    const source = typescript.createSourceFile(path, text, typescript.ScriptTarget.Latest, true, scriptKind(typescript, path));
+    const found = [];
+    const lineOf = (position) => source.getLineAndCharacterOfPosition(position).line + 1;
+    const push = (name, kind, node) => {
+        found.push({ name, kind, startLine: lineOf(node.getStart(source)), endLine: lineOf(node.end) });
+    };
+    const isExported = (node) => (typescript.getCombinedModifierFlags(node) &
+        typescript.ModifierFlags.Export) !==
+        0;
+    const isFunctionValue = (node) => node !== undefined &&
+        (typescript.isArrowFunction(node) ||
+            typescript.isFunctionExpression(node) ||
+            typescript.isClassExpression(node) ||
+            ((typescript.isAsExpression(node) ||
+                typescript.isSatisfiesExpression(node) ||
+                typescript.isParenthesizedExpression(node)) &&
+                isFunctionValue(node.expression)));
+    const visitClass = (node, className) => {
+        push(className, "class", node);
+        for (const member of node.members) {
+            const memberName = member.name !== undefined && typescript.isIdentifier(member.name)
+                ? member.name.text
+                : member.name !== undefined && typescript.isPrivateIdentifier(member.name)
+                    ? member.name.text
+                    : typescript.isConstructorDeclaration(member)
+                        ? "constructor"
+                        : undefined;
+            if (memberName === undefined)
+                continue;
+            if (typescript.isMethodDeclaration(member) ||
+                typescript.isConstructorDeclaration(member) ||
+                typescript.isGetAccessorDeclaration(member) ||
+                typescript.isSetAccessorDeclaration(member) ||
+                (typescript.isPropertyDeclaration(member) && isFunctionValue(member.initializer)))
+                push(`${className}.${memberName}`, "method", member);
+        }
+    };
+    for (const statement of source.statements) {
+        if (typescript.isFunctionDeclaration(statement)) {
+            push(statement.name?.text ?? "default", "function", statement);
+        }
+        else if (typescript.isClassDeclaration(statement)) {
+            visitClass(statement, statement.name?.text ?? "default");
+        }
+        else if (typescript.isInterfaceDeclaration(statement) ||
+            typescript.isTypeAliasDeclaration(statement) ||
+            typescript.isEnumDeclaration(statement)) {
+            push(statement.name.text, "type", statement);
+        }
+        else if (typescript.isModuleDeclaration(statement) &&
+            typescript.isIdentifier(statement.name)) {
+            push(statement.name.text, "module", statement);
+        }
+        else if (typescript.isVariableStatement(statement)) {
+            const exported = isExported(statement);
+            for (const declaration of statement.declarationList.declarations) {
+                if (!typescript.isIdentifier(declaration.name))
+                    continue;
+                const initializer = declaration.initializer;
+                if (initializer !== undefined && typescript.isClassExpression(initializer)) {
+                    visitClass(initializer, declaration.name.text);
+                }
+                else if (isFunctionValue(initializer)) {
+                    push(declaration.name.text, "function", statements(declaration, statement));
+                }
+                else if (exported) {
+                    push(declaration.name.text, "const", statements(declaration, statement));
+                }
+            }
+        }
+        else if (typescript.isExportAssignment(statement) && isFunctionValue(statement.expression)) {
+            push("default", "function", statement);
+        }
+    }
+    return found;
+}
+/** A lone declarator spans its whole statement, so the `export const` line counts as its own. */
+function statements(declaration, statement) {
+    return statement.declarationList.declarations.length === 1 ? statement : declaration;
+}
+function indentation(line) {
+    const match = /^[\t ]*/.exec(line);
+    return (match?.[0] ?? "").replace(/\t/g, "    ").length;
+}
+function pythonSymbols(text) {
+    const lines = text.split("\n");
+    const found = [];
+    const open = [];
+    const close = (upTo, atIndent) => {
+        while (open.length > 0 && (open[open.length - 1]?.indent ?? -1) >= atIndent) {
+            const symbol = open.pop();
+            if (symbol === undefined)
+                break;
+            found.push({ name: symbol.name, kind: symbol.kind, startLine: symbol.start, endLine: upTo });
+        }
+    };
+    let lastCode = 0;
+    lines.forEach((line, index) => {
+        const lineNumber = index + 1;
+        if (line.trim().length === 0 || /^\s*#/.test(line))
+            return;
+        const indent = indentation(line);
+        close(lastCode, indent);
+        lastCode = lineNumber;
+        const declaration = /^\s*(?:async\s+)?(def|class)\s+([A-Za-z_]\w*)/.exec(line);
+        if (declaration) {
+            const enclosingClass = [...open].reverse().find((symbol) => symbol.kind === "class");
+            const isMethod = declaration[1] === "def" && enclosingClass !== undefined;
+            const name = isMethod
+                ? `${enclosingClass?.name}.${declaration[2]}`
+                : declaration[2];
+            const kind = declaration[1] === "class" ? "class" : isMethod ? "method" : "function";
+            // Decorators directly above belong to the declaration.
+            let start = lineNumber;
+            while (start > 1 && /^\s*@/.test(lines[start - 2] ?? ""))
+                start -= 1;
+            open.push({ name, kind, indent, start });
+        }
+    });
+    close(lastCode, -1);
+    return found.sort((a, b) => a.startLine - b.startLine);
+}
+const GENERIC_DECLARATIONS = [
+    // Go: func Name( and func (r *T) Name(
+    /^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*[[(]/,
+    // Rust: fn name
+    /^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?(?:unsafe\s+)?fn\s+([A-Za-z_]\w*)/,
+    // Kotlin: fun name
+    /^\s*(?:(?:public|private|internal|protected|override|suspend|inline|open)\s+)*fun\s+(?:<[^>]*>\s*)?(?:[\w.]+\.)?([A-Za-z_]\w*)\s*\(/,
+    // Ruby: def name
+    /^\s*def\s+(?:self\.)?([A-Za-z_]\w*[?!]?)/,
+    // Classes, structs, interfaces, traits, modules
+    /^\s*(?:(?:public|private|protected|internal|abstract|final|sealed|open|data|static|export|pub)\s+)*(?:class|struct|interface|trait|module|object|enum|impl)\s+([A-Za-z_]\w*)/,
+    // Java/C#-style methods: modifiers, a return type, a name and an open parenthesis.
+    /^\s*(?:(?:public|private|protected|static|final|synchronized|abstract|override|virtual|async)\s+)+[\w<>[\],.? ]+\s+([A-Za-z_]\w*)\s*\([^;]*$/,
+    // JavaScript-like: function name(
+    /^\s*(?:export\s+)?(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/,
+];
+function genericSymbols(text) {
+    const lines = text.split("\n");
+    const starts = [];
+    lines.forEach((line, index) => {
+        for (const pattern of GENERIC_DECLARATIONS) {
+            const match = pattern.exec(line);
+            if (match?.[1] === undefined)
+                continue;
+            const kind = /\b(?:class|struct|interface|trait|module|object|enum|impl)\b/.test(line) &&
+                !/\b(?:func|fn|fun|def|function)\b/.test(line)
+                ? "class"
+                : "function";
+            starts.push({ name: match[1], kind, line: index + 1 });
+            break;
+        }
+    });
+    return starts.map((start, index) => ({
+        name: start.name,
+        kind: start.kind,
+        startLine: start.line,
+        endLine: (starts[index + 1]?.line ?? lines.length + 1) - 1,
+    }));
+}
+/**
+ * Where a declaration starting on `start` (1-based) ends, by counting braces
+ * outside strings and comments. A declaration with no brace (an arrow function
+ * returning an expression) ends at its first line that closes the statement.
+ */
+function braceEnd(lines, start) {
+    let depth = 0;
+    let opened = false;
+    let inBlockComment = false;
+    for (let index = start - 1; index < lines.length && index < start - 1 + 2000; index += 1) {
+        const line = lines[index] ?? "";
+        let quote;
+        for (let at = 0; at < line.length; at += 1) {
+            const char = line[at];
+            const next = line[at + 1];
+            if (inBlockComment) {
+                if (char === "*" && next === "/") {
+                    inBlockComment = false;
+                    at += 1;
+                }
+                continue;
+            }
+            if (quote !== undefined) {
+                if (char === "\\")
+                    at += 1;
+                else if (char === quote)
+                    quote = undefined;
+                continue;
+            }
+            if (char === "/" && next === "/")
+                break;
+            if (char === "/" && next === "*") {
+                inBlockComment = true;
+                at += 1;
+            }
+            else if (char === '"' || char === "'" || char === "`")
+                quote = char;
+            else if (char === "{") {
+                depth += 1;
+                opened = true;
+            }
+            else if (char === "}")
+                depth -= 1;
+        }
+        if (opened && depth <= 0)
+            return index + 1;
+        if (!opened && /[;,]\s*$/.test(line) && index - (start - 1) < 3)
+            return index + 1;
+    }
+    return Math.min(lines.length, start + 1999);
+}
+const SCRIPT_KEYWORDS = new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "function",
+    "return",
+    "with",
+    "else",
+    "do",
+    "try",
+    "new",
+    "typeof",
+    "await",
+]);
+/**
+ * TypeScript and JavaScript without a compiler to hand: functions, arrow
+ * functions assigned to constants, classes and their methods, exported
+ * constants and types, each spanning its braces.
+ */
+function scriptPatternSymbols(text) {
+    const lines = text.split("\n");
+    const found = [];
+    const classes = [];
+    lines.forEach((line, index) => {
+        const lineNumber = index + 1;
+        const indent = indentation(line);
+        while (classes.length > 0 && (classes[classes.length - 1]?.end ?? 0) < lineNumber)
+            classes.pop();
+        const push = (name, kind) => found.push({ name, kind, startLine: lineNumber, endLine: braceEnd(lines, lineNumber) });
+        let match = /^\s*(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/.exec(line);
+        if (match?.[1] !== undefined)
+            return push(match[1], "function");
+        match =
+            /^\s*(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/.exec(line);
+        if (match?.[1] !== undefined) {
+            push(match[1], "class");
+            classes.push({ name: match[1], indent, end: braceEnd(lines, lineNumber) });
+            return;
+        }
+        match = /^\s*(?:export\s+)?(?:declare\s+)?(?:interface|type|enum)\s+([A-Za-z_$][\w$]*)/.exec(line);
+        if (match?.[1] !== undefined)
+            return push(match[1], "type");
+        match =
+            /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*(?:async\s+)?(?:function\b|\([^)]*\)?\s*(?::[^=]+)?=>|\(\s*$|[A-Za-z_$][\w$]*\s*=>|<)/.exec(line);
+        if (match?.[1] !== undefined)
+            return push(match[1], "function");
+        match = /^\s*export\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/.exec(line);
+        if (match?.[1] !== undefined)
+            return push(match[1], "const");
+        const owner = classes[classes.length - 1];
+        if (owner !== undefined && indent > owner.indent) {
+            match =
+                /^\s+(?:(?:public|private|protected|static|async|readonly|override|abstract|get|set)\s+)*(#?[A-Za-z_$][\w$]*)\s*(?:<[^>]*>)?\s*\(.*\)?\s*(?::\s*[^{;=]+)?\{?\s*$/.exec(line);
+            const name = match?.[1];
+            if (name !== undefined && !SCRIPT_KEYWORDS.has(name))
+                push(`${owner.name}.${name}`, "method");
+        }
+    });
+    return found;
+}
+/** Every symbol declared in a file, with its line range, and which reader found them. */
+export function declaredSymbols(path, text, root) {
+    const language = languageOf(path);
+    if (language === "ts" || language === "tsx" || language === "js") {
+        const typescript = loadTypeScript(root);
+        if (typescript !== undefined) {
+            try {
+                return { symbols: scriptSymbols(typescript, path, text), extractor: "typescript" };
+            }
+            catch {
+                // A file the parser cannot read falls through to the pattern.
+            }
+        }
+        return { symbols: scriptPatternSymbols(text), extractor: "regex" };
+    }
+    if (language === "py")
+        return { symbols: pythonSymbols(text), extractor: "regex" };
+    return { symbols: genericSymbols(text), extractor: "regex" };
+}
+/** The symbols whose range contains any of the given lines. */
+export function symbolsAtLines(symbols, lines) {
+    if (lines.size === 0)
+        return [];
+    return symbols.filter((symbol) => {
+        for (const line of lines) {
+            if (line >= symbol.startLine && line <= symbol.endLine)
+                return true;
+        }
+        return false;
+    });
+}

package/dist/risk/text.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Tokens and lexical similarity.
+ *
+ * Two different readings of text live here. Identifiers are what the change
+ * extraction records: whole tokens of four or more characters from changed
+ * lines, minus one shared stop list. Words are what similarity compares:
+ * identifiers split at case and underscore boundaries, lowercased, lightly
+ * stemmed, so `idempotencyKey` in a diff can meet "idempotency key" in a failing
+ * case.
+ */
+/**
+ * The shared stop list: language keywords and words so common in code that
+ * they say nothing about which behavior a change touches.
+ */
+export declare const STOP_WORDS: ReadonlySet<string>;
+/** Identifier tokens of four or more characters, minus the stop list, in first-seen order. */
+export declare function identifierTokens(text: string): string[];
+/** `idempotencyKey` → idempotency, key; `HTTPServer` → http, server; `retry_count` → retry, count. */
+export declare function splitIdentifier(token: string): string[];
+/**
+ * A light suffix stemmer: enough that charge, charges, charged and charging
+ * meet, and nothing that needs a dictionary.
+ */
+export declare function stem(word: string): string;
+/** The comparable words of a text: split, lowercased, stop words out, stemmed, deduplicated. */
+export declare function words(text: string): Set<string>;
+/** Inverse document frequency over a small corpus, smoothed so an unseen word counts most. */
+export type Idf = Readonly<{
+    weight: (word: string) => number;
+}>;
+export declare function buildIdf(documents: readonly ReadonlySet<string>[]): Idf;
+/**
+ * Cosine similarity of two word sets under idf weights, in [0, 1]. Binary term
+ * frequency, so a long source text is penalized for its length: a fifty-file
+ * diff's identifiers do not resemble every failing case by covering them.
+ */
+export declare function cosine(source: ReadonlySet<string>, target: ReadonlySet<string>, idf: Idf): number;
+/**
+ * Wording that says a change takes something away or goes around it. When the
+ * stated intent carries one of these and resembles the promise's own outcome,
+ * the change is saying out loud that it undoes what was agreed.
+ */
+export declare const REVERSAL_CUE: RegExp;

package/dist/risk/text.js

@@ -0,0 +1,277 @@
+/**
+ * Tokens and lexical similarity.
+ *
+ * Two different readings of text live here. Identifiers are what the change
+ * extraction records: whole tokens of four or more characters from changed
+ * lines, minus one shared stop list. Words are what similarity compares:
+ * identifiers split at case and underscore boundaries, lowercased, lightly
+ * stemmed, so `idempotencyKey` in a diff can meet "idempotency key" in a failing
+ * case.
+ */
+/**
+ * The shared stop list: language keywords and words so common in code that
+ * they say nothing about which behavior a change touches.
+ */
+export const STOP_WORDS = new Set([
+    // keywords across the languages the extraction reads
+    "abstract",
+    "async",
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "declare",
+    "default",
+    "defer",
+    "delete",
+    "elif",
+    "else",
+    "enum",
+    "except",
+    "export",
+    "extends",
+    "false",
+    "final",
+    "finally",
+    "func",
+    "function",
+    "global",
+    "implements",
+    "import",
+    "interface",
+    "lambda",
+    "module",
+    "none",
+    "null",
+    "package",
+    "pass",
+    "private",
+    "protected",
+    "public",
+    "raise",
+    "readonly",
+    "require",
+    "return",
+    "self",
+    "static",
+    "string",
+    "struct",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "throws",
+    "true",
+    "type",
+    "typeof",
+    "undefined",
+    "unless",
+    "void",
+    "while",
+    "with",
+    "yield",
+    "number",
+    "boolean",
+    "object",
+    "unknown",
+    "never",
+    "keyof",
+    "instanceof",
+    "impl",
+    "trait",
+    "then",
+    "from",
+    "nonlocal",
+    "assert",
+    // words that carry no behavior
+    "that",
+    "these",
+    "those",
+    "there",
+    "their",
+    "they",
+    "what",
+    "when",
+    "where",
+    "which",
+    "will",
+    "would",
+    "should",
+    "could",
+    "must",
+    "does",
+    "done",
+    "have",
+    "has",
+    "been",
+    "being",
+    "into",
+    "onto",
+    "only",
+    "also",
+    "every",
+    "each",
+    "some",
+    "such",
+    "than",
+    "them",
+    "just",
+    "more",
+    "most",
+    "other",
+    "over",
+    "same",
+    "very",
+    "your",
+    "yours",
+    "about",
+    "after",
+    "before",
+    "again",
+    "always",
+    "without",
+    "within",
+    "because",
+    "value",
+    "values",
+    "data",
+    "item",
+    "items",
+    "result",
+    "results",
+    "todo",
+    "fixme",
+    "http",
+    "https",
+    "the",
+    "and",
+    "for",
+    "not",
+    "are",
+    "but",
+    "can",
+    "any",
+    "all",
+    "its",
+    "was",
+    "one",
+    "two",
+    "new",
+    "get",
+    "set",
+    "let",
+    "var",
+    "def",
+    "use",
+    "via",
+    "per",
+    "out",
+    "now",
+    "yet",
+]);
+const IDENTIFIER = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+/** Identifier tokens of four or more characters, minus the stop list, in first-seen order. */
+export function identifierTokens(text) {
+    const seen = new Set();
+    for (const match of text.matchAll(IDENTIFIER)) {
+        const token = match[0];
+        if (token.length < 4)
+            continue;
+        if (STOP_WORDS.has(token.toLowerCase()))
+            continue;
+        seen.add(token);
+    }
+    return [...seen];
+}
+/** `idempotencyKey` → idempotency, key; `HTTPServer` → http, server; `retry_count` → retry, count. */
+export function splitIdentifier(token) {
+    return token
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .split(/[^A-Za-z0-9]+/)
+        .map((part) => part.toLowerCase())
+        .filter((part) => part.length > 0);
+}
+/**
+ * A light suffix stemmer: enough that charge, charges, charged and charging
+ * meet, and nothing that needs a dictionary.
+ */
+export function stem(word) {
+    let w = word;
+    if (w.length > 4 && w.endsWith("ies"))
+        w = `${w.slice(0, -3)}y`;
+    else if (w.endsWith("sses"))
+        w = w.slice(0, -2);
+    else if (w.length > 4 && /(?:[sxz]|ch|sh)es$/.test(w))
+        w = w.slice(0, -2);
+    else if (w.length > 3 && w.endsWith("s") && !/(?:ss|us|is)$/.test(w))
+        w = w.slice(0, -1);
+    if (w.length > 5 && w.endsWith("ing"))
+        w = w.slice(0, -3);
+    else if (w.length > 4 && w.endsWith("ed"))
+        w = w.slice(0, -2);
+    if (w.length > 4 && w.endsWith("e"))
+        w = w.slice(0, -1);
+    if (w.length > 4 && /([b-df-hj-np-tv-z])\1$/.test(w))
+        w = w.slice(0, -1);
+    return w;
+}
+/** The comparable words of a text: split, lowercased, stop words out, stemmed, deduplicated. */
+export function words(text) {
+    const found = new Set();
+    for (const match of text.matchAll(IDENTIFIER)) {
+        for (const part of splitIdentifier(match[0])) {
+            if (part.length < 3 || /^\d+$/.test(part))
+                continue;
+            if (STOP_WORDS.has(part))
+                continue;
+            found.add(stem(part));
+        }
+    }
+    return found;
+}
+export function buildIdf(documents) {
+    const frequency = new Map();
+    for (const document of documents) {
+        for (const word of document)
+            frequency.set(word, (frequency.get(word) ?? 0) + 1);
+    }
+    const total = documents.length;
+    return {
+        weight: (word) => Math.log(1 + (total + 1) / ((frequency.get(word) ?? 0) + 1)),
+    };
+}
+/**
+ * Cosine similarity of two word sets under idf weights, in [0, 1]. Binary term
+ * frequency, so a long source text is penalized for its length: a fifty-file
+ * diff's identifiers do not resemble every failing case by covering them.
+ */
+export function cosine(source, target, idf) {
+    if (source.size === 0 || target.size === 0)
+        return 0;
+    let shared = 0;
+    let sourceNorm = 0;
+    let targetNorm = 0;
+    for (const word of source) {
+        const w = idf.weight(word);
+        sourceNorm += w * w;
+        if (target.has(word))
+            shared += w * w;
+    }
+    for (const word of target) {
+        const w = idf.weight(word);
+        targetNorm += w * w;
+    }
+    if (shared === 0)
+        return 0;
+    return Math.min(1, shared / (Math.sqrt(sourceNorm) * Math.sqrt(targetNorm)));
+}
+/**
+ * Wording that says a change takes something away or goes around it. When the
+ * stated intent carries one of these and resembles the promise's own outcome,
+ * the change is saying out loud that it undoes what was agreed.
+ */
+export const REVERSAL_CUE = /\b(?:no longer|stop(?:s|ped|ping)?|remov(?:e|es|ed|ing)|drop(?:s|ped|ping)?|skip(?:s|ped|ping)?|bypass(?:es|ed|ing)?|disabl(?:e|es|ed|ing)|revert(?:s|ed|ing)?|ignor(?:e|es|ed|ing)|instead of|rather than|allow(?:s|ed|ing)? (?:\w+ ){0,3}(?:again|twice|more than once|without)|without)\b/i;

package/dist/risk/validate.d.ts

@@ -0,0 +1,19 @@
+import { type ChangeExtraction, type RiskReport } from "./contract.js";
+/**
+ * The change extraction and the risk report, checked by hand against the
+ * contract's field names. A shape arriving from outside this process (a model's
+ * deltas, a report the evaluation harness reads back) is checked before it is
+ * trusted; unknown fields are refused, as the behavior map's checker refuses
+ * them.
+ */
+export type ParseResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    errors: string[];
+};
+/** A change extraction, checked against the contract. */
+export declare function parseChangeExtraction(value: unknown): ParseResult<ChangeExtraction>;
+/** A risk report, checked against the contract. */
+export declare function parseRiskReport(value: unknown): ParseResult<RiskReport>;