feat(rss): Clone protocol + Clone.clone<T> / String.clone (managed-value clone)

Adds a Clone capability protocol (mirrors Ord/Eq): clone() deep-copies any builtin scalar,
derives(Clone) user struct/sum, and List/Option/Result of Clone elements. Closes the clone-gap
(could not copy a String/managed field out of a read value -> E0507): now a read field copies via
Clone.clone<T>(self: read x). Wired across stdlib/clone/clone.rssi, interfaces, checks/calls
protocol satisfaction, analyzer fresh-Self bound, reg_vm (RegIntrinsic::CloneClone + resolver +
receiver call), runtime_abi + runtime clone_value, regenerated core index + vm parity. Full
cargo test -p rsscript green (25 targets, 0 failed). Subagent-produced, applied + reverified.

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

Author: claude

crates/rsscript/src/analyzer.rs

@@ -3336,9 +3336,15 @@ impl Analyzer<'_> {
         bounds: &HashMap<String, Option<GenericBound>>,
     ) {
         let target = fresh_return_target_type(return_ty);
-        if bounds.contains_key(&target.name)
-            && bounds.get(&target.name).and_then(Option::as_ref) != Some(&GenericBound::Struct)
-        {
+        // A protocol method's implicit `Self` parameter is bound `Managed`, which
+        // still admits a `fresh Self` return: managed structs/sums are freshly
+        // ownable, and the per-instantiation derive (`derives(Clone)`) is checked
+        // at the use site. A `fresh Self` from a value scalar is impossible
+        // because scalars do not satisfy the protocol's `Managed` `Self` bound.
+        let bound = bounds.get(&target.name).and_then(Option::as_ref);
+        let fresh_bound_ok = matches!(bound, Some(GenericBound::Struct))
+            || (target.name == "Self" && matches!(bound, Some(GenericBound::Managed)));
+        if bounds.contains_key(&target.name) && !fresh_bound_ok {
             self.diagnostics.push(
                 Diagnostic::error(
                     code::INVALID_FRESH_RETURN_TYPE,

crates/rsscript/src/checks/calls.rs

@@ -1480,6 +1480,9 @@ fn type_satisfies_protocol_bound(
     if (protocol == "Hashable" || protocol == "Eq") && builtin_type_is_hashable(actual_root) {
         return true;
     }
+    if protocol == "Clone" && builtin_type_is_clone(actual_root) {
+        return true;
+    }
     // `List<T>`/`Option<T>`/`Result<A, B>` are `Hashable`/`Eq` exactly when their
     // element types are, so a key like `List<Coord>` is satisfiable structurally.
     if (protocol == "Hashable" || protocol == "Eq")
@@ -1491,6 +1494,15 @@ fn type_satisfies_protocol_bound(
                 .all(|arg| type_satisfies_protocol_bound(analyzer, function, arg, protocol));
         }
     }
+    // `List<T>`/`Option<T>`/`Result<A, B>` are `Clone` exactly when their element
+    // types are, mirroring the structural derive support for value containers.
+    if protocol == "Clone" && matches!(actual_root, "List" | "Option" | "Result") {
+        if let Some(args) = type_arg_names(strip_fresh_type(actual)) {
+            return args
+                .iter()
+                .all(|arg| type_satisfies_protocol_bound(analyzer, function, arg, protocol));
+        }
+    }
     if function.type_params.iter().any(|param| {
         param.name == actual_root
             && matches!(
@@ -1611,6 +1623,32 @@ fn builtin_type_is_hashable(type_name: &str) -> bool {
     )
 }
 
+/// Builtin scalar types that are `Clone` directly (no derive needed). Every
+/// value scalar is copyable, including `Float` (which is not `Eq`/`Hash`).
+fn builtin_type_is_clone(type_name: &str) -> bool {
+    matches!(
+        type_name,
+        "Int"
+            | "Int8"
+            | "Int16"
+            | "Int32"
+            | "Int64"
+            | "UInt"
+            | "UInt8"
+            | "UInt16"
+            | "UInt32"
+            | "UInt64"
+            | "Bool"
+            | "Byte"
+            | "Char"
+            | "Unit"
+            | "Float"
+            | "Float32"
+            | "Float64"
+            | "String"
+    )
+}
+
 /// Whether a user-declared `type_name` satisfies a compiler-derived `protocol`
 /// bound. `Ord` requires `derives(Ord)`; `Hashable` requires `derives(Hash)`;
 /// `Eq` requires `derives(Eq)` or `derives(Ord)` (which implies `Eq`).
@@ -1621,10 +1659,11 @@ fn type_derives_protocol(items: &[Item], type_name: &str, protocol: &str) -> boo
             "Ord" => has("Ord"),
             "Hashable" => has("Hash"),
             "Eq" => has("Eq") || has("Ord"),
+            "Clone" => has("Clone"),
             _ => false,
         }
     };
-    if !matches!(protocol, "Ord" | "Hashable" | "Eq") {
+    if !matches!(protocol, "Ord" | "Hashable" | "Eq" | "Clone") {
         return false;
     }
     items.iter().any(|item| match item {

crates/rsscript/src/interfaces.rs

@@ -65,6 +65,10 @@ pub(crate) const CORE_INTERFACES: &[(&str, &str)] = &[
         "stdlib/clock/clock.rssi",
         include_str!("../../../stdlib/clock/clock.rssi"),
     ),
+    (
+        "stdlib/clone/clone.rssi",
+        include_str!("../../../stdlib/clone/clone.rssi"),
+    ),
     ("stdlib/cmp/eq.rssi", include_str!("../../../stdlib/cmp/eq.rssi")),
     ("stdlib/cmp/ord.rssi", include_str!("../../../stdlib/cmp/ord.rssi")),
     (

crates/rsscript/src/reg_vm/mod.rs

@@ -1997,6 +1997,7 @@ enum RegIntrinsic {
     CharToLower,
     CharToString,
     CharToUpper,
+    CloneClone,
     ClockNow,
     ClockSystemUnixMs,
     ConfigLoad,
@@ -3578,6 +3579,14 @@ impl RegLowerer<'_> {
                 .map(|arg| self.expr(&arg.value))
                 .collect::<Result<Vec<_>, _>>()?;
             match (type_root_name(namespace), type_root_name(method)) {
+                ("Clone", "clone") => {
+                    self.emit(RegInstr::CallIntrinsic {
+                        dst,
+                        intrinsic: RegIntrinsic::CloneClone,
+                        args: vec![receiver_reg],
+                    });
+                    return Ok(dst);
+                }
                 ("Float", "to_string") => {
                     self.emit(RegInstr::CallIntrinsic {
                         dst,
@@ -4648,6 +4657,7 @@ impl RegLowerer<'_> {
                     ("Option", "or") => RegIntrinsic::OptionOr,
                     ("Option", "unwrap_or") => RegIntrinsic::OptionUnwrapOr,
                     ("Option", "unwrap_or_else") => RegIntrinsic::OptionUnwrapOrElse,
+                    ("Clone", "clone") => RegIntrinsic::CloneClone,
                     ("Ord", "compare") => RegIntrinsic::OrdCompare,
                     ("OS", "close") => RegIntrinsic::OsClose,
                     ("Patch", "apply_text") => RegIntrinsic::PatchApplyText,
@@ -4958,7 +4968,7 @@ impl RegLowerer<'_> {
                     ("String", "char_at") => RegIntrinsic::StringCharAt,
                     ("String", "contains") => RegIntrinsic::StringContains,
                     ("String", "count") => RegIntrinsic::StringCount,
-                    ("String", "copy") => RegIntrinsic::StringCopy,
+                    ("String", "copy") | ("String", "clone") => RegIntrinsic::StringCopy,
                     ("String", "ends_with") => RegIntrinsic::StringEndsWith,
                     ("String", "env") => RegIntrinsic::EnvGet,
                     ("String", "env_or") => RegIntrinsic::EnvGetOrDefault,
@@ -11156,6 +11166,10 @@ impl RegVm {
                     ))),
                 }
             }
+            RegIntrinsic::CloneClone => {
+                let value = intrinsic_arg(&self.stack, base, args, 0)?;
+                Ok(deep_copy_value(value))
+            }
             RegIntrinsic::OrdCompare => {
                 let left = intrinsic_arg(&self.stack, base, args, 0)?;
                 let right = intrinsic_arg(&self.stack, base, args, 1)?;

crates/rsscript/src/runtime_abi.rs

@@ -923,6 +923,7 @@ const RUNTIME_INTRINSICS: &[RuntimeIntrinsic] = &[
     runtime_intrinsic("Deque", "push_back", "rsscript_runtime::deque_push_back"),
     runtime_intrinsic("Deque", "push_front", "rsscript_runtime::deque_push_front"),
     runtime_intrinsic("Deque", "to_list", "rsscript_runtime::deque_to_list"),
+    runtime_intrinsic("Clone", "clone", "rsscript_runtime::clone_value"),
     runtime_intrinsic("Ord", "compare", "rsscript_runtime::ord_compare"),
     runtime_intrinsic("List", "all", "rsscript_runtime::list_all"),
     runtime_intrinsic("List", "any", "rsscript_runtime::list_any"),
@@ -1365,6 +1366,7 @@ const RUNTIME_INTRINSICS: &[RuntimeIntrinsic] = &[
     runtime_intrinsic("String", "before", "rsscript_runtime::string_before"),
     runtime_intrinsic("String", "concat", "rsscript_runtime::string_concat"),
     runtime_intrinsic("String", "copy", "rsscript_runtime::string_copy"),
+    runtime_intrinsic("String", "clone", "rsscript_runtime::string_copy"),
     runtime_intrinsic("String", "ends_with", "rsscript_runtime::string_ends_with"),
     runtime_intrinsic("String", "env", "rsscript_runtime::env_get"),
     runtime_intrinsic("String", "env_or", "rsscript_runtime::env_get_or_default"),

crates/rsscript/tests/vm_eval.rs

@@ -803,6 +803,7 @@ pub fn echo(message: &String) -> String {
 // parity: runtime:ChannelError.message
 // parity: runtime:CancellationSource.cancel runtime:CancellationSource.new
 // parity: runtime:CancellationSource.token runtime:CancellationToken.is_cancelled
+// parity: runtime:Clone.clone
 // parity: runtime:Clock.now runtime:Clock.system_unix_ms
 // parity: runtime:Config.load runtime:Config.name runtime:Config.new runtime:Config.rule_count
 // parity: runtime:ConfigStore.name runtime:ConfigStore.new runtime:ConfigStore.replace
@@ -947,7 +948,7 @@ pub fn echo(message: &String) -> String {
 // parity: runtime:SortedMap.values
 // parity: runtime:String.after runtime:String.before runtime:String.char_at runtime:String.concat
 // parity: runtime:String.chars
-// parity: runtime:String.contains runtime:String.count runtime:String.copy runtime:String.ends_with
+// parity: runtime:String.clone runtime:String.contains runtime:String.count runtime:String.copy runtime:String.ends_with
 // parity: runtime:String.env runtime:String.env_or
 // parity: runtime:String.format runtime:String.from_bool runtime:String.from_float runtime:String.from_int
 // parity: runtime:String.index_of runtime:String.is_empty runtime:String.join runtime:String.len

crates/runtime/src/collections.rs

@@ -11,6 +11,10 @@ pub struct RssFalliblePipeline<T, E> {
     pub result: Result<Vec<T>, E>,
 }
 
+pub fn clone_value<T: Clone>(value: &T) -> T {
+    value.clone()
+}
+
 pub fn ord_compare<T: Ord>(left: &T, right: &T) -> i64 {
     match left.cmp(right) {
         std::cmp::Ordering::Less => -1,

schemas/core-package-index.json

@@ -41,6 +41,16 @@
         "Instant"
       ]
     },
+    {
+      "path": "stdlib/clone/clone.rssi",
+      "module": "clone.clone",
+      "functions": [
+        "clone"
+      ],
+      "types": [
+        "Clone"
+      ]
+    },
     {
       "path": "stdlib/cmp/eq.rssi",
       "module": "cmp.eq",
@@ -877,6 +887,7 @@
         "String.before",
         "String.char_at",
         "String.chars",
+        "String.clone",
         "String.concat",
         "String.contains",
         "String.copy",

stdlib/clone/clone.rssi

@@ -0,0 +1,14 @@
+// `Clone` is an explicit, deep value copy, modeled on Swift's value semantics
+// and Rust's `Clone`.
+//
+// A managed `struct` or `sum` satisfies `Clone` by listing `derives(Clone)`,
+// which the compiler expands into a structural copy of every field. The builtin
+// value scalars (`Int`, `String`, `Bool`, ...) satisfy `Clone` directly.
+//
+// `Clone.clone<T>(self: read x)` copies a value out of a shared (`read`) borrow
+// into a `fresh` owned value, closing the "clone gap" where a `read` field
+// cannot be moved into a constructor. `Clone` is a pure contract: it introduces
+// no mutation, retention, native, or unsafe boundary.
+protocol Clone {
+    fn clone(self: read Self) -> fresh Self
+}

stdlib/string/string.rssi

@@ -46,6 +46,9 @@ pub fn String.concat(left: read String, right: read String) -> fresh String
 pub fn String.copy(value: read String) -> fresh String
     effects(pure)
 
+pub fn String.clone(value: read String) -> fresh String
+    effects(pure)
+
 pub fn String.from_int(value: Int) -> fresh String
     effects(pure)