//! The pure providers a frame binds in place of the host
//! ([`blue_lang_waku::Provision`]): a deterministic stepped clock, a seeded
//! PRNG, a filesystem as an in-memory overlay or a null sink, the wire's
//! two channels over an in-process loopback, and the threshold words over a
//! seeded stream. Each interpreter gets its own
//! provider state, as each process owns its interpreter.
use std::collections::{BTreeMap, BTreeSet};
use std::sync::{Arc, Mutex, MutexGuard};
use blue_lang_waku::{Provision, Provisions};
use tatara_lisp_eval::ffi::Arity;
use tatara_lisp_eval::{EvalError, Interpreter, Value};
use crate::sys::{arg_int, arg_str};
/// The name a provider binds one of its capability's words under.
pub(crate) type Key = fn(&'static str) -> String;
/// Bind every provider in `provisions` into `interp`. A whole-program
/// provider binds its capability's names over whatever the host or a refusal
/// bound to them; a scoped one binds them under [`crate::provided_name`],
/// where [`crate::Hold::rebind_scoped`] moved the references its packages
/// write.
pub fn provide<H: 'static>(
interp: &mut Interpreter<H>,
provisions: &Provisions,
) -> Option<crate::wire::ClockRead> {
let mut frame_clock = None;
let mut links = Vec::new();
for p in provisions.iter() {
let key: Key = if p.scope.is_some() {
crate::provided_name
} else {
String::from
};
match &p.provision {
Provision::DeterministicStepped { at_ms, step_ms } => {
let peek = clock(interp, key, *at_ms, *step_ms);
if p.scope.is_none() {
frame_clock = Some(peek);
}
}
Provision::SeededPrng { seed } => entropy(interp, key, seed),
Provision::InMemoryOverlay => filesystem(interp, key, true),
Provision::NullSink => filesystem(interp, key, false),
Provision::Loopback { channel } => links.push((key, *channel)),
Provision::Seeded { seed } => crate::threshold::provide_seeded(interp, key, seed),
}
}
if !links.is_empty() {
let net = Arc::new(crate::wire::LoopbackNet::default());
let read = frame_clock.clone().unwrap_or_else(crate::wire::host_clock);
for (key, channel) in links {
crate::wire::provide_loopback(interp, key, channel, &net, Arc::clone(&read));
}
}
frame_clock
}
fn locked<T>(m: &Mutex<T>) -> MutexGuard<'_, T> {
m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
fn str_value(s: impl Into<String>) -> Value {
Value::Str(Arc::from(s.into()))
}
fn clock<H: 'static>(
interp: &mut Interpreter<H>,
key: Key,
at_ms: i64,
step_ms: i64,
) -> crate::wire::ClockRead {
let t = Arc::new(Mutex::new(at_ms));
let peek = {
let t = Arc::clone(&t);
Arc::new(move || *locked(&t))
};
let read = {
let t = Arc::clone(&t);
Arc::new(move || {
let mut g = locked(&t);
let now = *g;
*g = g.saturating_add(step_ms);
now
})
};
let advance = Arc::new(move |ms: i64| {
let mut g = locked(&t);
*g = g.saturating_add(ms.max(0));
});
let r = Arc::clone(&read);
interp.register_fn(
key("now_ms"),
Arity::Exact(0),
move |_: &[Value], _: &mut H, _| Ok(Value::Int(r())),
);
let r = Arc::clone(&read);
interp.register_fn(
key("now"),
Arity::Exact(0),
move |_: &[Value], _: &mut H, _| Ok(Value::Int(r().div_euclid(1000))),
);
let r = Arc::clone(&read);
interp.register_fn(
key("now_ns"),
Arity::Exact(0),
move |_: &[Value], _: &mut H, _| Ok(Value::Int(r().saturating_mul(1_000_000))),
);
let r = Arc::clone(&read);
interp.register_fn(
key("now_rfc3339"),
Arity::Exact(0),
move |_: &[Value], _: &mut H, _| {
Ok(str_value(crate::sys::format_rfc3339_utc(
r().div_euclid(1000),
)))
},
);
let r = Arc::clone(&read);
interp.register_fn(
key("elapsed_since"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let start = arg_int(&a[0], "elapsed_since", span)?;
Ok(Value::Int(
r().saturating_mul(1_000_000).saturating_sub(start),
))
},
);
let adv = Arc::clone(&advance);
interp.register_fn(
key("sleep"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
adv(arg_int(&a[0], "sleep", span)?.saturating_mul(1000));
Ok(Value::Nil)
},
);
interp.register_fn(
key("sleep_ms"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
advance(arg_int(&a[0], "sleep_ms", span)?);
Ok(Value::Nil)
},
);
peek
}
fn entropy<H: 'static>(interp: &mut Interpreter<H>, key: Key, seed: &str) {
let stream = Mutex::new(
blake3::Hasher::new_derive_key("blue seeded-entropy 2026-10-30")
.update(seed.as_bytes())
.finalize_xof(),
);
interp.register_fn(
key("random_bytes"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let count = crate::entropy::count_of(&a[0])
.map_err(|e| EvalError::native_fn("random_bytes", e.to_string(), span))?;
let mut bytes = vec![0u8; count];
locked(&stream).fill(&mut bytes);
Ok(Value::list(
bytes.into_iter().map(|b| Value::Int(i64::from(b))),
))
},
);
}
#[derive(Default)]
struct Tree {
files: BTreeMap<String, String>,
dirs: BTreeSet<String>,
}
impl Tree {
fn is_dir(&self, p: &str) -> bool {
p == "/" || self.dirs.contains(p)
}
fn parents(&mut self, p: &str) {
let mut at = parent(p);
while at != "/" {
self.dirs.insert(at.clone());
at = parent(&at);
}
}
fn under<'a>(&'a self, root: &'a str) -> impl Iterator<Item = &'a String> + 'a {
let prefix = if root == "/" {
"/".to_string()
} else {
format!("{root}/")
};
self.files.keys().filter(move |f| f.starts_with(&prefix))
}
}
fn absolute(p: &str) -> String {
let parts: Vec<&str> = p
.split('/')
.filter(|s| !s.is_empty() && *s != ".")
.collect();
format!("/{}", parts.join("/"))
}
fn parent(p: &str) -> String {
match p.rfind('/') {
Some(0) | None => "/".to_string(),
Some(i) => p[..i].to_string(),
}
}
fn absent(word: &'static str, path: &str, span: tatara_lisp::Span) -> EvalError {
EvalError::native_fn(
word,
format!("{path}: no such file or directory (virtual filesystem)"),
span,
)
}
fn segments_match(pattern: &[&str], path: &[&str]) -> bool {
match (pattern.first(), path.first()) {
(None, None) => true,
(Some(&"**"), _) => {
segments_match(&pattern[1..], path)
|| (!path.is_empty() && segments_match(pattern, &path[1..]))
}
(Some(p), Some(s)) => {
crate::sys::glob_match(p, s) && segments_match(&pattern[1..], &path[1..])
}
_ => false,
}
}
#[allow(clippy::too_many_lines)]
fn filesystem<H: 'static>(interp: &mut Interpreter<H>, key: Key, keep: bool) {
let tree = Arc::new(Mutex::new(Tree::default()));
let path_of = |a: &Value, word: &'static str, span| -> Result<String, EvalError> {
Ok(absolute(&arg_str(a, word, span)?))
};
let t = Arc::clone(&tree);
interp.register_fn(
key("read_file"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "read_file", span)?;
locked(&t)
.files
.get(&p)
.map(|s| str_value(s.clone()))
.ok_or_else(|| absent("read_file", &p, span))
},
);
let write = {
let t = Arc::clone(&tree);
Arc::new(move |p: String, text: String, append: bool| {
if keep {
let mut g = locked(&t);
g.parents(&p);
let slot = g.files.entry(p).or_default();
if !append {
slot.clear();
}
slot.push_str(&text);
}
})
};
let w = Arc::clone(&write);
interp.register_fn(
key("write_file"),
Arity::Exact(2),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "write_file", span)?;
w(p, arg_str(&a[1], "write_file", span)?.to_string(), false);
Ok(Value::Nil)
},
);
let w = Arc::clone(&write);
interp.register_fn(
key("append_file"),
Arity::Exact(2),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "append_file", span)?;
w(p, arg_str(&a[1], "append_file", span)?.to_string(), true);
Ok(Value::Nil)
},
);
let w = Arc::clone(&write);
interp.register_fn(
key("write_program"),
Arity::Exact(2),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "write_program", span)?;
let source = arg_str(&a[1], "write_program", span)?;
let canonical = blue_lang_fmt::format_source_lossless(&source).map_err(|e| {
EvalError::native_fn(
"write_program",
format!("{p}: the program does not parse: {e}"),
span,
)
})?;
w(p, canonical, false);
Ok(Value::Nil)
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("file_size"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "file_size", span)?;
let len = locked(&t)
.files
.get(&p)
.map(String::len)
.ok_or_else(|| absent("file_size", &p, span))?;
Ok(Value::Int(i64::try_from(len).unwrap_or(i64::MAX)))
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("file_mtime_ms"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "file_mtime_ms", span)?;
if locked(&t).files.contains_key(&p) {
Ok(Value::Int(0))
} else {
Err(absent("file_mtime_ms", &p, span))
}
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("is_file?"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "is_file?", span)?;
Ok(Value::Bool(locked(&t).files.contains_key(&p)))
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("is_dir?"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "is_dir?", span)?;
Ok(Value::Bool(locked(&t).is_dir(&p)))
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("path_exists"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "path_exists", span)?;
let g = locked(&t);
Ok(Value::Bool(g.files.contains_key(&p) || g.is_dir(&p)))
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("ls"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "ls", span)?;
let g = locked(&t);
if !g.is_dir(&p) {
return Err(absent("ls", &p, span));
}
let entries: BTreeSet<String> = g
.files
.keys()
.chain(g.dirs.iter())
.filter(|e| *e != &p && parent(e) == p)
.cloned()
.collect();
Ok(Value::list(entries.into_iter().map(str_value)))
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("walk_dir"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "walk_dir", span)?;
let g = locked(&t);
Ok(Value::list(g.under(&p).cloned().map(str_value)))
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("glob"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let pattern = arg_str(&a[0], "glob", span)?;
if pattern.starts_with('/') {
return Ok(Value::list(Vec::<Value>::new()));
}
let wanted: Vec<&str> = pattern.split('/').filter(|s| !s.is_empty()).collect();
let g = locked(&t);
let hits: Vec<Value> = g
.files
.keys()
.filter(|f| {
let rel: Vec<&str> = f.split('/').filter(|s| !s.is_empty()).collect();
segments_match(&wanted, &rel)
})
.map(|f| str_value(f.trim_start_matches('/')))
.collect();
Ok(Value::list(hits))
},
);
for word in ["mkdir", "mkdir_p"] {
let t = Arc::clone(&tree);
interp.register_fn(
key(word),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], word, span)?;
if keep && p != "/" {
let mut g = locked(&t);
g.parents(&p);
g.dirs.insert(p);
}
Ok(Value::Nil)
},
);
}
let t = Arc::clone(&tree);
interp.register_fn(
key("rm"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "rm", span)?;
locked(&t)
.files
.remove(&p)
.map(|_| Value::Nil)
.ok_or_else(|| absent("rm", &p, span))
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("rm_rf"),
Arity::Exact(1),
move |a: &[Value], _: &mut H, span| {
let p = path_of(&a[0], "rm_rf", span)?;
let mut g = locked(&t);
let prefix = format!("{p}/");
g.files.retain(|f, _| *f != p && !f.starts_with(&prefix));
g.dirs.retain(|d| *d != p && !d.starts_with(&prefix));
Ok(Value::Nil)
},
);
let t = Arc::clone(&tree);
interp.register_fn(
key("rename_file"),
Arity::Exact(2),
move |a: &[Value], _: &mut H, span| {
let from = path_of(&a[0], "rename_file", span)?;
let to = path_of(&a[1], "rename_file", span)?;
let mut g = locked(&t);
let text = g
.files
.remove(&from)
.ok_or_else(|| absent("rename_file", &from, span))?;
g.parents(&to);
g.files.insert(to, text);
Ok(Value::Nil)
},
);
interp.register_fn(key("cwd"), Arity::Exact(0), |_: &[Value], _: &mut H, _| {
Ok(str_value("/"))
});
crate::sys::install_path_words(interp, key);
}
#[cfg(test)]
mod tests {
use super::*;
fn eval(provisions: &[Provision], src: &str) -> Result<String, String> {
let mut interp = crate::interpreter_hostless();
let mut ps = Provisions::default();
for p in provisions {
ps.add(p.clone()).unwrap();
}
provide(&mut interp, &ps);
let forms = tatara_lisp::read_spanned(src).map_err(|e| e.to_string())?;
interp
.eval_program(&forms, &mut ())
.map(|v| v.to_string())
.map_err(|e| e.to_string())
}
fn ok(provisions: &[Provision], src: &str) -> String {
eval(provisions, src).unwrap_or_else(|e| panic!("{src}: {e}"))
}
#[test]
fn a_stepped_clock_reads_its_start_and_steps_and_a_sleep_advances_without_waiting() {
let c = [Provision::DeterministicStepped {
at_ms: 1_000,
step_ms: 10,
}];
assert_eq!(
ok(&c, "(list (now_ms) (now_ms) (now_ms))"),
"(1000 1010 1020)"
);
let started = std::time::Instant::now();
assert_eq!(ok(&c, "(begin (sleep_ms 60000) (now_ms))"), "61000");
assert!(started.elapsed() < std::time::Duration::from_secs(5));
assert_eq!(ok(&c, "(begin (sleep 2) (now))"), "3");
let fixed = [Provision::DeterministicStepped {
at_ms: 86_400_000,
step_ms: 0,
}];
assert_eq!(
ok(&fixed, "(list (now_ms) (now_ms))"),
"(86400000 86400000)"
);
assert_eq!(ok(&fixed, "(now_rfc3339)"), "\"1970-01-02T00:00:00Z\"");
assert_eq!(ok(&fixed, "(elapsed_since (now_ns))"), "0");
}
#[test]
fn seeded_entropy_is_one_stream_per_seed() {
let a = [Provision::SeededPrng { seed: "a".into() }];
let b = [Provision::SeededPrng { seed: "b".into() }];
let first = ok(&a, "(random_bytes 8)");
assert_eq!(
first,
ok(&a, "(random_bytes 8)"),
"the same seed gives the same bytes"
);
assert_ne!(
first,
ok(&b, "(random_bytes 8)"),
"another seed gives others"
);
let two = ok(&a, "(list (random_bytes 4) (random_bytes 4))");
assert_ne!(
two,
format!("({0} {0})", ok(&a, "(random_bytes 4)")),
"the stream moves on"
);
assert!(eval(&a, "(random_bytes -1)").is_err());
}
#[test]
fn an_in_memory_overlay_keeps_what_the_run_writes_and_reads_nothing_of_the_host() {
let m = [Provision::InMemoryOverlay];
assert_eq!(
ok(&m, "(begin (write_file \"a/b.txt\" \"hi\") (append_file \"/a/b.txt\" \"!\") (list (read_file \"/a/b.txt\") (is_dir? \"/a\") (is_file? \"a/b.txt\") (file_size \"a/b.txt\") (ls \"/a\") (glob \"**/*.txt\") (cwd)))"),
"(\"hi!\" #t #t 3 (\"/a/b.txt\") (\"a/b.txt\") \"/\")"
);
assert_eq!(
ok(&m, "(begin (write_file \"x\" \"1\") (rename_file \"x\" \"d/y\") (list (path_exists \"x\") (read_file \"d/y\") (walk_dir \"/\") (begin (rm_rf \"d\") (walk_dir \"/\"))))"),
"(#f \"1\" (\"/d/y\") ())"
);
assert!(eval(&m, "(read_file \"/etc/hosts\")")
.unwrap_err()
.contains("virtual filesystem"));
assert!(eval(&m, "(rm \"nothing\")").is_err());
assert_eq!(ok(&m, "(path_join \"a\" \"b\")"), "\"a/b\"");
}
#[test]
fn a_null_sink_drops_every_write() {
let n = [Provision::NullSink];
assert_eq!(
ok(&n, "(begin (write_file \"a\" \"x\") (mkdir_p \"d\") (list (path_exists \"a\") (is_dir? \"d\") (walk_dir \"/\")))"),
"(#f #f ())"
);
assert!(eval(&n, "(read_file \"a\")").is_err());
}
#[test]
fn a_provider_replaces_every_name_of_its_capability_and_no_other() {
use blue_lang_waku::Capability;
let mut interp = crate::interpreter_hostless();
let refused: Vec<_> = [Capability::FileSystem, Capability::Environment]
.into_iter()
.flat_map(|c| c.names().into_iter().map(move |n| (n, c)))
.collect();
crate::refuse_host_names(&mut interp, &refused, "the test");
let mut ps = Provisions::default();
ps.add(Provision::InMemoryOverlay).unwrap();
provide(&mut interp, &ps);
let breaches = |name: &str, interp: &mut Interpreter<()>| {
let forms = tatara_lisp::read_spanned(&format!("({name})")).unwrap();
matches!(interp.eval_program(&forms, &mut ()), Err(e) if crate::is_breach(&e))
};
for name in Capability::FileSystem.names() {
assert!(!breaches(name, &mut interp), "{name} is provided");
}
assert!(breaches("getenv", &mut interp), "environment stays refused");
}
#[test]
fn a_scoped_provider_binds_every_name_of_its_capability_under_its_alias_and_leaves_the_bare_name_to_the_frame(
) {
use blue_lang_waku::{Capability, Provided};
for p in [
Provision::DeterministicStepped {
at_ms: 7,
step_ms: 0,
},
Provision::SeededPrng { seed: "s".into() },
Provision::InMemoryOverlay,
Provision::NullSink,
Provision::Loopback {
channel: blue_lang_waku::Channel::Flash,
},
Provision::Loopback {
channel: blue_lang_waku::Channel::Tide,
},
Provision::Seeded { seed: "s".into() },
] {
let cap = p.capability();
let mut interp = crate::interpreter_hostless();
let refused: Vec<_> = cap.names().into_iter().map(|n| (n, cap)).collect();
crate::refuse_host_names(&mut interp, &refused, "the test");
let mut ps = Provisions::default();
ps.add(Provided {
provision: p.clone(),
scope: Some(std::iter::once("rede".to_string()).collect()),
})
.unwrap();
provide(&mut interp, &ps);
for name in cap.names() {
let alias = crate::provided_name(name);
assert!(
interp.lookup_global(&alias).is_some(),
"{}: {alias} is bound",
p.name()
);
let forms = tatara_lisp::read_spanned(&format!("({name})")).unwrap();
assert!(
matches!(interp.eval_program(&forms, &mut ()), Err(e) if crate::is_breach(&e)),
"{}: bare {name} is the frame's",
p.name()
);
}
if cap == Capability::Clock {
let forms = tatara_lisp::read_spanned("(%provided/now_ms)").unwrap();
assert_eq!(
interp.eval_program(&forms, &mut ()).unwrap().to_string(),
"7"
);
}
}
}
fn wired(provisions: &[Provision], src: &str) -> Result<String, String> {
let mut interp = crate::interpreter_hostless();
crate::wire::install_wire(&mut interp);
let mut ps = Provisions::default();
for p in provisions {
ps.add(p.clone()).unwrap();
}
provide(&mut interp, &ps);
let forms = tatara_lisp::read_spanned(src).map_err(|e| e.to_string())?;
interp
.eval_program(&forms, &mut ())
.map(|v| v.to_string())
.map_err(|e| e.to_string())
}
fn loopback() -> Vec<Provision> {
vec![
Provision::Loopback {
channel: blue_lang_waku::Channel::Flash,
},
Provision::Loopback {
channel: blue_lang_waku::Channel::Tide,
},
]
}
#[test]
fn a_loopback_link_carries_both_channels_in_process_and_resolves_no_name() {
let src = "(begin (define a (tide_open (flash_open \"127.0.0.1:0\"))) (define b (tide_open (flash_open \"127.0.0.1:0\"))) (define to (get (flash_stats b) :address)) (flash_put a to \"alert\") (tide_send a to \"bulk\" 7) (define f (flash_next b 0)) (define t (tide_next b 0)) (list to (get f :payload) (get f :from) (get t :payload) (get t :sent_ms) (flash_next b 60000) (tide_next b 60000)))";
let started = std::time::Instant::now();
assert_eq!(
wired(&loopback(), src).unwrap(),
"(\"127.0.0.1:49153\" \"alert\" \"127.0.0.1:49152\" \"bulk\" 7 () ())"
);
assert!(
started.elapsed() < std::time::Duration::from_secs(5),
"an empty loopback inbox answers at once"
);
let named = wired(&loopback(), "(flash_open \"localhost:0\")").unwrap_err();
assert!(named.contains("resolves no name"), "{named}");
let peer = wired(
&loopback(),
"(flash_put (flash_open \"127.0.0.1:0\") \"localhost:9\" \"x\")",
)
.unwrap_err();
assert!(peer.contains("resolves no name"), "{peer}");
let taken = wired(
&loopback(),
"(begin (define keep (flash_open \"127.0.0.1:7\")) (flash_open \"127.0.0.1:7\"))",
)
.unwrap_err();
assert!(taken.contains("in use"), "{taken}");
}
#[test]
fn a_loopback_word_refuses_a_host_socket() {
let mut interp = crate::interpreter_hostless();
crate::wire::install_wire(&mut interp);
let host = interp
.eval_program(
&tatara_lisp::read_spanned("(tide_open \"127.0.0.1:0\")").unwrap(),
&mut (),
)
.unwrap();
let mut ps = Provisions::default();
ps.add(Provision::Loopback {
channel: blue_lang_waku::Channel::Flash,
})
.unwrap();
provide(&mut interp, &ps);
interp.define_global("host", host);
let joined = interp
.eval_program(
&tatara_lisp::read_spanned("(flash_open host)").unwrap(),
&mut (),
)
.unwrap_err()
.to_string();
assert!(joined.contains("reaches no socket"), "{joined}");
}
#[test]
fn the_host_rate_reads_a_whole_program_stepped_clock_so_a_virtual_sleep_refills_it() {
let mut ps = vec![Provision::DeterministicStepped {
at_ms: 0,
step_ms: 0,
}];
ps.extend(loopback());
let big = "x".repeat(1279);
let src = format!(
"(begin (define w (flash_open \"127.0.0.1:0\")) (define big \"{big}\") (define sent (map (lambda (i) (flash_put w \"127.0.0.1:9\" big)) (list 1 2 3 4 5 6 7 8 9 10 11 12))) (define refused (try (flash_put w \"127.0.0.1:9\" big) (catch (e) (list (blue-field e :kind) (blue-field (blue-field e :data) :wait_ms))))) (sleep_ms 15) (define early (try (flash_put w \"127.0.0.1:9\" big) (catch (e) (blue-field e :kind)))) (sleep_ms 1) (list (length sent) refused early (flash_put w \"127.0.0.1:9\" big) (get (flash_stats w) :refused)))"
);
assert_eq!(
wired(&ps, &src).unwrap(),
"(12 (:rate_limited 16) :rate_limited 1280 2)"
);
let scoped = blue_lang_waku::Provided {
provision: Provision::DeterministicStepped {
at_ms: 0,
step_ms: 0,
},
scope: Some(std::iter::once("rede".to_string()).collect()),
};
let mut interp = crate::interpreter_hostless();
let mut only = Provisions::default();
only.add(scoped).unwrap();
assert!(
provide(&mut interp, &only).is_none(),
"a scoped clock is not the frame's: the rate reads the host's"
);
let mut whole = Provisions::default();
whole
.add(Provision::DeterministicStepped {
at_ms: 42,
step_ms: 5,
})
.unwrap();
let read = provide(&mut interp, &whole).expect("a whole-program clock is the frame's");
assert_eq!(
(read(), read()),
(42, 42),
"the rate peeks, it never steps the clock"
);
}
}