tiny.closure.qualify

1pub const Bound = struct {2    name: schema.Name,3    value: u64,4};

1pub const BuildMode = enum(u8) {2    debug,3    release_safe,4    release_fast,5    release_small,6};

1pub const CapacityCase = enum(u8) {2    none,3    at_capacity,4    over_capacity,5};

1pub const Capture = enum(u8) {2    complete,3    truncated,4    capacity_arithmetic_overflow,5    unsupported,6    insufficient_samples,7    missing_threshold,8    explorer_frontier_exhausted,9    trace_capacity_exceeded,10};

1pub const Cell = struct {2    id: schema.Name,3    owner: schema.Name,4    requirement: Requirement,5    kind: CellKind,6    evidence: EvidenceKind,7    workload: schema.Descriptor,8    phase: schema.Phase,9    scale: u64,10    build_mode: BuildMode,11    fault: schema.Descriptor,12    overload_counter: schema.Name,13    loss_counter: schema.Name,14    bound_start: u16,15    bound_count: u16,16    seed_start: u16,17    seed_count: u16,18    repetitions: u32,19    threshold: Threshold,20    capacity_case: CapacityCase,21    capacity: u64,22    work_max: u64,23    trace_steps_max: u64,24};

1pub const CellKind = enum(u8) {2    correctness,3    slo,4};

1pub const EvidenceKind = enum(u8) {2    proof,3    finite_exhaustive,4    simulation,5    qemu,6    hardware,7    assumption,8    measurement,9};

1pub const Frozen = struct {2    plan: Plan,3    sha256: schema.Digest,4    bytes: []const u8,5};

1pub const OutcomeCounts = struct {2    offered: u64,3    accepted: u64,4    completed: u64,5    rejected: u64,6    dropped: u64,7    outstanding: u64,8};

1pub const Plan = struct {2    claim: schema.Descriptor,3    artifact_sha256: schema.Digest,4    execution_profile_sha256: schema.Digest,5    cells: []const Cell,6    bounds: []const Bound,7    seeds: []const u64,8};

1pub const Requirement = enum(u8) {2    required,3    excluded,4};

1pub const Row = struct {2    cell: schema.Name,3    evidence: EvidenceKind,4    verdict: schema.Verdict,5    capture: Capture,6    contract_pass: bool,7    outcomes: OutcomeCounts,8    before_digest: schema.Digest,9    after_digest: schema.Digest,10    effect_before_digest: schema.Digest,11    effect_after_digest: schema.Digest,12    high_water: u64,13    work: u64,14    allocation_count_after_seal: u64,15    storage_address_before: usize,16    storage_address_after: usize,17    storage_capacity_before: u64,18    storage_capacity_after: u64,19    transition: Transition,20    overload_count_before: u64,21    overload_count_after: u64,22    loss_count_before: u64,23    loss_count_after: u64,24    undeclared_effect_count: u64,25    undeclared_state_change_count: u64,26    statistics: Statistics,27    evidence_path: schema.Descriptor,28    trace_path: schema.Descriptor,29};

1pub const Statistics = struct {2    present: bool = false,3    interval_present: bool = false,4    interleaved: bool = false,5    baseline_profile_sha256: schema.Digest = schema.Digest.zero(),6    candidate_profile_sha256: schema.Digest = schema.Digest.zero(),7    sample_count: u32 = 0,8    baseline_count: u32 = 0,9    candidate_count: u32 = 0,10    minimum: i64 = 0,11    p50: i64 = 0,12    p95: i64 = 0,13    p99: i64 = 0,14    maximum: i64 = 0,15    interval_low: i64 = 0,16    interval_high: i64 = 0,17    baseline_high_water: u64 = 0,18    candidate_high_water: u64 = 0,19};

1pub const Summary = struct {2    verdict: schema.Verdict,3    passed: u16,4    refuted: u16,5    inconclusive: u16,6    not_exercised: u16,7    work: u64,8    high_water: u64,9    allocation_count_after_seal: u64,10};

1pub const Threshold = struct {2    kind: ThresholdKind,3    value: i64 = 0,4    confidence_ppm: u32 = 0,5};

1pub const ThresholdKind = enum(u8) {2    none,3    correctness,4    absolute_max,5    baseline_delta_max,6};

1pub const Transition = enum(u8) {2    none,3    reject,4    drop,5    replace,6    backpressure,7};

1pub fn freeze(2    plan: model.Plan,3    output: []u8,4) Error!model.Frozen {5    try owner.validatePlan(plan);6    const length = try json.measure(writePlan, .{plan});7    if (length > output.len or8        length > model.plan_bytes_max)9    {10        return error.ReceiptCapacityExceeded;11    }12    const encoded = try json.render(13        output,14        length,15        writePlan,16        .{plan},17    );18    var plan_digest = schema.Digest.zero();19    std.crypto.hash.sha2.Sha256.hash(20        encoded,21        &plan_digest.bytes,22        .{},23    );24    return .{25        .plan = plan,26        .sha256 = plan_digest,27        .bytes = encoded,28    };29}

1pub fn receipt(2    frozen: model.Frozen,3    rows: []const model.Row,4    output: []u8,5) Error![]const u8 {6    const summary = try owner.evaluate(frozen, rows);7    const length = try json.measure(8        writeReceipt,9        .{ frozen, rows, summary },10    );11    if (length > output.len or12        length > model.receipt_bytes_max)13    {14        return error.ReceiptCapacityExceeded;15    }16    return try json.render(17        output,18        length,19        writeReceipt,20        .{ frozen, rows, summary },21    );22}

1pub const bounds_max: usize = 256;

1pub const cells_max: usize = 64;

1pub const plan_bytes_max: usize = 256 * 1_024;

1pub const receipt_bytes_max: usize = 512 * 1_024;

1pub const seeds_max: usize = 256;

1pub fn classify(2    cell: *const model.Cell,3    row: *const model.Row,4) schema.Verdict {5    if (cell.requirement == .excluded) return .not_exercised;6    if (row.capture != .complete) return .inconclusive;7    if (cell.threshold.kind == .none) return .inconclusive;8    if (cell.evidence == .assumption) return .inconclusive;9    if (!evidenceComplete(cell, row)) return .refuted;10    if (!row.contract_pass) return .refuted;11    return switch (cell.kind) {12        .correctness => if (cell.threshold.kind == .correctness)13            .pass14        else15            .inconclusive,16        .slo => sloVerdict(cell, row.statistics),17    };18}

1pub fn evaluate(2    frozen: model.Frozen,3    rows: []const model.Row,4) Error!model.Summary {5    try validatePlan(frozen.plan);6    if (!frozen.sha256.isKnown()) return error.PlanDigestMissing;7    if (rows.len != frozen.plan.cells.len) {8        return error.ResultCountMismatch;9    }10    var summary = model.Summary{11        .verdict = .pass,12        .passed = 0,13        .refuted = 0,14        .inconclusive = 0,15        .not_exercised = 0,16        .work = 0,17        .high_water = 0,18        .allocation_count_after_seal = 0,19    };20    for (frozen.plan.cells, rows, 0..) |*cell, *row, index| {21        if (!cell.id.eql(&row.cell)) return error.ResultOrderMismatch;22        if (row.evidence != cell.evidence) return error.EvidenceMismatch;23        var expected = classify(cell, row);24        if (expected == .pass and25            cell.capacity_case != .none and26            !pairEvidenceEquivalent(27                frozen.plan,28                rows,29                index,30            ))31        {32            expected = .refuted;33        }34        if (expected == .pass and35            cell.kind == .slo and36            (!row.statistics.baseline_profile_sha256.eql(37                &frozen.plan.execution_profile_sha256,38            ) or39                !row.statistics.candidate_profile_sha256.eql(40                    &frozen.plan.execution_profile_sha256,41                )))42        {43            expected = .refuted;44        }45        if (row.verdict != expected) return error.VerdictMismatch;46        switch (row.verdict) {47            .pass => summary.passed += 1,48            .refuted => summary.refuted += 1,49            .inconclusive => summary.inconclusive += 1,50            .not_exercised => summary.not_exercised += 1,51        }52        if (cell.requirement == .required) {53            summary.work = std.math.add(54                u64,55                summary.work,56                row.work,57            ) catch std.math.maxInt(u64);58            summary.high_water = @max(summary.high_water, row.high_water);59            summary.allocation_count_after_seal = std.math.add(60                u64,61                summary.allocation_count_after_seal,62                row.allocation_count_after_seal,63            ) catch std.math.maxInt(u64);64        }65    }66    summary.verdict = if (summary.refuted != 0)67        .refuted68    else if (summary.inconclusive != 0)69        .inconclusive70    else71        .pass;72    return summary;73}

1pub fn validatePlan(plan: model.Plan) Error!void {2    if (plan.cells.len == 0) return error.PlanEmpty;3    if (plan.cells.len > model.cells_max or4        plan.bounds.len > model.bounds_max or5        plan.seeds.len > model.seeds_max)6    {7        return error.CellCapacityExceeded;8    }9    if (plan.claim.isEmpty() or10        !plan.artifact_sha256.isKnown() or11        !plan.execution_profile_sha256.isKnown())12    {13        return error.PlanDigestMissing;14    }15    var required_count: u16 = 0;16    var work_max: u64 = 0;17    for (plan.cells, 0..) |*cell, index| {18        try validateCell(plan, cell);19        if (cell.requirement == .required) {20            required_count += 1;21            work_max = std.math.add(22                u64,23                work_max,24                cell.work_max,25            ) catch return error.PlanWorkOverflow;26        }27        for (plan.cells[0..index]) |*prior| {28            if (cell.id.eql(&prior.id)) return error.CellDuplicate;29        }30    }31    if (required_count == 0) return error.PlanRequiredMissing;32    try validateCapacityPairs(plan);33}

1const model = @import("model.zig");2const owner = @import("owner.zig");3const encode = @import("encode.zig");45pub const Bound = model.Bound;6pub const BuildMode = model.BuildMode;7pub const CapacityCase = model.CapacityCase;8pub const Capture = model.Capture;9pub const Cell = model.Cell;10pub const CellKind = model.CellKind;11pub const EvidenceKind = model.EvidenceKind;12pub const Frozen = model.Frozen;13pub const OutcomeCounts = model.OutcomeCounts;14pub const Plan = model.Plan;15pub const Requirement = model.Requirement;16pub const Row = model.Row;17pub const Statistics = model.Statistics;18pub const Summary = model.Summary;19pub const Threshold = model.Threshold;20pub const ThresholdKind = model.ThresholdKind;21pub const Transition = model.Transition;2223pub const bounds_max = model.bounds_max;24pub const cells_max = model.cells_max;25pub const plan_bytes_max = model.plan_bytes_max;26pub const receipt_bytes_max = model.receipt_bytes_max;27pub const seeds_max = model.seeds_max;2829pub const classify = owner.classify;30pub const freeze = encode.freeze;31pub const receipt = encode.receipt;32pub const evaluate = owner.evaluate;33pub const validatePlan = owner.validatePlan;

1pub const qualify = @import("qualify/root.zig");