v0.7.0

0.7.0 (2026-11-05)

Changed

• Breaking: A program reads and writes one of a fixed run at an index worked out while running where the run is inside one of another run at an index written down, inside an element of an array (boxes[0].ss[1].xs[j]). The verifier refused it under every build and switch as a fault in the compiler, with K0411 ("load.at at 102 reads layout 0 at 24 bytes into what an address is at, which has no such field there"): with struct S { tag: i32; xs: [i32; 4] }, struct Box { ss: [S; 2] }, boxes holding one Box of S(1, [1, 2, 3, 4]) and S(2, [5, 6, 7, 8]) and j worked out while running as 2, a program printing boxes[0].ss[1].xs[j], writing 9 there and printing boxes[0].ss[1].xs[2] now prints 7 and 9. A run of runs with its first index written down (bs[0].grid[1][j]) is the same case. Nothing the verifier accepted before changes, and no instruction the compiler writes changes. (#254)
• Breaking: A program writes one of a run of runs at indexes worked out while running, in a local and inside an element of an array, and writes one of a run in a local at such an index with an operator or into a field of one. Each was refused under every build and switch as a fault in the compiler, with K0505 ("this assigns to something that is not a place, which the checker allowed"): with struct P { x: i32; y: i32 }, grid: [[i32; 3]; 2] holding [[1, 2, 3], [4, 5, 6]], xs: [i32; 3] holding [1, 2, 3], ps: [P; 2] holding [P(1, 2), P(3, 4)], and i and j worked out while running as 1 and 2, grid[i][j] = 9, xs[i] += 5 and ps[i].y = 9 were each refused, and printing {grid[1][2]} {xs[1]} {ps[1].y} after them now prints 9 7 9. Where more than one index is worked out while running, each is held to its own count, so an index past its run is refused with K0604 naming that index and that run's count ("index 3 is outside 3 of them"), in every engine and in a body compiled to C. kest emit writes one new instruction, in.run, and load.slots and store.slots carry how many slots of one of the run they read or write. A program that compiled before compiles to the same instructions, with load.slots and store.slots each two bytes wider. (#256)
• Breaking: A program writes one of a run that is a field of one of another run, each at an index worked out while running (ss[i].xs[j] = 9), in a local and inside an element of an array, with = or an operator. Each was refused under every build and switch as a fault in the compiler, with K0505 ("this assigns to something that is not a place, which the checker allowed"): with struct S { tag: i32; xs: [i32; 4] }, ss: [S; 2] holding S(1, [1, 2, 3, 4]) and S(2, [5, 6, 7, 8]), and i and j worked out while running as 1 and 2, ss[i].xs[j] = 9 followed by printing ss[1].xs[2] now prints 9. An index past its run is refused with K0604 and that run's count. Inside an element, a write whose right-hand side writes the same element, or grows the array, keeps what the right-hand side wrote. A program that compiled before compiles to the same instructions. (#257)