plan(vm): define wide local bytecode

Cargo.toml

@@ -27,6 +27,9 @@ name = "vm"
 [features]
 default = ["runtime", "cli", "cranelift-jit"]
 runtime = []
+async = ["runtime", "dep:reqwest", "dep:url", "dep:tokio", "dep:futures-util"]
+http-client = ["async"]
+sqlite = ["runtime", "dep:rusqlite"]
 edge-abi = [
  "dep:edge_abi",
  "edge_abi/console",
@@ -60,6 +63,11 @@ cranelift-jit = { version = "0.129.1", optional = true }
 cranelift-module = { version = "0.129.1", optional = true }
 cranelift-native = { version = "0.129.1", optional = true }
 pd-host-function = { path = "./pd-host-function", version = "0.1.0" }
+reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "stream"], optional = true }
+rusqlite = { version = "0.32", default-features = false, features = ["bundled", "hooks", "limits"], optional = true }
+url = { version = "2", optional = true }
+futures-util = { version = "0.3", optional = true }
+tokio = { version = "1", features = ["rt-multi-thread", "net", "time", "sync", "fs", "io-util", "process"], optional = true }
 edge_abi = { package = "pd-edge-abi", version = "0.1.1", default-features = false, optional = true }
 futures-channel = "0.3"
 paste = "1"
@@ -77,6 +85,7 @@ windows-sys = { version = "0.59", features = ["Win32_System_Diagnostics_Debug",
 libc = "0.2"
 
 [dev-dependencies]
+futures-util = "0.3"
 syn = { version = "2", features = ["full"] }
 tokio = { version = "1", features = ["macros", "rt", "time", "sync"] }
 
@@ -85,5 +94,15 @@ name = "host_binding_generation_tests"
 path = "tests/host_binding_generation_tests.rs"
 required-features = ["cranelift-jit"]
 
+[[test]]
+name = "http_host_tests"
+path = "tests/vm/http_host_tests.rs"
+required-features = ["runtime", "http-client"]
+
+[[test]]
+name = "sqlite_host_tests"
+path = "tests/vm/sqlite_host_tests.rs"
+required-features = ["sqlite"]
+
 [build-dependencies]
 syn = { version = "2", features = ["full"] }

build.rs

@@ -115,6 +115,7 @@ struct CallableDecl {
  wrapper: Option<WrapperDecl>,
  host_binding_kind: HostBindingKind,
  host_execution: HostExecutionKind,
+ runtime_owned_pending: bool,
 }
 
 #[derive(Clone, Debug)]
@@ -149,11 +150,32 @@ fn main() {
  println!("cargo:rerun-if-changed={}", catalog_path.display());
  let catalog = parse_catalog(&catalog_path);
 
- let host_sources = [SourceSpec {
- path: "src/builtins/runtime/host.rs".to_string(),
- module: "host".to_string(),
- category: SourceCategory::DefaultHost,
- }];
+ let mut host_sources = vec![
+ SourceSpec {
+ path: "src/builtins/runtime/host.rs".to_string(),
+ module: "host".to_string(),
+ category: SourceCategory::DefaultHost,
+ },
+ SourceSpec {
+ path: "src/builtins/runtime/context_host.rs".to_string(),
+ module: "context_host".to_string(),
+ category: SourceCategory::DefaultHost,
+ },
+ ];
+ if env::var_os("CARGO_FEATURE_ASYNC").is_some() {
+ host_sources.push(SourceSpec {
+ path: "src/builtins/runtime/http.rs".to_string(),
+ module: "http".to_string(),
+ category: SourceCategory::DefaultHost,
+ });
+ }
+ if env::var_os("CARGO_FEATURE_SQLITE").is_some() {
+ host_sources.push(SourceSpec {
+ path: "src/builtins/runtime/sqlite.rs".to_string(),
+ module: "sqlite".to_string(),
+ category: SourceCategory::DefaultHost,
+ });
+ }
  let builtin_sources = builtin_source_specs(&namespaces);
  let core_sources = [SourceSpec {
  path: "src/builtins/runtime/core.rs".to_string(),
@@ -229,10 +251,21 @@ fn write_generated_file(path: &Path, contents: &str) {
 fn builtin_source_specs(namespaces: &[NamespaceDecl]) -> Vec<SourceSpec> {
  namespaces
  .iter()
- .map(|namespace| SourceSpec {
- path: format!("src/builtins/runtime/{}.rs", namespace.module),
- module: namespace.module.clone(),
- category: SourceCategory::NamespacedBuiltin,
+ .map(|namespace| {
+ let path = if namespace.module == "io" {
+ if cfg!(feature = "async") {
+ "src/builtins/runtime/io/async_io.rs".to_string()
+ } else {
+ "src/builtins/runtime/io/blocking.rs".to_string()
+ }
+ } else {
+ format!("src/builtins/runtime/{}.rs", namespace.module)
+ };
+ SourceSpec {
+ path,
+ module: namespace.module.clone(),
+ category: SourceCategory::NamespacedBuiltin,
+ }
  })
  .collect()
 }
@@ -254,6 +287,9 @@ fn parse_sources(
 }
 
 pub(crate) fn classify_host_binding(function: &ItemFn) -> HostBindingKind {
+ if function.sig.asyncness.is_some() {
+ return HostBindingKind::StaticStack;
+ }
  if function.sig.inputs.iter().any(|input| match input {
  FnArg::Typed(pat_type) => is_vm_context_type(&pat_type.ty),
  _ => false,
@@ -279,6 +315,9 @@ pub(crate) fn classify_host_binding(function: &ItemFn) -> HostBindingKind {
 }
 
 pub(crate) fn infer_host_execution(function: &ItemFn) -> HostExecutionKind {
+ if function.sig.asyncness.is_some() {
+ return HostExecutionKind::MaySuspend;
+ }
  let return_type = normalized_return_type(&function.sig.output);
  if contains_host_call_result(&return_type) {
  HostExecutionKind::MaySuspend
@@ -425,6 +464,8 @@ fn parse_source_file(path: &Path, spec: &SourceSpec, _order_offset: usize) -> Ve
  wrapper,
  host_binding_kind: classify_host_binding(function),
  host_execution: infer_host_execution(function),
+ runtime_owned_pending: function.sig.asyncness.is_none()
+ && contains_host_call_result(&normalized_return_type(&function.sig.output)),
  });
  }
  out
@@ -934,6 +975,7 @@ fn render_builtin_catalog(
 
  writeln!(&mut out, "impl BuiltinFunction {{").unwrap();
  render_builtin_name_method(&mut out, &builtin_variant_order, &actual_builtin_by_variant);
+ render_builtin_capability_method(&mut out, builtin_callables);
  render_builtin_arity_method(&mut out, &builtin_variant_order, &actual_builtin_by_variant);
  render_builtin_accepts_arity_method(
  &mut out,
@@ -1075,6 +1117,14 @@ fn render_builtin_runtime_dispatch(
  )
  .unwrap();
  }
+ if callable.runtime_owned_pending {
+ writeln!(
+ &mut out,
+ " registry.mark_runtime_owned_pending({:?});",
+ callable.name
+ )
+ .unwrap();
+ }
  }
  writeln!(&mut out, "}}").unwrap();
  writeln!(&mut out).unwrap();
@@ -1091,6 +1141,14 @@ fn render_builtin_runtime_dispatch(
  .render_bind_static_call(&callable.name, &host_wrapper_adapter_name(callable));
  writeln!(&mut out, " {:?} => {{", callable.name).unwrap();
  writeln!(&mut out, " {bind_call}").unwrap();
+ if callable.runtime_owned_pending {
+ writeln!(
+ &mut out,
+ " vm.mark_runtime_owned_pending_binding({:?});",
+ callable.name
+ )
+ .unwrap();
+ }
  writeln!(&mut out, " true").unwrap();
  writeln!(&mut out, " }}").unwrap();
  }
@@ -1408,6 +1466,35 @@ fn render_builtin_name_method(
  writeln!(out).unwrap();
 }
 
+fn render_builtin_capability_method(out: &mut String, builtin_callables: &[CallableDecl]) {
+ let mut capability_variants = Vec::new();
+ for callable in builtin_callables {
+ let variant = builtin_variant_name(&callable.name);
+ if !capability_variants.contains(&variant) {
+ capability_variants.push(variant);
+ }
+ }
+ capability_variants.sort();
+ writeln!(out, " #[cfg(feature = \"runtime\")]").unwrap();
+ writeln!(
+ out,
+ " pub(crate) const fn requires_explicit_host_capability(self) -> bool {{"
+ )
+ .unwrap();
+ if capability_variants.is_empty() {
+ writeln!(out, " false").unwrap();
+ } else {
+ let patterns = capability_variants
+ .iter()
+ .map(|variant| format!("BuiltinFunction::{variant}"))
+ .collect::<Vec<_>>()
+ .join(" | ");
+ writeln!(out, " matches!(self, {patterns})").unwrap();
+ }
+ writeln!(out, " }}").unwrap();
+ writeln!(out).unwrap();
+}
+
 fn render_builtin_arity_method(
  out: &mut String,
  builtin_variant_order: &[String],
@@ -1830,6 +1917,9 @@ fn host_wrapper_adapter_name(callable: &CallableDecl) -> String {
 
 fn generated_wrapper_decl(function: &ItemFn) -> WrapperDecl {
  let mut params = Vec::new();
+ if function.sig.asyncness.is_some() {
+ params.push(WrapperParamKind::Vm);
+ }
  for input in &function.sig.inputs {
  let FnArg::Typed(pat_type) = input else {
  panic!("methods are not supported in #[pd_host_function] declarations");
@@ -1856,6 +1946,13 @@ fn parse_callable_params(function: &ItemFn) -> Vec<CallableParamDecl> {
  let FnArg::Typed(pat_type) = input else {
  panic!("methods are not supported in #[pd_host_function] declarations");
  };
+ if pat_type
+ .attrs
+ .iter()
+ .any(|attr| attr.path().is_ident("pd_host_context"))
+ {
+ return None;
+ }
  if is_vm_context_type(&pat_type.ty) {
  return None;
  }
@@ -2022,7 +2119,7 @@ fn type_label(ty: &Type) -> String {
  };
  format!("{} | null", type_label(inner))
  }
- "VmResult" | "HostCallResult" => {
+ "VmResult" | "HostCallResult" | "HostFutureOutput" => {
  let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
  panic!("{ident}<T> requires one generic argument");
  };

crates/rustscript/Cargo.toml

@@ -16,6 +16,8 @@ runtime = ["pd_vm_crate/runtime"]
 edge-abi = ["pd_vm_crate/edge-abi"]
 cli = ["pd_vm_crate/cli"]
 cranelift-jit = ["pd_vm_crate/cranelift-jit"]
+http-client = ["runtime", "pd_vm_crate/http-client"]
+sqlite = ["pd_vm_crate/sqlite"]
 
 [dependencies]
-pd_vm_crate = { package = "pd-vm", path = "../..", version = ">=0.1.0, <1.0.0" }
+pd_vm_crate = { package = "pd-vm", path = "../..", version = "=0.1.0", default-features = false }

crates/rustscript/tests/alias_smoke.rs

@@ -1,3 +1,6 @@
+#[cfg(feature = "sqlite")]
+use rustscript::SqliteHostExt;
+
 /// Verify that the `rustscript` alias crate re-exports the same API as `pd-vm`.
 #[test]
 fn alias_exports_compile_source() {
@@ -21,3 +24,51 @@ fn alias_exports_op_code() {
  let _ = rustscript::OpCode::Nop;
  let _ = rustscript::OpCode::Add;
 }
+
+#[cfg(feature = "runtime")]
+#[test]
+fn alias_exports_public_invocation_stream_contract() {
+ fn accept_item(_item: rustscript::InvocationItem) {}
+
+ accept_item(rustscript::InvocationItem::Complete(
+ rustscript::Value::Null,
+ ));
+ accept_item(rustscript::InvocationItem::Event(rustscript::Value::Bool(
+ true,
+ )));
+
+ fn accept_poll(_poll: rustscript::InvocationPoll) {}
+ accept_poll(rustscript::InvocationPoll::Pending);
+ accept_poll(rustscript::InvocationPoll::Ready(None));
+ accept_poll(rustscript::InvocationPoll::Ready(Some(Ok(
+ rustscript::InvocationItem::Complete(rustscript::Value::Null),
+ ))));
+
+ fn accept_error(_error: rustscript::InvocationError) {}
+ accept_error(rustscript::InvocationError::Cancelled(
+ rustscript::CancellationReason::Requested,
+ ));
+ accept_error(rustscript::InvocationError::Host {
+ message: "boom".to_string(),
+ });
+}
+
+#[cfg(feature = "http-client")]
+#[test]
+fn alias_http_client_includes_runtime_contract() {
+ fn accept_runtime_result(_result: rustscript::RuntimeResult<()>) {}
+
+ accept_runtime_result(Ok(()));
+}
+
+#[cfg(feature = "sqlite")]
+#[test]
+fn alias_exports_public_sqlite_configuration() {
+ let program = rustscript::compile_source("0;")
+ .expect("minimal alias SQLite program should compile")
+ .program;
+ let mut vm = rustscript::Vm::new(program);
+ vm.configure_sqlite(rustscript::SqlitePolicy::default());
+ let _limits = rustscript::SqliteLimits::default();
+ vm.clear_sqlite_configuration();
+}