pabst-checker 0.12.0

package/dist/prefix-parser.js

@@ -0,0 +1,188 @@
+import ts from "typescript";
+import { isDomain } from "./domains.js";
+import { PabstError } from "./errors.js";
+import { parseRange } from "./range.js";
+import { parseRegexGuard, scanRegexLiteral, TRUNCATION_HINT, } from "./regex-guard.js";
+import { scanTokens, sliceText } from "./formula-lexer.js";
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** prefix ::= FORALL binder-group+   (docs/grammar.ebnf) */
+export function parsePrefix(formula) {
+    const { toks, unterminatedSlash } = prefixTokens(formula);
+    const head = toks[0];
+    if (head && (head.text === "∃" || head.text === "exists")) {
+        throw new PabstError("existential quantifiers (∃ / exists) are not supported: property-based " +
+            "testing samples inputs, so it can refute ∀ with a counterexample but cannot " +
+            "soundly confirm ∃ (a bounded/exhaustive mode would be needed)");
+    }
+    if (!head || (head.text !== "forall" && head.text !== "∀")) {
+        throw new PabstError(`expected 'forall' (or ∀) at start of property: ${formula.trim().slice(0, 60)}`);
+    }
+    let i = 1;
+    const binders = [];
+    while (i < toks.length && toks[i].text === "(") {
+        const close = groupExtent(toks, i, formula, unterminatedSlash);
+        binders.push(...parseBinderGroup(toks, i, close, formula));
+        i = close + 1;
+    }
+    if (binders.length === 0) {
+        throw new PabstError(`expected at least one binder group '(x: domain)' after forall`);
+    }
+    const comma = toks[i];
+    if (!comma || comma.text !== ",") {
+        const at = comma?.start ?? formula.length;
+        throw new PabstError(`expected ',' separating binders from body, got: ${formula.slice(at, at + 60)}`);
+    }
+    const body = formula.slice(comma.end).trim();
+    if (body.length === 0)
+        throw new PabstError(`property body is empty`);
+    return { binders, body };
+}
+function isMembership(t) {
+    return t.text === "∈" || t.text === "in";
+}
+/** Tokenize the annotation for prefix parsing. A regex literal that never
+ * closes would swallow the rest of the group as one token, so its leading
+ * '/' is emitted alone, scanning restarts after it, and the slash's offset
+ * feeds the truncation hint. */
+function prefixTokens(formula) {
+    const toks = [];
+    const unterminatedSlash = new Set();
+    let from = 0;
+    scan: while (true) {
+        for (const t of scanTokens(formula, from)) {
+            if (t.kind === ts.SyntaxKind.RegularExpressionLiteral &&
+                scanRegexLiteral(t.text, 0).close === -1) {
+                toks.push({
+                    kind: ts.SyntaxKind.SlashToken,
+                    text: "/",
+                    start: t.start,
+                    end: t.start + 1,
+                });
+                unterminatedSlash.add(t.start);
+                from = t.start + 1;
+                continue scan;
+            }
+            toks.push(t);
+        }
+        return { toks, unterminatedSlash };
+    }
+}
+/** Index of the ')' closing the group opened at toks[open]. Guard tokens
+ * never take part in paren counting: an interval's delimiters may be
+ * deliberately mismatched — (0, 1] is a legal half-open interval — so a
+ * membership token followed by a plausible interval is skipped atomically,
+ * and a terminated regex literal is already a single token. */
+function groupExtent(toks, open, formula, unterminatedSlash) {
+    let depth = 0;
+    let j = open;
+    while (j < toks.length) {
+        if (isMembership(toks[j])) {
+            const e = intervalExtent(toks, j + 1);
+            if (e !== -1) {
+                j = e + 1;
+                continue;
+            }
+        }
+        const t = toks[j];
+        if (t.text === "(")
+            depth++;
+        else if (t.text === ")") {
+            depth--;
+            if (depth === 0)
+                return j;
+        }
+        j++;
+    }
+    const sawUnterminated = [...unterminatedSlash].some((at) => at >= toks[open].start);
+    const hint = sawUnterminated
+        ? ` (if this is a regex guard: ${TRUNCATION_HINT})`
+        : "";
+    throw new PabstError(`unbalanced parentheses in binder group: ${formula.slice(toks[open].start)}${hint}`);
+}
+/** Index of the token closing a plausible two-endpoint interval starting at
+ * toks[at], or -1 when none starts there — the group scan then proceeds as
+ * usual and the guard text reaches parseRange for the precise complaint. */
+function intervalExtent(toks, at) {
+    const open = toks[at];
+    if (!open || (open.text !== "[" && open.text !== "("))
+        return -1;
+    let commas = 0;
+    for (let j = at + 1; j < toks.length; j++) {
+        const text = toks[j].text;
+        if (text === "]" || text === ")")
+            return commas === 1 ? j : -1;
+        if (text === ":")
+            return -1;
+        if (text === ",")
+            commas++;
+    }
+    return -1;
+}
+/** binder-group ::= "(" var-name+ ":" domain constraint? ")" */
+function parseBinderGroup(toks, open, close, formula) {
+    const interior = toks.slice(open + 1, close);
+    const groupText = formula.slice(toks[open].end, toks[close].start).trim();
+    const colon = interior.findIndex((t) => t.text === ":");
+    if (colon === -1) {
+        throw new PabstError(`binder group missing ':' — expected '(x: domain)', got: (${groupText})`);
+    }
+    const domainToks = interior.slice(colon + 1);
+    const member = domainToks.findIndex(isMembership);
+    const nameEnd = member === -1 ? domainToks.length : member;
+    const domainName = sliceText(formula, domainToks.slice(0, nameEnd)).trim();
+    if (!isDomain(domainName)) {
+        throw new PabstError(`unknown generation domain '${domainName}' — valid domains: int, nat, number, boolean, string, bigint`);
+    }
+    let range;
+    let pattern;
+    if (member !== -1) {
+        const guardText = formula
+            .slice(domainToks[member].end, toks[close].start)
+            .trim();
+        // A leading '/' is a regex guard when the domain is string or when
+        // the literal closes (a deliberate regex on a numeric domain deserves
+        // the regex-guard domain complaint). An unterminated '/' on a
+        // non-string domain is more likely a mistyped '(' — fall through to
+        // parseRange for the precise interval complaint.
+        const regexGuard = guardText.startsWith("/") &&
+            (domainName === "string" || scanRegexLiteral(guardText, 0).close !== -1);
+        if (regexGuard)
+            pattern = parseRegexGuard(guardText, domainName);
+        else
+            range = parseRange(guardText, domainName);
+    }
+    const names = adjacentRuns(interior.slice(0, colon), formula);
+    if (names.length === 0) {
+        throw new PabstError(`binder group has no variable names: (${groupText})`);
+    }
+    for (const n of names) {
+        if (!NAME.test(n)) {
+            throw new PabstError(`invalid binder variable name '${n}'`);
+        }
+    }
+    return names.map((varName) => {
+        const binder = { varName, domain: domainName };
+        if (range)
+            binder.range = range;
+        if (pattern)
+            binder.pattern = pattern;
+        return binder;
+    });
+}
+/** Group adjacent tokens (no gap between them) into runs; each run's source
+ * text is one candidate name — the token-level analogue of splitting the
+ * variable segment on whitespace, so 'x-y' stays one (invalid) name. */
+function adjacentRuns(toks, formula) {
+    const runs = [];
+    for (let i = 0; i < toks.length;) {
+        const start = toks[i].start;
+        let end = toks[i].end;
+        i++;
+        while (i < toks.length && toks[i].start === end) {
+            end = toks[i].end;
+            i++;
+        }
+        runs.push(formula.slice(start, end));
+    }
+    return runs;
+}

package/dist/qualified-name.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Render a property's identity: the bare function name, or `Class#method`
+ * (instance) / `Class.method` (static) when it lives on a class.
+ */
+export declare function qualifiedName(functionName: string, className?: string, isStatic?: boolean): string;

package/dist/qualified-name.js

@@ -0,0 +1,11 @@
+/**
+ * Render a property's identity: the bare function name, or `Class#method`
+ * (instance) / `Class.method` (static) when it lives on a class.
+ */
+export function qualifiedName(functionName, className, isStatic) {
+    if (className === undefined)
+        return functionName;
+    return isStatic
+        ? `${className}.${functionName}`
+        : `${className}#${functionName}`;
+}

package/dist/range.d.ts

@@ -0,0 +1,5 @@
+import type { Domain, Range } from "./ir.js";
+export declare function isNumericDomain(d: Domain): boolean;
+/** Parse and validate an interval constraint like "[1, 30]" or "(0, 1]".
+ * A round bracket excludes its endpoint. */
+export declare function parseRange(text: string, domain: Domain): Range;

package/dist/range.js

@@ -0,0 +1,152 @@
+import fc from "fast-check";
+import { bigintBounds, intBounds, numberConstraints } from "./domains.js";
+import { PabstError } from "./errors.js";
+const INT_LITERAL = /^[+-]?\d+$/;
+const BIGINT_LITERAL = /^[+-]?\d+n?$/;
+const NUMBER_LITERAL = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
+const INFINITE_LITERAL = /^([+-]?)(?:∞|Infinity)$/;
+export function isNumericDomain(d) {
+    return d === "int" || d === "nat" || d === "number" || d === "bigint";
+}
+/** Interval delimiters may be deliberately mismatched — (0, 1] is legal —
+ * so the FIRST of ']' or ')' always closes an interval. */
+const CLOSE_DELIM = /[\])]/;
+/** Parse and validate an interval constraint like "[1, 30]" or "(0, 1]".
+ * A round bracket excludes its endpoint. */
+export function parseRange(text, domain) {
+    if (!isNumericDomain(domain)) {
+        throw new PabstError(`domain '${domain}' does not support ∈ interval constraints — ` +
+            `only int, nat, number, and bigint do`);
+    }
+    const minOpen = text.startsWith("(");
+    if (!minOpen && !text.startsWith("[")) {
+        throw new PabstError(`expected interval '[lo, hi]' or '(lo, hi]' after ∈, got: ${text || "(nothing)"}`);
+    }
+    const close = text.search(CLOSE_DELIM);
+    if (close === -1) {
+        throw new PabstError(`interval is missing its closing ']' or ')' (in: ${text})`);
+    }
+    if (close !== text.length - 1) {
+        throw new PabstError(`unexpected text after interval: '${text.slice(close + 1).trim()}' (in: ${text})`);
+    }
+    const maxOpen = text[close] === ")";
+    const parts = text.slice(1, close).split(",");
+    if (parts.length !== 2) {
+        throw new PabstError(`expected exactly two endpoints '[lo, hi]', got: ${text}`);
+    }
+    const min = parseBound(parts[0].trim(), "lower", minOpen, domain);
+    const max = parseBound(parts[1].trim(), "upper", maxOpen, domain);
+    const range = {};
+    if (min !== undefined)
+        range.min = min;
+    if (max !== undefined)
+        range.max = max;
+    if (minOpen)
+        range.minOpen = true;
+    if (maxOpen)
+        range.maxOpen = true;
+    if (domain === "number") {
+        validateNumberInterval(range, text);
+    }
+    else {
+        validateIntegerInterval(domain, range, text);
+    }
+    return range;
+}
+/** Returns the normalized endpoint literal, or undefined for an unbounded
+ * (±∞) endpoint. */
+function parseBound(lit, side, open, domain) {
+    const inf = INFINITE_LITERAL.exec(lit);
+    if (!inf)
+        return parseEndpoint(lit, domain);
+    if (side === "lower" && inf[1] !== "-") {
+        throw new PabstError(`an interval's lower endpoint cannot be +∞ (in endpoint '${lit}')`);
+    }
+    if (side === "upper" && inf[1] === "-") {
+        throw new PabstError(`an interval's upper endpoint cannot be -∞ (in endpoint '${lit}')`);
+    }
+    if (domain !== "number" && !open) {
+        throw new PabstError(`${domain} has no infinite values, so an ∞ endpoint must be open — ` +
+            `use ${side === "lower" ? `'(${lit},'` : `'${lit})'`} (a closed ∞ ` +
+            `bound is only meaningful for number, where Infinity is a value)`);
+    }
+    return undefined;
+}
+/** Validity is judged on the exact bounds lowering will emit (intBounds /
+ * bigintBounds fold open endpoints into ±1, floor nat at 0, and intersect
+ * int/nat with the safe integer range), so validation and generation can
+ * never disagree. A nat interval reaching below 0 clamps — `(-2, 5]` and
+ * `(-∞, 5]` denote the same naturals — and an int/nat endpoint beyond the
+ * safe range clamps with a warning; either is an error only when nothing
+ * satisfiable remains. */
+function validateIntegerInterval(domain, range, text) {
+    if (domain === "bigint") {
+        const { lo, hi } = bigintBounds(range);
+        if (lo !== undefined && hi !== undefined && lo > hi) {
+            throw new PabstError(`empty interval: no bigint satisfies ${text}`);
+        }
+        return;
+    }
+    const { lo, hi, clamped } = intBounds(domain, range);
+    if (lo > hi) {
+        throw new PabstError(`empty interval: no ${domain}${clamped ? " within the safe integer range (±9007199254740991)" : ""} satisfies ${text}`);
+    }
+    if (clamped) {
+        console.error(`warning: interval ${text} extends beyond the safe integer range; ` +
+            `${domain} generation is clamped to [${lo}, ${hi}]`);
+    }
+}
+/** A number interval denotes a set of fc-generatable doubles, so emptiness
+ * is fast-check's call, not ours: constructing the exact fc.double
+ * constraints lowering will emit lets fc apply its own ordering, in which
+ * every double is distinct — -0 sits below 0 (so [0, -0] is empty but
+ * (-0, 0] is the singleton {0}) and an excluded bound removes exactly one
+ * double, by adjacency rather than numeric equality (so [-1, 0) can
+ * generate -0, and (0, 5e-324) is empty). */
+function validateNumberInterval(range, text) {
+    const c = numberConstraints(range);
+    const opts = {
+        noNaN: true,
+        minExcluded: c.minExcluded,
+        maxExcluded: c.maxExcluded,
+    };
+    if (c.min)
+        opts.min = c.min.val;
+    if (c.max)
+        opts.max = c.max.val;
+    try {
+        fc.double(opts);
+    }
+    catch {
+        throw new PabstError(`empty interval: no number satisfies ${text} (fast-check treats every ` +
+            `double as distinct — it orders -0 below 0, and an excluded bound ` +
+            `removes exactly one double)`);
+    }
+}
+function parseEndpoint(lit, domain) {
+    switch (domain) {
+        case "int":
+        case "nat": {
+            if (!INT_LITERAL.test(lit))
+                throw new PabstError(`interval endpoint '${lit}' is not an integer literal (domain ${domain})`);
+            return normalizeLiteral(lit);
+        }
+        case "bigint": {
+            if (!BIGINT_LITERAL.test(lit))
+                throw new PabstError(`interval endpoint '${lit}' is not an integer literal (domain bigint)`);
+            return normalizeLiteral(lit.endsWith("n") ? lit.slice(0, -1) : lit);
+        }
+        default: {
+            if (!NUMBER_LITERAL.test(lit) || !Number.isFinite(Number(lit)))
+                throw new PabstError(`interval endpoint '${lit}' is not a finite number literal`);
+            return normalizeLiteral(lit);
+        }
+    }
+}
+/** Strip a leading '+' and redundant leading zeros: endpoints are emitted
+ * verbatim into an ES module, where '010' is a SyntaxError. The lookahead
+ * keeps a lone (possibly signed) zero intact, so '-0' survives. */
+function normalizeLiteral(lit) {
+    const unsigned = lit.startsWith("+") ? lit.slice(1) : lit;
+    return unsigned.replace(/^(-?)0+(?=\d)/, "$1");
+}

package/dist/regex-guard.d.ts

@@ -0,0 +1,28 @@
+import { PabstError } from "./errors.js";
+import type { Domain, StringPattern } from "./ir.js";
+export declare const TRUNCATION_HINT: string;
+export interface RegexScan {
+    /** Index just past the literal (closing '/' plus flags), or text.length
+     * if the literal never closes. */
+    end: number;
+    /** Index of the closing '/', or -1 if the literal never closes. */
+    close: number;
+}
+/** Scan a JS regex literal starting at text[start] === '/'. Tracks
+ * backslash escapes and [...] character classes, so '(', ')' and '/'
+ * inside them do not close the literal. A line terminator — even after a
+ * backslash, which cannot escape one — ends the scan unterminated, as in
+ * JS source; admitting one would re-emit it inside a regex literal in the
+ * generated spec, where it is a SyntaxError. */
+export declare function scanRegexLiteral(text: string, start: number): RegexScan;
+/** Full-string semantics: '∈ /re/' denotes the language of re, so lowering
+ * wraps the pattern before handing it to fc.stringMatching. */
+export declare function anchoredSource(source: string): string;
+/** The complaint a regex guard on a non-string domain raises; shared with
+ * arbitraryFor's backstop so the two throw sites cannot drift apart. */
+export declare function regexGuardDomainError(domain: Domain): PabstError;
+/** Parse and validate a regex guard like "/^[a-z]+$/u". Source and flags
+ * are kept verbatim; anchoring happens at lowering. Validation probes
+ * fast-check itself — a peer dependency, so it resolves to the same copy
+ * the generated spec runs against and the accepted subset cannot drift. */
+export declare function parseRegexGuard(text: string, domain: Domain): StringPattern;

package/dist/regex-guard.js

@@ -0,0 +1,100 @@
+import { stringMatching } from "fast-check";
+import { PabstError } from "./errors.js";
+// A line comment on purpose: spelling star-slash inside a block comment
+// would end it — which is exactly the hazard this hint is about. An
+// unterminated literal is the telltale symptom of a pattern whose "*/"
+// ended the enclosing JSDoc comment early.
+export const TRUNCATION_HINT = "a '*/' inside a pattern ends the enclosing JSDoc comment early — " +
+    "write {0,} instead of a trailing *, or wrap it in (?:...)";
+const FLAG_ERRORS = {
+    m: "regex flag 'm' would let the pattern match a single line inside a " +
+        "longer string, but ∈ guards match the whole string",
+    i: "regex flag 'i' is not supported by fast-check's string generator",
+    v: "regex flag 'v' is not supported by fast-check's string generator",
+    g: "regex flag 'g' has no effect on generation",
+    y: "regex flag 'y' has no effect on generation",
+    d: "regex flag 'd' has no effect on generation",
+};
+const LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
+/** Scan a JS regex literal starting at text[start] === '/'. Tracks
+ * backslash escapes and [...] character classes, so '(', ')' and '/'
+ * inside them do not close the literal. A line terminator — even after a
+ * backslash, which cannot escape one — ends the scan unterminated, as in
+ * JS source; admitting one would re-emit it inside a regex literal in the
+ * generated spec, where it is a SyntaxError. */
+export function scanRegexLiteral(text, start) {
+    let inClass = false;
+    for (let i = start + 1; i < text.length; i++) {
+        const c = text[i];
+        if (LINE_TERMINATOR.test(c))
+            break;
+        if (c === "\\") {
+            const next = text[i + 1];
+            if (next === undefined || LINE_TERMINATOR.test(next))
+                break;
+            i++;
+        }
+        else if (c === "[")
+            inClass = true;
+        else if (c === "]")
+            inClass = false;
+        else if (c === "/" && !inClass) {
+            const close = i;
+            i++;
+            while (i < text.length && /[a-zA-Z]/.test(text[i]))
+                i++;
+            return { end: i, close };
+        }
+    }
+    return { end: text.length, close: -1 };
+}
+/** Full-string semantics: '∈ /re/' denotes the language of re, so lowering
+ * wraps the pattern before handing it to fc.stringMatching. */
+export function anchoredSource(source) {
+    return `^(?:${source})$`;
+}
+/** The complaint a regex guard on a non-string domain raises; shared with
+ * arbitraryFor's backstop so the two throw sites cannot drift apart. */
+export function regexGuardDomainError(domain) {
+    return new PabstError(`domain '${domain}' does not support ∈ regex guards — only string does`);
+}
+/** Parse and validate a regex guard like "/^[a-z]+$/u". Source and flags
+ * are kept verbatim; anchoring happens at lowering. Validation probes
+ * fast-check itself — a peer dependency, so it resolves to the same copy
+ * the generated spec runs against and the accepted subset cannot drift. */
+export function parseRegexGuard(text, domain) {
+    if (domain !== "string") {
+        throw regexGuardDomainError(domain);
+    }
+    const { end, close } = scanRegexLiteral(text, 0);
+    if (close === -1) {
+        throw new PabstError(`unterminated regular expression (in: ${text}) — ${TRUNCATION_HINT}`);
+    }
+    if (end !== text.length) {
+        throw new PabstError(`unexpected text after regular expression: '${text.slice(end).trim()}' (in: ${text})`);
+    }
+    const source = text.slice(1, close);
+    const flags = text.slice(close + 1, end);
+    if (source.length === 0) {
+        throw new PabstError("empty regular expression after ∈ — to generate only the empty string, use ∈ /^$/");
+    }
+    for (const f of flags) {
+        if (f === "s" || f === "u")
+            continue;
+        const why = FLAG_ERRORS[f] ?? `regex flag '${f}' is not supported`;
+        throw new PabstError(`${why} (allowed flags: s, u; in: ${text})`);
+    }
+    try {
+        new RegExp(source, flags);
+    }
+    catch (e) {
+        throw new PabstError(`invalid regular expression (in: ${text}): ${e.message}`);
+    }
+    try {
+        stringMatching(new RegExp(anchoredSource(source), flags));
+    }
+    catch (e) {
+        throw new PabstError(`regular expression not supported by fast-check (in: ${text}): ${e.message}`);
+    }
+    return { source, flags };
+}

package/dist/run.d.ts

@@ -0,0 +1,26 @@
+import { type RunMeta } from "./envelope.js";
+import type { Envelope } from "./issue.js";
+/** Where the spawned vitest writes its JSON results, relative to cwd. */
+export declare const RESULTS_FILE = ".pabst/.last-run.json";
+export type RunResult = {
+    kind: "completed";
+    envelope: Envelope;
+} | {
+    kind: "no-results";
+    status: number;
+    stdout: string;
+    stderr: string;
+} | {
+    kind: "broken-run";
+    status: number;
+    messages: string[];
+};
+/**
+ * Run vitest over `target` (the generated-test root, or a single generated
+ * file) and assemble the run envelope from its JSON results. When vitest
+ * produces no parseable results file (e.g. it died on startup before its
+ * reporter ran), the run yielded nothing trustworthy to report: instead of an
+ * envelope, return vitest's raw output and exit status so the caller can
+ * surface the underlying error.
+ */
+export declare function runTests(target: string, meta: RunMeta, resultsFile?: string): RunResult;

package/dist/run.js

@@ -0,0 +1,50 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync, rmSync } from "node:fs";
+import { buildEnvelope } from "./envelope.js";
+/** Where the spawned vitest writes its JSON results, relative to cwd. */
+export const RESULTS_FILE = ".pabst/.last-run.json";
+/**
+ * Run vitest over `target` (the generated-test root, or a single generated
+ * file) and assemble the run envelope from its JSON results. When vitest
+ * produces no parseable results file (e.g. it died on startup before its
+ * reporter ran), the run yielded nothing trustworthy to report: instead of an
+ * envelope, return vitest's raw output and exit status so the caller can
+ * surface the underlying error.
+ */
+export function runTests(target, meta, resultsFile = RESULTS_FILE) {
+    // A stale results file from a previous run must not be mistaken for this
+    // run's output when vitest dies before writing one.
+    try {
+        rmSync(resultsFile, { force: true });
+    }
+    catch (e) {
+        return {
+            kind: "no-results",
+            status: 1,
+            stdout: "",
+            stderr: `pabst: cannot clear stale results file ${resultsFile}: ${e instanceof Error ? e.message : String(e)}\n`,
+        };
+    }
+    const res = spawnSync("npx", ["vitest", "run", target, "--reporter=json", `--outputFile=${resultsFile}`], { encoding: "utf8" });
+    let json;
+    try {
+        json = JSON.parse(readFileSync(resultsFile, "utf8"));
+    }
+    catch {
+        return {
+            kind: "no-results",
+            status: res.status ?? 1,
+            stdout: res.stdout ?? "",
+            stderr: (res.stderr ?? "") + (res.error ? `${String(res.error)}\n` : ""),
+        };
+    }
+    // An unhealthy run vitest couldn't attribute to any test (e.g. a test file
+    // that failed to load) must not be reported as a trustworthy envelope. The
+    // json reporter keeps the underlying errors in each file's `message`, not
+    // on stdout/stderr.
+    if (json.success === false && json.numFailedTests === 0) {
+        const messages = (json.testResults ?? []).flatMap((f) => f.status === "failed" && f.message ? [f.message] : []);
+        return { kind: "broken-run", status: res.status || 1, messages };
+    }
+    return { kind: "completed", envelope: buildEnvelope(meta, json) };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The subset of fast-check's RunDetails that the reporter consumes. The
+ * counterexample is the tuple of generated arguments, in binder order.
+ */
+export interface ReportDetails {
+    failed: boolean;
+    counterexample: unknown[] | null;
+    errorInstance?: {
+        message?: string;
+    } | null;
+}
+/**
+ * Assert that a property atom evaluated to a genuine boolean (no truthiness
+ * coercion), returning it so it composes inside lowered boolean expressions.
+ * Throwing here surfaces as a `threw` issue whose message names the atom.
+ */
+export declare function bool(v: unknown, expr: string): boolean;
+/**
+ * Reporter used by generated property tests. fast-check invokes this instead of
+ * its default throw, so it is solely responsible for failing the test — it must
+ * throw on `d.failed`. On failure it throws an Error whose message is a
+ * sentinel-tagged JSON Issue that the CLI parses back out of vitest's reporter
+ * output.
+ */
+export declare function report(file: string, functionName: string, name: string, varNames: string[], d: ReportDetails): void;

package/dist/runtime.js

@@ -0,0 +1,62 @@
+import { stringify } from "fast-check";
+import { ISSUE_SENTINEL } from "./issue.js";
+/**
+ * Encode a single counterexample value for JSON output: finite numbers,
+ * booleans, and strings round-trip as native JSON; everything else (bigint,
+ * NaN/Infinity, objects) becomes its lossless fast-check stringify() form.
+ */
+function encodeValue(v) {
+    if (typeof v === "string" || typeof v === "boolean")
+        return v;
+    if (typeof v === "number" && Number.isFinite(v))
+        return v;
+    return stringify(v);
+}
+function throwIssue(issue) {
+    throw new Error(ISSUE_SENTINEL + JSON.stringify(issue));
+}
+/**
+ * Assert that a property atom evaluated to a genuine boolean (no truthiness
+ * coercion), returning it so it composes inside lowered boolean expressions.
+ * Throwing here surfaces as a `threw` issue whose message names the atom.
+ */
+export function bool(v, expr) {
+    if (v !== true && v !== false) {
+        const shown = typeof v === "string"
+            ? JSON.stringify(v)
+            : typeof v === "bigint"
+                ? `${v}n`
+                : String(v);
+        throw new Error(`atom ${JSON.stringify(expr)} evaluated to ${shown}, not a boolean`);
+    }
+    return v;
+}
+/**
+ * Reporter used by generated property tests. fast-check invokes this instead of
+ * its default throw, so it is solely responsible for failing the test — it must
+ * throw on `d.failed`. On failure it throws an Error whose message is a
+ * sentinel-tagged JSON Issue that the CLI parses back out of vitest's reporter
+ * output.
+ */
+export function report(file, functionName, name, varNames, d) {
+    if (!d.failed)
+        return;
+    const base = { file, function: functionName, property: name };
+    if (d.counterexample === null) {
+        throwIssue({
+            ...base,
+            kind: "exhausted",
+            error: d.errorInstance?.message ?? "too many skipped runs",
+        });
+    }
+    const counterexample = {};
+    varNames.forEach((n, i) => {
+        counterexample[n] = encodeValue(d.counterexample[i]);
+    });
+    const err = d.errorInstance;
+    const threw = !!err && err.message !== "Property failed by returning false";
+    if (threw) {
+        throwIssue({ ...base, kind: "threw", counterexample, error: err.message });
+    }
+    throwIssue({ ...base, kind: "falsified", counterexample });
+}

package/dist/seed.d.ts

@@ -0,0 +1,7 @@
+/** A fresh 32-bit unsigned integer, suitable as a fast-check seed. */
+export declare function randomSeed(): number;
+/**
+ * Parse and validate a `--seed` CLI argument. fast-check seeds are 32-bit
+ * integers, so we require a non-negative integer below 2^32.
+ */
+export declare function parseSeed(raw: string): number;