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();
+}