/**
 * Would the signals this tick produced actually be accepted?
 *
 * A tick can read successfully, compute correctly, and emit something intake rejects at the wire —
 * and from the scanner's side that is indistinguishable from success. It returned its candidates
 * and the loop reported a healthy tick; the 400 happens somewhere else, to someone else. That gap
 * is the last place a strategy can look runnable while producing nothing.
 *
 * ## Judged against intake's own schema
 *
 * `SignalsBodySchema` is imported from the route rather than described here, and checked with the
 * same `Value.Check` the route calls. A second description of the contract would be a second thing
 * to keep in step, and the failure mode of getting it wrong is the one this feature exists to
 * prevent: a green result that means less than it claims.
 *
 * The whole body is checked, not the signal alone, because the body is what intake receives —
 * `additionalProperties: false` at that level is part of the contract too.
 */
import type { ScannerTarget } from "./import-stage.js";
import type { Finding } from "./types.js";
/** One candidate as the harness reports it, before and after the envelope was built. */
export interface SignalRecord {
    /** What scan() returned. */
    emitted: unknown;
    /** The envelope, or null when the scaffold refused to build one. */
    wire: unknown;
    /** Why the scaffold refused, when it did. */
    rejected_by_scaffold: {
        reason?: string;
    }[];
}
/**
 * Judge the signals one tick produced.
 *
 * Separate from judging the tick because these are separate claims — a tick can be perfectly
 * healthy and emit nothing acceptable — and because this needs no harness at all, so the cases that
 * matter are testable directly.
 */
export declare function judgeSignals(scanner: ScannerTarget, signals: SignalRecord[]): Finding[];
//# sourceMappingURL=signal-stage.d.ts.map