import { type Event, type Spec, type World } from "../spec/index.ts";
/** What the exploring so far knows: which properties broke, which errors were met, which steps ran. */
export interface Verdicts {
    broken: Set<string>;
    errors: Set<string>;
    /** Steps (`Actor.key`) that ran somewhere. */
    reached: Set<string>;
}
export declare function verdicts(): Verdicts;
/**
 * Judge a world and the event that led to it: the event's error and `always` violations, and
 * `never` over the path. Only properties not yet broken are judged. A step that fails is a
 * spec error and breaks no property: what is left after it is not a state the system gets to.
 */
export declare function judge(spec: Spec, event: Event | null, path: () => Event[], v: Verdicts): {
    findings: string[];
    error?: string;
};
/**
 * The properties a world breaks before anything happens: where a path starts (the initial
 * world, or where a scenario ends). Its `always` properties, and `never` ones over no events.
 */
export declare function startBreaks(spec: Spec, world: World): string[];
/** The `everyStep` properties a step breaks, of those not yet broken. A predicate that cannot be evaluated holds, as an `always` one does. */
export declare function stepBreaks(spec: Spec, before: World, after: World, event: Event, broken: Set<string>): string[];
/**
 * Whether nothing can happen in a world, and the spec does not call it final: nothing pending,
 * no action whose `when` holds, and no fair guard whose `when` holds. A bound of the model (a
 * step's parts, such as atMost or a budget) does not count: running out of repeats is not the
 * system getting stuck, and neither is a fault left to happen (RFD0012).
 */
export declare function stuck(spec: Spec, world: World): boolean;
export declare function safely<T>(f: () => T): T | false;