vyre-conform 0.1.0

Conformance suite for vyre backends — proves byte-identical output to CPU reference
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Operation specifications, findings, collection types, and registry.
//!
//! Per ARCHITECTURE.md §8-Module Target, `spec/` owns the OpSpec registry,
//! the Finding trait, the spec-table validator, the runtime op registry,
//! per-op specification instances (`primitive/`, `decode/`,
//! `hash/`, `string/`, `graph/`, `match_ops/`, `engine/`, `workgroup/`),
//! and shared collection types (`collection/`).

/// Archetype reference declarations.
pub mod archetype_ref;
/// Internal builder for operation specifications.
pub(crate) mod builder;
/// Category taxonomy (A/B/C).
pub mod categories;
/// Category enforcement finding data.
pub mod category_finding;
/// Operation chain construction helpers.
pub mod chain;
/// Collection wrapper types (SmallVec, arena-backed slices, ...).
pub mod collection;
/// Provenance-bearing law declarations.
pub mod declared_law;
/// Engine specification contract types.
pub mod engine_spec;
/// Frozen structured finding extension contract.
pub mod finding;
/// Runtime-invariant findings surfaced by gates and oracles.
pub mod findings;
/// Single engine invariant definition.
pub mod invariant;
/// Engine invariant catalog.
pub mod invariants;
/// Algebraic law enum and catalog.
pub mod law;
/// Law verification dispatch tables.
pub mod laws;
/// Admission minimums.
pub mod minimums;
/// Mutation classification enum.
pub mod mutation_class;
/// Op specification type.
pub mod op;
/// Runtime registry of discovered operation specifications.
pub mod op_registry;
/// Spec-table op entries.
pub mod ops;
/// Oracle kind enum.
pub mod oracle_kind;
/// Integer overflow contract declarations.
pub mod overflow;
/// Probe data contracts.
pub mod probe;
/// Operation-spec to vyre IR program construction.
pub mod program;
/// Composition proof-token data.
pub mod proof_token;
/// Oracle property identifiers.
pub mod property;
/// Published semantic fingerprints for immutable operation versions.
pub mod published;
/// Spec-table validation registry.
pub mod registry;
/// Spec-table row type.
pub mod row;
/// Spec source provenance.
pub mod source;
/// Spec-table data.
pub mod tables;
/// Core types re-exported from vyre-spec.
pub mod types;
/// Runtime value representation.
pub mod value;
/// Verification level descriptors.
pub mod verification;
/// Semantic version tracking.
pub mod version;
/// Version history catalog.
pub mod versions;
/// Shared workgroup-level test harness spec.
pub mod workgroup;

/// Decode operations (base64, hex, url, unicode).
pub mod decode;
/// Engine-level conformance specifications (DFA, eval, scatter).
pub mod engine;
/// Graph operations (BFS, reachability).
pub mod graph;
/// Hash operations (`fnv1a`, `crc32`).
pub mod hash;
/// Pattern matching operations (DFA scan).
pub mod match_ops;
/// Arithmetic, bitwise, and comparison primitives.
pub mod primitive;
/// Hand-verified golden samples aggregated for every primitive op.
pub mod primitive_goldens;
/// String operations (tokenize, split).
pub mod string;

pub use archetype_ref::ArchetypeRef;
pub use category_finding::{CategoryFinding, FindingLocation};
pub use declared_law::DeclaredLaw;
pub use engine_spec::EngineSpec;
pub use finding::Finding;
pub use invariant::EngineInvariant;
pub use invariants::{
    by_category, by_id, catalog_is_complete, empty_test_family, invariants, Invariant,
    InvariantCategory, InvariantId, TestDescriptor,
};
pub use law::{AlgebraicLaw, MonotonicDirection, LAW_CATALOG};
pub use mutation_class::MutationClass;
pub use op::{BoundaryValue, EquivalenceClass, OpSpec};
pub use oracle_kind::OracleKind;
pub use overflow::{OverflowContract, OverflowDeclaration};
pub use probe::{LabeledProbe, ReferenceTrustProbes};
pub use proof_token::{ConstructionTime, ProofToken, ProofTokenError};
pub use property::Property;
pub use row::SpecRow;
pub use source::{LawId, SpecSource};
pub use types::{BufferAccess, Convention, DataType, OpSignature};
pub use value::Value;
pub use verification::{FloatType, Verification};
pub use version::{Version, CURRENT_VERSION, V1_0};

/// Provide runtime executable hooks for spec-layer operation declarations.
#[must_use]
#[inline]
pub fn spec_op_sources() -> crate::spec::ops::OpSpecSources {
    crate::spec::ops::OpSpecSources {
        add: primitive::add::spec_layer_source(),
    }
}