reg VM: make Managed transparent on read; don't wrap immutable scalars

The reg VM models the 'manage' keyword as VmValue::Managed(Rc<RefCell<..>>),
a shared mutable cell for retaining a value in a collection/field. But this
wrapper leaked into reads: a value stored via 'manage' (e.g. List.push(manage x)
or Map.insert(value: read (manage x))) came back wrapped, and the typed
accessors rejected it ("reg VM expected List/String, got ...").

Two complementary fixes, matching the rest of the value model where Managed is
already transparent (display/native_value/equality all unwrap it):

1. Owned/Copy/Rc-returning accessors (expect_int/float/char/bool/list/deque/
   map/closure_ref) now peel Managed by recursing, so a Managed collection or
   scalar reaching an op is handled from any source.

2. The borrow-returning accessors (String/Bytes/Json -> &str/&[u8]/&Value)
   cannot peel through a RefCell. Fix at the source: Manage now skips wrapping
   immutable scalars (Unit/Int/Float/Bool/Char/Bytes/String/Json), since they
   have value semantics and no in-place mutation -- wrapping them was a no-op
   that only leaked an opaque Managed. Collections/structs still wrap (aliasing).

Unblocks running real packages on the dev VM (tinygrad port): the device
allocator/buffer store and state-dict name lists round-trip managed values
through Map/List. Full rsscript suite green (only the unrelated pre-existing
Channel.message parity-fixture failure remains).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/reg_vm/mod.rs

@@ -6677,7 +6677,18 @@ impl RegVm {
             }
             RegInstr::Manage { dst, src } => {
                 let value = self.reg(base + *src).clone();
-                self.set_reg(base + *dst, VmValue::Managed(Rc::new(RefCell::new(value))));
+                // `manage` wraps a value in a shared mutable cell so it can be
+                // retained (stored in a collection/field) and mutated in place.
+                // Immutable scalars cannot be mutated in place and have value (not
+                // reference) semantics, so wrapping them is a no-op that only leaks
+                // an opaque `Managed` into reads — borrow-returning accessors
+                // (`String`/`Bytes`/`Json`) can't peel it. Store them directly.
+                let managed = if value.is_immutable_scalar() {
+                    value
+                } else {
+                    VmValue::Managed(Rc::new(RefCell::new(value)))
+                };
+                self.set_reg(base + *dst, managed);
             }
             RegInstr::GetField {
                 dst,
@@ -12634,6 +12645,10 @@ fn eval_numeric_compare(
 fn expect_int_ref(value: &VmValue) -> Result<i64, EvalError> {
     match value {
         VmValue::Int(value) => Ok(*value),
+        // `Managed` is transparent (see vm_value: display/native_value/equality
+        // all unwrap it). A value retained into storage via `manage` and read
+        // back arrives wrapped; see through it like the rest of the value model.
+        VmValue::Managed(inner) => expect_int_ref(&inner.borrow()),
         other => Err(EvalError::Runtime(format!(
             "reg VM expected Int, got `{}`.",
             other.display()
@@ -12644,6 +12659,7 @@ fn expect_int_ref(value: &VmValue) -> Result<i64, EvalError> {
 fn expect_float_ref(value: &VmValue) -> Result<f64, EvalError> {
     match value {
         VmValue::Float(value) => Ok(*value),
+        VmValue::Managed(inner) => expect_float_ref(&inner.borrow()),
         other => Err(EvalError::Runtime(format!(
             "reg VM expected Float, got `{}`.",
             other.display()
@@ -12654,6 +12670,7 @@ fn expect_float_ref(value: &VmValue) -> Result<f64, EvalError> {
 fn expect_char_ref(value: &VmValue) -> Result<char, EvalError> {
     match value {
         VmValue::Char(value) => Ok(*value),
+        VmValue::Managed(inner) => expect_char_ref(&inner.borrow()),
         other => Err(EvalError::Runtime(format!(
             "reg VM expected Char, got `{}`.",
             other.display()
@@ -13094,6 +13111,7 @@ fn expect_string_list_ref(value: &VmValue) -> Result<Vec<String>, EvalError> {
 fn expect_bool_ref(value: &VmValue) -> Result<bool, EvalError> {
     match value {
         VmValue::Bool(value) => Ok(*value),
+        VmValue::Managed(inner) => expect_bool_ref(&inner.borrow()),
         other => Err(EvalError::Runtime(format!(
             "reg VM expected Bool, got `{}`.",
             other.display()
@@ -13104,6 +13122,7 @@ fn expect_bool_ref(value: &VmValue) -> Result<bool, EvalError> {
 fn expect_list_ref(value: &VmValue) -> Result<Rc<RefCell<Vec<VmValue>>>, EvalError> {
     match value {
         VmValue::List(value) => Ok(Rc::clone(value)),
+        VmValue::Managed(inner) => expect_list_ref(&inner.borrow()),
         other => Err(EvalError::Runtime(format!(
             "reg VM expected List, got `{}`.",
             other.display()
@@ -13116,6 +13135,7 @@ fn expect_deque_ref(
 ) -> Result<Rc<RefCell<std::collections::VecDeque<VmValue>>>, EvalError> {
     match value {
         VmValue::Deque(value) => Ok(Rc::clone(value)),
+        VmValue::Managed(inner) => expect_deque_ref(&inner.borrow()),
         other => Err(EvalError::Runtime(format!(
             "reg VM expected Deque, got `{}`.",
             other.display()
@@ -13139,6 +13159,7 @@ fn list_item_at(
 fn expect_map_ref(value: &VmValue) -> Result<Rc<RefCell<ValueMap>>, EvalError> {
     match value {
         VmValue::Map(value) => Ok(Rc::clone(value)),
+        VmValue::Managed(inner) => expect_map_ref(&inner.borrow()),
         other => Err(EvalError::Runtime(format!(
             "reg VM expected Map, got `{}`.",
             other.display()
@@ -13159,6 +13180,7 @@ fn expect_json_ref(value: &VmValue) -> Result<&serde_json::Value, EvalError> {
 fn expect_closure_rc(value: &VmValue) -> Result<Rc<VmClosure>, EvalError> {
     match value {
         VmValue::Closure(value) => Ok(Rc::clone(value)),
+        VmValue::Managed(inner) => expect_closure_rc(&inner.borrow()),
         other => Err(EvalError::Runtime(format!(
             "reg VM expected Closure, got `{}`.",
             other.display()

crates/rsscript/src/vm_value.rs

@@ -303,6 +303,25 @@ impl VmValue {
         Self::String(Rc::new(value.into()))
     }
 
+    /// Whether this value has value (not reference) semantics and no in-place
+    /// mutation — so wrapping it in a `Managed` shared cell would be a semantic
+    /// no-op. Used by the `manage` op to avoid leaking an opaque `Managed`
+    /// around immutable scalars (`String`/`Bytes`/`Json` are `Rc`-shared and
+    /// immutable; the rest are `Copy`).
+    pub(crate) fn is_immutable_scalar(&self) -> bool {
+        matches!(
+            self,
+            Self::Unit
+                | Self::Int(_)
+                | Self::Float(_)
+                | Self::Bool(_)
+                | Self::Char(_)
+                | Self::Bytes(_)
+                | Self::String(_)
+                | Self::Json(_)
+        )
+    }
+
     pub(crate) fn display(&self) -> String {
         match self {
             Self::Unit => "Unit".to_string(),