You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
This commit was created on GitHub.com and signed with GitHub’s verified signature.
Highlights
A join has the type its arms share (#1716). An if, a match or an Exn handler is recorded at what every arm that completes states, in either order, where the checker kept one arm's refinements and effect row whatever the others stated; the proofs that read verified on the strength of an arm the value did not take are closed.
The type a value is expected at fixes what its arguments or elements leave open, and argument order never decides a type variable (#1684). let @Array<Option<Nat>> = [None, None] checks and runs, and a type variable two arguments give different types takes the type they share, where it took the first argument's and ran a Nat closure on -5 with every gate green.
A message quotes the program's own text, and a fix it offers can be written (#1573, #1778, #1763, #1858). An expression in a message is written as vera fmt writes it, a fix that names a type writes it as the program does, and a fix's example is computed from the site, a precondition offered only where the solver confirms it discharges the obligation.
A check on a tail call's result runs (#1849), where the call left by return_call and the check after it never ran.
The nightly mutation sweep accounts for each mutant (#1838): a mutant is kept as the engine decides it, a slice's record is uploaded in legs that outlive a lost runner, and the engine runs under a memory bound.
Changed
A slice of the nightly mutation sweep survives the loss of its runner (#1838). A lost runner takes its job's log with it and uploads nothing after the loss: on 11 November 2026 slice 0 lost its runner at +161 minutes and left neither a record nor a log, its one function the same that lost a runner on 7 and 10 November. The slice now runs in the background across the job's steps and rewrites its partial record at every heartbeat, and ten leg steps upload it as mutation-sweep-slice-<n>-leg-<k> (the plan, then every 30 minutes, kept three days). Every leg step and leg upload continues on error, so a leg that fails never ends the slice. A partial record never holds less than an earlier one: a mutmut results listing that fails keeps the results last read whole, and the record says when it failed. The stitch takes a slice's final record, whose name and shape are unchanged, and otherwise its legs together (a mutant any valid leg decided is decided; two legs that disagree leave it undecided and are a problem), and the slice counts as lost. A cancelled run charges no loss. The record's heartbeat series holds the runner's memory, swap, load and free disk and the bound's processes, memory and kill count.
The nightly mutation sweep's engine runs under a memory bound: a transient systemd scope, set up with the hosted runner's own sudo, with MemoryMax at the runner's memory less 2.5 GiB, no swap, and OOMPolicy=continue, as the runner's user with its environment. The oracle plugin makes each mutant's run the kernel's preferred choice (oom_score_adj 1000, the engine 500), so a run that outgrows the bound is ended in preference to the engine, and the runner, outside the scope, lives; it is a preference, not a guarantee, and an engine the kernel ends shows as an engine stop with the count risen. A bound that cannot be set stops the slice as a lane failure; it never runs unbounded. A mutant whose run the kernel ended there (the bound's oom_kill count rose while its process disappeared, and mutmut recorded the -9 it reports as segfault) is memory; one in flight, having run at least five minutes, at the last record of two slices that ended with neither the engine finishing nor the budget stopping it is lost. Both are decided, counted apart and listed, never caught and never survived, and a slice lost two nights running on the same plan with nothing decided is red. The state stays schema 3: a unit's losses, the memory and lost columns and a night's lost plans are written only when they hold a fact.
A segfault or suspicious mutant the engine recorded before a budget stop was sent is kept; only a status that appears after the stop is left undecided, in every record the slice writes. A budget stop whose final listing fails charges no loss. Each mutant's duration is its own run's, from the start to the end the oracle plugin records in the run; a run with no end (the cap's exit, a kill) has no measured duration: mutmut's fork server reports every duration as zero, and the calibration of the sweep's plan, which moved halfway to zero on each such night, now leaves a zero duration out.
scripts/mutate_diff.py's engine runner ends the engine's whole process group on any exception that ends its wait (a keyboard interrupt, a signal the caller turned into one, a test's timeout), where only its own budget did before. The diff lane runs without the memory bound: a worker the kernel ended there would read as a segfault, and what its result means stays as it is. A group that can be sent nothing is taken as gone: on macOS a group whose last member has exited and is not yet reaped answers EPERM where Linux reports no error, and that answer ended the stop in a PermissionError.
The nightly mutation sweep keeps each mutant as the engine decides it (#1838): a window partly decided keeps its decided mutants and becomes a decided window with its last, and the next night hands mutmut the undecided mutants by name and no others. mutmut runs a bin's mutants in ascending order of estimated cost across the whole bin, so under the rule that counted a window only when it was whole the nights of 7 to 10 November 2026 decided at least 201 mutants and recorded 34, each night deciding the same cheap mutants again. The state is schema 3: a window's partial decisions, a slow column, and each survivor a record of its line, the hash of that line's text and the test files it ran; a schema 2 state loads with no window partly decided and its cycle goes on. A slice's record carries each mutant's duration and mutmut's estimate, the engine's phase times, its last count and the runner's memory floor and swap peak.
A budget stop is a normal stop for the nightly mutation sweep: the rule "its budget ran out before its first mutant" fired on nine slice-nights whose engines had decided 9 to 39 mutants each, and is gone. A night is red for a slice whose engine or lane failed, more than two slices with no record, records that disagree, an empty plan while the cycle is open, or a second night in a row that decides no mutant; a cycle closes when its sample is decided, whatever else the night did.
The nightly mutation sweep plans the night over every job: the functions with undecided mutants, in the tree's order up to the night's capacity, go the dearest first into the job holding least, where on four nights three of seven jobs planned nothing while 362 mutants waited; the estimate learns from each decided mutant's recorded duration, its clamp widened from 5.0 to 100.
Each slice of the nightly mutation sweep runs two mutmut workers, and tests/mutation_oracle.py ends a mutant's run at 2,400 s with a timer in mutmut's worker, naming it in a file the slice reads: the mutant is slow, decided for the cycle, counted apart, never caught and never a survivor. With four workers a bin's survivors ran together at its end and took the runner to 269 to 469 MiB available with up to 3 GiB of swap, and two bins lost their runners twice.
Both mutation lanes' clean run is the covering tests of the functions they mutate, not the whole selection: mutmut reads the clean run's tests off the names it is handed, and a glob such as key__mutmut_*, which it matches against the functions' names, named none, so each sweep slice ran its whole oracle clean, 40 to 80 minutes on one core. The sweep hands mutmut each mutant by name, and the diff lane each changed function's first mutant by name beside its glob.
Fixed
The type a value is expected at fixes what its arguments or elements leave open, and argument order never decides a type variable (#1684). let @Array<Option<Nat>> = [None, None] was refused (E170, and E121 as a return, E171 as a closure's body), and so was let @Tuple<Option<Int>, Int> = Tuple(None, 1); both now check and run. nat_to_int(string_length(head_plain([]))), with forall<T> fn head_plain(@Array<T> -> @T), compiled head_plain at a default type and its module did not load; the String parameter now fixes T. A type variable two arguments give different types took the first argument's, so second(fn(@Int -> @Int) ..., fn(@Nat -> @Int) ...) applied to -5 ran the Nat closure on -5 with every gate green, and the other order was refused; it now takes the type they share (at a function's parameter, what both accept), in either order and whatever the result is expected at, and the -5 is refused (E503). Where the result is bound at the stronger type, let @Nat = second(@Nat.0, @Int.0) is second at Int in both orders, and the narrowing into Nat is the binding's, of the call's result, guarded at run time where the solver does not prove it; bind the Int argument at Nat first for a proof where it is passed. So a narrowing of the argument that came second moves to where the result is bound: pick(@Nat.0, @Int.0) returned at @Nat, refused before (E503), now compiles with a run-time check at the return, and one the caller's facts proved at the argument is now that run-time check. An indexed literal goes the other way: [@Nat.0, @Int.0][1] returned at @Nat was a run-time check at the @Int element and is now refused at the return (E503), as [@Int.0, @Nat.0][0] already was, and verifies with a precondition such as requires(@Int.0 >= 0). Binding the argument or element at the stronger type first keeps the narrowing where it was. second(@PosInt.0, @Small.0), two refinements of one base with different predicates, was refused (E505 at whichever came second, an indexed literal of the two trapping on a valid value) and now joins at Int and verifies, in either order. An array literal's element type is its elements' shared type where nothing is expected of it, so idg([@PosInt.0, @Int.0]) is no longer refused where idg([@Int.0, @PosInt.0]) is accepted, and [pure_fn, io_fn] is accepted as [io_fn, pure_fn] was. An empty literal takes its type from its context, and an index expected at a type reads an array of that type, so let @Int = [][0]; compiles where code generation skipped the function. Spec §4.2, §4.8, §4.12.1, §5.9 and §11 state the rules. An index no context types (match [][0] { ... }) is #1862's.
E613's fix names what clears it (#1684). For a generic call that no argument fixes, the fix offers binding the call's result at a type (a let of that type), now that the type a result is expected at fixes such a variable, or giving the generic a parameter that carries the variable. The binding is offered only where the result's type holds every variable no argument fixes, and with several such variables the fix asks for a parameter for each, where it named the first alone.
Spec §4.8 states the rule the checker applies to an Int branch beside a @Nat one (#1684). The branch reads as a Nat only where it is made of non-negative literals and @Nat slot references; a call's result does not count, whatever its type, so nat_to_int(n(())) + 1 beside a @Nat makes the if an Int, obligated where it is bound into a Nat position. The section said "Nat values"; the checker is unchanged.
An if, a match or an Exn handler has the type its arms share (#1716). The checker recorded a join at one arm's type, keeping that arm's refinements whatever the other arms stated, so if @Bool.0 then { @Int.0 } else { @PosInt.0 } was a @PosInt and the same if with its branches swapped an @Int. A join is now recorded at what every arm that completes states, position by position and in either order: a refinement one arm lacks, or states with another predicate, is dropped to its base (@Int, Option<Int> beside Option<PosInt>), and a @Nat beside an @Int is an @Int at every position that holds a value, a non-negative literal with no subtraction beside a @Nat at the top still making a @Nat. A function type's parameter accepts a value, so there a @Nat beside an @Int is a @Nat: fn(Int -> Int) beside fn(Nat -> Int) is fn(Nat -> Int) in either order, and applying the join to an @Int that can be negative is refused (E503); with the Nat-taking arm first, the closure was handed the negative value. A refined parameter beside its base is the refined one by the same rule, fn(Int -> Int) beside fn(Small -> Int) being fn(Small -> Int), so an argument bound into it is obligated (E505 where it can break the refinement) in either order, where with the Small-taking arm first it reached the closure's entry check at run time; a refinement is never moved onto another base, so a Small parameter beside a Nat one is a Nat. A callback parameter's effect row is what every arm accepts: a function taking a pure callback beside one taking an <IO> callback, or an <IO, E> one, takes a pure one, so passing it an <IO> callback is refused (E202), as passing it to either function is; in either order the effects(pure) function ran the <IO> callback. Binding such a join where the refinement is expected is the narrowing it is, obligated by its arms. This closes silent false proofs, where an ensures read verified and the run broke it: a Box<Int> beside a Box<PosInt>, a Result<Int, Int> beside a Result<PosInt, NegInt>, an Err(@Int.0) beside a Result<PosInt, NegInt> and a Tuple<Int, Option<Int>> beside a Tuple<Int, Option<PosInt>>, each through a generic function; a join of joins with a @NegInt arm; a State handler inside an Exn handler whose clause yields an @Int; an Exn handler whose clause is @Nat.0 - 1 beside a @Nat body, which proved ensures(@Int.result >= 0); and a match whose first arm is a pure function and whose other arm an <IO> one, which was typed pure, so a function declared effects(pure) could apply it and perform the effect (now E125). A join of function types has the wider effect row in either order. Two reports change: a generic call over such a join, idg(if @Bool.0 then { @Int.0 } else { @PosInt.0 }) under ensures(@Int.result > 0), is instantiated at @Int, so the ensures is checked at run time (E522) in either order, where with the @Int arm first it read verified beside an E505 at the argument; and a let @PosInt bound to such a join keeps its post-fact, so an ensures over the binder is verified, where with the @Int arm first it was refuted (E500) at an input the bind's guard traps on first. One proof becomes a run-time check: a join of a literal and a refined value passed to a generic function with no expected type is instantiated at the base type, so a contract over the result that was proved is checked at run time (E522, or E506 at a refined let); bind the join at the refined type first, then pass the binding.
A check on a tail call's result runs (#1849). A function whose last expression is a call returning the Int form of its own composite return type (wrap(@Int.0) returning @Option<Int> into an @Option<Nat>, through an if or match arm, a block's tail, a where helper, a generic callee or a call by the module's own path) compiled the call as a return_call with the coercion's check after it, so the check never ran: Some(-1) reached the @Nat binder of the caller's match, while vera verify reported the narrowing as a runtime check and reconciliation found it in the module. Whether a call leaves by return_call is now one rule read from the obligation table: a call in tail position after which no check runs, none standing at the call and none after the function's body, so the call lowers to a plain call and the check traps; the same value bound by a let first already trapped. Every other tail call keeps its return_call, the compiled output of the 252 example and conformance programs that compile and of the program generator's 1,000 seeds is unchanged, and a code generation that would leave a check after a return_call stops with an E699 naming the function.
A verifier fix offers a requires only in the function entry's terms (#1858). E526, E527, E505 and E501 wrote a precondition from the operands as the site has them, and a slot reference at the entry names the nearest binding of its type there: for let @Int = @Int.0 - 1; 10 / @Int.0, E526 offered `requires(@Int.0 != 0)`, a fact about the parameter, and with it in place E526 fired again. E526, E505 and E501 now offer a clause only where it reads at the entry as at the site and the solver confirms it discharges the obligation, the rule E503 follows, and E502 outside a decreases measure; otherwise the sentence stands without the example. E527 offers none, since it fires only where the premises prove the index out of bounds, so no clause added beside them can discharge it. E505's clause is the refinement's predicate at the narrowed value (`requires(@Int.0 - 1 > 0)` for let @Pos = @Int.0 - 1), where it pasted the predicate over its binder, `requires(@Int.0 > 0)`, which did not clear it even for a parameter. The guard each of E526, E527 and E501 names is written around the operation, with braces and a <default> placeholder for the value the reader supplies, so it parses as Vera once that is filled in, and by the canonical formatter, so 10 / (@Int.0 - @Int.1) keeps its parentheses; E501's guard and clause are backticked spans. A call to a where helper whose precondition may not hold is reported as any other call is, with its "At this call site" line, its guard and its clause, where it had the general sentence. A clause is offered only where every operation in it that can trap traps at the entry on no input the program does not already trap on: a @Nat subtraction its site's path made safe, as in a callee's precondition copied to its caller, is not offered.
A source file that starts with a UTF-8 byte-order mark is read as the file without it, by every command and for an imported module, where it was refused with E006 at line 1, column 1 (#1790). vera fmt --check reports a marked file as not canonical and vera fmt --write writes it without the mark. E006 also names a character that has no glyph (a control or format character such as a zero-width space) by its code point and name, U+200B (zero width space), where it quoted the invisible character itself.
The quoted String in an uncaught exception's message is cut at a character boundary (#1526). A thrown String longer than 64 bytes whose cut fell inside a multi-byte character ended its quoted value in U+FFFD; the quoted value is now whole characters, on vera run, --target wasi-p2 and the browser runtime. The provider error text std.inference quotes from an HTTP error body longer than its 64 KiB read cap is cut the same way.
An expression a message quotes is the expression the program holds, written as vera fmt writes it (#1573). Every trap message, refinement guard, vera run's requires(...) failed and ensures(...) failed, every obligation description in vera verify --json and every verifier diagnostic printed an operand without the parentheses its precedence needs, so @Nat.1 - (@Nat.0 - 1) read as @Nat.1 - @Nat.0 - 1, requires((@Int.0 + 1) * 2 > 4) as @Int.0 + 1 * 2 > 4, and E501's "At this call site" line named an instance that was true for a precondition the verifier refuted. The same text now spells a match, an if, a block, a constructor or a qualified call where it printed <expr>, a quantifier's predicate where it printed ..., a string literal with its escapes, and a small or large float positionally where it printed 1.847e-05. A suggested clause the message composes, such as a requires to add or an index's bounds, is built from the operands and written the same way.
A refinement at a handler clause's binder is checked when it differs from the operation's payload refinement only by parentheses, or by a match, if or constructor in its predicate (#1573). The narrowing decision compared the two refinements by their rendered predicates, which the old renderer wrote alike, so throw(@Tight) under handle[Exn<Loose>], with Loose = { @Int | (@Int.0 + 1) * 2 > 4 } and Tight = { @Int | @Int.0 + 1 * 2 > 4 }, bound 2 into @Tight with no obligation and no guard. The binder now carries a refine_bind row (E506 when it is checked at run time) and the guard traps.
A diagnostic quotes the source line its location names when the line before it holds one of U+000B, U+000C, U+001C to U+001E, U+0085, U+2028 or U+2029 (#1853). The lexer reads those characters inside a line and counts lines by the newline, while the quoted line was cut at each of them too, so it was the wrong line or none. Every reader of a source line (the parser, checker, verifier, code generation, module resolver, reconciliation, vera test and the language server's column transcoding) now cuts at the newline alone.
The stack_exhausted trap's Fix paragraph states what the compiler does (#1851): a call in tail position compiles to a plain call when something is checked after it returns (a postcondition the compiled code checks at run time, the guard of a refined return type, or the guard on the call's result where it becomes a type with a Nat component), and vera verify proving the postcondition or the refinement does not by itself remove the check. It named only a postcondition left to run time and advised making it provable, which leaves the tail calls as they were.
A fix that tells the reader to write a type writes it as the program does (#1778). A type a fix named was rendered in the message form, which elides a refinement's predicate, so under type Pos = { @Int | @Int.0 > 0 } the E336 fix for handle[State<Pos>](@Int = 1) said to declare the state as @{@Int | ...}, which does not parse; it now says `@Pos`, and E202's fix for a Bool passed at a @Pos parameter names `{ @Int | @Int.0 > 0 }`. Every fix that names a type or an effect row writes it through the one renderer of a type as written (vera.types.written_type, by ast.format_type): E122, E125, E162, E170, E171, E201, E202, E204, E213, E241, E301, E302, E313, E314, E320, E321, E331, E334, E335, E336, E340, E341, E533 and W001; each but W001's, whose type names the expression to write, is a backticked span to paste. A refinement keeps its predicate, and one whose predicate names its binder by an alias (type Count = Nat; type Pos = { @Count | @Count.0 > 0 };) is written over that alias, { @Count | @Count.0 > 0 }, where its base resolved to Nat would leave the predicate's @Count.0 unbound (E130); inside forall<Count>, where the name is the type parameter, it is not written. A type with a part no program writes, a type variable no argument fixed (fn(? -> ?)), is not named: E301 converts to the other branch's type, and E162 names the element type it can.
A fix's example is computed from the site (#1763). A fix written as a literal example named a slot or a shape the site may not have: E503's requires(@Int.0 >= 0) in a function with no @Int is refused (E130) when written. E503, and E502 outside a decreases measure, now offer a precondition over the narrowed value or the subtraction's operands where those read at the function's entry as they do at the site (a division only by a non-zero literal), or over one parameter the counterexample names (a numeric one before a Bool, whose clause could make the narrowing branch dead), and only one the solver confirms discharges the obligation, within the run's per-query budget: the reported sentinel gets `requires(@Bool.0)`. E123, E124, E126 and E300 compare the site's own operand with zero, written by the canonical formatter so a grouped operand keeps its parentheses; E127 and E137 measure the function's own Nat, Int, data-type or array parameter; E128 passes the array's own length; E201 and E202 apply a function value in scope at the site; E216 writes one element per component the site expects; E321 writes a binding per field at its type; E337 keeps the handler's own type argument; and E340's handler fix aliases the site's own type argument, where the argument names none of the function's type parameters, its description naming the shape written (a function type, not "an inline refinement"). E040's example names its operand a, where it named @Int.0, and E323's and E333's fixes are the sentence alone, without the literal example each gave. Where nothing can be computed, the sentence stands without an example, and so where the example applied would draw another error: E337 gives no handler for a type argument written inline, which E340 refuses, E341 no value for a refined handled body, whose base value need not satisfy the predicate, and E127 and E137 no measure over a type parameter in scope, a where helper's inherited ones included. E024 on a file that begins with a UTF-8 byte-order mark gives a command that drops the mark before converting (tail -c +4 marked.vera | iconv -f ISO-8859-1 -t UTF-8 > marked.utf8.vera), where the old one wrote the mark into the copy as , which vera check refused (E006).
Inside a generic function, a value passed where the function's own type parameter is required is held to that parameter, as a call's argument is (#1684). An effect operation's argument (put(9) under handle[State<T>]), an ability operation's (eq(@T.0, 9) under forall<T where Eq<T>>), an argument to a callee with no forall of its own whose parameter is the outer T (resume(9) in a handle[State<T>] clause, a where helper's helper(9)) and an argument apply_fn passes to a function whose parameter is T are refused at check (E204, E241, E202). apply_fn of a value whose type is a bare type variable, the enclosing function's own (apply_fn(@T.0, 1)) or one a call left open (apply_fn(head_plain([]), 1)), is refused too (E202): no function type is there to apply it by. Each of these passed vera check and then failed to load, failed to compile at run, was dropped from the compiled module with E600, E616, E602 and E620 warnings, or drew an internal error from vera verify (E699). An argument apply_fn passes to a function value whose call gave its type variable no type, apply_fn(mk(()), 40), is refused the same way (E202): the function was compiled at a type of its own, and the module did not load. So is a value whose call left its variable open at an operation's or a call's parameter that is the outer T (put(head_plain([])) under handle[State<T>], E204; helper(head_plain([])), E202), which ran only where the open variable's default instance happened to be the right one. Each refusal's fix names a value of the required type where one is in scope, or the function type to hold the applied value at.
A destructuring let holds its value to its bindings together, so a type variable the value's type leaves open takes one type across them: let Tuple<@Option<Int>, @Option<String>> = dup(None);, with forall<A> fn dup(@A -> @Tuple<A, A>), is refused (E170) where it checked and ran with dup's one A read as Int in one binding and String in the other. Such a variable is one no value fixes, so it carries no value, and no wrong value followed.
Of the programs these refusals reach, only the destructuring let above and the open variable at an outer T ran; every other one failed to load or to compile, was dropped from the compiled module or drew E699. Over the examples, the conformance programs, the documentation's Vera blocks and generator seeds 0 to 999, every check verdict, verification status, reconciliation report and compiled module is the same as before.