1use 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
62pub 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