Version 7.4.1: Performance improvements: .NET method arguments and property/field values are now passed pre-decoded, eliminating decoding hops; property, field, and constructor bind caching accelerates re-invocation. Further refined HeapExpansionMultiplier handling; miscellaneous NuGet package updates. Tested with V8 11.2.214.13.

ClearScript/Exports/VersionSymbols.h

@@ -5,7 +5,7 @@
 
 #pragma once
 
-#define CLEARSCRIPT_VERSION_STRING "7.4.0"
-#define CLEARSCRIPT_VERSION_COMMA_SEPARATED 7,4,0
-#define CLEARSCRIPT_VERSION_STRING_INFORMATIONAL "7.4.0"
+#define CLEARSCRIPT_VERSION_STRING "7.4.1"
+#define CLEARSCRIPT_VERSION_COMMA_SEPARATED 7,4,1
+#define CLEARSCRIPT_VERSION_STRING_INFORMATIONAL "7.4.1"
 #define CLEARSCRIPT_FILE_FLAGS 0L

ClearScript/HostItem.InvokeMethod.cs

@@ -111,7 +111,7 @@ namespace Microsoft.ClearScript
             var signature = new BindSignature(AccessContext, bindFlags, Target, name, typeArgs, bindArgs);
             MethodBindResult result;
 
-            if (Engine.TryGetCachedBindResult(signature, out var rawResult))
+            if (Engine.TryGetCachedMethodBindResult(signature, out var rawResult))
             {
                 result = MethodBindResult.Create(name, bindFlags, rawResult, Target, args);
             }
@@ -154,7 +154,7 @@ namespace Microsoft.ClearScript
                     }
                 }
 
-                Engine.CacheBindResult(signature, result.RawResult);
+                Engine.CacheMethodBindResult(signature, result.RawResult);
             }
 
             return result;
@@ -422,7 +422,7 @@ namespace Microsoft.ClearScript
 
         #region unit test support
 
-        internal static void ResetCoreBindCache()
+        internal static void ClearCoreBindCache()
         {
             coreBindCache.Clear();
             Interlocked.Exchange(ref coreBindCount, 0);

ClearScript/HostItem.cs

@@ -1235,7 +1235,7 @@ namespace Microsoft.ClearScript
                                         return DelegateFactory.CreateDelegate(Engine, args[0], specificType);
                                     }
 
-                                    return specificType.CreateInstance(this, AccessContext, DefaultAccess, args, bindArgs);
+                                    return specificType.CreateInstance(this, Target, args, bindArgs);
                                 }
                             }
 
@@ -1255,7 +1255,7 @@ namespace Microsoft.ClearScript
                             return DelegateFactory.CreateDelegate(Engine, args[0], type);
                         }
 
-                        return type.CreateInstance(this, AccessContext, DefaultAccess, args, bindArgs);
+                        return type.CreateInstance(this, Target, args, bindArgs);
                     }
 
                     if (TargetDynamicMetaObject != null)
@@ -1386,12 +1386,26 @@ namespace Microsoft.ClearScript
         {
             isCacheable = false;
 
+            var signature = new BindSignature(AccessContext, invokeFlags, Target, name, ArrayHelpers.GetEmptyArray<Type>(), bindArgs);
+            if (Engine.TryGetCachedPropertyGetBindResult(signature, out var boundMember))
+            {
+                if (boundMember is PropertyInfo boundProperty)
+                {
+                    return GetHostPropertyWorker(boundProperty, boundProperty.GetMethod, args);
+                }
+
+                if (boundMember is FieldInfo boundField)
+                {
+                    return GetHostFieldWorker(boundField, out isCacheable);
+                }
+            }
+
             if (name == SpecialMemberNames.Default)
             {
                 var defaultProperty = Target.Type.GetScriptableDefaultProperty(invokeFlags, args, bindArgs, AccessContext, DefaultAccess);
                 if (defaultProperty != null)
                 {
-                    return GetHostProperty(defaultProperty, invokeFlags, args);
+                    return GetHostProperty(signature, defaultProperty, invokeFlags, args);
                 }
 
                 if (TargetDynamicMetaObject != null)
@@ -1476,7 +1490,7 @@ namespace Microsoft.ClearScript
             var property = Target.Type.GetScriptableProperty(name, invokeFlags, args, bindArgs, AccessContext, DefaultAccess);
             if (property != null)
             {
-                return GetHostProperty(property, invokeFlags, args);
+                return GetHostProperty(signature, property, invokeFlags, args);
             }
 
             if (args.Length > 0)
@@ -1494,9 +1508,7 @@ namespace Microsoft.ClearScript
             var field = Target.Type.GetScriptableField(name, invokeFlags, AccessContext, DefaultAccess);
             if (field != null)
             {
-                var result = field.GetValue(Target.InvokeTarget);
-                isCacheable = (TargetDynamicMetaObject == null) && (field.IsLiteral || field.IsInitOnly);
-                return Engine.PrepareResult(result, field.FieldType, field.GetScriptMemberFlags(), false);
+                return GetHostField(signature, field, out isCacheable);
             }
 
             if (includeBoundMembers)
@@ -1539,7 +1551,7 @@ namespace Microsoft.ClearScript
             return Nonexistent.Value;
         }
 
-        private object GetHostProperty(PropertyInfo property, BindingFlags invokeFlags, object[] args)
+        private object GetHostProperty(BindSignature signature, PropertyInfo property, BindingFlags invokeFlags, object[] args)
         {
             if (reflectionProperties.Contains(property, MemberComparer<PropertyInfo>.Instance))
             {
@@ -1569,11 +1581,46 @@ namespace Microsoft.ClearScript
                 throw new UnauthorizedAccessException("The property get method is unavailable or inaccessible");
             }
 
+            var result = GetHostPropertyWorker(property, getMethod, args);
+            Engine.CachePropertyGetBindResult(signature, property);
+            return result;
+        }
+
+        private object GetHostPropertyWorker(PropertyInfo property, MethodInfo getMethod, object[] args)
+        {
             return InvokeHelpers.InvokeMethod(this, getMethod, Target.InvokeTarget, args, property.GetScriptMemberFlags());
         }
 
+        private object GetHostField(BindSignature signature, FieldInfo field, out bool isCacheable)
+        {
+            var result = GetHostFieldWorker(field, out isCacheable);
+            Engine.CachePropertyGetBindResult(signature, field);
+            return result;
+        }
+
+        private object GetHostFieldWorker(FieldInfo field, out bool isCacheable)
+        {
+            var result = field.GetValue(Target.InvokeTarget);
+            isCacheable = (TargetDynamicMetaObject == null) && (field.IsLiteral || field.IsInitOnly);
+            return Engine.PrepareResult(result, field.FieldType, field.GetScriptMemberFlags(), false);
+        }
+
         private object SetHostProperty(string name, BindingFlags invokeFlags, object[] args, object[] bindArgs)
         {
+            var signature = new BindSignature(AccessContext, invokeFlags, Target, name, ArrayHelpers.GetEmptyArray<Type>(), bindArgs);
+            if (Engine.TryGetCachedPropertySetBindResult(signature, out var boundMember))
+            {
+                if (boundMember is PropertyInfo boundProperty)
+                {
+                    return SetHostPropertyWorker(boundProperty, boundProperty.SetMethod, args, bindArgs);
+                }
+
+                if (boundMember is FieldInfo boundField)
+                {
+                    return SetHostFieldWorker(boundField, args);
+                }
+            }
+
             if (name == SpecialMemberNames.Default)
             {
                 if (args.Length < 1)
@@ -1586,7 +1633,7 @@ namespace Microsoft.ClearScript
                 var defaultProperty = Target.Type.GetScriptableDefaultProperty(invokeFlags, args.Take(args.Length - 1).ToArray(), bindArgs.Take(bindArgs.Length - 1).ToArray(), AccessContext, DefaultAccess);
                 if (defaultProperty != null)
                 {
-                    return SetHostProperty(defaultProperty, args, bindArgs);
+                    return SetHostProperty(signature, defaultProperty, args, bindArgs);
                 }
 
                 if (args.Length < 2)
@@ -1641,36 +1688,19 @@ namespace Microsoft.ClearScript
             var property = Target.Type.GetScriptableProperty(name, invokeFlags, args.Take(args.Length - 1).ToArray(), bindArgs.Take(bindArgs.Length - 1).ToArray(), AccessContext, DefaultAccess);
             if (property != null)
             {
-                return SetHostProperty(property, args, bindArgs);
+                return SetHostProperty(signature, property, args, bindArgs);
             }
 
             var field = Target.Type.GetScriptableField(name, invokeFlags, AccessContext, DefaultAccess);
             if (field != null)
             {
-                if (args.Length == 1)
-                {
-                    if (field.IsLiteral || field.IsInitOnly || field.IsReadOnlyForScript(DefaultAccess))
-                    {
-                        throw new UnauthorizedAccessException("The field is read-only");
-                    }
-
-                    var value = args[0];
-                    if (field.FieldType.IsAssignableFromValue(ref value))
-                    {
-                        field.SetValue(Target.InvokeTarget, value);
-                        return value;
-                    }
-
-                    throw new ArgumentException("Invalid field assignment");
-                }
-
-                throw new InvalidOperationException("Invalid argument count");
+                return SetHostField(signature, field, args);
             }
 
             throw new MissingMemberException(MiscHelpers.FormatInvariant("The object has no suitable property or field named '{0}'", name));
         }
 
-        private object SetHostProperty(PropertyInfo property, object[] args, object[] bindArgs)
+        private object SetHostProperty(BindSignature signature, PropertyInfo property, object[] args, object[] bindArgs)
         {
             var scriptAccess = property.GetScriptAccess(DefaultAccess);
             if (scriptAccess == ScriptAccess.ReadOnly)
@@ -1684,6 +1714,13 @@ namespace Microsoft.ClearScript
                 throw new UnauthorizedAccessException("The property set method is unavailable or inaccessible");
             }
 
+            var result = SetHostPropertyWorker(property, setMethod, args, bindArgs);
+            Engine.CachePropertySetBindResult(signature, property);
+            return result;
+        }
+
+        private object SetHostPropertyWorker(PropertyInfo property, MethodInfo setMethod, object[] args, object[] bindArgs)
+        {
             var value = args[args.Length - 1];
 
             var argCount = args.Length - 1;
@@ -1741,6 +1778,35 @@ namespace Microsoft.ClearScript
             throw new ArgumentException("Invalid property assignment");
         }
 
+        private object SetHostField(BindSignature signature, FieldInfo field, object[] args)
+        {
+            if (args.Length != 1)
+            {
+                throw new InvalidOperationException("Invalid argument count");
+            }
+
+            if (field.IsLiteral || field.IsInitOnly || field.IsReadOnlyForScript(DefaultAccess))
+            {
+                throw new UnauthorizedAccessException("The field is read-only");
+            }
+
+            var result = SetHostFieldWorker(field, args);
+            Engine.CachePropertySetBindResult(signature, field);
+            return result;
+        }
+
+        private object SetHostFieldWorker(FieldInfo field, object[] args)
+        {
+            var value = args[0];
+            if (field.FieldType.IsAssignableFromValue(ref value))
+            {
+                field.SetValue(Target.InvokeTarget, value);
+                return value;
+            }
+
+            throw new ArgumentException("Invalid field assignment");
+        }
+
         private static object CreateScriptableEnumerator<T>(IEnumerable<T> enumerable)
         {
             return HostObject.Wrap(new ScriptableEnumeratorOnEnumerator<T>(enumerable.GetEnumerator()), typeof(IScriptableEnumerator<T>));

ClearScript/HostObject.cs

@@ -149,7 +149,7 @@ namespace Microsoft.ClearScript
 
         private static class NullWrapper<T>
         {
-            public static HostObject Value { get; } = new HostObject(null, typeof(T));
+            public static readonly HostObject Value = new HostObject(null, typeof(T));
         }
 
         // ReSharper restore UnusedMember.Local

ClearScript/HostSettings.cs

@@ -51,6 +51,6 @@ namespace Microsoft.ClearScript
             }
         }
 
-        internal static CustomAttributeLoader DefaultCustomAttributeLoader { get; } = new CustomAttributeLoader();
+        internal static readonly CustomAttributeLoader DefaultCustomAttributeLoader = new CustomAttributeLoader();
     }
 }

ClearScript/Properties/AssemblyInfo.Core.cs

@@ -18,15 +18,15 @@ using System.Runtime.InteropServices;
 [assembly: InternalsVisibleTo("ClearScriptTest")]
 
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("7.4.0")]
-[assembly: AssemblyFileVersion("7.4.0")]
-[assembly: AssemblyInformationalVersion("7.4.0")]
+[assembly: AssemblyVersion("7.4.1")]
+[assembly: AssemblyFileVersion("7.4.1")]
+[assembly: AssemblyInformationalVersion("7.4.1")]
 
 namespace Microsoft.ClearScript.Properties
 {
     internal static class ClearScriptVersion
     {
-        public const string Triad = "7.4.0";
-        public const string Informational = "7.4.0";
+        public const string Triad = "7.4.1";
+        public const string Informational = "7.4.1";
     }
 }

ClearScript/Properties/AssemblyInfo.V8.ICUData.cs

@@ -15,6 +15,6 @@ using System.Runtime.InteropServices;
 [assembly: InternalsVisibleTo("ClearScript.V8")]
 
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("7.4.0")]
-[assembly: AssemblyFileVersion("7.4.0")]
-[assembly: AssemblyInformationalVersion("7.4.0")]
+[assembly: AssemblyVersion("7.4.1")]
+[assembly: AssemblyFileVersion("7.4.1")]
+[assembly: AssemblyInformationalVersion("7.4.1")]

ClearScript/Properties/AssemblyInfo.V8.cs

@@ -15,6 +15,6 @@ using System.Runtime.InteropServices;
 [assembly: InternalsVisibleTo("ClearScriptTest")]
 
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("7.4.0")]
-[assembly: AssemblyFileVersion("7.4.0")]
-[assembly: AssemblyInformationalVersion("7.4.0")]
+[assembly: AssemblyVersion("7.4.1")]
+[assembly: AssemblyFileVersion("7.4.1")]
+[assembly: AssemblyInformationalVersion("7.4.1")]

ClearScript/Properties/AssemblyInfo.Windows.Core.cs

@@ -16,6 +16,6 @@ using System.Runtime.InteropServices;
 [assembly: InternalsVisibleTo("ClearScriptTest")]
 
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("7.4.0")]
-[assembly: AssemblyFileVersion("7.4.0")]
-[assembly: AssemblyInformationalVersion("7.4.0")]
+[assembly: AssemblyVersion("7.4.1")]
+[assembly: AssemblyFileVersion("7.4.1")]
+[assembly: AssemblyInformationalVersion("7.4.1")]

ClearScript/Properties/AssemblyInfo.Windows.cs

@@ -15,6 +15,6 @@ using System.Runtime.InteropServices;
 [assembly: InternalsVisibleTo("ClearScriptTest")]
 
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("7.4.0")]
-[assembly: AssemblyFileVersion("7.4.0")]
-[assembly: AssemblyInformationalVersion("7.4.0")]
+[assembly: AssemblyVersion("7.4.1")]
+[assembly: AssemblyFileVersion("7.4.1")]
+[assembly: AssemblyInformationalVersion("7.4.1")]

ClearScript/ScriptEngine.cs

@@ -143,7 +143,7 @@ namespace Microsoft.ClearScript
                         if (newExtensionMethodTable != extensionMethodTable)
                         {
                             extensionMethodTable = newExtensionMethodTable;
-                            bindCache.Clear();
+                            ClearMethodBindCache();
                             OnAccessSettingsChanged();
                         }
                     });
@@ -626,6 +626,8 @@ namespace Microsoft.ClearScript
 
         internal virtual void OnAccessSettingsChanged()
         {
+            ClearConstructorBindCache();
+            ClearPropertyBindCache();
         }
 
         #endregion
@@ -760,7 +762,7 @@ namespace Microsoft.ClearScript
             {
                 if (extensionMethodTable.ProcessType(type, AccessContext, DefaultAccess))
                 {
-                    bindCache.Clear();
+                    ClearMethodBindCache();
                 }
             }
         }
@@ -777,18 +779,77 @@ namespace Microsoft.ClearScript
 
         #endregion
 
-        #region bind cache
+        #region constructor bind cache
 
-        private readonly Dictionary<BindSignature, object> bindCache = new Dictionary<BindSignature, object>();
+        private readonly Dictionary<BindSignature, ConstructorInfo> constructorBindCache = new Dictionary<BindSignature, ConstructorInfo>();
 
-        internal void CacheBindResult(BindSignature signature, object result)
+        internal void CacheConstructorBindResult(BindSignature signature, ConstructorInfo result)
         {
-            bindCache.Add(signature, result);
+            constructorBindCache.Add(signature, result);
         }
 
-        internal bool TryGetCachedBindResult(BindSignature signature, out object result)
+        internal bool TryGetCachedConstructorBindResult(BindSignature signature, out ConstructorInfo result)
         {
-            return bindCache.TryGetValue(signature, out result);
+            return constructorBindCache.TryGetValue(signature, out result);
+        }
+
+        private void ClearConstructorBindCache()
+        {
+            constructorBindCache.Clear();
+        }
+
+        #endregion
+
+        #region method bind cache
+
+        private readonly Dictionary<BindSignature, object> methodBindCache = new Dictionary<BindSignature, object>();
+
+        internal void CacheMethodBindResult(BindSignature signature, object result)
+        {
+            methodBindCache.Add(signature, result);
+        }
+
+        internal bool TryGetCachedMethodBindResult(BindSignature signature, out object result)
+        {
+            return methodBindCache.TryGetValue(signature, out result);
+        }
+
+        private void ClearMethodBindCache()
+        {
+            methodBindCache.Clear();
+        }
+
+        #endregion
+
+        #region property bind cache
+
+        private readonly Dictionary<BindSignature, MemberInfo> propertyGetBindCache = new Dictionary<BindSignature, MemberInfo>();
+        private readonly Dictionary<BindSignature, MemberInfo> propertySetBindCache = new Dictionary<BindSignature, MemberInfo>();
+
+        internal void CachePropertyGetBindResult(BindSignature signature, MemberInfo property)
+        {
+            propertyGetBindCache.Add(signature, property);
+        }
+
+        internal bool TryGetCachedPropertyGetBindResult(BindSignature signature, out MemberInfo property)
+        {
+            return propertyGetBindCache.TryGetValue(signature, out property);
+        }
+
+        internal void CachePropertySetBindResult(BindSignature signature, MemberInfo property)
+        {
+            propertySetBindCache.Add(signature, property);
+        }
+
+        internal bool TryGetCachedPropertySetBindResult(BindSignature signature, out MemberInfo property)
+        {
+            return propertySetBindCache.TryGetValue(signature, out property);
+        }
+
+        private void ClearPropertyBindCache()
+        {
+            propertyGetBindCache.Clear();
+            propertySetBindCache.Clear();
         }
 
         #endregion

ClearScript/Util/ArrayHelpers.cs

@@ -47,7 +47,7 @@ namespace Microsoft.ClearScript.Util
 
         private static class EmptyArray<T>
         {
-            public static T[] Value { get; } = new T[0];
+            public static readonly T[] Value = new T[0];
         }
 
         #endregion

ClearScript/Util/MemberComparer.cs

@@ -8,7 +8,7 @@ namespace Microsoft.ClearScript.Util
 {
     internal sealed class MemberComparer<T> : EqualityComparer<T> where T : MemberInfo
     {
-        public static MemberComparer<T> Instance { get; } = new MemberComparer<T>();
+        public static readonly MemberComparer<T> Instance = new MemberComparer<T>();
 
         private MemberComparer()
         {

ClearScript/Util/SpecialMemberNames.cs

@@ -5,8 +5,8 @@ namespace Microsoft.ClearScript.Util
 {
     internal static class SpecialMemberNames
     {
-        public static string Default = MiscHelpers.GetDispIDName(SpecialDispIDs.Default);
-        public static string NewEnum = MiscHelpers.GetDispIDName(SpecialDispIDs.NewEnum);
-        public static string NewAsyncEnum = MiscHelpers.GetDispIDName(SpecialDispIDs.NewAsyncEnum);
+        public static readonly string Default = MiscHelpers.GetDispIDName(SpecialDispIDs.Default);
+        public static readonly string NewEnum = MiscHelpers.GetDispIDName(SpecialDispIDs.NewEnum);
+        public static readonly string NewAsyncEnum = MiscHelpers.GetDispIDName(SpecialDispIDs.NewAsyncEnum);
     }
 }

ClearScript/Util/SpecialParamNames.cs

@@ -5,6 +5,6 @@ namespace Microsoft.ClearScript.Util
 {
     internal static class SpecialParamNames
     {
-        public static string This = MiscHelpers.GetDispIDName(SpecialDispIDs.This);
+        public static readonly string This = MiscHelpers.GetDispIDName(SpecialDispIDs.This);
     }
 }

ClearScript/Util/TypeHelpers.cs

@@ -485,7 +485,7 @@ namespace Microsoft.ClearScript.Util
             return type.InvokeMember(string.Empty, BindingFlags.CreateInstance | BindingFlags.Instance | (flags & ~BindingFlags.Static), null, null, args, CultureInfo.InvariantCulture);
         }
 
-        public static object CreateInstance(this Type type, IHostInvokeContext invokeContext, Type accessContext, ScriptAccess defaultAccess, object[] args, object[] bindArgs)
+        public static object CreateInstance(this Type type, IHostInvokeContext invokeContext, HostTarget target, object[] args, object[] bindArgs)
         {
             if (type.IsCOMObject || (type.IsValueType && (args.Length < 1)))
             {
@@ -493,19 +493,26 @@ namespace Microsoft.ClearScript.Util
             }
 
             const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
-            var candidates = type.GetConstructors(flags).Where(testConstructor => testConstructor.IsAccessible(accessContext) && !testConstructor.IsBlockedFromScript(defaultAccess)).ToArray();
+
+            var signature = new BindSignature(invokeContext.AccessContext, flags, target, type.TypeHandle.Value.ToString(), ArrayHelpers.GetEmptyArray<Type>(), bindArgs);
+            if (invokeContext.Engine.TryGetCachedConstructorBindResult(signature, out var boundConstructor))
+            {
+                return InvokeHelpers.InvokeConstructor(invokeContext, boundConstructor, args);
+            }
+
+            var candidates = type.GetConstructors(flags).Where(testConstructor => testConstructor.IsAccessible(invokeContext.AccessContext) && !testConstructor.IsBlockedFromScript(invokeContext.DefaultAccess)).ToArray();
             if (candidates.Length < 1)
             {
                 throw new MissingMethodException(MiscHelpers.FormatInvariant("Type '{0}' has no constructor that matches the specified arguments", type.GetFullFriendlyName()));
             }
 
-            ConstructorInfo constructor = BindToMember(candidates, flags, args, bindArgs);
-
+            var constructor = BindToMember(candidates, flags, args, bindArgs);
             if (constructor == null)
             {
                 throw new MissingMethodException(MiscHelpers.FormatInvariant("Type '{0}' has no constructor that matches the specified arguments", type.GetFullFriendlyName()));
             }
 
+            invokeContext.Engine.CacheConstructorBindResult(signature, constructor);
             return InvokeHelpers.InvokeConstructor(invokeContext, constructor, args);
         }
 
@@ -1171,7 +1178,7 @@ namespace Microsoft.ClearScript.Util
 
         private sealed class PropertySignatureComparer : IEqualityComparer<PropertyInfo>
         {
-            public static PropertySignatureComparer Instance { get; } = new PropertySignatureComparer();
+            public static readonly PropertySignatureComparer Instance = new PropertySignatureComparer();
 
             #region IEqualityComparer<PropertyInfo> implementation
 

ClearScript/V8/SplitProxy/IV8SplitProxyNative.cs

@@ -110,7 +110,7 @@ namespace Microsoft.ClearScript.V8.SplitProxy
         void V8Value_SetBigInt(V8Value.Ptr pV8Value, int signBit, byte[] bytes);
         void V8Value_SetV8Object(V8Value.Ptr pV8Value, V8Object.Handle hObject, V8Value.Subtype subtype, V8Value.Flags flags);
         void V8Value_SetHostObject(V8Value.Ptr pV8Value, IntPtr pObject);
-        V8Value.Type V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle);
+        void V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded);
         void V8Value_Delete(V8Value.Ptr pV8Value);
 
         #endregion

ClearScript/V8/SplitProxy/V8SplitProxyHelpers.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
 using System;
@@ -897,49 +897,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
 
         public static object Get(Ptr pV8Value)
         {
-            var intValue = 0;
-            var uintValue = 0U;
-            var doubleValue = 0D;
-            var ptrOrHandle = IntPtr.Zero;
-
-            switch (V8SplitProxyNative.InvokeNoThrow(instance => instance.V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle)))
-            {
-                case Type.Nonexistent:
-                    return Nonexistent.Value;
-
-                case Type.Null:
-                    return DBNull.Value;
-
-                case Type.Boolean:
-                    return intValue != 0;
-
-                case Type.Number:
-                    return doubleValue;
-
-                case Type.Int32:
-                    return intValue;
-
-                case Type.UInt32:
-                    return uintValue;
-
-                case Type.String:
-                    return Marshal.PtrToStringUni(ptrOrHandle, intValue);
-
-                case Type.DateTime:
-                    return new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc) + TimeSpan.FromMilliseconds(doubleValue);
-
-                case Type.BigInt:
-                    return TryGetBigInteger(intValue, (int)uintValue, ptrOrHandle, out var result) ? (object)result : null;
-
-                case Type.V8Object:
-                    return new V8ObjectImpl((V8Object.Handle)ptrOrHandle, (Subtype)(uintValue & 0xFFFFU), (Flags)(uintValue >> 16), intValue);
-
-                case Type.HostObject:
-                    return V8ProxyHelpers.GetHostObject(ptrOrHandle);
-
-                default:
-                    return null;
-            }
+            var decoded = default(Decoded);
+            V8SplitProxyNative.InvokeNoThrow(instance => instance.V8Value_Decode(pV8Value, out decoded));
+            return decoded.Get();
         }
 
         private static bool TryGetBigInteger(int signBit, int wordCount, IntPtr pWords, out BigInteger result)
@@ -1039,7 +999,7 @@ namespace Microsoft.ClearScript.V8.SplitProxy
 
         #region Nested type: Type
 
-        public enum Type : ushort
+        public enum Type : byte
         {
             // IMPORTANT: maintain bitwise equivalence with native enum V8Value::Type
             Nonexistent,
@@ -1060,7 +1020,7 @@ namespace Microsoft.ClearScript.V8.SplitProxy
 
         #region Nested type: Subtype
 
-        public enum Subtype : ushort
+        public enum Subtype : byte
         {
             // IMPORTANT: maintain bitwise equivalence with native enum V8Value::Subtype
             None,
@@ -1101,7 +1061,7 @@ namespace Microsoft.ClearScript.V8.SplitProxy
 
         #region Nested type: Ptr
 
-        internal readonly struct Ptr
+        public readonly struct Ptr
         {
             private readonly IntPtr bits;
 
@@ -1124,8 +1084,113 @@ namespace Microsoft.ClearScript.V8.SplitProxy
         }
 
         #endregion
-    }
 
+        #region Nested type: Decoded
+
+        [StructLayout(LayoutKind.Explicit)]
+        public struct Decoded
+        {
+            // IMPORTANT: maintain bitwise equivalence with native struct V8Value::Decoded
+            [FieldOffset(0)] public Type Type;
+            [FieldOffset(1)] public Subtype Subtype;
+            [FieldOffset(2)] public Flags Flags;
+            [FieldOffset(2)] public short SignBit;
+            [FieldOffset(4)] public int Length;
+            [FieldOffset(4)] public int IdentityHash;
+            [FieldOffset(8)] public int Int32Value;
+            [FieldOffset(8)] public uint UInt32Value;
+            [FieldOffset(8)] public double DoubleValue;
+            [FieldOffset(8)] public IntPtr PtrOrHandle;
+
+            public object Get()
+            {
+                switch (Type)
+                {
+                    case Type.Nonexistent:
+                        return Nonexistent.Value;
+
+                    case Type.Null:
+                        return DBNull.Value;
+
+                    case Type.Boolean:
+                        return Int32Value != 0;
+
+                    case Type.Number:
+                        return DoubleValue;
+
+                    case Type.Int32:
+                        return Int32Value;
+
+                    case Type.UInt32:
+                        return UInt32Value;
+
+                    case Type.String:
+                        return Marshal.PtrToStringUni(PtrOrHandle, Length);
+
+                    case Type.DateTime:
+                        return new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc) + TimeSpan.FromMilliseconds(DoubleValue);
+
+                    case Type.BigInt:
+                        return TryGetBigInteger(SignBit, Length, PtrOrHandle, out var result) ? (object)result : null;
+
+                    case Type.V8Object:
+                        return new V8ObjectImpl((V8Object.Handle)PtrOrHandle, Subtype, Flags, IdentityHash);
+
+                    case Type.HostObject:
+                        return V8ProxyHelpers.GetHostObject(PtrOrHandle);
+
+                    default:
+                        return null;
+                }
+            }
+
+            public static unsafe object Get(Ptr pValues, int index)
+            {
+                return ((Decoded*)(IntPtr)pValues + index)->Get();
+            }
+
+            public static object[] ToArray(int count, Ptr pValues)
+            {
+                var array = new object[count];
+
+                for (var index = 0; index < count; index++)
+                {
+                    array[index] = Get(pValues, index);
+                }
+
+                return array;
+            }
+
+            #region Nested type: Ptr
+
+            // ReSharper disable once MemberHidesStaticFromOuterClass
+            public readonly struct Ptr
+            {
+                private readonly IntPtr bits;
+
+                private Ptr(IntPtr bits) => this.bits = bits;
+
+                public static readonly Ptr Null = new Ptr(IntPtr.Zero);
+
+                public static bool operator ==(Ptr left, Ptr right) => left.bits == right.bits;
+                public static bool operator !=(Ptr left, Ptr right) => left.bits != right.bits;
+
+                public static explicit operator IntPtr(Ptr ptr) => ptr.bits;
+                public static explicit operator Ptr(IntPtr bits) => new Ptr(bits);
+
+                #region Object overrides
+
+                public override bool Equals(object obj) => (obj is Ptr ptr) && (this == ptr);
+                public override int GetHashCode() => bits.GetHashCode();
+
+                #endregion
+            }
+
+            #endregion
+        }
+
+        #endregion
+    }
     internal static class V8CpuProfile
     {
         public static void ProcessProfile(V8Entity.Handle hEntity, Ptr pProfile, V8.V8CpuProfile profile)

ClearScript/V8/SplitProxy/V8SplitProxyManaged.Net5.cs

@@ -153,12 +153,12 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             get
             {
                 [UnmanagedCallersOnly(CallConvs = new[] { typeof(CallConvStdcall) })]
-                static void Thunk(IntPtr pObject, StdString.Ptr pName, V8Value.Ptr pValue)
+                static void Thunk(IntPtr pObject, StdString.Ptr pName, V8Value.Decoded.Ptr pValue)
                 {
                     SetHostObjectNamedProperty(pObject, pName, pValue);
                 }
 
-                delegate* unmanaged[Stdcall]<IntPtr, StdString.Ptr, V8Value.Ptr, void> pThunk = &Thunk;
+                delegate* unmanaged[Stdcall]<IntPtr, StdString.Ptr, V8Value.Decoded.Ptr, void> pThunk = &Thunk;
                 return (IntPtr)pThunk;
             }
         }
@@ -183,12 +183,12 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             get
             {
                 [UnmanagedCallersOnly(CallConvs = new[] { typeof(CallConvStdcall) })]
-                static void Thunk(IntPtr pObject, int index, V8Value.Ptr pValue)
+                static void Thunk(IntPtr pObject, int index, V8Value.Decoded.Ptr pValue)
                 {
                     SetHostObjectIndexedProperty(pObject, index, pValue);
                 }
 
-                delegate* unmanaged[Stdcall]<IntPtr, int, V8Value.Ptr, void> pThunk = &Thunk;
+                delegate* unmanaged[Stdcall]<IntPtr, int, V8Value.Decoded.Ptr, void> pThunk = &Thunk;
                 return (IntPtr)pThunk;
             }
         }
@@ -198,12 +198,12 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             get
             {
                 [UnmanagedCallersOnly(CallConvs = new[] { typeof(CallConvStdcall) })]
-                static void Thunk(IntPtr pObject, StdBool asConstructor, StdV8ValueArray.Ptr pArgs, V8Value.Ptr pResult)
+                static void Thunk(IntPtr pObject, StdBool asConstructor, int argCount, V8Value.Decoded.Ptr pArgs, V8Value.Ptr pResult)
                 {
-                    InvokeHostObject(pObject, asConstructor, pArgs, pResult);
+                    InvokeHostObject(pObject, asConstructor, argCount, pArgs, pResult);
                 }
 
-                delegate* unmanaged[Stdcall]<IntPtr, StdBool, StdV8ValueArray.Ptr, V8Value.Ptr, void> pThunk = &Thunk;
+                delegate* unmanaged[Stdcall]<IntPtr, StdBool, int, V8Value.Decoded.Ptr, V8Value.Ptr, void> pThunk = &Thunk;
                 return (IntPtr)pThunk;
             }
         }
@@ -213,12 +213,12 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             get
             {
                 [UnmanagedCallersOnly(CallConvs = new[] { typeof(CallConvStdcall) })]
-                static void Thunk(IntPtr pObject, StdString.Ptr pName, StdV8ValueArray.Ptr pArgs, V8Value.Ptr pResult)
+                static void Thunk(IntPtr pObject, StdString.Ptr pName, int argCount, V8Value.Decoded.Ptr pArgs, V8Value.Ptr pResult)
                 {
-                    InvokeHostObjectMethod(pObject, pName, pArgs, pResult);
+                    InvokeHostObjectMethod(pObject, pName, argCount, pArgs, pResult);
                 }
 
-                delegate* unmanaged[Stdcall]<IntPtr, StdString.Ptr, StdV8ValueArray.Ptr, V8Value.Ptr, void> pThunk = &Thunk;
+                delegate* unmanaged[Stdcall]<IntPtr, StdString.Ptr, int, V8Value.Decoded.Ptr, V8Value.Ptr, void> pThunk = &Thunk;
                 return (IntPtr)pThunk;
             }
         }

ClearScript/V8/SplitProxy/V8SplitProxyManaged.cs

@@ -190,7 +190,7 @@ namespace Microsoft.ClearScript.V8.SplitProxy
         private delegate void RawSetHostObjectNamedProperty(
             [In] IntPtr pObject,
             [In] StdString.Ptr pName,
-            [In] V8Value.Ptr pValue
+            [In] V8Value.Decoded.Ptr pValue
         );
 
         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
@@ -217,7 +217,7 @@ namespace Microsoft.ClearScript.V8.SplitProxy
         private delegate void RawSetHostObjectIndexedProperty(
             [In] IntPtr pObject,
             [In] int index,
-            [In] V8Value.Ptr pValue
+            V8Value.Decoded.Ptr pValue
         );
 
         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
@@ -237,7 +237,8 @@ namespace Microsoft.ClearScript.V8.SplitProxy
         private delegate void RawInvokeHostObject(
             [In] IntPtr pObject,
             [In] [MarshalAs(UnmanagedType.I1)] bool asConstructor,
-            [In] StdV8ValueArray.Ptr pArgs,
+            [In] int argCount,
+            [In] V8Value.Decoded.Ptr pArgs,
             [In] V8Value.Ptr pResult
         );
 
@@ -245,7 +246,8 @@ namespace Microsoft.ClearScript.V8.SplitProxy
         private delegate void RawInvokeHostObjectMethod(
             [In] IntPtr pObject,
             [In] StdString.Ptr pName,
-            [In] StdV8ValueArray.Ptr pArgs,
+            [In] int argCount,
+            [In] V8Value.Decoded.Ptr pArgs,
             [In] V8Value.Ptr pResult
         );
 
@@ -636,11 +638,11 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             }
         }
 
-        private static void SetHostObjectNamedProperty(IntPtr pObject, StdString.Ptr pName, V8Value.Ptr pValue)
+        private static void SetHostObjectNamedProperty(IntPtr pObject, StdString.Ptr pName, V8Value.Decoded.Ptr pValue)
         {
             try
             {
-                V8ProxyHelpers.SetHostObjectProperty(pObject, StdString.GetValue(pName), V8Value.Get(pValue));
+                V8ProxyHelpers.SetHostObjectProperty(pObject, StdString.GetValue(pName), V8Value.Decoded.Get(pValue, 0));
             }
             catch (Exception exception)
             {
@@ -689,11 +691,11 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             }
         }
 
-        private static void SetHostObjectIndexedProperty(IntPtr pObject, int index, V8Value.Ptr pValue)
+        private static void SetHostObjectIndexedProperty(IntPtr pObject, int index, V8Value.Decoded.Ptr pValue)
         {
             try
             {
-                V8ProxyHelpers.SetHostObjectProperty(pObject, index, V8Value.Get(pValue));
+                V8ProxyHelpers.SetHostObjectProperty(pObject, index, V8Value.Decoded.Get(pValue, 0));
             }
             catch (Exception exception)
             {
@@ -730,11 +732,11 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             StdInt32Array.CopyFromArray(pIndices, indices);
         }
 
-        private static void InvokeHostObject(IntPtr pObject, bool asConstructor, StdV8ValueArray.Ptr pArgs, V8Value.Ptr pResult)
+        private static void InvokeHostObject(IntPtr pObject, bool asConstructor, int argCount, V8Value.Decoded.Ptr pArgs, V8Value.Ptr pResult)
         {
             try
             {
-                V8Value.Set(pResult, V8ProxyHelpers.InvokeHostObject(pObject, asConstructor, StdV8ValueArray.ToArray(pArgs)));
+                V8Value.Set(pResult, V8ProxyHelpers.InvokeHostObject(pObject, asConstructor, V8Value.Decoded.ToArray(argCount, pArgs)));
             }
             catch (Exception exception)
             {
@@ -742,11 +744,11 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             }
         }
 
-        private static void InvokeHostObjectMethod(IntPtr pObject, StdString.Ptr pName, StdV8ValueArray.Ptr pArgs, V8Value.Ptr pResult)
+        private static void InvokeHostObjectMethod(IntPtr pObject, StdString.Ptr pName, int argCount, V8Value.Decoded.Ptr pArgs, V8Value.Ptr pResult)
         {
             try
             {
-                V8Value.Set(pResult, V8ProxyHelpers.InvokeHostObjectMethod(pObject, StdString.GetValue(pName), StdV8ValueArray.ToArray(pArgs)));
+                V8Value.Set(pResult, V8ProxyHelpers.InvokeHostObjectMethod(pObject, StdString.GetValue(pName), V8Value.Decoded.ToArray(argCount, pArgs)));
             }
             catch (Exception exception)
             {

ClearScript/V8/SplitProxy/V8SplitProxyNative.Common.tt

@@ -378,9 +378,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -1440,12 +1440,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("<#= fileName #>", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("<#= fileName #>", CallingConvention = CallingConvention.StdCall)]

ClearScript/V8/SplitProxy/V8SplitProxyNative.Generated.cs

@@ -420,9 +420,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -1482,12 +1482,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.win-x86.dll", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.win-x86.dll", CallingConvention = CallingConvention.StdCall)]
@@ -2482,9 +2479,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -3544,12 +3541,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.win-x64.dll", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.win-x64.dll", CallingConvention = CallingConvention.StdCall)]
@@ -4544,9 +4538,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -5606,12 +5600,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.win-arm64.dll", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.win-arm64.dll", CallingConvention = CallingConvention.StdCall)]
@@ -6606,9 +6597,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -7668,12 +7659,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.linux-x64.so", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.linux-x64.so", CallingConvention = CallingConvention.StdCall)]
@@ -8668,9 +8656,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -9730,12 +9718,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.linux-arm64.so", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.linux-arm64.so", CallingConvention = CallingConvention.StdCall)]
@@ -10730,9 +10715,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -11792,12 +11777,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
@@ -12792,9 +12774,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -13854,12 +13836,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.osx-x64.dylib", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.osx-x64.dylib", CallingConvention = CallingConvention.StdCall)]
@@ -14854,9 +14833,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -15916,12 +15895,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.osx-arm64.dylib", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.osx-arm64.dylib", CallingConvention = CallingConvention.StdCall)]

ClearScript/V8/SplitProxy/V8SplitProxyNative.UWP.Generated.cs

@@ -376,9 +376,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -1438,12 +1438,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.win-x86.dll", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.win-x86.dll", CallingConvention = CallingConvention.StdCall)]
@@ -2438,9 +2435,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -3500,12 +3497,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.win-x64.dll", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.win-x64.dll", CallingConvention = CallingConvention.StdCall)]
@@ -4500,9 +4494,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
                 V8Value_SetHostObject(pV8Value, pObject);
             }
 
-            V8Value.Type IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out int intValue, out uint uintValue, out double doubleValue, out IntPtr ptrOrHandle)
+            void IV8SplitProxyNative.V8Value_Decode(V8Value.Ptr pV8Value, out V8Value.Decoded decoded)
             {
-                return V8Value_Decode(pV8Value, out intValue, out uintValue, out doubleValue, out ptrOrHandle);
+                V8Value_Decode(pV8Value, out decoded);
             }
 
             void IV8SplitProxyNative.V8Value_Delete(V8Value.Ptr pV8Value)
@@ -5562,12 +5556,9 @@ namespace Microsoft.ClearScript.V8.SplitProxy
             );
 
             [DllImport("ClearScriptV8.win-arm64.dll", CallingConvention = CallingConvention.StdCall)]
-            private static extern V8Value.Type V8Value_Decode(
+            private static extern void V8Value_Decode(
                 [In] V8Value.Ptr pV8Value,
-                [Out] out int intValue,
-                [Out] out uint uintValue,
-                [Out] out double doubleValue,
-                [Out] out IntPtr ptrOrHandle
+                [Out] out V8Value.Decoded decoded
             );
 
             [DllImport("ClearScriptV8.win-arm64.dll", CallingConvention = CallingConvention.StdCall)]

ClearScript/V8/V8Runtime.cs

@@ -847,9 +847,9 @@ namespace Microsoft.ClearScript.V8
 
         #region internal members
 
-        internal IUniqueNameManager DocumentNameManager { get; } = new UniqueFileNameManager();
+        internal readonly UniqueFileNameManager DocumentNameManager = new UniqueFileNameManager();
 
-        internal HostItemCollateral HostItemCollateral { get; } = new HostItemCollateral();
+        internal readonly HostItemCollateral HostItemCollateral = new HostItemCollateral();
 
         internal V8IsolateProxy IsolateProxy
         {

ClearScriptBenchmarks/ClearScriptBenchmarks.Unix.cs

@@ -22,7 +22,7 @@ namespace Microsoft.ClearScript.Test
             var burn = (args.Length == 2) && (args[0] == "-b") && uint.TryParse(args[1], out choice) && (choice >= 1) && (choice <= 2);
 
             Console.Clear();
-            if (!burn) Console.WriteLine("ClearScript Benchmarks ({0}, {1}, {2} {3})\n", RuntimeInformation.FrameworkDescription, RuntimeInformation.OSDescription, RuntimeInformation.ProcessArchitecture, flavor);
+            if (!burn) Console.WriteLine("ClearScript Benchmarks ({0}, {1}, {2} {3})\n", RuntimeInformation.FrameworkDescription.Trim(), RuntimeInformation.OSDescription.Trim(), RuntimeInformation.ProcessArchitecture, flavor);
 
             var count = 0UL;
 

ClearScriptBenchmarks/ClearScriptBenchmarks.Windows.cs

@@ -23,7 +23,7 @@ namespace Microsoft.ClearScript.Test
             var burn = (args.Length == 2) && (args[0] == "-b") && uint.TryParse(args[1], out choice) && (choice >= 1) && (choice <= 3);
 
             Console.Clear();
-            if (!burn) Console.WriteLine("ClearScript Benchmarks ({0}, {1}, {2} {3})\n", RuntimeInformation.FrameworkDescription, RuntimeInformation.OSDescription, RuntimeInformation.ProcessArchitecture, flavor);
+            if (!burn) Console.WriteLine("ClearScript Benchmarks ({0}, {1}, {2} {3})\n", RuntimeInformation.FrameworkDescription.Trim(), RuntimeInformation.OSDescription.Trim(), RuntimeInformation.ProcessArchitecture, flavor);
 
             var count = 0UL;
 

ClearScriptBenchmarks/Properties/AssemblyInfo.cs

@@ -11,6 +11,6 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCopyright("(c) Microsoft Corporation")]
 
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("7.4.0")]
-[assembly: AssemblyFileVersion("7.4.0")]
-[assembly: AssemblyInformationalVersion("7.4.0")]
+[assembly: AssemblyVersion("7.4.1")]
+[assembly: AssemblyFileVersion("7.4.1")]
+[assembly: AssemblyInformationalVersion("7.4.1")]

ClearScriptConsole/ClearScriptConsole.cs

@@ -6,12 +6,19 @@ using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.InteropServices;
 using Microsoft.ClearScript.V8;
 
 namespace Microsoft.ClearScript.Test
 {
     internal static class ClearScriptConsole
     {
+    #if DEBUG
+        private const string flavor = "Debug";
+    #else
+        private const string flavor = "Release";
+    #endif
+
         public static void Main(string[] args)
         {
             if ((args.Length == 2) && (args[0] == "-t"))
@@ -20,6 +27,8 @@ namespace Microsoft.ClearScript.Test
                 return;
             }
 
+            Console.WriteLine("ClearScript Console ({0}, {1}, {2} {3})", RuntimeInformation.FrameworkDescription.Trim(), RuntimeInformation.OSDescription.Trim(), RuntimeInformation.ProcessArchitecture, flavor);
+
             using (var engine = new V8ScriptEngine(nameof(ClearScriptConsole), V8ScriptEngineFlags.EnableDebugging))
             {
                 engine.AddHostObject("host", new ExtendedHostFunctions());

ClearScriptConsole/Properties/AssemblyInfo.cs

@@ -11,6 +11,6 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCopyright("(c) Microsoft Corporation")]
 
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("7.4.0")]
-[assembly: AssemblyFileVersion("7.4.0")]
-[assembly: AssemblyInformationalVersion("7.4.0")]
+[assembly: AssemblyVersion("7.4.1")]
+[assembly: AssemblyFileVersion("7.4.1")]
+[assembly: AssemblyInformationalVersion("7.4.1")]

ClearScriptTest/BugFixTest.cs

@@ -299,7 +299,7 @@ namespace Microsoft.ClearScript.Test
         [TestMethod, TestCategory("BugFix")]
         public void BugFix_CoreBindCache()
         {
-            HostItem.ResetCoreBindCache();
+            HostItem.ClearCoreBindCache();
 
             engine.Dispose();
             for (var i = 0; i < 10; i++)

ClearScriptTest/Properties/AssemblyInfo.cs

@@ -11,6 +11,6 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCopyright("(c) Microsoft Corporation")]
 
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("7.4.0")]
-[assembly: AssemblyFileVersion("7.4.0")]
-[assembly: AssemblyInformationalVersion("7.4.0")]
+[assembly: AssemblyVersion("7.4.1")]
+[assembly: AssemblyFileVersion("7.4.1")]
+[assembly: AssemblyInformationalVersion("7.4.1")]

ClearScriptTest/V8ScriptEngineTest.cs

@@ -4613,6 +4613,39 @@ namespace Microsoft.ClearScript.Test
             Assert.AreEqual((JavaScriptObjectKind.TypedArray, JavaScriptObjectFlags.Shared), Inspect("new Float64Array(new SharedArrayBuffer(256))"));
         }
 
+        [TestMethod, TestCategory("V8ScriptEngine")]
+        public void V8ScriptEngine_ConstructorBinding()
+        {
+            engine.AddHostType("Foo", typeof(ConstructorBindingTest));
+            dynamic test = engine.Evaluate(@"(function(length) {
+                const a = new Array(length);
+                for (let i = 0; i < length; ++i)
+                    a[i] = new Foo(123);
+                const b = new Array(length);
+                for (let i = 0; i < length; ++i)
+                    b[i] = new Foo('qux');
+                const c = new Array(length);
+                for (let i = 0; i < length; ++i)
+                    c[i] = new Foo(456.789);
+                return { a, b, c };
+            })");
+
+            const int length = 1000;
+            var result = (IDictionary<string, object>)test(length);
+
+            var a = (IList<object>)result["a"];
+            var b = (IList<object>)result["b"];
+            var c = (IList<object>)result["c"];
+
+            Assert.AreEqual(length, a.Count);
+            Assert.AreEqual(length, b.Count);
+            Assert.AreEqual(length, c.Count);
+
+            Assert.IsTrue(a.All(value => ((ConstructorBindingTest)value).A == 123));
+            Assert.IsTrue(b.All(value => ((ConstructorBindingTest)value).A == 456));
+            Assert.IsTrue(c.All(value => ((ConstructorBindingTest)value).A == 789));
+        }
+
         // ReSharper restore InconsistentNaming
 
         #endregion
@@ -4958,6 +4991,28 @@ namespace Microsoft.ClearScript.Test
 
         // ReSharper restore UnusedMember.Local
 
+        public class ConstructorBindingTest
+        {
+            public int A;
+            public string B;
+            public double C;
+
+            public ConstructorBindingTest(int a, string b = "foo", double c = 456.789)
+            {
+                A = a; B = b; C = c;
+            }
+
+            public ConstructorBindingTest(string b, int a = 456, double c = 789.987)
+            {
+                A = a; B = b; C = c;
+            }
+
+            public ConstructorBindingTest(double c, int a = 789, string b = "bar")
+            {
+                A = a; B = b; C = c;
+            }
+        }
+
         #endregion
     }
 }

ClearScriptV8/HostObjectUtil.cpp

@@ -47,7 +47,9 @@ public:
 
     virtual void SetProperty(void* pvObject, const StdString& name, const V8Value& value) override
     {
-        V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(SetHostObjectNamedProperty, pvObject, name, value);
+        V8Value::Decoded decodedValue;
+        value.Decode(decodedValue);
+        V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(SetHostObjectNamedProperty, pvObject, name, decodedValue);
     }
 
     virtual bool DeleteProperty(void* pvObject, const StdString& name) override
@@ -69,7 +71,9 @@ public:
 
     virtual void SetProperty(void* pvObject, int32_t index, const V8Value& value) override
     {
-        V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(SetHostObjectIndexedProperty, pvObject, index, value);
+        V8Value::Decoded decodedValue;
+        value.Decode(decodedValue);
+        V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(SetHostObjectIndexedProperty, pvObject, index, decodedValue);
     }
 
     virtual bool DeleteProperty(void* pvObject, int32_t index) override
@@ -85,14 +89,54 @@ public:
     virtual V8Value Invoke(void* pvObject, bool asConstructor, const std::vector<V8Value>& args) override
     {
         V8Value result(V8Value::Nonexistent);
-        V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(InvokeHostObject, pvObject, asConstructor, args, result);
+
+        auto argCount = args.size();
+        if (argCount < 1)
+        {
+            V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(InvokeHostObject, pvObject, asConstructor, 0, nullptr, result);
+        }
+        else
+        {
+            auto pArgs = args.data();
+
+            auto upDecodedArgs = std::make_unique<V8Value::Decoded[]>(argCount);
+            auto pDecodedArgs = upDecodedArgs.get();
+
+            for (size_t index = 0; index < argCount; index++)
+            {
+                pArgs[index].Decode(pDecodedArgs[index]);
+            }
+
+            V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(InvokeHostObject, pvObject, asConstructor, static_cast<int32_t>(argCount), pDecodedArgs, result);
+        }
+
         return result;
     }
 
     virtual V8Value InvokeMethod(void* pvObject, const StdString& name, const std::vector<V8Value>& args) override
     {
         V8Value result(V8Value::Nonexistent);
-        V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(InvokeHostObjectMethod, pvObject, name, args, result);
+
+        auto argCount = args.size();
+        if (argCount < 1)
+        {
+            V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(InvokeHostObjectMethod, pvObject, name, 0, nullptr, result);
+        }
+        else
+        {
+            auto pArgs = args.data();
+
+            auto upDecodedArgs = std::make_unique<V8Value::Decoded[]>(argCount);
+            auto pDecodedArgs = upDecodedArgs.get();
+
+            for (size_t index = 0; index < argCount; index++)
+            {
+                pArgs[index].Decode(pDecodedArgs[index]);
+            }
+
+            V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(InvokeHostObjectMethod, pvObject, name, static_cast<int32_t>(argCount), pDecodedArgs, result);
+        }
+
         return result;
     }
 

ClearScriptV8/V8IsolateImpl.cpp

@@ -2109,28 +2109,15 @@ void V8IsolateImpl::FlushContext(V8ContextImpl& contextImpl)
 
 size_t V8IsolateImpl::HeapExpansionCallback(void* pvData, size_t currentLimit, size_t /*initialLimit*/)
 {
+    const size_t minBump = 1024 * 1024;
+
     if (pvData)
     {
         auto multiplier = static_cast<const V8IsolateImpl*>(pvData)->m_HeapExpansionMultiplier;
         if (multiplier > 1.0)
         {
-            multiplier = std::max(multiplier, 1.001);
-            const size_t minBump = 1024 * 1024;
-
-            auto newLimit = static_cast<double>(currentLimit);
-            while ((static_cast<size_t>(newLimit) - currentLimit) < minBump)
-            {
-                auto tempLimit = multiplier * newLimit;
-                if (tempLimit > newLimit)
-                {
-                    newLimit = tempLimit;
-                    continue;
-                }
-
-                break;
-            }
-
-            return std::max(static_cast<size_t>(newLimit), currentLimit);
+            auto newLimit = static_cast<size_t>(static_cast<double>(currentLimit) * multiplier);
+            return std::max(newLimit, currentLimit + minBump);
         }
     }
 

ClearScriptV8/V8SplitProxyManaged.h

@@ -41,17 +41,17 @@
     \
     V8_SPLIT_PROXY_MANAGED_METHOD(void, GetHostObjectNamedProperty, void* pvObject, const StdString& name, V8Value& value) \
     V8_SPLIT_PROXY_MANAGED_METHOD(void, GetHostObjectNamedPropertyWithCacheability, void* pvObject, const StdString& name, V8Value& value, StdBool& isCacheable) \
-    V8_SPLIT_PROXY_MANAGED_METHOD(void, SetHostObjectNamedProperty, void* pvObject, const StdString& name, const V8Value& value) \
+    V8_SPLIT_PROXY_MANAGED_METHOD(void, SetHostObjectNamedProperty, void* pvObject, const StdString& name, const V8Value::Decoded& value) \
     V8_SPLIT_PROXY_MANAGED_METHOD(StdBool, DeleteHostObjectNamedProperty, void* pvObject, const StdString& name) \
     V8_SPLIT_PROXY_MANAGED_METHOD(void, GetHostObjectPropertyNames, void* pvObject, std::vector<StdString>& names) \
     \
     V8_SPLIT_PROXY_MANAGED_METHOD(void, GetHostObjectIndexedProperty, void* pvObject, int32_t index, V8Value& value) \
-    V8_SPLIT_PROXY_MANAGED_METHOD(void, SetHostObjectIndexedProperty, void* pvObject, int32_t index, const V8Value& value) \
+    V8_SPLIT_PROXY_MANAGED_METHOD(void, SetHostObjectIndexedProperty, void* pvObject, int32_t index, const V8Value::Decoded& value) \
     V8_SPLIT_PROXY_MANAGED_METHOD(StdBool, DeleteHostObjectIndexedProperty, void* pvObject, int32_t index) \
     V8_SPLIT_PROXY_MANAGED_METHOD(void, GetHostObjectPropertyIndices, void* pvObject, std::vector<int32_t>& indices) \
     \
-    V8_SPLIT_PROXY_MANAGED_METHOD(void, InvokeHostObject, void* pvObject, StdBool asConstructor, const std::vector<V8Value>& args, V8Value& result) \
-    V8_SPLIT_PROXY_MANAGED_METHOD(void, InvokeHostObjectMethod, void* pvObject, const StdString& name, const std::vector<V8Value>& args, V8Value& result) \
+    V8_SPLIT_PROXY_MANAGED_METHOD(void, InvokeHostObject, void* pvObject, StdBool asConstructor, int32_t argCount, const V8Value::Decoded* pArgs, V8Value& result) \
+    V8_SPLIT_PROXY_MANAGED_METHOD(void, InvokeHostObjectMethod, void* pvObject, const StdString& name, int32_t argCount, const V8Value::Decoded* pArgs, V8Value& result) \
     \
     V8_SPLIT_PROXY_MANAGED_METHOD(void, GetHostObjectEnumerator, void* pvObject, V8Value& result) \
     V8_SPLIT_PROXY_MANAGED_METHOD(void, GetHostObjectAsyncEnumerator, void* pvObject, V8Value& result) \

ClearScriptV8/V8SplitProxyNative.cpp

@@ -65,19 +65,6 @@ static void ProcessCpuProfile(const v8::CpuProfile& profile, void* pvAction)
     }
 }
 
-//-----------------------------------------------------------------------------
-
-static uint32_t PackV8ObjectInfo(V8Value::Subtype subtype, V8Value::Flags flags)
-{
-    static_assert(sizeof(subtype) == 2);
-    uint32_t subtypeBits = static_cast<std::underlying_type_t<V8Value::Subtype>>(subtype);
-
-    static_assert(sizeof(flags) == 2);
-    uint32_t flagsBits = static_cast<std::underlying_type_t<V8Value::Flags>>(flags);
-
-    return subtypeBits | (flagsBits << 16);
-}
-
 //-----------------------------------------------------------------------------
 // V8Exception implementation
 //-----------------------------------------------------------------------------
@@ -119,6 +106,57 @@ void V8EntityHandleBase::ScheduleInvalidOperationException(const StdString& mess
     V8_SPLIT_PROXY_MANAGED_INVOKE_VOID(ScheduleInvalidOperationException, message);
 }
 
+//-----------------------------------------------------------------------------
+// V8Value (implementation)
+//-----------------------------------------------------------------------------
+
+void V8Value::Decode(Decoded& decoded) const
+{
+    decoded.Type = m_Type;
+    if (m_Type == Type::Boolean)
+    {
+        decoded.Int32Value = m_Data.BooleanValue;
+    }
+    else if (m_Type == Type::Number)
+    {
+        decoded.DoubleValue = m_Data.DoubleValue;
+    }
+    else if (m_Type == Type::Int32)
+    {
+        decoded.Int32Value = m_Data.Int32Value;
+    }
+    else if (m_Type == Type::UInt32)
+    {
+        decoded.UInt32Value = m_Data.UInt32Value;
+    }
+    else if (m_Type == Type::String)
+    {
+        decoded.pvData = m_Data.pString->ToCString();
+        decoded.Length = static_cast<int32_t>(m_Data.pString->GetLength());
+    }
+    else if (m_Type == Type::DateTime)
+    {
+        decoded.DoubleValue = m_Data.DoubleValue;
+    }
+    else if (m_Type == Type::BigInt)
+    {
+        decoded.pvData = m_Data.pBigInt->GetWords().data();
+        decoded.Length = static_cast<int32_t>(m_Data.pBigInt->GetWords().size());
+        decoded.SignBit = static_cast<int16_t>(m_Data.pBigInt->GetSignBit());
+    }
+    else if (m_Type == Type::V8Object)
+    {
+        decoded.pvData = new V8ObjectHandle(m_Data.pV8ObjectHolder->Clone());
+        decoded.Subtype = m_Subtype;
+        decoded.Flags = m_Flags;
+        decoded.IdentityHash = m_Data.pV8ObjectHolder->GetIdentityHash();
+    }
+    else if (m_Type == Type::HostObject)
+    {
+        decoded.pvData = m_Data.pHostObjectHolder->GetObject();
+    }
+}
+
 //-----------------------------------------------------------------------------
 // V8 split proxy native entry points (implementation)
 //-----------------------------------------------------------------------------
@@ -528,97 +566,9 @@ NATIVE_ENTRY_POINT(void) V8Value_SetHostObject(V8Value* pV8Value, void* pvObject
 
 //-----------------------------------------------------------------------------
 
-NATIVE_ENTRY_POINT(V8Value::Type) V8Value_Decode(const V8Value& value, int32_t& intValue, uint32_t& uintValue, double& doubleValue, const void*& pvData) noexcept
+NATIVE_ENTRY_POINT(void) V8Value_Decode(const V8Value& value, V8Value::Decoded& decoded) noexcept
 {
-    {
-        bool result;
-        if (value.AsBoolean(result))
-        {
-            intValue = result;
-            return V8Value::Type::Boolean;
-        }
-    }
-
-    {
-        double result;
-        if (value.AsNumber(result))
-        {
-            doubleValue = result;
-            return V8Value::Type::Number;
-        }
-    }
-
-    {
-        int32_t result;
-        if (value.AsInt32(result))
-        {
-            intValue = result;
-            return V8Value::Type::Int32;
-        }
-    }
-
-    {
-        uint32_t result;
-        if (value.AsUInt32(result))
-        {
-            uintValue = result;
-            return V8Value::Type::UInt32;
-        }
-    }
-
-    {
-        const StdString* pString;
-        if (value.AsString(pString))
-        {
-            pvData = pString->ToCString();
-            intValue = pString->GetLength();
-            return V8Value::Type::String;
-        }
-    }
-
-    {
-        double result;
-        if (value.AsDateTime(result))
-        {
-            doubleValue = result;
-            return V8Value::Type::DateTime;
-        }
-    }
-
-    {
-        const V8BigInt* pBigInt;
-        if (value.AsBigInt(pBigInt))
-        {
-            intValue = pBigInt->GetSignBit();
-            pvData = pBigInt->GetWords().data();
-            uintValue = static_cast<uint32_t>(pBigInt->GetWords().size());
-            return V8Value::Type::BigInt;
-        }
-    }
-
-    {
-        V8ObjectHolder* pHolder;
-        V8Value::Subtype subtype;
-        V8Value::Flags flags;
-        if (value.AsV8Object(pHolder, subtype, flags))
-        {
-            pvData = new V8ObjectHandle(pHolder->Clone());
-            uintValue = PackV8ObjectInfo(subtype, flags);
-            intValue = pHolder->GetIdentityHash();
-            return V8Value::Type::V8Object;
-        }
-    }
-
-    {
-        HostObjectHolder* pHolder;
-        if (value.AsHostObject(pHolder))
-        {
-            pvData = pHolder->GetObject();
-            return V8Value::Type::HostObject;
-        }
-    }
-
-    return value.GetType();
+    value.Decode(decoded);
 }
 
 //-----------------------------------------------------------------------------

ClearScriptV8/V8SplitProxyNative.h

@@ -221,7 +221,7 @@ NATIVE_ENTRY_POINT(void) V8Value_SetDateTime(V8Value* pV8Value, double value) no
 NATIVE_ENTRY_POINT(void) V8Value_SetBigInt(V8Value* pV8Value, int32_t signBit, const uint8_t* pBytes, int32_t length) noexcept;
 NATIVE_ENTRY_POINT(void) V8Value_SetV8Object(V8Value* pV8Value, const V8ObjectHandle& handle, V8Value::Subtype subtype, V8Value::Flags flags) noexcept;
 NATIVE_ENTRY_POINT(void) V8Value_SetHostObject(V8Value* pV8Value, void* pvObject) noexcept;
-NATIVE_ENTRY_POINT(V8Value::Type) V8Value_Decode(const V8Value& value, int32_t& intValue, uint32_t& uintValue, double& doubleValue, const void*& pvData) noexcept;
+NATIVE_ENTRY_POINT(void) V8Value_Decode(const V8Value& value, V8Value::Decoded& decoded) noexcept;
 NATIVE_ENTRY_POINT(void) V8Value_Delete(V8Value* pV8Value) noexcept;
 
 NATIVE_ENTRY_POINT(void) V8CpuProfile_GetInfo(const v8::CpuProfile& profile, const V8EntityHandleBase& entityHandle, StdString& name, uint64_t& startTimestamp, uint64_t& endTimestamp, int32_t& sampleCount, const v8::CpuProfileNode*& pRootNode) noexcept;

ClearScriptV8/V8Value.h

@@ -95,7 +95,7 @@ public:
         DateTime
     };
 
-    enum class Type: uint16_t
+    enum class Type: uint8_t
     {
         // IMPORTANT: maintain bitwise equivalence with managed enum V8.SplitProxy.V8Value.Type
         Nonexistent,
@@ -112,7 +112,7 @@ public:
         HostObject
     };
 
-    enum class Subtype: uint16_t
+    enum class Subtype: uint8_t
     {
         // IMPORTANT: maintain bitwise equivalence with managed enum V8.SplitProxy.V8Value.Subtype
         None,
@@ -144,6 +144,42 @@ public:
         Generator = 0x0004
     };
 
+    struct Decoded
+    {
+        // IMPORTANT: maintain bitwise equivalence with managed struct V8.SplitProxy.V8Value.Decoded
+        Type Type;
+        Subtype Subtype;
+        union
+        {
+            Flags Flags;
+            int16_t SignBit;
+        };
+        union
+        {
+            int32_t Length;
+            int32_t IdentityHash;
+        };
+        union
+        {
+            int32_t Int32Value;
+            uint32_t UInt32Value;
+            double DoubleValue;
+            const void* pvData;
+        };
+    };
+
+    static_assert(sizeof(Decoded) == 16, "The managed SplitProxy code assumes that sizeof(Decoded) is 16 on all platforms.");
+    static_assert(offsetof(Decoded, Type) == 0, "The managed SplitProxy code assumes that offsetof(Decoded, Type) is 0 on all platforms.");
+    static_assert(offsetof(Decoded, Subtype) == 1, "The managed SplitProxy code assumes that offsetof(Decoded, Subtype) is 1 on all platforms.");
+    static_assert(offsetof(Decoded, Flags) == 2, "The managed SplitProxy code assumes that offsetof(Decoded, Flags) is 2 on all platforms.");
+    static_assert(offsetof(Decoded, SignBit) == 2, "The managed SplitProxy code assumes that offsetof(Decoded, SignBit) is 2 on all platforms.");
+    static_assert(offsetof(Decoded, Length) == 4, "The managed SplitProxy code assumes that offsetof(Decoded, Length) is 4 on all platforms.");
+    static_assert(offsetof(Decoded, IdentityHash) == 4, "The managed SplitProxy code assumes that offsetof(Decoded, IdentityHash) is 4 on all platforms.");
+    static_assert(offsetof(Decoded, Int32Value) == 8, "The managed SplitProxy code assumes that offsetof(Decoded, Int32Value) is 8 on all platforms.");
+    static_assert(offsetof(Decoded, UInt32Value) == 8, "The managed SplitProxy code assumes that offsetof(Decoded, UInt32Value) is 8 on all platforms.");
+    static_assert(offsetof(Decoded, DoubleValue) == 8, "The managed SplitProxy code assumes that offsetof(Decoded, DoubleValue) is 8 on all platforms.");
+    static_assert(offsetof(Decoded, pvData) == 8, "The managed SplitProxy code assumes that offsetof(Decoded, pvData) is 8 on all platforms.");
+
     explicit V8Value(NonexistentInitializer):
         m_Type(Type::Nonexistent)
     {
@@ -360,6 +396,8 @@ public:
         return m_Type;
     }
 
+    void Decode(Decoded& decoded) const;
+
     ~V8Value()
     {
         Dispose();
@@ -455,7 +493,7 @@ private:
     Type m_Type;
     Subtype m_Subtype;
     Flags m_Flags;
-    int16_t m_Padding;
+    int32_t m_Padding;
     Data m_Data;
 };
 

ReadMe.md

@@ -1,4 +1,4 @@
-[![Banner](https://github.com/microsoft/ClearScript/blob/master/docs/ClearScript7-ReadMe.png)](https://microsoft.github.io/ClearScript/)
+[![Banner](https://raw.githubusercontent.com/microsoft/ClearScript/master/docs/ClearScript7-ReadMe.png)](https://microsoft.github.io/ClearScript/)
 
 [![Twitter Follow](https://img.shields.io/badge/Follow-%40ClearScriptLib-white?logo=twitter&style=social)](https://twitter.com/ClearScriptLib)
 

Unix/V8Update.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-v8testedrev=11.1.277.14
+v8testedrev=11.2.214.13
 v8testedcommit=
 v8cherrypicks=
 v8linuxbuildcommit=3d9590754d5d23e62d15472c5baf6777ca59df20

V8/V8Patch.txt

@@ -1,8 +1,8 @@
 diff --git a/BUILD.gn b/BUILD.gn
-index 316bcb4d3c..65833d40b6 100644
+index 277f47717d..9589c54e60 100644
 --- a/BUILD.gn
 +++ b/BUILD.gn
-@@ -1119,7 +1119,7 @@ config("toolchain") {
+@@ -1121,7 +1121,7 @@ config("toolchain") {
    visibility = [ "./*" ]
  
    defines = []
@@ -36,6 +36,19 @@ index d3e35d6ec5..2d2fb458fe 100644
  
    /**
     * Initialize the ICU library bundled with V8. The embedder should only
+diff --git a/include/v8-platform.h b/include/v8-platform.h
+index 750131d4c9..c390d801ed 100644
+--- a/include/v8-platform.h
++++ b/include/v8-platform.h
+@@ -1089,7 +1089,7 @@ class Platform {
+    * required.
+    */
+   virtual int64_t CurrentClockTimeMilliseconds() {
+-    return floor(CurrentClockTimeMillis());
++    return static_cast<int64_t>(floor(CurrentClockTimeMillis()));
+   }
+ 
+   /**
 diff --git a/include/v8-template.h b/include/v8-template.h
 index 11296cd488..0f090446dc 100644
 --- a/include/v8-template.h
@@ -51,10 +64,10 @@ index 11296cd488..0f090446dc 100644
     * Support for TC39 "dynamic code brand checks" proposal.
     *
 diff --git a/include/v8config.h b/include/v8config.h
-index b44995e7cd..cb7928b515 100644
+index 9410eb4135..b9bdc7a6a0 100644
 --- a/include/v8config.h
 +++ b/include/v8config.h
-@@ -524,7 +524,7 @@ path. Add it with -I<path> to the command line
+@@ -531,7 +531,7 @@ path. Add it with -I<path> to the command line
  // Use like:
  //   V8_NOINLINE V8_PRESERVE_MOST void UnlikelyMethod();
  #if V8_HAS_ATTRIBUTE_PRESERVE_MOST
@@ -78,10 +91,10 @@ index 05a883f2d5..3ea0b8ce62 100644
      // Keep prototypes in slow-mode. Let them be lazily turned fast later on.
      // TODO(dcarney): is this necessary?
 diff --git a/src/api/api.cc b/src/api/api.cc
-index 81c7d1e3f9..da9e93fa17 100644
+index fac24bae12..0c558589ea 100644
 --- a/src/api/api.cc
 +++ b/src/api/api.cc
-@@ -2043,6 +2043,17 @@ void ObjectTemplate::SetImmutableProto() {
+@@ -2057,6 +2057,17 @@ void ObjectTemplate::SetImmutableProto() {
    self->set_immutable_proto(true);
  }
  
@@ -99,7 +112,7 @@ index 81c7d1e3f9..da9e93fa17 100644
  bool ObjectTemplate::IsCodeLike() const {
    return Utils::OpenHandle(this)->code_like();
  }
-@@ -6466,6 +6477,10 @@ bool v8::V8::InitializeICU(const char* icu_data_file) {
+@@ -6445,6 +6456,10 @@ bool v8::V8::InitializeICU(const char* icu_data_file) {
    return i::InitializeICU(icu_data_file);
  }
  
@@ -127,7 +140,7 @@ index 34a26d9c26..f995a2fc64 100644
           MatchLiteralCompareTypeof(right_, op(), left_, expr, literal);
  }
 diff --git a/src/base/platform/platform.h b/src/base/platform/platform.h
-index 88d35540b1..20863d6f5b 100644
+index b9b734dac8..b577e3e01a 100644
 --- a/src/base/platform/platform.h
 +++ b/src/base/platform/platform.h
 @@ -52,6 +52,8 @@
@@ -154,10 +167,10 @@ index 417e6f1dfa..108dc20972 100644
      // The evaluation of async module can not throwing a JavaScript observable
      // exception.
 diff --git a/src/codegen/code-stub-assembler.cc b/src/codegen/code-stub-assembler.cc
-index 7d47afa2c9..cc95781cbc 100644
+index 1091943889..dbc699384c 100644
 --- a/src/codegen/code-stub-assembler.cc
 +++ b/src/codegen/code-stub-assembler.cc
-@@ -2006,6 +2006,10 @@ TNode<Uint32T> CodeStubAssembler::LoadMapBitField3(TNode<Map> map) {
+@@ -2027,6 +2027,10 @@ TNode<Uint32T> CodeStubAssembler::LoadMapBitField3(TNode<Map> map) {
    return LoadObjectField<Uint32T>(map, Map::kBitField3Offset);
  }
  
@@ -168,7 +181,7 @@ index 7d47afa2c9..cc95781cbc 100644
  TNode<Uint16T> CodeStubAssembler::LoadMapInstanceType(TNode<Map> map) {
    return LoadObjectField<Uint16T>(map, Map::kInstanceTypeOffset);
  }
-@@ -14308,6 +14312,11 @@ TNode<String> CodeStubAssembler::Typeof(TNode<Object> value) {
+@@ -14364,6 +14368,11 @@ TNode<String> CodeStubAssembler::Typeof(TNode<Object> value) {
  
    GotoIf(InstanceTypeEqual(instance_type, ODDBALL_TYPE), &if_oddball);
  
@@ -181,7 +194,7 @@ index 7d47afa2c9..cc95781cbc 100644
        Word32And(LoadMapBitField(map),
                  Int32Constant(Map::Bits1::IsCallableBit::kMask |
 diff --git a/src/codegen/code-stub-assembler.h b/src/codegen/code-stub-assembler.h
-index fdd6da6017..c4eb41496c 100644
+index d4d6e12bae..890a6cf249 100644
 --- a/src/codegen/code-stub-assembler.h
 +++ b/src/codegen/code-stub-assembler.h
 @@ -1409,6 +1409,8 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
@@ -194,7 +207,7 @@ index fdd6da6017..c4eb41496c 100644
    TNode<Uint16T> LoadMapInstanceType(TNode<Map> map);
    // Load the ElementsKind of a map.
 diff --git a/src/common/globals.h b/src/common/globals.h
-index d379cbfc61..d11438763b 100644
+index 34d0c01cb6..bda045dece 100644
 --- a/src/common/globals.h
 +++ b/src/common/globals.h
 @@ -270,7 +270,7 @@ const size_t kShortBuiltinCallsOldSpaceSizeThreshold = size_t{2} * GB;
@@ -207,7 +220,7 @@ index d379cbfc61..d11438763b 100644
  #define V8_HEAP_USE_PTHREAD_JIT_WRITE_PROTECT false
  #endif
 diff --git a/src/diagnostics/unwinding-info-win64.cc b/src/diagnostics/unwinding-info-win64.cc
-index 767eb015ab..acd70f7167 100644
+index a71b866135..4f1d26676c 100644
 --- a/src/diagnostics/unwinding-info-win64.cc
 +++ b/src/diagnostics/unwinding-info-win64.cc
 @@ -462,6 +462,14 @@ void InitUnwindingRecord(Record* record, size_t code_size_in_bytes) {
@@ -286,7 +299,7 @@ index 767eb015ab..acd70f7167 100644
        // Unprotect reserved page.
        DWORD old_protect;
 diff --git a/src/execution/isolate-inl.h b/src/execution/isolate-inl.h
-index 026e7cfd71..c833440dff 100644
+index 8edeb5dfb8..9189c32794 100644
 --- a/src/execution/isolate-inl.h
 +++ b/src/execution/isolate-inl.h
 @@ -35,7 +35,6 @@ V8_INLINE Isolate* Isolate::TryGetCurrent() { return g_current_isolate_; }
@@ -298,7 +311,7 @@ index 026e7cfd71..c833440dff 100644
  }
  
 diff --git a/src/execution/stack-guard.cc b/src/execution/stack-guard.cc
-index 2b4af70bc0..2607f22922 100644
+index ff64beb8b2..b26b3fe323 100644
 --- a/src/execution/stack-guard.cc
 +++ b/src/execution/stack-guard.cc
 @@ -218,8 +218,10 @@ void StackGuard::FreeThreadResources() {
@@ -314,10 +327,10 @@ index 2b4af70bc0..2607f22922 100644
    set_jslimit(SimulatorStack::JsLimitFromCLimit(isolate, limit));
    real_climit_ = limit;
 diff --git a/src/heap/factory.cc b/src/heap/factory.cc
-index caab258158..398cd2bf6c 100644
+index 4c868825d7..a84535f103 100644
 --- a/src/heap/factory.cc
 +++ b/src/heap/factory.cc
-@@ -2063,6 +2063,7 @@ Map Factory::InitializeMap(Map map, InstanceType type, int instance_size,
+@@ -2079,6 +2079,7 @@ Map Factory::InitializeMap(Map map, InstanceType type, int instance_size,
        Map::Bits3::ConstructionCounterBits::encode(Map::kNoSlackTracking) |
        Map::Bits3::IsExtensibleBit::encode(true);
    map.set_bit_field3(bit_field3);
@@ -325,25 +338,11 @@ index caab258158..398cd2bf6c 100644
    map.set_instance_type(type);
    ReadOnlyRoots ro_roots(roots);
    map.init_prototype_and_constructor_or_back_pointer(ro_roots);
-diff --git a/src/heap/memory-chunk-layout.h b/src/heap/memory-chunk-layout.h
-index 67e3a7b9dd..ff68856972 100644
---- a/src/heap/memory-chunk-layout.h
-+++ b/src/heap/memory-chunk-layout.h
-@@ -73,6 +73,9 @@ class V8_EXPORT_PRIVATE MemoryChunkLayout {
-     FIELD(FreeListCategory**, Categories),
-     FIELD(CodeObjectRegistry*, CodeObjectRegistry),
-     FIELD(PossiblyEmptyBuckets, PossiblyEmptyBuckets),
-+#if defined(V8_TARGET_OS_WIN) && defined(V8_TARGET_ARCH_IA32)
-+    FIELD(int32_t, WinIa32Padding),
-+#endif  // V8_TARGET_OS_WIN && V8_TARGET_ARCH_IA32
-     FIELD(ActiveSystemPages, ActiveSystemPages),
- #ifdef V8_ENABLE_INNER_POINTER_RESOLUTION_OSB
-     FIELD(ObjectStartBitmap, ObjectStartBitmap),
 diff --git a/src/heap/setup-heap-internal.cc b/src/heap/setup-heap-internal.cc
-index 60ef0cc4b0..245ea249de 100644
+index 5f352d1349..10020d538c 100644
 --- a/src/heap/setup-heap-internal.cc
 +++ b/src/heap/setup-heap-internal.cc
-@@ -240,6 +240,7 @@ AllocationResult Heap::AllocatePartialMap(InstanceType instance_type,
+@@ -241,6 +241,7 @@ AllocationResult Heap::AllocatePartialMap(InstanceType instance_type,
        Map::Bits3::OwnsDescriptorsBit::encode(true) |
        Map::Bits3::ConstructionCounterBits::encode(Map::kNoSlackTracking);
    map.set_bit_field3(bit_field3);
@@ -431,10 +430,10 @@ index 2bbbb7e1f4..5cbd5e8c43 100644
      IdleTaskSupport idle_task_support,
      InProcessStackDumping in_process_stack_dumping,
 diff --git a/src/objects/js-objects.cc b/src/objects/js-objects.cc
-index 682e77ec24..3b9ec4525b 100644
+index 7bb2558cec..65b547b0fd 100644
 --- a/src/objects/js-objects.cc
 +++ b/src/objects/js-objects.cc
-@@ -5203,6 +5203,13 @@ void JSObject::SetImmutableProto(Handle<JSObject> object) {
+@@ -5246,6 +5246,13 @@ void JSObject::SetImmutableProto(Handle<JSObject> object) {
    object->set_map(*new_map, kReleaseStore);
  }
  
@@ -449,10 +448,10 @@ index 682e77ec24..3b9ec4525b 100644
                                          JavaScriptArguments* args,
                                          uint32_t arg_count,
 diff --git a/src/objects/js-objects.h b/src/objects/js-objects.h
-index 06489c2b7b..927d68d926 100644
+index f83083cdbc..f9f274eadb 100644
 --- a/src/objects/js-objects.h
 +++ b/src/objects/js-objects.h
-@@ -740,6 +740,8 @@ class JSObject : public TorqueGeneratedJSObject<JSObject, JSReceiver> {
+@@ -745,6 +745,8 @@ class JSObject : public TorqueGeneratedJSObject<JSObject, JSReceiver> {
    // Never called from JavaScript
    static void SetImmutableProto(Handle<JSObject> object);
  
@@ -462,10 +461,10 @@ index 06489c2b7b..927d68d926 100644
    // the caller to initialize object header. Fill the pre-allocated fields with
    // undefined_value and the rest with filler_map.
 diff --git a/src/objects/map-inl.h b/src/objects/map-inl.h
-index bc25dd1117..661972f6c0 100644
+index 2c42cf2ee6..5fc4e46ba9 100644
 --- a/src/objects/map-inl.h
 +++ b/src/objects/map-inl.h
-@@ -124,6 +124,9 @@ BIT_FIELD_ACCESSORS(Map, bit_field3, may_have_interesting_symbols,
+@@ -125,6 +125,9 @@ BIT_FIELD_ACCESSORS(Map, bit_field3, may_have_interesting_symbols,
  BIT_FIELD_ACCESSORS(Map, relaxed_bit_field3, construction_counter,
                      Map::Bits3::ConstructionCounterBits)
  
@@ -476,10 +475,10 @@ index bc25dd1117..661972f6c0 100644
    DCHECK(has_named_interceptor());
    FunctionTemplateInfo info = GetFunctionTemplateInfo(cage_base);
 diff --git a/src/objects/map.cc b/src/objects/map.cc
-index b29db773e4..92cb13f012 100644
+index ea57d93925..34763a37ef 100644
 --- a/src/objects/map.cc
 +++ b/src/objects/map.cc
-@@ -1179,6 +1179,7 @@ Handle<Map> Map::RawCopy(Isolate* isolate, Handle<Map> src_handle,
+@@ -1185,6 +1185,7 @@ Handle<Map> Map::RawCopy(Isolate* isolate, Handle<Map> src_handle,
      }
      // Same as bit_field comment above.
      raw.set_bit_field3(new_bit_field3);
@@ -487,7 +486,7 @@ index b29db773e4..92cb13f012 100644
      raw.clear_padding();
    }
    Handle<HeapObject> prototype(src_handle->prototype(), isolate);
-@@ -1305,6 +1306,12 @@ Handle<Map> Map::TransitionToImmutableProto(Isolate* isolate, Handle<Map> map) {
+@@ -1311,6 +1312,12 @@ Handle<Map> Map::TransitionToImmutableProto(Isolate* isolate, Handle<Map> map) {
    return new_map;
  }
  
@@ -501,10 +500,10 @@ index b29db773e4..92cb13f012 100644
  void EnsureInitialMap(Isolate* isolate, Handle<Map> map) {
  #ifdef DEBUG
 diff --git a/src/objects/map.h b/src/objects/map.h
-index 4f2462c715..cd6cec6b2c 100644
+index bdc10ee2ba..838f81cd5d 100644
 --- a/src/objects/map.h
 +++ b/src/objects/map.h
-@@ -319,6 +319,11 @@ class Map : public TorqueGeneratedMap<Map, HeapObject> {
+@@ -321,6 +321,11 @@ class Map : public TorqueGeneratedMap<Map, HeapObject> {
    static_assert(kSlackTrackingCounterStart <=
                  Bits3::ConstructionCounterBits::kMax);
  
@@ -516,7 +515,7 @@ index 4f2462c715..cd6cec6b2c 100644
    // Inobject slack tracking is the way to reclaim unused inobject space.
    //
    // The instance size is initially determined by adding some slack to
-@@ -662,6 +667,8 @@ class Map : public TorqueGeneratedMap<Map, HeapObject> {
+@@ -666,6 +671,8 @@ class Map : public TorqueGeneratedMap<Map, HeapObject> {
  
    DECL_BOOLEAN_ACCESSORS(is_immutable_proto)
  
@@ -525,7 +524,7 @@ index 4f2462c715..cd6cec6b2c 100644
    // This counter is used for in-object slack tracking.
    // The in-object slack tracking is considered enabled when the counter is
    // non zero. The counter only has a valid count for initial maps. For
-@@ -830,6 +837,8 @@ class Map : public TorqueGeneratedMap<Map, HeapObject> {
+@@ -834,6 +841,8 @@ class Map : public TorqueGeneratedMap<Map, HeapObject> {
    static Handle<Map> TransitionToImmutableProto(Isolate* isolate,
                                                  Handle<Map> map);
  
@@ -561,10 +560,10 @@ index a8b367ff82..98637087ee 100644
    prototype: JSReceiver|Null;
    constructor_or_back_pointer_or_native_context: Object;
 diff --git a/src/objects/objects.cc b/src/objects/objects.cc
-index b5f0260f4b..4d41e4f62f 100644
+index 26a8d59b34..108b20ee8b 100644
 --- a/src/objects/objects.cc
 +++ b/src/objects/objects.cc
-@@ -882,6 +882,12 @@ Handle<String> Object::TypeOf(Isolate* isolate, Handle<Object> object) {
+@@ -886,6 +886,12 @@ Handle<String> Object::TypeOf(Isolate* isolate, Handle<Object> object) {
    if (object->IsString()) return isolate->factory()->string_string();
    if (object->IsSymbol()) return isolate->factory()->symbol_string();
    if (object->IsBigInt()) return isolate->factory()->bigint_string();
@@ -578,10 +577,10 @@ index b5f0260f4b..4d41e4f62f 100644
    return isolate->factory()->object_string();
  }
 diff --git a/src/objects/source-text-module.cc b/src/objects/source-text-module.cc
-index fbb89b4617..915d4a450c 100644
+index 070788138b..2ac555d1c6 100644
 --- a/src/objects/source-text-module.cc
 +++ b/src/objects/source-text-module.cc
-@@ -747,7 +747,7 @@ MaybeHandle<Object> SourceTextModule::Evaluate(
+@@ -746,7 +746,7 @@ MaybeHandle<Object> SourceTextModule::Evaluate(
      if (!module->IsAsyncEvaluating()) {
        //   i. Perform ! Call(capability.[[Resolve]], undefined,
        //                     «undefined»).
@@ -590,7 +589,7 @@ index fbb89b4617..915d4a450c 100644
            .ToHandleChecked();
      }
  
-@@ -760,7 +760,7 @@ MaybeHandle<Object> SourceTextModule::Evaluate(
+@@ -759,7 +759,7 @@ MaybeHandle<Object> SourceTextModule::Evaluate(
  }
  
  Maybe<bool> SourceTextModule::AsyncModuleExecutionFulfilled(
@@ -599,7 +598,7 @@ index fbb89b4617..915d4a450c 100644
    // 1. If module.[[Status]] is evaluated, then
    if (module->status() == kErrored) {
      // a. Assert: module.[[EvaluationError]] is not empty.
-@@ -784,7 +784,7 @@ Maybe<bool> SourceTextModule::AsyncModuleExecutionFulfilled(
+@@ -783,7 +783,7 @@ Maybe<bool> SourceTextModule::AsyncModuleExecutionFulfilled(
      //                     «undefined»).
      Handle<JSPromise> capability(
          JSPromise::cast(module->top_level_capability()), isolate);
@@ -608,7 +607,7 @@ index fbb89b4617..915d4a450c 100644
          .ToHandleChecked();
    }
  
-@@ -850,7 +850,7 @@ Maybe<bool> SourceTextModule::AsyncModuleExecutionFulfilled(
+@@ -849,7 +849,7 @@ Maybe<bool> SourceTextModule::AsyncModuleExecutionFulfilled(
            //                     undefined, «undefined»).
            Handle<JSPromise> capability(
                JSPromise::cast(m->top_level_capability()), isolate);

V8Update.cmd

@@ -1,7 +1,7 @@
 @echo off
 setlocal
 
-set v8testedrev=11.1.277.14
+set v8testedrev=11.2.214.13
 set v8testedcommit=
 
 if not "%v8testedcommit%"=="" goto ProcessArgs

Version.tt

@@ -1,5 +1,5 @@
 <#
-    var version = new Version(7, 4, 0);
+    var version = new Version(7, 4, 1);
     var versionSuffix = string.Empty;
     new Random(versionSuffix.Length); // suppress "versionSuffix not used" warning
 #>

docs/Gemfile.lock

@@ -1,12 +1,11 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.6.1)
+    activesupport (7.0.4.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
     addressable (2.8.1)
       public_suffix (>= 2.0.2, < 6.0)
     coffee-script (2.4.1)
@@ -14,8 +13,8 @@ GEM
       execjs
     coffee-script-source (1.11.1)
     colorator (1.1.0)
-    commonmarker (0.23.7)
-    concurrent-ruby (1.2.0)
+    commonmarker (0.23.8)
+    concurrent-ruby (1.2.2)
     dnsruby (1.61.9)
       simpleidn (~> 0.1)
     em-websocket (0.5.3)
@@ -32,12 +31,12 @@ GEM
     ffi (1.15.5)
     forwardable-extended (2.6.0)
     gemoji (3.0.1)
-    github-pages (227)
+    github-pages (228)
       github-pages-health-check (= 1.17.9)
-      jekyll (= 3.9.2)
+      jekyll (= 3.9.3)
       jekyll-avatar (= 0.7.0)
       jekyll-coffeescript (= 1.1.1)
-      jekyll-commonmark-ghpages (= 0.2.0)
+      jekyll-commonmark-ghpages (= 0.4.0)
       jekyll-default-layout (= 0.1.4)
       jekyll-feed (= 0.15.1)
       jekyll-gist (= 1.5.0)
@@ -71,7 +70,7 @@ GEM
       jemoji (= 0.12.0)
       kramdown (= 2.3.2)
       kramdown-parser-gfm (= 1.1.0)
-      liquid (= 4.0.3)
+      liquid (= 4.0.4)
       mercenary (~> 0.3)
       minima (= 2.5.1)
       nokogiri (>= 1.13.6, < 2.0)
@@ -87,13 +86,13 @@ GEM
       activesupport (>= 2)
       nokogiri (>= 1.4)
     http_parser.rb (0.8.0)
-    i18n (0.9.5)
+    i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    jekyll (3.9.2)
+    jekyll (3.9.3)
       addressable (~> 2.4)
       colorator (~> 1.0)
       em-websocket (~> 0.5)
-      i18n (~> 0.7)
+      i18n (>= 0.7, < 2)
       jekyll-sass-converter (~> 1.0)
       jekyll-watch (~> 2.0)
       kramdown (>= 1.17, < 3)
@@ -109,11 +108,11 @@ GEM
       coffee-script-source (~> 1.11.1)
     jekyll-commonmark (1.4.0)
       commonmarker (~> 0.22)
-    jekyll-commonmark-ghpages (0.2.0)
-      commonmarker (~> 0.23.4)
+    jekyll-commonmark-ghpages (0.4.0)
+      commonmarker (~> 0.23.7)
       jekyll (~> 3.9.0)
       jekyll-commonmark (~> 1.4.0)
-      rouge (>= 2.0, < 4.0)
+      rouge (>= 2.0, < 5.0)
     jekyll-default-layout (0.1.4)
       jekyll (~> 3.0)
     jekyll-feed (0.15.1)
@@ -201,7 +200,7 @@ GEM
       rexml
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
-    liquid (4.0.3)
+    liquid (4.0.4)
     listen (3.8.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
@@ -210,8 +209,8 @@ GEM
       jekyll (>= 3.5, < 5.0)
       jekyll-feed (~> 0.9)
       jekyll-seo-tag (~> 2.1)
-    minitest (5.17.0)
-    nokogiri (1.14.0-x86_64-linux)
+    minitest (5.18.0)
+    nokogiri (1.14.2-x86_64-linux)
       racc (~> 1.4)
     octokit (4.25.1)
       faraday (>= 1, < 3)
@@ -240,16 +239,14 @@ GEM
       unf (~> 0.1.4)
     terminal-table (1.8.0)
       unicode-display_width (~> 1.1, >= 1.1.1)
-    thread_safe (0.3.6)
     typhoeus (1.4.0)
       ethon (>= 0.9.0)
-    tzinfo (1.2.10)
-      thread_safe (~> 0.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unf (0.1.4)
       unf_ext
     unf_ext (0.0.8.2)
     unicode-display_width (1.8.0)
-    zeitwerk (2.6.6)
 
 PLATFORMS
   x86_64-linux