avm1: Mirror AS3 Array → StrictArray promotion for AVM1 NetConnection/LocalConnection (#16381)

Signed-off-by: Onyeka Obi <softwareengineerasaservant@isurvivable.cv>

Author: MavenRain

core/src/avm1/globals/local_connection.rs

@@ -6,6 +6,7 @@ use crate::avm1::globals::shared_object::{deserialize_value, serialize};
 use crate::avm1::property_decl::{DeclContext, StaticDeclarations, SystemClass};
 use crate::avm1::{ActivationIdentifier, ExecutionReason, NativeObject, Object, Value};
 use crate::avm1_stub;
+use crate::avm2::amf::promote_dense_ecma_to_strict_array;
 use crate::context::UpdateContext;
 use crate::display_object::TDisplayObject;
 use crate::local_connection::{LocalConnectionHandle, LocalConnections};
@@ -226,7 +227,11 @@ pub fn send<'gc>(
 
     let mut amf_arguments = Vec::with_capacity(args.len() - 2);
     for arg in &args[2..] {
-        amf_arguments.push(serialize(activation, *arg));
+        // Real Flash sends dense AS1/AS2 `Array` arguments as `StrictArray`
+        // over the LocalConnection wire (#16381).  Mirrors the same promotion
+        // done in `NetConnection.call`.
+        let value = serialize(activation, *arg);
+        amf_arguments.push(promote_dense_ecma_to_strict_array(value));
     }
 
     activation.context.local_connections.send(

core/src/avm1/globals/netconnection.rs

@@ -4,6 +4,7 @@ use crate::avm1::{
     Activation, ActivationIdentifier, Error, ExecutionReason, NativeObject, Object, Value,
 };
 use crate::avm1_stub;
+use crate::avm2::amf::promote_dense_ecma_to_strict_array;
 use crate::context::UpdateContext;
 use crate::net_connection::{NetConnectionHandle, NetConnections, ResponderCallback};
 use crate::string::AvmString;
@@ -274,7 +275,12 @@ fn call<'gc>(
 
     if args.len() > 2 {
         for arg in &args[2..] {
-            arguments.push(Rc::new(serialize(activation, *arg)));
+            // Real Flash sends dense AS1/AS2 `Array` arguments as `StrictArray`
+            // on the NetConnection.call wire (#16381).  Nested dense arrays
+            // produced by `recursive_serialize`'s `ECMAArray` path are promoted
+            // here as well.
+            let value = serialize(activation, *arg);
+            arguments.push(Rc::new(promote_dense_ecma_to_strict_array(value)));
         }
     }
 

core/src/avm1/globals/shared_object.rs

@@ -5,7 +5,7 @@ use crate::display_object::TDisplayObject;
 use crate::string::AvmString;
 use flash_lso::amf0::read::AMF0Decoder;
 use flash_lso::amf0::writer::{Amf0Writer, CacheKey, ObjWriter};
-use flash_lso::types::{Lso, ObjectId, Reference, Value as AmfValue};
+use flash_lso::types::{Element, Lso, ObjectId, Reference, Value as AmfValue};
 use gc_arena::{Collect, Gc};
 use ruffle_macros::istr;
 use std::borrow::Cow;
@@ -86,13 +86,56 @@ pub fn serialize<'gc>(activation: &mut Activation<'_, 'gc>, value: Value<'gc>) -
         Value::Number(number) => AmfValue::Number(number),
         Value::String(string) => AmfValue::String(string.to_string()),
         Value::Object(object) => {
-            let lso = new_lso(activation, "root", object);
-            AmfValue::Object(ObjectId::INVALID, lso.into_iter().collect(), None)
+            if let NativeObject::Array(_) = object.native() {
+                // AS1/AS2 `Array` values are serialized using the AMF0 array
+                // markers so that Flash Remoting / LocalConnection endpoints
+                // round-trip them as arrays rather than as anonymous objects
+                // with `"0"`/`"1"`/... keys.  Callers that wire the result
+                // onto a path Flash sends as `StrictArray` (NetConnection.call
+                // / LocalConnection.send argument trees, #16381) post-process
+                // with `crate::avm2::amf::promote_dense_ecma_to_strict_array`.
+                serialize_array(activation, object)
+            } else {
+                let lso = new_lso(activation, "root", object);
+                AmfValue::Object(ObjectId::INVALID, lso.into_iter().collect(), None)
+            }
         }
         Value::MovieClip(_) => AmfValue::Undefined,
     }
 }
 
+/// Serialize an AS1/AS2 `Array` into the AMF0 array form.  Dense indices fill
+/// the first slot of the returned `ECMAArray`; non-numeric or out-of-range
+/// keys go into the associative part.  The wrapping `ECMAArray` matches what
+/// flash-lso's `ObjWriter::array`/`ArrayWriter::commit` produces for nested
+/// arrays inside `recursive_serialize`, so behavior is uniform between
+/// top-level and nested `Array` serialization.
+fn serialize_array<'gc>(activation: &mut Activation<'_, 'gc>, array: Object<'gc>) -> AmfValue {
+    let length = array.length(activation).unwrap_or(0).max(0) as u32;
+    let mut dense: Vec<std::rc::Rc<AmfValue>> = (0..length)
+        .map(|_| std::rc::Rc::new(AmfValue::Undefined))
+        .collect();
+    let mut associative: Vec<Element> = Vec::new();
+    // Reversed to match Flash Player enumeration order, mirroring
+    // `recursive_serialize`.
+    for key in array.get_keys(activation, false).into_iter().rev() {
+        let key_str = key.to_utf8_lossy();
+        let value = array
+            .get(key, activation)
+            .map(|v| serialize(activation, v))
+            .unwrap_or(AmfValue::Undefined);
+        match key_str.parse::<u32>() {
+            Ok(idx) if idx < length => {
+                dense[idx as usize] = std::rc::Rc::new(value);
+            }
+            _ => {
+                associative.push(Element::new(key_str.to_string(), std::rc::Rc::new(value)));
+            }
+        }
+    }
+    AmfValue::ECMAArray(ObjectId::INVALID, dense, associative, length)
+}
+
 /// Serialize an Object and any children to a JSON object
 fn recursive_serialize<'gc>(
     activation: &mut Activation<'_, 'gc>,

core/src/avm2.rs

@@ -41,7 +41,7 @@ macro_rules! avm_debug {
 }
 
 pub mod activation;
-mod amf;
+pub(crate) mod amf;
 pub mod api_version;
 mod array;
 pub mod bytearray;