Host values in BAML (#3571)

The problem: we want to be able to pass lambdas/closures/function
pointers into BAML from a host language in a type-safe way and let BAML
call it as if it were a normal BAML function. BAML->host handles already
exist in the language, allowing the host language to own opaque BAML
values. This PR implements the opposite: a way to have opaque handles to
host values in BAML.

## Lifecycle
1. A code-genned BAML function is called by the host language, passing
in an opaque/non-serializable value (such as a
callable/function/closure)
2. The bridge (on the host side) saves a reference to the value and
creates a new host value id. It ensures the host will not deallocate the
value until BAML informs it that it no longer has any references.
3. The bridge passes the newly created host value id across the ffi
boundary as an opaque handle.
4. The BAML side decodes the host value based on type. Currently this is
only host callables (BAML function-typed).
5. (for callables) When a BAML function call occurs on a host callable,
it will dispatch back across the host boundary with a new host call
operation.
6. When a host value handle is dropped in BAML (there are no references
to it and the GC runs on it), a message is sent to the bridge to notify
it that it may release the (real) value.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Pass host-language functions as callable parameters and invoke them
from BAML.
* Structured host-callable errors surfaced as a catchable
baml.errors.HostCallable with message/class/category/traceback.
* Cross-platform runtime support (Python, Node.js, Go, WASM) for
registering, dispatching and completing host callables.
* Strict host-return validation against declared types; sync-path
encoding fast-fails for host-callable args to avoid main-thread hangs.

<!-- review_stack_entry_start -->

[![Review Change
Stack](https://storage.googleapis.com/coderabbit_public_assets/review-stack-in-coderabbit-ui.svg)](https://app.coderabbit.ai/change-stack/BoundaryML/baml/pull/3571?utm_source=github_walkthrough&utm_medium=github&utm_campaign=change_stack)

<!-- review_stack_entry_end -->
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: 2kai2kai2

baml_language/Cargo.lock

@@ -54,3 +54,11 @@ class DevOther {
 class HostPanic {
   message string
 }
+
+class HostCallable {
+  message string
+  class_name string
+  language string
+  traceback string?
+  category int
+}

baml_language/crates/baml_builtins2/baml_std/baml/ns_errors/errors.baml

@@ -0,0 +1,18 @@
+/// Internal: invoked only by compiler-synthesized host-callable wrapper
+/// closures. Not directly callable by user code.
+///
+/// `T` is the expected return type, delivered to the native handler at
+/// runtime via the type-arg channel. The handler validates both the
+/// inbound `args` and the host's returned value against the declared
+/// signature, raising `root.errors.HostCallable` on mismatch.
+function call_host_value<T>(handle: HostValue, args: unknown[])
+    -> T throws root.errors.HostCallable {
+  $rust_io_function
+}
+
+/// Opaque builtin class. Construction is reserved to the bridge
+/// boundary; users cannot construct or destructure it.
+class HostValue {
+  // intentionally empty; the value lives in the BexExternalValue
+  // HostValue slot.
+}

baml_language/crates/baml_builtins2/baml_std/baml/ns_host/host.baml

@@ -110,6 +110,7 @@ pub const ALL: &[BuiltinFile] = &[
     builtin!("baml", "ns_llm/llm.baml"),
     builtin!("baml", "ns_stream/stream.baml"),
     builtin!("baml", "ns_future/future.baml"),
+    builtin!("baml", "ns_host/host.baml"),
     // --- reflect package (standalone, accessible as `reflect.type_of(...)`) ---
     builtin!("reflect", "reflect.baml"),
     // --- testing package ---

baml_language/crates/baml_builtins2/src/lib.rs

@@ -26,6 +26,7 @@ class            errors.NotImplemented            <builtin>/baml/ns_errors/error
 class            errors.LlmClient                 <builtin>/baml/ns_errors/errors.baml:44
 class            errors.DevOther                  <builtin>/baml/ns_errors/errors.baml:49
 class            errors.HostPanic                 <builtin>/baml/ns_errors/errors.baml:54
+class            errors.HostCallable              <builtin>/baml/ns_errors/errors.baml:58
 class            errors.StackFrame                <builtin>/baml/ns_errors/stack_trace.baml:2
 class            errors.StackTrace                <builtin>/baml/ns_errors/stack_trace.baml:9
 function         events.send                      <builtin>/baml/ns_events/events.baml:3
@@ -46,6 +47,8 @@ class            future.Future                    <builtin>/baml/ns_future/futur
 class            glob.ScanOptions                 <builtin>/baml/ns_glob/glob.baml:2
 class            glob.Glob                        <builtin>/baml/ns_glob/glob.baml:18
 function         glob.new                         <builtin>/baml/ns_glob/glob.baml:34
+function         host.call_host_value             <builtin>/baml/ns_host/host.baml:8
+class            host.HostValue                   <builtin>/baml/ns_host/host.baml:15
 class            http.Request                     <builtin>/baml/ns_http/http.baml:2
 class            http.Response                    <builtin>/baml/ns_http/http.baml:10
 class            http.SseStream                   <builtin>/baml/ns_http/http.baml:33

baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap

@@ -0,0 +1,11 @@
+// snapshot the bytecode shape for a host-callable call site.
+//
+// A `Ty::Function` parameter is bound at the FFI boundary to an
+// `Object::HostClosure`; calling it via `f(x)` lowers to a plain
+// `CallIndirect` instruction at compile time. The HostClosure-specific
+// dispatch (yielding `VmExecState::SysOp { operation:
+// SysOp::BamlHostCallHostValue, args }`) is entirely a runtime concern
+// — the compiler emits no synthesized wrapper for this call.
+function call_with_callback(callback: (int) -> string, x: int) -> string {
+    callback(x)
+}