✓
Passing This code compiles and runs correctly.
Code
// PINS: `! query <row> when <row>.<icol> == <k>` on an `std/indexes`-declared
// store routes to the key's membership bucket instead of sweeping — the same
// declaration `! first` consumes, widened to a key→ordered-member map.
// Three oracles, one mechanism:
// 1. Membership: the routed query visits exactly the rows carrying the
// key, in join order — the bucket's order, which coincides with the
// sweep's until a take reshuffles dense slots.
// 2. A `stored` write to the indexed column MOVES membership eagerly:
// the row leaves the old bucket and joins the new one at the end —
// a write that moves membership is a join for ordering purposes.
// 3. A take inside a routed query is safe: the taken row's handle stays
// a dead member the row-resolve skips — the sweep's re-check
// contract (690_031) carried at bucket granularity.
// Plus the floor: a `when` on a NON-indexed column still sweeps, and
// `! first` still answers the lowest dense live member (690_327's parity).
import std/store
import std/indexes
import std/io
std/store:new(players, capacity: 8) { key: i64, val: i64 }
std/indexes:store(players, key)
std/store:insert(players) { key: 1, val: 10 }
std/store:insert(players) { key: 2, val: 20 }
std/store:insert(players) { key: 1, val: 11 }
std/store:insert(players) { key: 1, val: 12 }
std/store:insert(players) { key: 2, val: 21 }
// 1. routed membership, join order
std/store:query(players)
! query p when p.key == 1 |> std/io:print.ln("one {{ p.val:d }}")
// 2. the val==11 row moves to key 2 — membership follows the write
std/store:query(players)
! first p when p.val == 11 |> std/store:stored { p.key: 2 }
std/store:query(players)
! query p when p.key == 1 |> std/io:print.ln("one' {{ p.val:d }}")
std/store:query(players)
! query p when p.key == 2 |> std/io:print.ln("two {{ p.val:d }}")
// 3. take every key-2 member inside the routed walk — all three must be
// visited even though each take is mid-iteration
std/store:query(players)
! query p when p.key == 2 |> std/store:take(players[p])
| item i |> std/io:print.ln("took {{ i.val:d }}")
// the taken rows are gone — the bucket answers honestly through dead members
std/store:query(players)
! first p when p.key == 2 |> std/io:print.ln("key2 {{ p.val:d }}")
| none |> std/io:print.ln("key2 none")
// the untouched bucket is still whole
std/store:query(players)
! query p when p.key == 1 |> std/io:print.ln("last {{ p.val:d }}")
// floor: a non-indexed predicate still scans
std/store:query(players)
! query p when p.val == 10 |> std/io:print.ln("scan {{ p.val:d }}")
// 4. a routed query whose body writes the INDEXED column takes the
// survival walk — each visited member leaves the bucket mid-iteration
// and hands its slot to the next unvisited member, which the walk must
// still examine. Both key-1 rows must move, exactly once each.
std/store:query(players)
! query p when p.key == 1 |> std/store:stored { p.key: 9 }
std/store:query(players)
! query p when p.key == 9 |> std/io:print.ln("nine {{ p.val:d }}")
Actual
one 10
one 11
one 12
one' 10
one' 12
two 20
two 21
two 11
took 20
took 21
took 11
key2 none
last 10
last 12
scan 10
nine 10
nine 12
Expected output
✓ Zig✓ JavaScript✓ C#one 10
one 11
one 12
one' 10
one' 12
two 20
two 21
two 11
took 20
took 21
took 11
key2 none
last 10
last 12
scan 10
nine 10
nine 12
Emitted Zig source
// Access compiler flags via the per-user compiler_env module
const CompilerEnv = @import("compiler_env").CompilerEnv;
pub const panic = if (@import("builtin").mode == .Debug)
@import("std").debug.FullPanic(@import("std").debug.defaultPanic)
else
@import("std").debug.simple_panic;
const __koru_bare = struct {
extern fn posix_memalign(memptr: *?*anyopaque, alignment: usize, size: usize) c_int;
extern fn free(ptr: ?*anyopaque) void;
fn bareAlloc(_: *anyopaque, len: usize, alignment: @import("std").mem.Alignment, _: usize) ?[*]u8 {
var p: ?*anyopaque = null;
const a = @max(alignment.toByteUnits(), @sizeOf(usize));
if (posix_memalign(&p, a, len) != 0) return null;
return @ptrCast(p);
}
fn bareResize(_: *anyopaque, _: []u8, _: @import("std").mem.Alignment, _: usize, _: usize) bool { return false; }
fn bareRemap(_: *anyopaque, _: []u8, _: @import("std").mem.Alignment, _: usize, _: usize) ?[*]u8 { return null; }
fn bareFree(_: *anyopaque, memory: []u8, _: @import("std").mem.Alignment, _: usize) void { free(@ptrCast(memory.ptr)); }
const vtable = @import("std").mem.Allocator.VTable{ .alloc = bareAlloc, .resize = bareResize, .remap = bareRemap, .free = bareFree };
const allocator = @import("std").mem.Allocator{ .ptr = undefined, .vtable = &vtable };
};
const __koru_backing = if (@import("builtin").link_libc) @import("std").heap.c_allocator else if (@import("builtin").os.tag == .freestanding) __koru_bare.allocator else @import("std").heap.page_allocator;
var __koru_leak_count: @import("std").atomic.Value(usize) = .init(0);
fn __koru_alloc(ctx: *anyopaque, len: usize, alignment: @import("std").mem.Alignment, ret_addr: usize) ?[*]u8 {
_ = ctx;
const r = __koru_backing.rawAlloc(len, alignment, ret_addr);
if (comptime @import("builtin").mode == .Debug) {
if (r != null) _ = __koru_leak_count.fetchAdd(1, .monotonic);
}
return r;
}
fn __koru_resize(ctx: *anyopaque, memory: []u8, alignment: @import("std").mem.Alignment, new_len: usize, ret_addr: usize) bool {
_ = ctx;
return __koru_backing.rawResize(memory, alignment, new_len, ret_addr);
}
fn __koru_remap(ctx: *anyopaque, memory: []u8, alignment: @import("std").mem.Alignment, new_len: usize, ret_addr: usize) ?[*]u8 {
_ = ctx;
return __koru_backing.rawRemap(memory, alignment, new_len, ret_addr);
}
fn __koru_free(ctx: *anyopaque, memory: []u8, alignment: @import("std").mem.Alignment, ret_addr: usize) void {
_ = ctx;
__koru_backing.rawFree(memory, alignment, ret_addr);
if (comptime @import("builtin").mode == .Debug) {
_ = __koru_leak_count.fetchSub(1, .monotonic);
}
}
const __koru_vtable = @import("std").mem.Allocator.VTable{ .alloc = __koru_alloc, .resize = __koru_resize, .remap = __koru_remap, .free = __koru_free };
pub fn koru_allocator() @import("std").mem.Allocator {
return .{ .ptr = undefined, .vtable = &__koru_vtable };
}
pub inline fn __koru_intcast(comptime T: type, x: anytype) T {
if (comptime (@import("builtin").mode == .Debug or @import("builtin").mode == .ReleaseSafe))
return @as(T, @intCast(x));
const dst = @typeInfo(T);
const src = @typeInfo(@TypeOf(x));
if (comptime (dst == .int and src == .int and dst.int.bits == src.int.bits and dst.int.signedness != src.int.signedness))
return @as(T, @bitCast(x));
return @as(T, @intCast(x));
}
pub fn koru_leak_check() void {
if (comptime @import("builtin").mode != .Debug) return;
if (__koru_leak_count.load(.acquire) == 0) return;
if (comptime @import("builtin").target.os.tag == .freestanding) {
if (comptime @import("builtin").cpu.arch == .wasm32 or @import("builtin").cpu.arch == .wasm64) {
@panic("KORU LEAK CHECK FAILED: the produced program leaked");
} else {
const __klc = struct { extern var stdout: ?*anyopaque; extern fn fputs(__s: [*:0]const u8, __st: ?*anyopaque) c_int; };
var __lb: [128]u8 = undefined;
const __lm = "KORU LEAK CHECK FAILED: allocations still outstanding at end of run: ";
@memcpy(__lb[0..__lm.len], __lm);
var __ln: usize = __lm.len;
var __lv = __koru_leak_count.load(.acquire);
var __ld: [20]u8 = undefined;
var __lk: usize = 0;
while (__lv > 0) : (__lk += 1) { __ld[__lk] = @intCast('0' + __lv % 10); __lv /= 10; }
for (0..__lk) |__li| { __lb[__ln] = __ld[__lk - 1 - __li]; __ln += 1; }
__lb[__ln] = '\n'; __ln += 1; __lb[__ln] = 0;
_ = __klc.fputs(@as([*:0]const u8, @ptrCast(&__lb)), __klc.stdout);
@trap();
}
} else {
@import("std").debug.print("KORU LEAK CHECK FAILED: the produced program leaked (trace above)\n", .{});
@import("std").process.exit(1);
}
}
pub const main_module = struct {
// std/store: plural store 'players' created (SoA cell + insert/query/write/take/stripe units); fields key: i64, val: i64
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:25 ~input:__store_insert_players()
pub fn flow0() void {
_ = main_module.__store_insert_players_event.handler(.{ .key = 1, .val = 10, .__site_line = 25 });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:26 ~input:__store_insert_players()
pub fn flow1() void {
_ = main_module.__store_insert_players_event.handler(.{ .key = 2, .val = 20, .__site_line = 26 });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:27 ~input:__store_insert_players()
pub fn flow2() void {
_ = main_module.__store_insert_players_event.handler(.{ .key = 1, .val = 11, .__site_line = 27 });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:28 ~input:__store_insert_players()
pub fn flow3() void {
_ = main_module.__store_insert_players_event.handler(.{ .key = 1, .val = 12, .__site_line = 28 });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:29 ~input:__store_insert_players()
pub fn flow4() void {
_ = main_module.__store_insert_players_event.handler(.{ .key = 2, .val = 21, .__site_line = 29 });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:32 ~input:__store_sweeprun_players_L33_690_341_index_query_membership_route_input_38a4f5()
pub fn flow5() void {
_ = main_module.__store_sweeprun_players_L33_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:36 ~input:__store_sweeprun_players_L37_690_341_index_query_membership_route_input_38a4f5()
pub fn flow6() void {
_ = main_module.__store_sweeprun_players_L37_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:39 ~input:__store_sweeprun_players_L40_690_341_index_query_membership_route_input_38a4f5()
pub fn flow7() void {
_ = main_module.__store_sweeprun_players_L40_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:42 ~input:__store_sweeprun_players_L43_690_341_index_query_membership_route_input_38a4f5()
pub fn flow8() void {
_ = main_module.__store_sweeprun_players_L43_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:47 ~input:__store_sweeprun_players_L48_690_341_index_query_membership_route_input_38a4f5()
pub fn flow9() void {
_ = main_module.__store_sweeprun_players_L48_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:52 ~input:__store_sweeprun_players_L53_690_341_index_query_membership_route_input_38a4f5()
pub fn flow10() void {
_ = main_module.__store_sweeprun_players_L53_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:57 ~input:__store_sweeprun_players_L58_690_341_index_query_membership_route_input_38a4f5()
pub fn flow11() void {
_ = main_module.__store_sweeprun_players_L58_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:61 ~input:__store_sweeprun_players_L62_690_341_index_query_membership_route_input_38a4f5()
pub fn flow12() void {
_ = main_module.__store_sweeprun_players_L62_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:68 ~input:__store_sweeprun_players_L69_690_341_index_query_membership_route_input_38a4f5()
pub fn flow13() void {
_ = main_module.__store_sweeprun_players_L69_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
// >>> FLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:71 ~input:__store_sweeprun_players_L72_690_341_index_query_membership_route_input_38a4f5()
pub fn flow14() void {
_ = main_module.__store_sweeprun_players_L72_690_341_index_query_membership_route_input_38a4f5_event.handler(.{ });
}
pub fn koru_start_flow() void {
const result_0 = koru_koru.start_event.handler(.{ });
const result_0_done = result_0.done;
_ = &result_0_done;
}
pub fn koru_end_flow() void {
const result_0 = koru_koru.end_event.handler(.{ });
const result_0_done = result_0.done;
_ = &result_0_done;
}
const __KoruStoreT_players = struct {
key: [8]i64 = undefined,
val: [8]i64 = undefined,
len: usize = 0,
__index_key: @import("std").AutoHashMapUnmanaged(i64, @import("std").ArrayListUnmanaged(i64)) = .{},
__koru_hslot_row: [8]usize = undefined,
__koru_hslot_gen: [8]u32 = [_]u32{0} ** 8,
__koru_row_hslot: [8]usize = undefined,
__koru_hslot_free: [8]usize = undefined,
__koru_hslot_free_len: usize = 0,
__koru_hslot_next: usize = 0,
// `__koru_ident` — no removal has run, so slot == dense row
// for every live row; mint/resolve skip both table loads, the
// first take materialises and flips it, drain and clear
// re-arm it by resetting the slot space. `__koru_gen0` — no gen
// bump has ever run; it implies slot == row for every minted
// slot, so resolve sheds the gen load entirely.
__koru_ident: bool = true, __koru_gen0: bool = true,
const __koru_brand: u32 = 1;
fn __koru_materialize(self: *@This()) void {
if (!self.__koru_ident) return;
for (0..self.len) |i| { self.__koru_hslot_row[i] = i; self.__koru_row_hslot[i] = i; }
self.__koru_ident = false;
}
fn __koru_row_of(self: *const @This(), h: i64) ?usize {
if (h < 0) return null;
const u = @as(u64, @bitCast(h));
const slot32 = @as(u32, @truncate(u));
if ((slot32 >> 24) != __koru_brand) return null;
const slot = @as(usize, @intCast(slot32 & 0xFFFFFF));
if (slot >= self.__koru_hslot_next) return null;
if (self.__koru_gen0) { if (u >> 32 != 0) return null; return slot; }
if (@as(u32, @truncate(u >> 32)) != self.__koru_hslot_gen[slot]) return null;
if (self.__koru_ident) return slot;
const __koru_r = self.__koru_hslot_row[slot];
if (__koru_r >= self.len) return null;
return __koru_r;
}
// DO NOT "simplify" into one pass — pre-check + row_of tail
// call keeps resolve under the inline threshold; callers
// inline BOTH and LLVM CSEs the duplicate checks into one
// validation in machine code. A flat single pass crossed
// the threshold: +57% read_handle, +2.6x write_handle
// (007 board, 2026-09-26). Shape, not count.
fn __koru_resolve(self: *const @This(), h: i64) usize {
if (h >= 0) {
const u = @as(u64, @bitCast(h));
const slot32 = @as(u32, @truncate(u));
if ((slot32 >> 24) != __koru_brand) @panic("std/store: 'players[...]' does not address a row - the value is not a handle this store issued (handles come from `| row` and row cursors)");
const slot = @as(usize, @intCast(slot32 & 0xFFFFFF));
if (self.__koru_gen0) {
if (u >> 32 != 0 and slot < self.__koru_hslot_next) @panic("std/store: stale row handle into store 'players' - the row it addressed was removed (stale-handle trap pinned at 690_115)");
} else if (slot < self.__koru_hslot_next and @as(u32, @truncate(u >> 32)) != self.__koru_hslot_gen[slot]) @panic("std/store: stale row handle into store 'players' - the row it addressed was removed (stale-handle trap pinned at 690_115)");
}
return self.__koru_row_of(h) orelse @panic("std/store: 'players[...]' does not address a row - the value is not a handle this store issued (handles come from `| row` and row cursors)");
}
fn __koru_handle_of(self: *const @This(), dense: usize) i64 {
if (self.__koru_gen0) return @as(i64, @intCast(dense | (@as(usize, __koru_brand) << 24)));
var slot = dense;
if (!self.__koru_ident) slot = self.__koru_row_hslot[dense];
return @as(i64, @intCast(slot | (@as(usize, __koru_brand) << 24))) | (@as(i64, @intCast(self.__koru_hslot_gen[slot])) << 32);
}
};
var __koru_store_players: __KoruStoreT_players = .{};
const __KoruStoreRow_players = struct { key: i64, val: i64 };
pub const __store_insert_players_event = struct {
pub const Input = struct {
key: i64,
val: i64,
__site_line: i64,
};
pub const Output = void;
pub inline fn handler(__koru_event_input: @This().Input) @This().Output {
return __koru_handler_impl(__koru_event_input.key, __koru_event_input.val, __koru_event_input.__site_line);
}
fn __koru_handler_impl(__koru_p_0: i64, __koru_p_1: i64, __koru_p_2: i64) @This().Output {
const __koru_event_input: @This().Input = .{ .key = __koru_p_0, .val = __koru_p_1, .__site_line = __koru_p_2 };
// >>> PROC: __store_insert_players [tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:22]
const key = __koru_event_input.key;
const val = __koru_event_input.val;
const __site_line = __koru_event_input.__site_line;
_ = &key;
_ = &val;
_ = &__site_line;
_ = &__koru_event_input;
if (__koru_store_players.len >= 8) @panic("std/store: store 'players' is full (capacity 8) - declared capacity and the `| full` branch are pinned at 690_011");
const __koru_new_row = __koru_store_players.len;
const __koru_hslot = if (__koru_store_players.__koru_hslot_free_len > 0) blk_hs: {
__koru_store_players.__koru_hslot_free_len -= 1;
break :blk_hs __koru_store_players.__koru_hslot_free[__koru_store_players.__koru_hslot_free_len];
} else blk_hs: {
const __koru_hn = __koru_store_players.__koru_hslot_next;
__koru_store_players.__koru_hslot_next += 1;
break :blk_hs __koru_hn;
};
if (!__koru_store_players.__koru_ident) {
__koru_store_players.__koru_hslot_row[__koru_hslot] = __koru_new_row;
__koru_store_players.__koru_row_hslot[__koru_new_row] = __koru_hslot;
}
__koru_store_players.key[__koru_new_row] = key;
__koru_store_players.val[__koru_new_row] = val;
__koru_store_players.len += 1;
const __koru_ik = __koru_store_players.key[__koru_new_row];
const __koru_ig = __koru_store_players.__index_key.getOrPut(koru_allocator(), __koru_ik) catch @panic("std/indexes: index insert ran out of memory");
if (!__koru_ig.found_existing) __koru_ig.value_ptr.* = .{};
__koru_ig.value_ptr.append(koru_allocator(), __koru_store_players.__koru_handle_of(__koru_new_row)) catch @panic("std/indexes: index insert ran out of memory");
return;
}
};
pub const __store_apply_players_event = struct {
pub const Input = struct {
row: usize,
field: i64,
value_0: i64,
value_1: i64,
};
pub const Output = union(enum(u8)) {
key: i64,
val: i64,
};
pub fn handler(__koru_event_input: @This().Input) @This().Output {
// >>> PROC: __store_apply_players [tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:22]
const row = __koru_event_input.row;
const field = __koru_event_input.field;
const value_0 = __koru_event_input.value_0;
const value_1 = __koru_event_input.value_1;
_ = &row;
_ = &field;
_ = &value_0;
_ = &value_1;
_ = &__koru_event_input;
const __koru_r: usize = row;
return switch (field) {
0 => blk: { const __koru_iold = __koru_store_players.key[__koru_r];
const __koru_ih = __koru_store_players.__koru_handle_of(__koru_r);
__koru_store_players.key[__koru_r] = value_0; if (__koru_iold != value_0) {
if (__koru_store_players.__index_key.getPtr(__koru_iold)) |__koru_ib| {
for (__koru_ib.items, 0..) |__koru_im, __koru_mi| {
if (__koru_im == __koru_ih) { _ = __koru_ib.orderedRemove(__koru_mi); break; }
}
if (__koru_ib.items.len == 0) {
__koru_ib.deinit(koru_allocator());
_ = __koru_store_players.__index_key.remove(__koru_iold);
}
}
const __koru_ig = __koru_store_players.__index_key.getOrPut(koru_allocator(), value_0) catch @panic("std/indexes: index write ran out of memory");
if (!__koru_ig.found_existing) __koru_ig.value_ptr.* = .{};
__koru_ig.value_ptr.append(koru_allocator(), __koru_ih) catch @panic("std/indexes: index write ran out of memory");
}
break :blk .{ .key = value_0 }; },
1 => blk: { __koru_store_players.val[__koru_r] = value_1; break :blk .{ .val = value_1 }; },
else => unreachable,
};
}
};
pub const __store_write_players_event = struct {
pub const Input = struct {
row: usize,
field: i64,
value_0: i64,
value_1: i64,
};
pub const Output = void;
pub fn handler(__koru_event_input: @This().Input) @This().Output {
// >>> SUBFLOW: tests/regression/600_STDLIB/690_STORE/690_341_index_query_membership_route/input.k:22
const row = __koru_event_input.row;
const field = __koru_event_input.field;
const value_0 = __koru_event_input.value_0;
const value_1 = __koru_event_input.value_1;
_ = &row;
_ = &field;
_ = &value_0;
_ = &value_1;
_ = &__koru_event_input;
const result = main_module.__store_apply_players_event.handler(.{ .row = row, .field
... [truncated - 56KB total]Emitted C# source
static class main_module {
public static void __koru_stdout_write(dynamic s) => global::System.Console.Out.Write(s);
public static void __koru_stderr_write(dynamic s) => global::System.Console.Error.Write(s);
// The mutable handle carrier — `*String`-style resources are
// `new __KoruBox { data = … }` because C# anonymous types are
// read-only: `s.data = …` (std/string append/clear, handle
// mutation generally) needs a settable member.
public class __KoruBox { public dynamic data; }
// Textification for `{{ … }}` operands: C# bool ToStrings as
// `True` where Koru prints `true`, and the operand's static type
// is unknown at this boundary — a `(x) is bool` inline test would
// be a compile error on statically-typed operands instead. Generic
// on purpose: `dynamic` boxed every value-type operand — measured
// ~1s/10M elements on 012_threat_scanner — while T specializes to
// the operand's own ToString() with no box.
public static string __koru_str<T>(T v) => v is bool b ? (b ? "true" : "false") : v?.ToString();
// std/store: plural store 'players' created (SoA cell + insert/query/write/take/stripe units); fields key: i64, val: i64
static class __koru_store_players {
public static long[] key = new long[8];
public static dynamic __koru_read_key(long __h) { long __r = __koru_resolve(__h); return key[(int)__r]; }
public static long[] val = new long[8];
public static dynamic __koru_read_val(long __h) { long __r = __koru_resolve(__h); return val[(int)__r]; }
public static global::System.Collections.Generic.Dictionary<long, global::System.Collections.Generic.List<long>> __index_key = new global::System.Collections.Generic.Dictionary<long, global::System.Collections.Generic.List<long>>();
public static long len = 0;
public static long[] __koru_hslot_row = new long[8];
public static long[] __koru_hslot_gen = new long[8];
public static long[] __koru_row_hslot = new long[8];
public static long[] __koru_hslot_free = new long[8];
public static long __koru_hslot_free_len = 0;
public static long __koru_hslot_next = 0;
public static long __koru_brand = 1;
public static bool __koru_ident = true;
public static bool __koru_gen0 = true;
public static void __koru_materialize() {
if (!__koru_ident) return;
for (long __i = 0; __i < len; __i++) { __koru_hslot_row[__i] = __i; __koru_row_hslot[__i] = __i; }
__koru_ident = false;
}
public static long __koru_row_of(long h) {
if (h < 0) return -1;
ulong __u = (ulong)h;
long __slot32 = (long)(__u & 0xFFFFFFFFUL);
if ((__slot32 >> 24) != __koru_brand) return -1;
long __slot = __slot32 & 0xFFFFFF;
if (__slot >= __koru_hslot_next) return -1;
if (__koru_gen0) { if ((__u >> 32) != 0) return -1; return __slot; }
if ((long)(__u >> 32) != __koru_hslot_gen[__slot]) return -1;
if (__koru_ident) return __slot;
long __r = __koru_hslot_row[__slot];
if (__r >= len) return -1;
return __r;
}
public static long __koru_resolve(long h) {
if (h >= 0) {
ulong __u = (ulong)h;
long __slot32 = (long)(__u & 0xFFFFFFFFUL);
if ((__slot32 >> 24) != __koru_brand) throw new global::System.Exception("std/store: 'players[...]' does not address a row - the value is not a handle this store issued (handles come from `| row` and row cursors)");
long __slot = __slot32 & 0xFFFFFF;
if (__koru_gen0) {
if ((__u >> 32) != 0 && __slot < __koru_hslot_next) throw new global::System.Exception("std/store: stale row handle into store 'players' - the row it addressed was removed (stale-handle trap pinned at 690_115)");
} else if (__slot < __koru_hslot_next && (long)(__u >> 32) != __koru_hslot_gen[__slot]) throw new global::System.Exception("std/store: stale row handle into store 'players' - the row it addressed was removed (stale-handle trap pinned at 690_115)");
}
long __r = __koru_row_of(h);
if (__r < 0) throw new global::System.Exception("std/store: 'players[...]' does not address a row - the value is not a handle this store issued (handles come from `| row` and row cursors)");
return __r;
}
public static long __koru_handle_of(long dense) {
if (__koru_gen0) return dense | (__koru_brand << 24);
long __slot = dense;
if (!__koru_ident) __slot = __koru_row_hslot[dense];
return (__slot | (__koru_brand << 24)) | (__koru_hslot_gen[__slot] << 32);
}
}
public static class __store_insert_players_event {
public struct Input {
public long key;
public long val;
public long __site_line;
}
public static dynamic handler(Input __koru_input) {
var key = __koru_input.key;
var val = __koru_input.val;
var __site_line = __koru_input.__site_line;
if (__koru_store_players.len >= 8) throw new global::System.Exception("std/store: store 'players' is full (capacity 8) - declared capacity and the `| full` branch are pinned at 690_011");
long __koru_new_row = __koru_store_players.len;
long __koru_hslot;
if (__koru_store_players.__koru_hslot_free_len > 0) {
__koru_store_players.__koru_hslot_free_len -= 1;
__koru_hslot = __koru_store_players.__koru_hslot_free[__koru_store_players.__koru_hslot_free_len];
} else {
__koru_hslot = __koru_store_players.__koru_hslot_next;
__koru_store_players.__koru_hslot_next += 1;
}
if (!__koru_store_players.__koru_ident) {
__koru_store_players.__koru_hslot_row[__koru_hslot] = __koru_new_row;
__koru_store_players.__koru_row_hslot[__koru_new_row] = __koru_hslot;
}
__koru_store_players.key[__koru_new_row] = key;
__koru_store_players.val[__koru_new_row] = val;
__koru_store_players.len += 1;
long __koru_ik = (long)(__koru_store_players.key[__koru_new_row]);
global::System.Collections.Generic.List<long> __koru_ib;
if (!__koru_store_players.__index_key.TryGetValue(__koru_ik, out __koru_ib)) { __koru_ib = new global::System.Collections.Generic.List<long>(); __koru_store_players.__index_key[__koru_ik] = __koru_ib; }
__koru_ib.Add(__koru_store_players.__koru_handle_of(__koru_new_row));
return default;
}
}
public static class __store_apply_players_event {
public struct Input {
public long row;
public long field;
public long value_0;
public long value_1;
}
public struct Output {
public string tag;
public long key;
public long val;
}
public static Output handler(Input __koru_input) {
var row = __koru_input.row;
var field = __koru_input.field;
var value_0 = __koru_input.value_0;
var value_1 = __koru_input.value_1;
var __koru_r = row;
switch (field) {
case 0: { long __koru_iold = (long)(__koru_store_players.key[__koru_r]);
long __koru_ih = __koru_store_players.__koru_handle_of(__koru_r);
__koru_store_players.key[__koru_r] = value_0; if (__koru_iold != (long)(value_0)) {
global::System.Collections.Generic.List<long> __koru_ib;
if (__koru_store_players.__index_key.TryGetValue(__koru_iold, out __koru_ib)) {
__koru_ib.Remove(__koru_ih);
if (__koru_ib.Count == 0) __koru_store_players.__index_key.Remove(__koru_iold);
}
global::System.Collections.Generic.List<long> __koru_ib2;
if (!__koru_store_players.__index_key.TryGetValue((long)(value_0), out __koru_ib2)) { __koru_ib2 = new global::System.Collections.Generic.List<long>(); __koru_store_players.__index_key[(long)(value_0)] = __koru_ib2; }
__koru_ib2.Add(__koru_ih);
}
return new Output { tag = "key", key = value_0 }; }
case 1: { __koru_store_players.val[__koru_r] = value_1; return new Output { tag = "val", val = value_1 }; }
}
throw new global::System.Exception("__store_apply_players: field index " + field + " is not a column of store 'players'");
return default;
}
}
public static class __store_write_players_event {
public struct Input {
public long row;
public long field;
public long value_0;
public long value_1;
}
public static dynamic handler(Input __koru_input) {
var row = __koru_input.row;
var field = __koru_input.field;
var value_0 = __koru_input.value_0;
var value_1 = __koru_input.value_1;
var result_0 = main_module.__store_apply_players_event.handler(new __store_apply_players_event.Input { row = (long)(row), field = (long)(field), value_0 = (long)(value_0), value_1 = (long)(value_1)});
if (result_0.tag == "key") {
var _auto_6 = result_0.key;
}
if (result_0.tag == "val") {
var _auto_7 = result_0.val;
}
return default;
}
}
public static class __store_take_players_event {
public struct Input {
public long row;
}
public struct Output {
public string tag;
public dynamic item;
public dynamic empty;
}
public static Output handler(Input __koru_input) {
var row = __koru_input.row;
__koru_store_players.__koru_materialize();
long __koru_r = __koru_store_players.__koru_row_of(row);
if (__koru_r < 0) return new Output { tag = "empty", empty = new { } };
long __koru_gone_slot = __koru_store_players.__koru_row_hslot[__koru_r];
var __koru_out_key = __koru_store_players.key[__koru_r];
var __koru_out_val = __koru_store_players.val[__koru_r];
var __koru_last = __koru_store_players.len - 1;
if (__koru_r != __koru_last) {
__koru_store_players.key[__koru_r] = __koru_store_players.key[__koru_last];
__koru_store_players.val[__koru_r] = __koru_store_players.val[__koru_last];
var __koru_mv_slot = __koru_store_players.__koru_row_hslot[__koru_last];
__koru_store_players.__koru_hslot_row[__koru_mv_slot] = __koru_r;
__koru_store_players.__koru_row_hslot[__koru_r] = __koru_mv_slot;
}
__koru_store_players.__koru_hslot_row[__koru_gone_slot] = -1;
__koru_store_players.len = __koru_last;
__koru_store_players.__koru_hslot_gen[__koru_gone_slot] = ((__koru_store_players.__koru_hslot_gen[__koru_gone_slot] + 1) & 4294967295L);
__koru_store_players.__koru_hslot_free[__koru_store_players.__koru_hslot_free_len] = __koru_gone_slot;
__koru_store_players.__koru_hslot_free_len += 1;
__koru_store_players.__koru_gen0 = false;
return new Output { tag = "item", item = new { key = __koru_out_key, val = __koru_out_val } };
return default;
}
}
public static class __store_teardown_players_event {
public struct Input {
}
public static dynamic handler(Input __koru_input) {
__koru_store_players.__index_key.Clear();
__koru_store_players.len = 0;
return default;
}
}
public static class __store_sweepbody_players_L33_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
public long __koru_srf_p_L33_val;
public long __koru_sdix_p_L33;
}
public static dynamic handler(Input __koru_input) {
var __koru_srf_p_L33_val = __koru_input.__koru_srf_p_L33_val;
var __koru_sdix_p_L33 = __koru_input.__koru_sdix_p_L33;
__koru_stdout_write("one " + __koru_str(__koru_srf_p_L33_val) + "\n");
return default;
}
}
public static class __store_sweeprun_players_L33_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
}
public static dynamic handler(Input __koru_input) {
{
long __koru_ik = (long)(1);
global::System.Collections.Generic.List<long> __koru_ib;
if (__koru_store_players.__index_key.TryGetValue(__koru_ik, out __koru_ib)) {
foreach (var __koru_bh in __koru_ib) {
var __koru_si = __koru_store_players.__koru_row_of(__koru_bh);
if (__koru_si < 0) continue;
var __koru_srf_p_L33_val = __koru_store_players.val[__koru_si];
main_module.__store_sweepbody_players_L33_690_341_index_query_membership_route_input_38a4f5_event.handler(new main_module.__store_sweepbody_players_L33_690_341_index_query_membership_route_input_38a4f5_event.Input { __koru_srf_p_L33_val = __koru_srf_p_L33_val, __koru_sdix_p_L33 = __koru_si });
}
}
}
return default;
}
}
public static class __store_sweepbody_players_L37_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
public long __koru_srf_p_L37_val;
public long __koru_sdix_p_L37;
}
public static dynamic handler(Input __koru_input) {
var __koru_srf_p_L37_val = __koru_input.__koru_srf_p_L37_val;
var __koru_sdix_p_L37 = __koru_input.__koru_sdix_p_L37;
main_module.__store_write_players_event.handler(new __store_write_players_event.Input { row = (long)(__koru_sdix_p_L37), field = (long)(0), value_0 = (long)(2), value_1 = (long)(0)});
return default;
}
}
public static class __store_sweeprun_players_L37_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
}
public static dynamic handler(Input __koru_input) {
{
for (var __koru_si = 0; __koru_si < __koru_store_players.len; __koru_si++) {
var __koru_srf_p_L37_val = __koru_store_players.val[__koru_si];
if (!(__koru_srf_p_L37_val == 11)) continue;
main_module.__store_sweepbody_players_L37_690_341_index_query_membership_route_input_38a4f5_event.handler(new main_module.__store_sweepbody_players_L37_690_341_index_query_membership_route_input_38a4f5_event.Input { __koru_srf_p_L37_val = __koru_srf_p_L37_val, __koru_sdix_p_L37 = __koru_si });
break;
}
}
return default;
}
}
public static class __store_sweepbody_players_L40_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
public long __koru_srf_p_L40_val;
public long __koru_sdix_p_L40;
}
public static dynamic handler(Input __koru_input) {
var __koru_srf_p_L40_val = __koru_input.__koru_srf_p_L40_val;
var __koru_sdix_p_L40 = __koru_input.__koru_sdix_p_L40;
__koru_stdout_write("one' " + __koru_str(__koru_srf_p_L40_val) + "\n");
return default;
}
}
public static class __store_sweeprun_players_L40_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
}
public static dynamic handler(Input __koru_input) {
{
long __koru_ik = (long)(1);
global::System.Collections.Generic.List<long> __koru_ib;
if (__koru_store_players.__index_key.TryGetValue(__koru_ik, out __koru_ib)) {
foreach (var __koru_bh in __koru_ib) {
var __koru_si = __koru_store_players.__koru_row_of(__koru_bh);
if (__koru_si < 0) continue;
var __koru_srf_p_L40_val = __koru_store_players.val[__koru_si];
main_module.__store_sweepbody_players_L40_690_341_index_query_membership_route_input_38a4f5_event.handler(new main_module.__store_sweepbody_players_L40_690_341_index_query_membership_route_input_38a4f5_event.Input { __koru_srf_p_L40_val = __koru_srf_p_L40_val, __koru_sdix_p_L40 = __koru_si });
}
}
}
return default;
}
}
public static class __store_sweepbody_players_L43_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
public long __koru_srf_p_L43_val;
public long __koru_sdix_p_L43;
}
public static dynamic handler(Input __koru_input) {
var __koru_srf_p_L43_val = __koru_input.__koru_srf_p_L43_val;
var __koru_sdix_p_L43 = __koru_input.__koru_sdix_p_L43;
__koru_stdout_write("two " + __koru_str(__koru_srf_p_L43_val) + "\n");
return default;
}
}
public static class __store_sweeprun_players_L43_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
}
public static dynamic handler(Input __koru_input) {
{
long __koru_ik = (long)(2);
global::System.Collections.Generic.List<long> __koru_ib;
if (__koru_store_players.__index_key.TryGetValue(__koru_ik, out __koru_ib)) {
foreach (var __koru_bh in __koru_ib) {
var __koru_si = __koru_store_players.__koru_row_of(__koru_bh);
if (__koru_si < 0) continue;
var __koru_srf_p_L43_val = __koru_store_players.val[__koru_si];
main_module.__store_sweepbody_players_L43_690_341_index_query_membership_route_input_38a4f5_event.handler(new main_module.__store_sweepbody_players_L43_690_341_index_query_membership_route_input_38a4f5_event.Input { __koru_srf_p_L43_val = __koru_srf_p_L43_val, __koru_sdix_p_L43 = __koru_si });
}
}
}
return default;
}
}
public static class __store_sweepbody_players_L48_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
public long __koru_sdix_p_L48;
}
public static dynamic handler(Input __koru_input) {
var __koru_sdix_p_L48 = __koru_input.__koru_sdix_p_L48;
var result_1 = main_module.__store_take_players_event.handler(new __store_take_players_event.Input { row = (long)(__koru_store_players.__koru_handle_of(__koru_sdix_p_L48))});
if (result_1.tag == "item") {
var i = result_1.item;
__koru_stdout_write("took " + __koru_str(i.val) + "\n");
}
if (result_1.tag == "empty") {
var _auto_8 = result_1.empty;
throw new global::System.Exception("__store_take_players: unhandled panic branch 'empty' fired at runtime");
}
return default;
}
}
public static class __store_sweeprun_players_L48_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
}
public static dynamic handler(Input __koru_input) {
{
long __koru_ik = (long)(2);
global::System.Collections.Generic.List<long> __koru_ib;
if (__koru_store_players.__index_key.TryGetValue(__koru_ik, out __koru_ib)) {
foreach (var __koru_bh in __koru_ib) {
var __koru_si = __koru_store_players.__koru_row_of(__koru_bh);
if (__koru_si < 0) continue;
main_module.__store_sweepbody_players_L48_690_341_index_query_membership_route_input_38a4f5_event.handler(new main_module.__store_sweepbody_players_L48_690_341_index_query_membership_route_input_38a4f5_event.Input { __koru_sdix_p_L48 = __koru_si });
}
}
}
return default;
}
}
public static class __store_sweepbody_players_L53_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
public long __koru_srf_p_L53_val;
public long __koru_sdix_p_L53;
}
public static dynamic handler(Input __koru_input) {
var __koru_srf_p_L53_val = __koru_input.__koru_srf_p_L53_val;
var __koru_sdix_p_L53 = __koru_input.__koru_sdix_p_L53;
__koru_stdout_write("key2 " + __koru_str(__koru_srf_p_L53_val) + "\n");
return default;
}
}
public static class __store_nonebody_players_L54_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
}
public static dynamic handler(Input __koru_input) {
__koru_stdout_write("key2 none" + "\n");
return default;
}
}
public static class __store_sweeprun_players_L53_690_341_index_query_membership_route_input_38a4f5_event {
public struct Input {
}
public static dynamic handler(Input __koru_input) {
{
var __koru_found = false;
{
global::System.Collections.Generic.List<long> __koru_ib;
if (__koru_store_players.__index_key.TryGetValue((long)(2), out __koru_ib)) {
long __koru_im = -1;
foreach (var __koru_bh in __koru_ib) {
var __koru_cand = __koru_store_players.__koru_row_of(__koru_bh);
if (__koru_cand >= 0 && (__koru_im < 0 || __koru_cand < __koru_im)) __koru_im = __koru_cand;
}
if (__koru_im >= 0) {
var __koru_si = __koru_im;
var __koru_srf_p_L53
... [truncated - 43KB total]Flows
flow ~new click a branch to expand · @labels scroll to their anchor
new (players, capacity: 8, source: key: i64, val: i64)
flow ~store click a branch to expand · @labels scroll to their anchor
store (expr: players, key, source: <implicit_source>)
flow ~insert click a branch to expand · @labels scroll to their anchor
insert (players, source: key: 1, val: 10)
flow ~insert click a branch to expand · @labels scroll to their anchor
insert (players, source: key: 2, val: 20)
flow ~insert click a branch to expand · @labels scroll to their anchor
insert (players, source: key: 1, val: 11)
flow ~insert click a branch to expand · @labels scroll to their anchor
insert (players, source: key: 1, val: 12)
flow ~insert click a branch to expand · @labels scroll to their anchor
insert (players, source: key: 2, val: 21)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
flow ~query click a branch to expand · @labels scroll to their anchor
query (players)
Test Configuration
MUST_RUN LANGUAGES: zig js cs
Post-validation Script:
#!/bin/bash
# Emitted-code oracle: `! query` on the indexed column must ROUTE, not
# sweep — membership output alone cannot tell a bucket walk from a full
# store scan. The stable path (bodies that cannot disturb the bucket)
# emits a direct `for` over the member list; a body that writes the
# indexed column emits the removal-tolerant cursor walk; the
# non-indexed guard keeps the dense sweep.
set -u
if [ ! -f output_emitted.zig ]; then
echo "FAIL: no output_emitted.zig"
exit 1
fi
if ! grep -q '__index_key: @import' output_emitted.zig; then
echo "FAIL: std/indexes:store(players, key) emitted no __index_key map"
exit 1
fi
if ! grep -q '__index_key.getPtr(__koru_ik)) |__koru_ib|' output_emitted.zig; then
echo "FAIL: '! query p when p.key == 1' did not route to the bucket"
exit 1
fi
if ! grep -q 'for (__koru_ib.items) |__koru_bh|' output_emitted.zig; then
echo "FAIL: the non-disturbing body lost the stable bucket walk"
exit 1
fi
if ! grep -q '__koru_bi: usize = 0;' output_emitted.zig; then
echo "FAIL: the indexed-column-writing body lost the survival walk"
exit 1
fi
if ! grep -q '__koru_ib2.items\[__koru_bi\] == __koru_bh' output_emitted.zig; then
echo "FAIL: the survival walk lost its post-body cursor re-check"
exit 1
fi
if ! grep -q 'for (0..main_module.__koru_store_players.len)' output_emitted.zig; then
echo "FAIL: the non-indexed guard (p.val) lost its sweep"
exit 1
fi
echo "PASS: ! query routes to the bucket — stable walk for take bodies, survival walk for indexed-column writes, sweep preserved"
exit 0