Skip to main content

vibe/capability_schema/
etalon_vibe_entries.rs

1//! Machine schema entries for all 8 Etalon VibeScript providers (`etalon-vibe`, 30 functions).
2//!
3//! Dynamically projects `etalon_vibe::ETALON_VIBE_PROVIDERS` descriptors into `SchemaEntry`
4//! records so `all_schemas()` and `schema_for()` never drift from the canonical ABI contracts.
5
6use super::{EffectClass, HonestyLabel, SchemaArg, SchemaEntry};
7use etalon_vibe::ETALON_VIBE_PROVIDERS;
8use vibescript_abi::{EffectSet, ParamSpec, PrimitiveKind};
9
10fn primitive_type_name(kind: PrimitiveKind) -> &'static str {
11    match kind {
12        PrimitiveKind::F32 => "f32",
13        PrimitiveKind::F64 => "f64",
14        PrimitiveKind::I32 => "i32",
15        PrimitiveKind::I64 => "i64",
16        PrimitiveKind::U32 => "u32",
17        PrimitiveKind::U64 => "u64",
18        PrimitiveKind::U8 => "u8",
19        PrimitiveKind::Bool => "bool",
20        PrimitiveKind::Utf8Bytes => "bytes",
21        PrimitiveKind::NQuin48 => "NQuin48",
22        PrimitiveKind::ResourceHandle => "ResourceHandle",
23    }
24}
25
26fn format_param_type(param: &ParamSpec) -> String {
27    let base = primitive_type_name(param.kind);
28    if param.min_elems == 1 && param.max_elems == 1 {
29        base.to_string()
30    } else if param.kind == PrimitiveKind::U8 || param.kind == PrimitiveKind::Utf8Bytes {
31        "bytes".to_string()
32    } else {
33        format!("List<{base}>")
34    }
35}
36
37fn format_return_type(kind: PrimitiveKind, required_output_elems: u32) -> String {
38    let base = primitive_type_name(kind);
39    if required_output_elems <= 1 {
40        base.to_string()
41    } else if kind == PrimitiveKind::U8 || kind == PrimitiveKind::Utf8Bytes {
42        "bytes".to_string()
43    } else {
44        format!("List<{base}>")
45    }
46}
47
48fn map_effect_class(effects: EffectSet) -> EffectClass {
49    if effects.contains_all(EffectSet::GRAPH_MUTATE) {
50        EffectClass::Write
51    } else if effects.contains_all(EffectSet::GRAPH_READ) {
52        EffectClass::Read
53    } else if effects.contains_all(EffectSet::HARDWARE_IO)
54        || effects.0 != EffectSet::PURE_COMPUTE.0
55    {
56        EffectClass::External
57    } else {
58        EffectClass::Pure
59    }
60}
61
62/// Generates `SchemaEntry` records for all functions across `ETALON_VIBE_PROVIDERS`.
63pub fn entries() -> Vec<SchemaEntry> {
64    let mut out = Vec::with_capacity(39);
65    for provider in ETALON_VIBE_PROVIDERS {
66        let d = provider.descriptor();
67        for sub in d.sub_namespaces {
68            for f in sub.functions {
69                let id = format!("{}.{}.{}", d.short_alias, sub.name, f.name);
70                let effect = map_effect_class(f.effects);
71                let returns = format_return_type(f.output_kind, f.required_output_elems);
72                let mut entry =
73                    SchemaEntry::new(&id, effect, HonestyLabel::CapabilityLease, &returns)
74                        .with_description(&format!(
75                            "Etalon VibeScript extension `{}` ({})",
76                            id, f.canonical_iri.iri
77                        ));
78                for p in f.params {
79                    entry = entry.with_arg(SchemaArg::new(p.name, &format_param_type(p), true));
80                }
81                out.push(entry);
82            }
83        }
84    }
85    out
86}
87
88#[cfg(test)]
89mod tests {
90    use super::*;
91    use crate::capability_schema::{ all_schemas, schema_for };
92
93    #[test]
94    fn t51_etalon_vibe_entries_all_39_functions_present() {
95        let etalon_entries = entries();
96        assert_eq!(etalon_entries.len(), 39);
97        let all = all_schemas();
98        assert!(all.len() >= 39);
99        let ids: Vec<&str> = etalon_entries.iter().map(|e| e.id.as_str()).collect();
100        let expected_specs: [(&str, usize, &str); 9] = [
101            ("render.emf.bioelectric_dipole_preview", 3, "List<"),
102            ("render.emf.radiative_transfer_slice", 2, "List<"),
103            ("render.emf.sh_irradiance_probe", 2, "List<"),
104            ("signal.qac.decode_container_summary", 1, "List<"),
105            ("signal.qac.render_binaural_frame", 2, "List<"),
106            ("signal.qac.evaluate_directivity_sh", 2, "List<"),
107            ("signal.qac.sonify_emf_envelope", 1, "List<"),
108            ("sense.authority.verify_evidence_gate", 1, "List<"),
109            ("sense.authority.dicom_modality_check", 1, "List<"),
110        ];
111        for (expected_id, expected_argc, ret_prefix) in expected_specs {
112            let entry = etalon_entries
113                .iter()
114                .find(|e| e.id == expected_id)
115                .unwrap_or_else(|| {
116                    panic!("missing UP-01 etalon-vibe entry `{expected_id}` in {ids:?}")
117                });
118            assert_eq!(
119                entry.args.len(),
120                expected_argc,
121                "unexpected arg count for `{expected_id}`"
122            );
123            assert!(
124                entry.returns.starts_with(ret_prefix),
125                "unexpected return schema `{}` for `{expected_id}`",
126                entry.returns
127            );
128            assert!(
129                schema_for(expected_id).is_some(),
130                "all_schemas() missing `{expected_id}`"
131            );
132        }
133        assert_eq!(
134            ids.iter().filter(|id| id.starts_with("render.")).count(),
135            7,
136            "expected 7 render entries in {ids:?}"
137        );
138        assert_eq!(
139            ids.iter().filter(|id| id.starts_with("signal.")).count(),
140            8,
141            "expected 8 signal entries in {ids:?}"
142        );
143        assert_eq!(
144            ids.iter().filter(|id| id.starts_with("sense.")).count(),
145            5,
146            "expected 5 sense entries in {ids:?}"
147        );
148        for id in [
149            "gpu.compute.affine_f32",
150            "gpu.compute.gemv4_f32",
151            "gpu.compute.topk2_f32",
152            "gpu.compute.rmsnorm_f32",
153            "gpu.compute.rope_f32",
154            "mech.kinematics.verlet_step",
155            "mech.kinematics.kinetic_energy",
156            "mech.kinematics.spring_damper_force",
157            "mech.geometry.aabb_volume",
158            "mech.geometry.excavation_prism_volume",
159            "forge.shader.tile_schedule_gemm",
160            "forge.shader.iq_power_reference",
161            "forge.shader.coop_matrix_tile_ops",
162            "render.spatial.project_10d_to_3d",
163            "render.spatial.sdf_torus_eval",
164            "render.spatial.skeletal_lerp_joint",
165            "render.spatial.brep_euler_characteristic",
166            "signal.dsp.signal_rms_peak",
167            "signal.dsp.cfar_cell_average",
168            "signal.dsp.biquad_df1_step",
169            "signal.vision.region_mean_u8",
170            "sense.telemetry.clock_stamp_drift_ns",
171            "sense.telemetry.spectrum_bin_hz",
172            "sense.telemetry.rssi_log_distance_m",
173            "p64.runtime.p64_align_offset",
174            "p64.runtime.moe_top2_softmax",
175            "p64.runtime.residency_admit_check",
176            "nquin.wire.compute_wire_parity",
177            "nquin.wire.verify_wire_words",
178            "nquin.wire.radix_bucket_byte",
179        ] {
180            let entry = schema_for(id).unwrap_or_else(|| panic!("missing schema for {id}"));
181            assert_eq!(entry.honesty, HonestyLabel::CapabilityLease);
182            assert!(!entry.args.is_empty());
183        }
184    }
185}
186