tiny.hypothesis.ReplayCursor

1pub const ReplayCursor = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: ReplayCapacity,4    dir: ?std.Io.Dir,5    names: []FailureName,6    encoded: []u8,7    choices: []ChoiceNode,8    name_count: usize = 0,9    next_name: usize = 0,10    status_value: ReplayStatus = .{},1112    pub const Limits: type = ReplayLimits;13    pub const Capacity: type = ReplayCapacity;14    pub const Status: type = ReplayStatus;1516    pub const claim: alloc_phase.capacity.Declaration = .{17        .source = .{18            .id = "hypothesis.replay_cursor",19            .kind = .phase_static,20            .limit_source = .caller,21            .storage = .{22                .covered = &.{23                    .{24                        .id = "bounded_sorted_content_address_candidate_names",25                        .lifetime = .steady,26                        .detail = "bounded sorted content-address candidate names",27                    },28                    .{29                        .id = "maximum_admitted_canonical_failure_bytes",30                        .lifetime = .steady,31                        .detail = "maximum admitted canonical failure bytes",32                    },33                    .{34                        .id = "maximum_admitted_decoded_choice_nodes",35                        .lifetime = .steady,36                        .detail = "maximum admitted decoded choice nodes",37                    },38                },39                .excluded = &.{40                    "caller-owned database path, namespace, replay context, and captured result",41                    "directory and file handles plus operating-system directory and file caches",42                },43            },44            .capacity = .{45                .inputs = &.{46                    alloc_phase.capacity.bindInput(Limits, "db_path", "db_path"),47                    alloc_phase.capacity.bindInput(Limits, "max_byte_blocks", "max_byte_blocks"),48                    alloc_phase.capacity.bindInput(Limits, "max_choices", "max_choices"),49                    alloc_phase.capacity.bindInput(Limits, "max_entries", "max_entries"),50                },51                .type_selectors = &.{},52                .nodes = &.{53                    .{ .collection = .{ .length = 0 } },54                    .{ .input = 1 },55                    .{ .input = 2 },56                    .{ .input = 3 },57                    .{ .add = .{ .left = 0, .right = 1 } },58                    .{ .add = .{ .left = 4, .right = 2 } },59                    .{ .add = .{ .left = 5, .right = 3 } },60                },61                .assertions = &.{.{62                    .scope = .closure_total,63                    .measure = .retained,64                    .relation = .upper_bound,65                    .expression = 6,66                }},67            },68            .overload = .{69                .kind = .not_applicable,70                .detail = "scan and record limits define the domain; rejected records do not exhaust storage",71            },72            .risks = .{73                .transitive = .{74                    .status = .open,75                    .detail = "directory, file, sort, and SHA callees lack an allocation-closure certificate",76                },77                .foreign = .{78                    .status = .excluded,79                    .detail = "filesystem handles and caches are excluded; sealed replay observes caller allocation",80                },81            },82            .obligations = &.{83                .{ .key = "hypothesis_replay_capacity", .role = .capacity_model },84                .{ .key = "hypothesis_replay_sealed", .role = .foreign_risk },85                .{ .key = "hypothesis_replay_oom_retry", .role = .custom },86            },87        },88        .bindings = .{89            .owner = @This(),90            .seal = .{91                .family = alloc_phase.capacity.selector(@This().activate),92                .premise = .{93                    .class = .checked_semantic_fact,94                    .authority = .checker,95                },96            },97            .teardown = .{98                .family = alloc_phase.capacity.selector(@This().deinit),99                .premise = .{100                    .class = .checked_semantic_fact,101                    .authority = .checker,102                },103            },104        },105    };106107    pub fn init(108        allocator: Allocator,109        limits: Limits,110    ) !ReplayCursor {111        const capacity = try Capacity.derive(limits);112        var cursor = ReplayCursor{113            .phase = .initialization,114            .capacity = capacity,115            .dir = null,116            .names = &.{},117            .encoded = &.{},118            .choices = &.{},119        };120        errdefer cursor.release(allocator);121        if (capacity.entries == 0) return cursor;122123        cursor.dir = openNamespaceDir(limits.db_path, limits.namespace) catch |err| switch (err) {124            error.FileNotFound => return cursor,125            else => return err,126        };127        cursor.names = try allocator.alloc(FailureName, capacity.entries);128        cursor.encoded = try allocator.alloc(u8, capacity.encoded_bytes);129        if (capacity.choices > 0) {130            cursor.choices = try allocator.alloc(ChoiceNode, capacity.choices);131        }132        try cursor.scanNames();133        return cursor;134    }135136    pub fn activate(self: *ReplayCursor) void {137        assert(self.phase == .initialization);138        assert(self.name_count <= self.capacity.entries);139        assert(self.next_name == 0);140        self.phase = .steady;141    }142143    pub fn next(self: *ReplayCursor) !?FailureEntry {144        assert(self.phase == .steady);145        assert(self.next_name <= self.name_count);146        while (self.next_name < self.name_count) {147            const name = self.names[self.next_name];148            self.next_name += 1;149            const failure = self.loadFailure(&name) catch |err| switch (err) {150                error.FileNotFound => null,151                else => return err,152            };153            if (failure) |entry| {154                self.status_value.failures_loaded += 1;155                assert(self.status_value.failures_loaded <= self.name_count);156                return entry;157            }158            self.status_value.failures_rejected += 1;159            assert(self.status_value.failures_rejected <= self.name_count);160        }161        return null;162    }163164    pub fn status(self: *const ReplayCursor) Status {165        assert(self.phase == .steady);166        return self.status_value;167    }168169    pub fn deinit(self: *ReplayCursor, allocator: Allocator) void {170        assert(self.phase != .teardown);171        self.phase = .teardown;172        self.release(allocator);173        self.* = undefined;174    }175176    fn scanNames(self: *ReplayCursor) !void {177        assert(self.phase == .initialization);178        var iterator = self.dir.?.iterate();179        while (self.status_value.entries_scanned < self.capacity.entries) {180            const entry = try iterator.next(std.Options.debug_io) orelse break;181            self.status_value.entries_scanned += 1;182            if (entry.kind != .file) continue;183            if (!isFailureName(entry.name)) continue;184            @memcpy(self.names[self.name_count][0..], entry.name);185            self.name_count += 1;186        }187        self.status_value.scan_budget_saturated =188            self.status_value.entries_scanned == self.capacity.entries;189        self.status_value.candidate_files = self.name_count;190        std.mem.sort(FailureName, self.names[0..self.name_count], {}, nameLessThan);191    }192193    fn loadFailure(self: *ReplayCursor, name: *const FailureName) !?FailureEntry {194        assert(self.phase == .steady);195        var file = try self.dir.?.openFile(std.Options.debug_io, name, .{196            .allow_directory = false,197        });198        defer file.close(std.Options.debug_io);199        const stat = try file.stat(std.Options.debug_io);200        if (stat.kind != .file) return null;201        const file_len = std.math.cast(usize, stat.size) orelse return null;202        if (file_len > self.encoded.len) return null;203        const data = self.encoded[0..file_len];204        if (try file.readPositionalAll(std.Options.debug_io, data, 0) != file_len) {205            return null;206        }207        var trailing: [1]u8 = undefined;208        if (try file.readPositionalAll(std.Options.debug_io, &trailing, file_len) != 0) {209            return null;210        }211        if (!failureNameMatches(name, data)) return null;212        return deserializeFailureInto(213            self.choices,214            self.capacity.byte_blocks,215            data,216        ) catch |err| switch (err) {217            error.InvalidFormat, error.UnsupportedVersion, error.CapacityExceeded => null,218        };219    }220221    fn release(self: *ReplayCursor, allocator: Allocator) void {222        if (self.choices.len > 0) allocator.free(self.choices);223        if (self.encoded.len > 0) allocator.free(self.encoded);224        if (self.names.len > 0) allocator.free(self.names);225        if (self.dir) |dir| dir.close(std.Options.debug_io);226    }227};

1pub const ReplayCursor = @import("database.zig").ReplayCursor;