1mod conditioning_host;
6mod wave19_host;
7
8pub use conditioning_host::{
9 conditioning_activate, conditioning_compile, conditioning_evaluate, conditioning_inspect,
10 conditioning_rollback, conditioning_validate,
11};
12pub use wave19_host::{
13 gelu_host as gelu, relu_host as relu, rms_norm_host as rms_norm, sigmoid_host as sigmoid,
14 softmax_host as softmax,
15};
16
17use super::args;
18use crate::inference::{post_turn_verify, quant_graph_grounding};
19use vibe::{DiagCode, Diagnostic, Span, Value};
20
21pub fn embed(args: &Value, span: Span) -> Result<Value, Diagnostic> {
23 let text =
24 args::as_str(args).ok_or_else(|| args::bad(span, "Inference.embed needs a string"))?;
25 if text.len() > 64 * 1024 {
26 return Err(Diagnostic::new(
27 DiagCode::E400,
28 span,
29 "Inference.embed exceeds 64 KiB",
30 ));
31 }
32 let embedder = crate::inference::semantic_skills::TextEmbedder::default();
33 let vec = embedder.embed(text);
34 Ok(args::f64_list_value(vec.dims.iter().map(|&x| x as f64)))
35}
36
37pub fn grounding(args: &Value, span: Span) -> Result<Value, Diagnostic> {
41 let prompt = args::rec_str(args, "prompt")
42 .ok_or_else(|| args::bad(span, "Inference.grounding needs prompt"))?;
43 let text = args::rec_str(args, "text")
44 .ok_or_else(|| args::bad(span, "Inference.grounding needs text"))?;
45 let result = quant_graph_grounding::maybe_ground_generation(prompt, text);
46 let mut rec = std::collections::BTreeMap::new();
47 rec.insert("text".into(), Value::String(result.text));
48 rec.insert("repaired".into(), Value::Bool(result.repaired));
49 if let Some(reason) = result.reason {
50 rec.insert("reason".into(), Value::String(reason));
51 }
52 if let Some(hash) = result.object_hash {
53 rec.insert("object_hash".into(), Value::U64(hash));
54 }
55 Ok(Value::Record(rec))
56}
57
58pub fn verify_turn(args: &Value, span: Span) -> Result<Value, Diagnostic> {
61 let prompt = args::rec_str(args, "prompt")
62 .ok_or_else(|| args::bad(span, "Inference.verify_turn needs prompt"))?;
63 let draft = args::rec_str(args, "draft")
64 .ok_or_else(|| args::bad(span, "Inference.verify_turn needs draft"))?;
65 let result = post_turn_verify::maybe_verify_turn(prompt, draft);
66 let mut rec = std::collections::BTreeMap::new();
67 rec.insert("final_text".into(), Value::String(result.final_text));
68 rec.insert("repaired".into(), Value::Bool(result.repaired));
69 let checks: Vec<Value> = result
70 .checks
71 .iter()
72 .map(|c| {
73 let mut r = std::collections::BTreeMap::new();
74 r.insert("id".into(), Value::String(c.id.clone()));
75 r.insert("ok".into(), Value::Bool(c.ok));
76 r.insert("detail".into(), Value::String(c.detail.clone()));
77 Value::Record(r)
78 })
79 .collect();
80 rec.insert("checks".into(), Value::List(checks));
81 if let Some(reason) = result.grounding_reason {
82 rec.insert("grounding_reason".into(), Value::String(reason));
83 }
84 Ok(Value::Record(rec))
85}
86
87pub fn detect_ungrounded(args: &Value, span: Span) -> Result<Value, Diagnostic> {
90 let prompt = args::rec_str(args, "prompt")
91 .ok_or_else(|| args::bad(span, "Inference.detect_ungrounded needs prompt"))?;
92 let draft = args::rec_str(args, "draft")
93 .ok_or_else(|| args::bad(span, "Inference.detect_ungrounded needs draft"))?;
94 let result = post_turn_verify::maybe_verify_turn(prompt, draft);
95 let ungrounded = result.repaired || result.grounding_reason.is_some();
96 let mut rec = std::collections::BTreeMap::new();
97 rec.insert("ungrounded".into(), Value::Bool(ungrounded));
98 if let Some(reason) = result.grounding_reason {
99 rec.insert("reason".into(), Value::String(reason));
100 }
101 Ok(Value::Record(rec))
102}
103
104#[cfg(not(target_arch = "wasm32"))]
110pub fn load_model(args: &Value, span: Span) -> Result<Value, Diagnostic> {
111 let path = args::rec_str(args, "path")
112 .ok_or_else(|| args::bad(span, "Inference.load_model needs path"))?;
113 let model_id = args::rec_u64(args, "model_id").unwrap_or(0);
114 let mlock = args::rec_bool(args, "mlock").unwrap_or(false);
115
116 match crate::inference::resident_model::mount_resident_model(model_id, path, mlock) {
117 Ok(report) => Ok(args::record([
118 ("loaded", Value::Bool(true)),
119 ("mapped_bytes", Value::U64(report.mapped_bytes)),
120 ("n_layer", Value::U64(report.n_layer as u64)),
121 ("n_head", Value::U64(report.n_head as u64)),
122 ("n_kv_head", Value::U64(report.n_kv_head as u64)),
123 ("kv_cache_bytes", Value::U64(report.kv_cache_bytes)),
124 ("directml_enabled", Value::Bool(report.directml_enabled)),
125 ])),
126 Err(e) => Err(Diagnostic::new(
127 DiagCode::E100,
128 span,
129 vibe::llm_missing(format!("Inference.load_model: {e}")),
130 )),
131 }
132}
133
134#[cfg(target_arch = "wasm32")]
135pub fn load_model(_args: &Value, span: Span) -> Result<Value, Diagnostic> {
137 Err(args::need_scientific(span, "Inference.load_model"))
138}
139
140#[cfg(not(target_arch = "wasm32"))]
143pub fn unload_model(_args: &Value, _span: Span) -> Result<Value, Diagnostic> {
144 crate::inference::resident_model::clear_resident_model();
145 Ok(args::record([
146 ("unloaded", Value::Bool(true)),
147 ("status", Value::String("cleared".into())),
148 ]))
149}
150
151#[cfg(target_arch = "wasm32")]
152pub fn unload_model(_args: &Value, span: Span) -> Result<Value, Diagnostic> {
154 Err(args::need_scientific(span, "Inference.unload_model"))
155}
156
157#[cfg(not(target_arch = "wasm32"))]
165pub fn run_transformer(args: &Value, span: Span) -> Result<Value, Diagnostic> {
166 let model_path = crate::inference::resident_model::resident_gguf_path();
169 if model_path.is_none() {
170 return Err(Diagnostic::new(
171 DiagCode::E100,
172 span,
173 "Inference.run_transformer: no resident model loaded; call Inference.load_model first",
174 ));
175 }
176 let tokens = args::rec_u64_list(args, "tokens")
178 .ok_or_else(|| args::bad(span, "Inference.run_transformer needs tokens"))?;
179 let max_layers = args::rec_u64(args, "max_layers").unwrap_or(0) as u32;
180 Ok(args::record([
181 ("status", Value::String("model_loaded".into())),
182 ("token_count", Value::U64(tokens.len() as u64)),
183 ("max_layers", Value::U64(max_layers as u64)),
184 (
185 "note",
186 Value::String("forward pass requires GPU dispatch via QTensorEngine".into()),
187 ),
188 ]))
189}
190
191#[cfg(target_arch = "wasm32")]
192pub fn run_transformer(_args: &Value, span: Span) -> Result<Value, Diagnostic> {
194 Err(args::need_scientific(span, "Inference.run_transformer"))
195}
196
197pub fn run_classifier(args: &Value, span: Span) -> Result<Value, Diagnostic> {
207 use crate::solvers::learning::classification;
208
209 let method = args::rec_str(args, "method")
210 .ok_or_else(|| args::bad(span, "Inference.run_classifier needs method"))?;
211 let features = args::rec_f64_list(args, "features")
212 .ok_or_else(|| args::bad(span, "Inference.run_classifier needs features"))?;
213 let n = args::rec_u64(args, "n")
214 .ok_or_else(|| args::bad(span, "Inference.run_classifier needs n"))? as usize;
215 let p = args::rec_u64(args, "p")
216 .ok_or_else(|| args::bad(span, "Inference.run_classifier needs p"))? as usize;
217 let query = args::rec_f64_list(args, "query")
218 .ok_or_else(|| args::bad(span, "Inference.run_classifier needs query"))?;
219
220 if features.len() < n * p {
221 return Err(args::bad(
222 span,
223 "Inference.run_classifier: features must have n*p elements",
224 ));
225 }
226 if query.len() < p {
227 return Err(args::bad(
228 span,
229 "Inference.run_classifier: query must have p elements",
230 ));
231 }
232
233 match method {
234 "knn" => {
235 let k = args::rec_u64(args, "k").unwrap_or(3) as usize;
236 let labels: Vec<usize> = args::rec_u64_list(args, "labels")
237 .ok_or_else(|| args::bad(span, "Inference.run_classifier needs labels"))?
238 .into_iter()
239 .map(|l| l as usize)
240 .collect();
241 if labels.len() != n {
242 return Err(args::bad(
243 span,
244 "Inference.run_classifier: labels must have n elements",
245 ));
246 }
247 let knn = classification::knn::KnnClassifier::fit(&features, &labels, n, p, k)
248 .map_err(|e| Diagnostic::new(DiagCode::E100, span, format!("KNN fit: {e:?}")))?;
249 let predicted = knn.predict_row(&query);
250 Ok(args::record([
251 ("method", Value::String("knn".into())),
252 ("predicted", Value::U64(predicted as u64)),
253 ("k", Value::U64(k as u64)),
254 ]))
255 }
256 "naive_bayes" | "nb" => {
257 let labels: Vec<usize> = args::rec_u64_list(args, "labels")
258 .ok_or_else(|| args::bad(span, "Inference.run_classifier needs labels"))?
259 .into_iter()
260 .map(|l| l as usize)
261 .collect();
262 if labels.len() != n {
263 return Err(args::bad(
264 span,
265 "Inference.run_classifier: labels must have n elements",
266 ));
267 }
268 let nb = classification::naive_bayes::GaussianNb::fit(&features, &labels, n, p)
269 .map_err(|e| Diagnostic::new(DiagCode::E100, span, format!("NB fit: {e:?}")))?;
270 let predicted = nb.predict_row(&query);
271 Ok(args::record([
272 ("method", Value::String("naive_bayes".into())),
273 ("predicted", Value::U64(predicted as u64)),
274 ]))
275 }
276 "svm" => {
277 let labels_bool: Vec<bool> = args::rec_u64_list(args, "labels")
278 .ok_or_else(|| args::bad(span, "Inference.run_classifier needs labels"))?
279 .into_iter()
280 .map(|l| l != 0)
281 .collect();
282 if labels_bool.len() != n {
283 return Err(args::bad(
284 span,
285 "Inference.run_classifier: labels must have n elements",
286 ));
287 }
288 let c = args::rec_f64(args, "c").unwrap_or(1.0);
289 let kernel_str = args::rec_str(args, "kernel").unwrap_or("linear");
290 let kernel = match kernel_str {
291 "rbf" => {
292 let gamma = args::rec_f64(args, "gamma").unwrap_or(0.5);
293 classification::svm::Kernel::Rbf { gamma }
294 }
295 _ => classification::svm::Kernel::Linear,
296 };
297 let svm = classification::svm::fit(&features, &labels_bool, n, p, c, kernel, 5, 1e-3)
298 .map_err(|e| {
299 Diagnostic::new(DiagCode::E100, span, format!("SVM fit: {e:?}"))
300 })?;
301 let predicted = svm.predict_row(&query);
302 let n_sv = svm.n_support_vectors();
303 Ok(args::record([
304 ("method", Value::String("svm".into())),
305 ("predicted", Value::Bool(predicted)),
306 ("n_support_vectors", Value::U64(n_sv as u64)),
307 ]))
308 }
309 _ => Err(args::bad(
310 span,
311 format!("Inference.run_classifier: unknown method '{method}'"),
312 )),
313 }
314}
315
316pub fn run_reranker(args: &Value, span: Span) -> Result<Value, Diagnostic> {
321 let query = args::rec_str(args, "query")
322 .ok_or_else(|| args::bad(span, "Inference.run_reranker needs query"))?;
323 let candidates: Vec<String> = args::rec_str_list(args, "candidates")
324 .ok_or_else(|| args::bad(span, "Inference.run_reranker needs candidates"))?;
325
326 let results = crate::inference::reranker::rerank_default(query, &candidates);
327 let result_values: Vec<Value> = results
328 .iter()
329 .map(|r| {
330 let mut rec = std::collections::BTreeMap::new();
331 rec.insert("index".into(), Value::U64(r.index as u64));
332 rec.insert("score".into(), Value::F64(r.score));
333 Value::Record(rec)
334 })
335 .collect();
336
337 Ok(args::record([
338 ("results", Value::List(result_values)),
339 ("count", Value::U64(results.len() as u64)),
340 ]))
341}
342
343pub fn vector_search(args: &Value, span: Span) -> Result<Value, Diagnostic> {
349 use crate::inference::semantic_skills::{TextEmbedder, VectorStore};
350
351 let texts = args::rec_str_list(args, "texts")
352 .ok_or_else(|| args::bad(span, "Inference.vector_search needs texts"))?;
353 let query = args::rec_str(args, "query")
354 .ok_or_else(|| args::bad(span, "Inference.vector_search needs query"))?;
355 let k = args::rec_u64(args, "k").unwrap_or(5) as usize;
356
357 let embedder = TextEmbedder::default();
358 let mut store = VectorStore::with_embedder(embedder);
359 for (i, text) in texts.iter().enumerate() {
360 let key = format!("doc_{i}");
361 let _ = store.add_text(&key, text, None);
362 }
363
364 let results = store.search_text(query, k);
365 let result_values: Vec<Value> = results
366 .iter()
367 .map(|r| {
368 let mut rec = std::collections::BTreeMap::new();
369 rec.insert("key".into(), Value::String(r.key.clone()));
370 rec.insert("similarity".into(), Value::F64(r.similarity as f64));
371 if let Some(meta) = &r.metadata {
372 rec.insert("metadata".into(), Value::String(meta.clone()));
373 }
374 Value::Record(rec)
375 })
376 .collect();
377
378 Ok(args::record([
379 ("results", Value::List(result_values)),
380 ("corpus_size", Value::U64(store.len() as u64)),
381 ]))
382}
383
384pub fn constrained_decode(args: &Value, span: Span) -> Result<Value, Diagnostic> {
391 use crate::inference::speculative_decode::{DominoMasker, GrammarStateMachine};
392
393 let vocab_val = args::rec(args, "vocab")
395 .ok_or_else(|| args::bad(span, "Inference.constrained_decode needs vocab"))?;
396 let vocab_list = args::list(vocab_val)
397 .ok_or_else(|| args::bad(span, "Inference.constrained_decode vocab must be a list"))?;
398
399 let mut vocab: Vec<(u32, String)> = Vec::new();
400 for entry in vocab_list {
401 if let Value::List(pair) = entry {
402 if pair.len() == 2 {
403 let id = match &pair[0] {
404 Value::U64(n) => *n as u32,
405 Value::I64(n) => *n as u32,
406 _ => continue,
407 };
408 if let Value::String(s) = &pair[1] {
409 vocab.push((id, s.clone()));
410 }
411 }
412 }
413 }
414
415 if vocab.is_empty() {
416 return Err(args::bad(
417 span,
418 "Inference.constrained_decode: vocab is empty or malformed",
419 ));
420 }
421
422 let mut masker = DominoMasker::new(&vocab);
423 masker.enable();
424
425 if let Some(logits_val) = args::rec(args, "logits") {
427 if let Some(logits_list) = args::list(logits_val) {
428 let mut logits: Vec<f32> = logits_list
429 .iter()
430 .map(|v| args::as_f64(v).unwrap_or(0.0) as f32)
431 .collect();
432 masker.apply_mask(&mut logits);
433 let allowed: Vec<Value> = logits
435 .iter()
436 .enumerate()
437 .filter(|(_, &l)| l.is_finite())
438 .map(|(i, _)| Value::U64(i as u64))
439 .collect();
440 let grammar_state = format!("{:?}", masker.grammar_state());
441 return Ok(args::record([
442 ("allowed_tokens", Value::List(allowed)),
443 ("grammar_state", Value::String(grammar_state)),
444 ("active", Value::Bool(masker.is_active())),
445 ]));
446 }
447 }
448
449 let grammar = GrammarStateMachine::new();
451 let state = format!("{:?}", grammar.state());
452 Ok(args::record([
453 ("allowed_tokens", Value::List(vec![])),
454 ("grammar_state", Value::String(state)),
455 ("active", Value::Bool(true)),
456 ]))
457}
458
459#[cfg(test)]
460mod tests {
461 use super::*;
462 use std::collections::BTreeMap;
463
464 #[test]
465 fn embed_returns_vector() {
466 let result = embed(
467 &Value::String("hello world".into()),
468 Span { start: 0, end: 0 },
469 );
470 assert!(result.is_ok());
471 match result.unwrap() {
472 Value::List(dims) => assert!(!dims.is_empty()),
473 _ => panic!("expected list"),
474 }
475 }
476
477 #[test]
478 fn embed_rejects_non_string() {
479 let result = embed(&Value::I64(42), Span { start: 0, end: 0 });
480 assert!(result.is_err());
481 }
482
483 #[test]
484 fn grounding_returns_record() {
485 let mut m = BTreeMap::new();
486 m.insert(
487 "prompt".into(),
488 Value::String("What is the capital of France?".into()),
489 );
490 m.insert(
491 "text".into(),
492 Value::String("The capital of France is Paris.".into()),
493 );
494 let result = grounding(&Value::Record(m), Span { start: 0, end: 0 });
495 assert!(result.is_ok());
496 match result.unwrap() {
497 Value::Record(rec) => {
498 assert!(rec.contains_key("text"));
499 assert!(rec.contains_key("repaired"));
500 }
501 _ => panic!("expected record"),
502 }
503 }
504
505 #[test]
506 fn verify_turn_returns_checks() {
507 let mut m = BTreeMap::new();
508 m.insert("prompt".into(), Value::String("Hello".into()));
509 m.insert("draft".into(), Value::String("Hi there".into()));
510 let result = verify_turn(&Value::Record(m), Span { start: 0, end: 0 });
511 assert!(result.is_ok());
512 match result.unwrap() {
513 Value::Record(rec) => {
514 assert!(rec.contains_key("final_text"));
515 assert!(rec.contains_key("checks"));
516 }
517 _ => panic!("expected record"),
518 }
519 }
520
521 #[test]
522 fn detect_ungrounded_returns_bool() {
523 let mut m = BTreeMap::new();
524 m.insert("prompt".into(), Value::String("Hello".into()));
525 m.insert("draft".into(), Value::String("Hi".into()));
526 let result = detect_ungrounded(&Value::Record(m), Span { start: 0, end: 0 });
527 assert!(result.is_ok());
528 match result.unwrap() {
529 Value::Record(rec) => {
530 assert!(rec.contains_key("ungrounded"));
531 }
532 _ => panic!("expected record"),
533 }
534 }
535
536 #[test]
537 fn run_reranker_basic() {
538 let mut m = BTreeMap::new();
539 m.insert("query".into(), Value::String("machine learning".into()));
540 m.insert(
541 "candidates".into(),
542 Value::List(vec![
543 Value::String("weather today".into()),
544 Value::String("machine learning algorithms".into()),
545 Value::String("cooking recipes".into()),
546 ]),
547 );
548 let result = run_reranker(&Value::Record(m), Span { start: 0, end: 0 });
549 assert!(result.is_ok());
550 match result.unwrap() {
551 Value::Record(rec) => {
552 assert!(rec.contains_key("results"));
553 match rec.get("results") {
554 Some(Value::List(results)) => {
555 assert_eq!(results.len(), 3);
556 match &results[0] {
558 Value::Record(r) => assert_eq!(r.get("index"), Some(&Value::U64(1))),
559 _ => panic!("expected record"),
560 }
561 }
562 _ => panic!("expected list"),
563 }
564 }
565 _ => panic!("expected record"),
566 }
567 }
568
569 #[test]
570 fn run_reranker_missing_query() {
571 let m = BTreeMap::new();
572 let result = run_reranker(&Value::Record(m), Span { start: 0, end: 0 });
573 assert!(result.is_err());
574 }
575
576 #[test]
577 fn vector_search_basic() {
578 let mut m = BTreeMap::new();
579 m.insert(
580 "texts".into(),
581 Value::List(vec![
582 Value::String("hello world".into()),
583 Value::String("machine learning".into()),
584 Value::String("foo bar baz".into()),
585 ]),
586 );
587 m.insert("query".into(), Value::String("hello".into()));
588 m.insert("k".into(), Value::U64(2));
589 let result = vector_search(&Value::Record(m), Span { start: 0, end: 0 });
590 assert!(result.is_ok());
591 match result.unwrap() {
592 Value::Record(rec) => {
593 assert!(rec.contains_key("results"));
594 match rec.get("results") {
595 Some(Value::List(results)) => assert!(!results.is_empty()),
596 _ => panic!("expected list"),
597 }
598 }
599 _ => panic!("expected record"),
600 }
601 }
602
603 #[test]
604 fn run_classifier_knn() {
605 let mut m = BTreeMap::new();
607 m.insert("method".into(), Value::String("knn".into()));
608 m.insert(
609 "features".into(),
610 Value::List(vec![
611 Value::F64(0.0),
612 Value::F64(0.0),
613 Value::F64(0.0),
614 Value::F64(1.0),
615 Value::F64(1.0),
616 Value::F64(0.0),
617 Value::F64(1.0),
618 Value::F64(1.0),
619 ]),
620 );
621 m.insert(
622 "labels".into(),
623 Value::List(vec![
624 Value::U64(0),
625 Value::U64(0),
626 Value::U64(1),
627 Value::U64(1),
628 ]),
629 );
630 m.insert("n".into(), Value::U64(4));
631 m.insert("p".into(), Value::U64(2));
632 m.insert("k".into(), Value::U64(3));
633 m.insert(
634 "query".into(),
635 Value::List(vec![Value::F64(0.1), Value::F64(0.1)]),
636 );
637 let result = run_classifier(&Value::Record(m), Span { start: 0, end: 0 });
638 assert!(result.is_ok());
639 match result.unwrap() {
640 Value::Record(rec) => {
641 assert_eq!(rec.get("method"), Some(&Value::String("knn".into())));
642 assert!(rec.contains_key("predicted"));
643 }
644 _ => panic!("expected record"),
645 }
646 }
647
648 #[test]
649 fn run_classifier_naive_bayes() {
650 let mut m = BTreeMap::new();
651 m.insert("method".into(), Value::String("naive_bayes".into()));
652 m.insert(
653 "features".into(),
654 Value::List(vec![
655 Value::F64(1.0),
656 Value::F64(2.0),
657 Value::F64(1.1),
658 Value::F64(2.1),
659 Value::F64(5.0),
660 Value::F64(6.0),
661 Value::F64(5.1),
662 Value::F64(6.1),
663 ]),
664 );
665 m.insert(
666 "labels".into(),
667 Value::List(vec![
668 Value::U64(0),
669 Value::U64(0),
670 Value::U64(1),
671 Value::U64(1),
672 ]),
673 );
674 m.insert("n".into(), Value::U64(4));
675 m.insert("p".into(), Value::U64(2));
676 m.insert(
677 "query".into(),
678 Value::List(vec![Value::F64(1.0), Value::F64(2.0)]),
679 );
680 let result = run_classifier(&Value::Record(m), Span { start: 0, end: 0 });
681 assert!(result.is_ok());
682 }
683
684 #[test]
685 fn run_classifier_unknown_method() {
686 let mut m = BTreeMap::new();
687 m.insert("method".into(), Value::String("unknown".into()));
688 m.insert("features".into(), Value::List(vec![]));
689 m.insert("labels".into(), Value::List(vec![]));
690 m.insert("n".into(), Value::U64(0));
691 m.insert("p".into(), Value::U64(1));
692 m.insert("query".into(), Value::List(vec![Value::F64(0.0)]));
693 let result = run_classifier(&Value::Record(m), Span { start: 0, end: 0 });
694 assert!(result.is_err());
695 }
696
697 #[test]
698 fn constrained_decode_basic() {
699 let mut m = BTreeMap::new();
700 m.insert(
701 "vocab".into(),
702 Value::List(vec![
703 Value::List(vec![Value::U64(0), Value::String("hello".into())]),
704 Value::List(vec![Value::U64(1), Value::String("world".into())]),
705 ]),
706 );
707 let result = constrained_decode(&Value::Record(m), Span { start: 0, end: 0 });
708 assert!(result.is_ok());
709 match result.unwrap() {
710 Value::Record(rec) => {
711 assert!(rec.contains_key("grammar_state"));
712 assert!(rec.contains_key("active"));
713 }
714 _ => panic!("expected record"),
715 }
716 }
717
718 #[test]
719 #[cfg(not(target_arch = "wasm32"))]
720 fn unload_model_returns_cleared() {
721 let result = unload_model(&Value::Null, Span { start: 0, end: 0 });
722 assert!(result.is_ok());
723 match result.unwrap() {
724 Value::Record(rec) => {
725 assert_eq!(rec.get("unloaded"), Some(&Value::Bool(true)));
726 }
727 _ => panic!("expected record"),
728 }
729 }
730}