You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@myfaces.apache.org by ta...@apache.org on 2026/03/25 13:42:48 UTC

(myfaces) branch main updated: [perf] some feedback from claude

This is an automated email from the ASF dual-hosted git repository.

tandraschko pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/myfaces.git


The following commit(s) were added to refs/heads/main by this push:
     new 1dd0a4a86 [perf] some feedback from claude
1dd0a4a86 is described below

commit 1dd0a4a86259063ac636bab67b697ca4a7b8346f
Author: tandraschko <ta...@apache.org>
AuthorDate: Wed Mar 25 14:42:34 2026 +0100

    [perf] some feedback from claude
---
 .../java/jakarta/faces/component/UIViewRoot.java   | 15 ++--
 .../myfaces/application/ResourceHandlerImpl.java   | 55 +++++++++++----
 .../java/org/apache/myfaces/cdi/util/CDIUtils.java | 14 ++--
 .../context/servlet/PartialViewContextImpl.java    | 39 +++++++---
 .../el/resolver/CompositeComponentELResolver.java  | 41 ++++-------
 .../apache/myfaces/lifecycle/LifecycleImpl.java    |  8 +--
 .../myfaces/lifecycle/PhaseListenerManager.java    | 64 ++++++++++-------
 .../myfaces/push/cdi/WebsocketSessionManager.java  | 61 ++++++++++------
 .../apache/myfaces/renderkit/ErrorPageWriter.java  |  2 +-
 .../myfaces/renderkit/html/HtmlRenderKitImpl.java  |  9 ++-
 .../html/base/HtmlInputFileRendererBase.java       | 13 ++--
 .../renderkit/html/util/JavascriptUtils.java       | 24 +++++--
 .../myfaces/resource/FacesJSResourceLoader.java    | 42 ++++++-----
 .../apache/myfaces/util/ViewNamespaceUtils.java    | 15 +++-
 .../myfaces/view/facelets/impl/DefaultFacelet.java |  8 +--
 .../view/facelets/impl/DefaultFaceletFactory.java  | 18 +++--
 .../renderkit/html/util/JavascriptUtilsTest.java   | 82 ++++++++++++++++++++++
 .../myfaces/test/core/AbstractMyFacesTestCase.java |  7 +-
 .../facelets/impl/DefaultFaceletFactoryTest.java   | 81 +++++++++++++++++++++
 .../myfaces/test/mock/lifecycle/MockLifecycle.java |  6 +-
 .../test/mock/lifecycle/PhaseListenerManager.java  | 66 ++++++++++++-----
 21 files changed, 489 insertions(+), 181 deletions(-)

diff --git a/api/src/main/java/jakarta/faces/component/UIViewRoot.java b/api/src/main/java/jakarta/faces/component/UIViewRoot.java
index b5bb263ab..971edda0a 100644
--- a/api/src/main/java/jakarta/faces/component/UIViewRoot.java
+++ b/api/src/main/java/jakarta/faces/component/UIViewRoot.java
@@ -28,7 +28,6 @@
 import java.util.*;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import java.util.stream.Collectors;
 
 import jakarta.el.MethodExpression;
 import jakarta.el.ValueExpression;
@@ -1814,14 +1813,16 @@ private void _processValidatorsDefault(FacesContext context)
      */
     public Map<PhaseId, List<FacesEvent>> getQueuedEvents()
     {
-        if (_events == null) {
+        if (_events == null || _events.isEmpty())
+        {
             return Collections.emptyMap();
         }
-
-        return _events.entrySet().stream().collect(
-                Collectors.toUnmodifiableMap(
-                        Map.Entry::getKey,
-                        entry -> Collections.unmodifiableList(entry.getValue())));
+        EnumMap<PhaseId, List<FacesEvent>> view = new EnumMap<>(PhaseId.class);
+        for (Map.Entry<PhaseId, List<FacesEvent>> e : _events.entrySet())
+        {
+            view.put(e.getKey(), Collections.unmodifiableList(e.getValue()));
+        }
+        return Collections.unmodifiableMap(view);
     }
 
     /**
diff --git a/impl/src/main/java/org/apache/myfaces/application/ResourceHandlerImpl.java b/impl/src/main/java/org/apache/myfaces/application/ResourceHandlerImpl.java
index 11a1c0baf..9520a942d 100644
--- a/impl/src/main/java/org/apache/myfaces/application/ResourceHandlerImpl.java
+++ b/impl/src/main/java/org/apache/myfaces/application/ResourceHandlerImpl.java
@@ -97,7 +97,10 @@ public class ResourceHandlerImpl extends ResourceHandler
     public final static String RENDERED_RESOURCES_SET = "org.apache.myfaces.RENDERED_RESOURCES_SET";
 
     private static final String SHARED_STRING_BUILDER = ResourceHandlerImpl.class.getName() + ".SHARED_STRING_BUILDER";
-    
+
+    private static final String PROGRAMMATIC_VIEW_IDS_CACHE_KEY =
+            ResourceHandlerImpl.class.getName() + ".PROGRAMMATIC_VIEW_IDS";
+
     private static final String[] FACELETS_VIEW_MAPPINGS_PARAM = {ViewHandler.FACELETS_VIEW_MAPPINGS_PARAM_NAME,
             "facelets.VIEW_MAPPINGS"};
 
@@ -1727,32 +1730,58 @@ public Stream<String> getViewResources(FacesContext facesContext,
             this._viewSuffixes = loadSuffixes(facesContext.getExternalContext());
         }
 
-        Iterator it = new FilterInvalidSuffixViewResourceIterator(new ViewResourceIterator(facesContext, 
+        Iterator<String> resourceIt = new FilterInvalidSuffixViewResourceIterator(
+                new ViewResourceIterator(facesContext,
                     getResourceHandlerSupport(), localePrefix, contracts,
                     contractPreferred, path, maxDepth, options), facesContext, _viewSuffixes);
 
-        return Stream.concat(StreamSupport.stream(Spliterators.spliteratorUnknownSize(it,Spliterator.DISTINCT),
-                                                    false), getProgrammaticViewIds(facesContext));
+        Stream<String> resourceStream = StreamSupport.stream(
+                Spliterators.spliteratorUnknownSize(resourceIt, Spliterator.DISTINCT), false);
+        return Stream.concat(resourceStream, resolveProgrammaticViewIds(facesContext).stream());
     }
 
-    private Stream<String> getProgrammaticViewIds(FacesContext facesContext)
+    /**
+     * CDI {@code @View} IDs; cached in the application map for the application lifetime.
+     */
+    @SuppressWarnings("unchecked")
+    private List<String> resolveProgrammaticViewIds(FacesContext facesContext)
     {
-        ArrayList<String> views = new ArrayList<String>();
-        BeanManager beanManager = CDIUtils.getBeanManager(facesContext);
-        if (beanManager != null)
+        Map<String, Object> appMap = facesContext.getExternalContext().getApplicationMap();
+        List<String> cached = (List<String>) appMap.get(PROGRAMMATIC_VIEW_IDS_CACHE_KEY);
+        if (cached != null)
+        {
+            return cached;
+        }
+        synchronized (appMap)
         {
-            for (Bean<?> bean : beanManager.getBeans(Object.class, Any.Literal.INSTANCE))
+            cached = (List<String>) appMap.get(PROGRAMMATIC_VIEW_IDS_CACHE_KEY);
+            if (cached != null)
             {
-                for (Annotation qualifier : bean.getQualifiers())
+                return cached;
+            }
+            BeanManager beanManager = CDIUtils.getBeanManager(facesContext);
+            if (beanManager == null)
+            {
+                cached = List.of();
+            }
+            else
+            {
+                ArrayList<String> views = new ArrayList<>();
+                for (Bean<?> bean : beanManager.getBeans(Object.class, Any.Literal.INSTANCE))
                 {
-                    if (qualifier instanceof View view)
+                    for (Annotation qualifier : bean.getQualifiers())
                     {
-                        views.add(view.value());
+                        if (qualifier instanceof View view)
+                        {
+                            views.add(view.value());
+                        }
                     }
                 }
+                cached = List.copyOf(views);
             }
+            appMap.put(PROGRAMMATIC_VIEW_IDS_CACHE_KEY, cached);
+            return cached;
         }
-        return views.stream();
     }
     
     private Set<String> loadSuffixes(ExternalContext context)
diff --git a/impl/src/main/java/org/apache/myfaces/cdi/util/CDIUtils.java b/impl/src/main/java/org/apache/myfaces/cdi/util/CDIUtils.java
index 93975ef16..be9856344 100644
--- a/impl/src/main/java/org/apache/myfaces/cdi/util/CDIUtils.java
+++ b/impl/src/main/java/org/apache/myfaces/cdi/util/CDIUtils.java
@@ -32,9 +32,9 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Type;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 import org.apache.myfaces.webapp.FacesInitializerImpl;
 
@@ -121,9 +121,15 @@ public static <T> T get(BeanManager beanManager, Type type, boolean create,
             Set<Bean<?>> beans = beanManager.getBeans(type, qualifiers);
             if (beanName != null)
             {
-                beans = beans.stream()
-                        .filter(bean -> Objects.equals(beanName, getBeanName(bean)))
-                        .collect(Collectors.toSet());
+                Set<Bean<?>> filtered = new HashSet<>();
+                for (Bean<?> bean : beans)
+                {
+                    if (Objects.equals(beanName, getBeanName(bean)))
+                    {
+                        filtered.add(bean);
+                    }
+                }
+                beans = filtered;
             }
             Bean<T> bean = (Bean<T>) beanManager.resolve(beans);
 
diff --git a/impl/src/main/java/org/apache/myfaces/context/servlet/PartialViewContextImpl.java b/impl/src/main/java/org/apache/myfaces/context/servlet/PartialViewContextImpl.java
index c2ee06ea1..614adcb95 100644
--- a/impl/src/main/java/org/apache/myfaces/context/servlet/PartialViewContextImpl.java
+++ b/impl/src/main/java/org/apache/myfaces/context/servlet/PartialViewContextImpl.java
@@ -46,6 +46,7 @@
 import jakarta.faces.context.PartialViewContext;
 import jakarta.faces.context.ResponseWriter;
 import jakarta.faces.event.BehaviorEvent;
+import jakarta.faces.event.FacesEvent;
 import jakarta.faces.event.PhaseId;
 import jakarta.faces.lifecycle.ClientWindow;
 import jakarta.faces.render.RenderKit;
@@ -93,6 +94,7 @@ public class PartialViewContextImpl extends PartialViewContext
     private Boolean _resetValues = null;
     private List<String> _evalScripts = new ArrayList<>();
     private List<AjaxBehavior> queuedAjaxBehaviors;
+    private boolean queuedAjaxClearModel;
 
     public PartialViewContextImpl(FacesContext context)
     {
@@ -392,13 +394,32 @@ public void processPartial(PhaseId phaseId)
         {
             if (phaseId == PhaseId.APPLY_REQUEST_VALUES)
             {
-                queuedAjaxBehaviors = viewRoot.getQueuedEvents().values().stream().flatMap(List::stream)
-                        .filter(BehaviorEvent.class::isInstance)
-                        .map(BehaviorEvent.class::cast)
-                        .map(BehaviorEvent::getBehavior)
-                        .filter(AjaxBehavior.class::isInstance)
-                        .map(AjaxBehavior.class::cast)
-                        .toList();
+                ArrayList<AjaxBehavior> ajaxList = new ArrayList<>();
+                boolean clearModel = false;
+                for (List<FacesEvent> events : viewRoot.getQueuedEvents().values())
+                {
+                    if (events == null)
+                    {
+                        continue;
+                    }
+                    for (FacesEvent fe : events)
+                    {
+                        if (fe instanceof BehaviorEvent be)
+                        {
+                            var behavior = be.getBehavior();
+                            if (behavior instanceof AjaxBehavior ab)
+                            {
+                                ajaxList.add(ab);
+                                if (!clearModel && ab.isClearModel())
+                                {
+                                    clearModel = true;
+                                }
+                            }
+                        }
+                    }
+                }
+                queuedAjaxBehaviors = ajaxList;
+                queuedAjaxClearModel = clearModel;
             }
 
             processPartialExecute(viewRoot, phaseId);
@@ -455,8 +476,7 @@ private void processPartialRendering(UIViewRoot viewRoot, PhaseId phaseId)
             
             if (isResetValues())
             {
-                boolean clearModel = queuedAjaxBehaviors != null
-                        && queuedAjaxBehaviors.stream().anyMatch(AjaxBehavior::isClearModel);
+                boolean clearModel = queuedAjaxBehaviors != null && queuedAjaxClearModel;
                 viewRoot.resetValues(context, getRenderIds(), clearModel, RESET_VALUES_HINTS);
             }
 
@@ -702,6 +722,7 @@ public void release()
         _renderAll = null;
         context = null;
         queuedAjaxBehaviors = null;
+        queuedAjaxClearModel = false;
         _released = true;
     }
     
diff --git a/impl/src/main/java/org/apache/myfaces/el/resolver/CompositeComponentELResolver.java b/impl/src/main/java/org/apache/myfaces/el/resolver/CompositeComponentELResolver.java
index f9f86fabb..539b4dd10 100644
--- a/impl/src/main/java/org/apache/myfaces/el/resolver/CompositeComponentELResolver.java
+++ b/impl/src/main/java/org/apache/myfaces/el/resolver/CompositeComponentELResolver.java
@@ -31,11 +31,10 @@
 
 import java.beans.BeanInfo;
 import java.beans.PropertyDescriptor;
-import java.lang.ref.WeakReference;
 import java.util.Collection;
+import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.Set;
-import java.util.WeakHashMap;
 
 /**
  * Composite component attribute EL resolver.  See Faces spec, section 5.6.2.2.
@@ -197,39 +196,25 @@ private Map<String, Object> _getCompositeComponentAttributesMapWrapper(
     {
         Map<Object, Object> contextMap = facesContext(elContext).getAttributes();
 
-        // We use a WeakHashMap<UIComponent, WeakReference<Map<String, Object>>> to
-        // hold attribute map wrappers by two reasons:
-        //
-        // 1. The wrapper is used multiple times for a very short amount of time (in fact on current request).
-        // 2. The original attribute map has an inner reference to UIComponent, so we need to wrap it
-        //    with WeakReference.
-        //
-        Map<UIComponent, WeakReference<Map<String, Object>>> compositeComponentAttributesMaps = 
-            (Map<UIComponent, WeakReference<Map<String, Object>>>) contextMap.get(COMPOSITE_COMPONENT_ATTRIBUTES_MAPS);
+        // IdentityHashMap: FacesContext is not thread-safe; keys are UIComponent instances by identity.
+        // The map lives only for the request (FacesContext attributes), avoiding WeakHashMap sync cost.
+        IdentityHashMap<UIComponent, Map<String, Object>> compositeComponentAttributesMaps =
+            (IdentityHashMap<UIComponent, Map<String, Object>>) contextMap.get(COMPOSITE_COMPONENT_ATTRIBUTES_MAPS);
 
         Map<String, Object> attributesMap = null;
-        WeakReference<Map<String, Object>> weakReference;
         if (compositeComponentAttributesMaps != null)
         {
-            weakReference = compositeComponentAttributesMaps.get(baseComponent);
-            if (weakReference != null)
-            {
-                attributesMap = weakReference.get();                
-            }
-            if (attributesMap == null)
-            {
-                //create a wrapper map
-                attributesMap = new CompositeComponentAttributesMapWrapper(baseComponent);
-                compositeComponentAttributesMaps.put(baseComponent, new WeakReference<>(attributesMap));
-            }
+            attributesMap = compositeComponentAttributesMaps.get(baseComponent);
         }
-        else
+        if (attributesMap == null)
         {
-            //Create both required maps
             attributesMap = new CompositeComponentAttributesMapWrapper(baseComponent);
-            compositeComponentAttributesMaps = new WeakHashMap<>();
-            compositeComponentAttributesMaps.put(baseComponent, new WeakReference<>(attributesMap));
-            contextMap.put(COMPOSITE_COMPONENT_ATTRIBUTES_MAPS, compositeComponentAttributesMaps);
+            if (compositeComponentAttributesMaps == null)
+            {
+                compositeComponentAttributesMaps = new IdentityHashMap<>(8);
+                contextMap.put(COMPOSITE_COMPONENT_ATTRIBUTES_MAPS, compositeComponentAttributesMaps);
+            }
+            compositeComponentAttributesMaps.put(baseComponent, attributesMap);
         }
         return attributesMap;
     }
diff --git a/impl/src/main/java/org/apache/myfaces/lifecycle/LifecycleImpl.java b/impl/src/main/java/org/apache/myfaces/lifecycle/LifecycleImpl.java
index 350c02edf..c2e106197 100755
--- a/impl/src/main/java/org/apache/myfaces/lifecycle/LifecycleImpl.java
+++ b/impl/src/main/java/org/apache/myfaces/lifecycle/LifecycleImpl.java
@@ -74,7 +74,7 @@ public class LifecycleImpl extends Lifecycle
      * note in this case the semantic of the variable must be preserved.
      */
     private volatile boolean _firstRequestProcessed = false;
-    
+
     public LifecycleImpl()
     {
         // hide from public access
@@ -131,7 +131,7 @@ public void execute(FacesContext facesContext) throws FacesException
             new FacesConfigurator(facesContext.getExternalContext()).update();
         }
 
-        PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, facesContext, getPhaseListeners());
+        PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, facesContext, phaseListeners);
         for (PhaseExecutor executor : lifecycleExecutors)
         {
             if (executePhase(facesContext, executor, phaseListenerMgr))
@@ -148,7 +148,7 @@ public PhaseExecutor getPhaseExecutor(PhaseId phaseId)
 
     public boolean executePhase(FacesContext facesContext, PhaseId phaseId)
     {
-        PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, facesContext, getPhaseListeners());
+        PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, facesContext, phaseListeners);
         return executePhase(facesContext, getPhaseExecutor(phaseId), phaseListenerMgr);
     }
 
@@ -242,7 +242,7 @@ public void render(FacesContext facesContext) throws FacesException
             log.finest("Entering " + renderExecutor.getPhase() + " in " + LifecycleImpl.class.getName());
         }
 
-        PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, facesContext, getPhaseListeners());
+        PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, facesContext, phaseListeners);
         Flash flash = facesContext.getExternalContext().getFlash();
 
         try
diff --git a/impl/src/main/java/org/apache/myfaces/lifecycle/PhaseListenerManager.java b/impl/src/main/java/org/apache/myfaces/lifecycle/PhaseListenerManager.java
index 4d5b30eb8..d692e70e3 100644
--- a/impl/src/main/java/org/apache/myfaces/lifecycle/PhaseListenerManager.java
+++ b/impl/src/main/java/org/apache/myfaces/lifecycle/PhaseListenerManager.java
@@ -19,8 +19,9 @@
 
 package org.apache.myfaces.lifecycle;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.Arrays;
+import java.util.List;
+
 import jakarta.faces.context.FacesContext;
 import jakarta.faces.event.ExceptionQueuedEvent;
 import jakarta.faces.event.ExceptionQueuedEventContext;
@@ -39,20 +40,32 @@ public class PhaseListenerManager
 {
     private Lifecycle lifecycle;
     private FacesContext facesContext;
-    private PhaseListener[] phaseListeners;
+    private List<PhaseListener> phaseListeners;
 
     // Tracks success in the beforePhase. Listeners that throw an exception
     // in beforePhase or were never called because a previous listener threw
     // an exception should not have its afterPhase called
-    private Map<PhaseId, boolean[]> listenerSuccessMap;
+    private boolean[] beforePhaseSuccessScratch;
+
+    /** Listener count at start of informPhaseListenersBefore; used for matching afterPhase. */
+    private int listenerCountForActivePhase;
 
-    public PhaseListenerManager(Lifecycle lifecycle, FacesContext facesContext, PhaseListener[] phaseListeners)
+    private PhaseId activePhaseIdForBeforeSuccess;
+    private PhaseEvent phaseEventForActivePhase;
+
+    public PhaseListenerManager(Lifecycle lifecycle, FacesContext facesContext, List<PhaseListener> phaseListeners)
     {
         this.lifecycle = lifecycle;
         this.facesContext = facesContext;
         this.phaseListeners = phaseListeners;
-        this.listenerSuccessMap = new HashMap<>(PhaseId.VALUES.size(), 1f);
-       
+    }
+
+    private void ensureScratch(int minSize)
+    {
+        if (beforePhaseSuccessScratch == null || beforePhaseSuccessScratch.length < minSize)
+        {
+            beforePhaseSuccessScratch = new boolean[minSize];
+        }
     }
  
     private boolean isListenerForThisPhase(PhaseListener phaseListener, PhaseId phaseId)
@@ -63,24 +76,27 @@ private boolean isListenerForThisPhase(PhaseListener phaseListener, PhaseId phas
 
     public void informPhaseListenersBefore(PhaseId phaseId)
     {
-        boolean[] beforePhaseSuccess = new boolean[phaseListeners.length];
-        listenerSuccessMap.put(phaseId, beforePhaseSuccess);
+        listenerCountForActivePhase = phaseListeners.size();
+        ensureScratch(listenerCountForActivePhase);
+        Arrays.fill(beforePhaseSuccessScratch, 0, listenerCountForActivePhase, false);
+        activePhaseIdForBeforeSuccess = phaseId;
 
         PhaseEvent event = new PhaseEvent(facesContext, phaseId, lifecycle);
+        phaseEventForActivePhase = event;
 
-        for (int i = 0; i < phaseListeners.length; i++)
+        for (int i = 0; i < listenerCountForActivePhase; i++)
         {
-            PhaseListener phaseListener = phaseListeners[i];
+            PhaseListener phaseListener = phaseListeners.get(i);
             if (isListenerForThisPhase(phaseListener, phaseId))
             {
                 try
                 {
                     phaseListener.beforePhase(event);
-                    beforePhaseSuccess[i] = true;
+                    beforePhaseSuccessScratch[i] = true;
                 }
                 catch (Throwable e)
                 {
-                    beforePhaseSuccess[i] = false; // redundant - for clarity
+                    beforePhaseSuccessScratch[i] = false; // redundant - for clarity
                     
                     // Faces 2.0: publish exceptions instead of logging them.
                     
@@ -94,25 +110,23 @@ public void informPhaseListenersBefore(PhaseId phaseId)
 
     public void informPhaseListenersAfter(PhaseId phaseId)
     {
-        boolean[] beforePhaseSuccess = listenerSuccessMap.get(phaseId);
-        
-        if (beforePhaseSuccess == null)
+        if (activePhaseIdForBeforeSuccess != phaseId)
         {
             // informPhaseListenersBefore method was not called : maybe an exception in LifecycleImpl.executePhase  
             return;
         }
 
-        PhaseEvent event = null;
+        PhaseEvent event = phaseEventForActivePhase;
 
-        for (int i = phaseListeners.length - 1; i >= 0; i--)
+        for (int i = listenerCountForActivePhase - 1; i >= 0; i--)
         {
-            PhaseListener phaseListener = phaseListeners[i];
-            if (isListenerForThisPhase(phaseListener, phaseId) && beforePhaseSuccess[i])
+            if (i >= phaseListeners.size())
+            {
+                continue;
+            }
+            PhaseListener phaseListener = phaseListeners.get(i);
+            if (isListenerForThisPhase(phaseListener, phaseId) && beforePhaseSuccessScratch[i])
             {
-                if (event == null)
-                {
-                    event = new PhaseEvent(facesContext, phaseId, lifecycle);
-                }
                 try
                 {
                     phaseListener.afterPhase(event);
@@ -126,6 +140,8 @@ public void informPhaseListenersAfter(PhaseId phaseId)
             }
         }
 
+        activePhaseIdForBeforeSuccess = null;
+        phaseEventForActivePhase = null;
     }
     
     private void publishException(Throwable e, PhaseId phaseId, String key)
diff --git a/impl/src/main/java/org/apache/myfaces/push/cdi/WebsocketSessionManager.java b/impl/src/main/java/org/apache/myfaces/push/cdi/WebsocketSessionManager.java
index e294cd107..77bdbd917 100644
--- a/impl/src/main/java/org/apache/myfaces/push/cdi/WebsocketSessionManager.java
+++ b/impl/src/main/java/org/apache/myfaces/push/cdi/WebsocketSessionManager.java
@@ -31,7 +31,6 @@
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.Queue;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -40,7 +39,6 @@
 import java.util.concurrent.Future;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import java.util.stream.Collectors;
 
 import jakarta.faces.context.ExternalContext;
 import jakarta.websocket.CloseReason;
@@ -164,12 +162,16 @@ public void initSessionMap(ExternalContext context)
                     Collection<Reference<Session>> referenceCollection = entry.getValue();
                     if (referenceCollection != null)
                     {
-                        Collection<Reference<Session>> newReferenceCollection =
-                                referenceCollection
-                                        .stream()
-                                        .filter(p -> p.get() != null && p.get().isOpen())
-                                        .distinct()
-                                        .collect(Collectors.toCollection(ConcurrentLinkedQueue::new));
+                        ConcurrentLinkedQueue<Reference<Session>> newReferenceCollection =
+                                new ConcurrentLinkedQueue<>();
+                        for (Reference<Session> p : referenceCollection)
+                        {
+                            Session s = p.get();
+                            if (s != null && s.isOpen())
+                            {
+                                newReferenceCollection.add(p);
+                            }
+                        }
                         newSessionMap.put(entry.getKey(), newReferenceCollection);
                     }
                 }
@@ -204,14 +206,14 @@ public boolean addOrUpdateSession(String channelToken, Session session)
             sessions = sessionMap.get(channelToken);
         }
 
-        Optional<Reference<Session>> referenceOptional =
-                sessions.stream().filter(p -> Objects.equals(p.get(), session)).findFirst();
-
-        if (!referenceOptional.isPresent())
+        for (Reference<Session> p : sessions)
         {
-            return sessions.add(new SoftReference<>(session));
+            if (Objects.equals(p.get(), session))
+            {
+                return true;
+            }
         }
-        return true;
+        return sessions.add(new SoftReference<>(session));
     }
 
     /**
@@ -231,9 +233,22 @@ public void removeSession(String channelToken, Session session)
                     "session.id = {1}", new Object[] {channelToken ,session.getId()});
         }
         Collection<Reference<Session>> collection = getSessionMap().get(channelToken);
-        Optional<Reference<Session>> referenceOptional =
-                collection.stream().filter(p -> Objects.equals(p.get(), session)).findFirst();
-        referenceOptional.ifPresent(collection::remove);
+        if (collection != null)
+        {
+            Reference<Session> toRemove = null;
+            for (Reference<Session> p : collection)
+            {
+                if (Objects.equals(p.get(), session))
+                {
+                    toRemove = p;
+                    break;
+                }
+            }
+            if (toRemove != null)
+            {
+                collection.remove(toRemove);
+            }
+        }
     }
 
     /**
@@ -280,7 +295,7 @@ protected Set<Future<Void>> send(String channelToken, Object message)
         {
             String json = Json.encode(message);
 
-            sessions.forEach(sessionRef ->
+            for (Reference<Session> sessionRef : sessions)
             {
                 if (sessionRef != null && sessionRef.get() != null)
                 {
@@ -297,7 +312,7 @@ protected Set<Future<Void>> send(String channelToken, Object message)
                         removeSession(channelToken, session);
                     }
                 }
-            });
+            }
             return results;
         }
         else
@@ -369,8 +384,12 @@ public void synchronizeSessionInstances()
             {
 
                 Collection<Reference<Session>> collectionRef = map.values().iterator().next();
-                collectionRef.stream().filter(ref -> ref != null).forEach(ref ->
+                for (Reference<Session> ref : collectionRef)
                 {
+                    if (ref == null)
+                    {
+                        continue;
+                    }
                     Session session = ref.get();
                     if (session != null)
                     {
@@ -389,7 +408,7 @@ public void synchronizeSessionInstances()
                         // Remove one element from the queue
                         queue.poll();
                     }
-                });
+                }
             }
         }
     }
diff --git a/impl/src/main/java/org/apache/myfaces/renderkit/ErrorPageWriter.java b/impl/src/main/java/org/apache/myfaces/renderkit/ErrorPageWriter.java
index 67cd80b91..effb3fbee 100644
--- a/impl/src/main/java/org/apache/myfaces/renderkit/ErrorPageWriter.java
+++ b/impl/src/main/java/org/apache/myfaces/renderkit/ErrorPageWriter.java
@@ -727,7 +727,7 @@ private static void writeComponent(FacesContext faces, Writer writer, UIComponen
                 stateSize = -1;
                 if (log.isLoggable(Level.FINEST))
                 {
-                    log.fine("Could not determine state size: " + e.getMessage());
+                    log.log(Level.FINEST, "Could not determine state size: {0}", e.getMessage());
                 }
             }
         }
diff --git a/impl/src/main/java/org/apache/myfaces/renderkit/html/HtmlRenderKitImpl.java b/impl/src/main/java/org/apache/myfaces/renderkit/html/HtmlRenderKitImpl.java
index ab595410f..45da2d4be 100755
--- a/impl/src/main/java/org/apache/myfaces/renderkit/html/HtmlRenderKitImpl.java
+++ b/impl/src/main/java/org/apache/myfaces/renderkit/html/HtmlRenderKitImpl.java
@@ -174,9 +174,12 @@ synchronized private void _put(String componentFamily, String rendererType, Rend
                 // this is not necessarily an error, but users do need to be
                 // very careful about jar processing order when overriding
                 // some component's renderer with an alternate renderer.
-                log.fine("Overwriting renderer with family = " + componentFamily +
-                   " rendererType = " + rendererType +
-                   " renderer class = " + renderer.getClass().getName());
+                if (log.isLoggable(Level.FINE))
+                {
+                    log.fine("Overwriting renderer with family = " + componentFamily +
+                       " rendererType = " + rendererType +
+                       " renderer class = " + renderer.getClass().getName());
+                }
             }
         }
         familyRendererMap.put(rendererType, renderer);
diff --git a/impl/src/main/java/org/apache/myfaces/renderkit/html/base/HtmlInputFileRendererBase.java b/impl/src/main/java/org/apache/myfaces/renderkit/html/base/HtmlInputFileRendererBase.java
index 79ffa3f4f..55139c6c3 100644
--- a/impl/src/main/java/org/apache/myfaces/renderkit/html/base/HtmlInputFileRendererBase.java
+++ b/impl/src/main/java/org/apache/myfaces/renderkit/html/base/HtmlInputFileRendererBase.java
@@ -37,7 +37,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.logging.Logger;
-import java.util.stream.Collectors;
 
 import jakarta.faces.FacesException;
 import jakarta.faces.application.FacesMessage;
@@ -136,9 +135,15 @@ public Object getConvertedValue(FacesContext context, UIComponent component, Obj
         else if (submittedValue instanceof Collection)
         {
             Collection<Part> parts = (Collection<Part>) submittedValue;
-            return Collections.unmodifiableList(parts.stream()
-                        .filter(part -> !isEmpty(part))
-                        .collect(Collectors.toList()));
+            List<Part> nonEmpty = new ArrayList<>(parts.size());
+            for (Part part : parts)
+            {
+                if (!isEmpty(part))
+                {
+                    nonEmpty.add(part);
+                }
+            }
+            return Collections.unmodifiableList(nonEmpty);
         }
         return submittedValue;
     }
diff --git a/impl/src/main/java/org/apache/myfaces/renderkit/html/util/JavascriptUtils.java b/impl/src/main/java/org/apache/myfaces/renderkit/html/util/JavascriptUtils.java
index 3cd1e6794..d8c5a40a3 100755
--- a/impl/src/main/java/org/apache/myfaces/renderkit/html/util/JavascriptUtils.java
+++ b/impl/src/main/java/org/apache/myfaces/renderkit/html/util/JavascriptUtils.java
@@ -22,14 +22,16 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.regex.Pattern;
 
 import org.apache.myfaces.config.webparameters.MyfacesConfig;
 
 import jakarta.faces.context.ExternalContext;
-import java.util.stream.Collectors;
 
 public final class JavascriptUtils
 {
+    private static final Pattern PATTERN = Pattern.compile("-");
+
     private JavascriptUtils()
     {
         // utility class, do not instantiate
@@ -96,7 +98,7 @@ private JavascriptUtils()
      */
     public static String getValidJavascriptNameAsInRI(String origIdentifier)
     {
-        return origIdentifier.replaceAll("-", "\\$_");
+        return PATTERN.matcher(origIdentifier).replaceAll("\\$_");
     }
 
     public static String getValidJavascriptName(String s, boolean allowNamespaces, boolean checkForReservedWord)
@@ -107,9 +109,21 @@ public static String getValidJavascriptName(String s, boolean allowNamespaces, b
         }
         else
         {
-            return Arrays.stream(s.split("\\."))
-                    .map(ns -> getValidJavascriptName(ns, checkForReservedWord))
-                    .collect(Collectors.joining("."));
+            String[] segments = s.split("\\.", -1);
+            if (segments.length == 1)
+            {
+                return getValidJavascriptName(segments[0], checkForReservedWord);
+            }
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < segments.length; i++)
+            {
+                if (i > 0)
+                {
+                    sb.append('.');
+                }
+                sb.append(getValidJavascriptName(segments[i], checkForReservedWord));
+            }
+            return sb.toString();
         }
     }
 
diff --git a/impl/src/main/java/org/apache/myfaces/resource/FacesJSResourceLoader.java b/impl/src/main/java/org/apache/myfaces/resource/FacesJSResourceLoader.java
index eb498555f..a8e1898f3 100644
--- a/impl/src/main/java/org/apache/myfaces/resource/FacesJSResourceLoader.java
+++ b/impl/src/main/java/org/apache/myfaces/resource/FacesJSResourceLoader.java
@@ -30,6 +30,7 @@
 
 import java.io.*;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.Comparator;
 import java.util.Iterator;
 
@@ -47,6 +48,8 @@ public class FacesJSResourceLoader extends ResourceLoaderWrapper
 
     public static final String SOURCE_MAP_MARKER = "//# sourceMappingURL=";
 
+    private static final byte[] NEWLINE_UTF8 = "\n".getBytes(StandardCharsets.UTF_8);
+
     private final ResourceLoader delegate;
 
     public FacesJSResourceLoader(ResourceLoader delegate)
@@ -111,25 +114,20 @@ public InputStream getResourceInputStream(ResourceMeta resourceMeta)
         try (InputStream inputStream = delegate.getResourceInputStream(resourceMeta);
              ByteArrayOutputStream writer = new ByteArrayOutputStream())
         {
-            new BufferedReader(new InputStreamReader(inputStream))
-                    .lines()
-                    .forEach(line ->
+            try (BufferedReader reader = new BufferedReader(
+                    new InputStreamReader(inputStream, StandardCharsets.UTF_8)))
+            {
+                String line;
+                while ((line = reader.readLine()) != null)
+                {
+                    if (line.contains(SOURCE_MAP_MARKER))
                     {
-                        // filtering out the source map for now
-                        if (line.contains(SOURCE_MAP_MARKER))
-                        {
-                            return;
-                        }
-                        try
-                        {
-                            writer.write(line.getBytes());
-                            writer.write("\n".getBytes());
-                        }
-                        catch (IOException e)
-                        {
-                            throw new FacesException(e);
-                        }
-                    });
+                        continue;
+                    }
+                    writer.write(line.getBytes(StandardCharsets.UTF_8));
+                    writer.write(NEWLINE_UTF8);
+                }
+            }
 
             // for development mode we reattach an altered map reference
             if(FacesContext.getCurrentInstance().isProjectStage(ProjectStage.Development))
@@ -149,11 +147,11 @@ public InputStream getResourceInputStream(ResourceMeta resourceMeta)
                 }
 
                 //We have to rely now on the resource being loaded during a request otherwise we cannot to the remapping
-                writer.write("\n".getBytes());
-                writer.write(SOURCE_MAP_MARKER.getBytes());
-                writer.write(mappedResourceName.getBytes());
+                writer.write(NEWLINE_UTF8);
+                writer.write(SOURCE_MAP_MARKER.getBytes(StandardCharsets.UTF_8));
+                writer.write(mappedResourceName.getBytes(StandardCharsets.UTF_8));
                 // we are now adding the library name to make the mapping request a resource request
-                writer.write(("?ln=" + libraryName).getBytes());
+                writer.write(("?ln=" + libraryName).getBytes(StandardCharsets.UTF_8));
             }
             return new ByteArrayInputStream(writer.toByteArray());
         }
diff --git a/impl/src/main/java/org/apache/myfaces/util/ViewNamespaceUtils.java b/impl/src/main/java/org/apache/myfaces/util/ViewNamespaceUtils.java
index 51fff8da3..c922c6c28 100644
--- a/impl/src/main/java/org/apache/myfaces/util/ViewNamespaceUtils.java
+++ b/impl/src/main/java/org/apache/myfaces/util/ViewNamespaceUtils.java
@@ -24,7 +24,9 @@
 import jakarta.faces.context.FacesContext;
 import jakarta.faces.render.ResponseStateManager;
 import jakarta.servlet.ServletRequest;
+
 import java.util.Map;
+import java.util.Set;
 
 public class ViewNamespaceUtils
 {
@@ -86,9 +88,16 @@ public static String getViewNamespace(FacesContext context, ServletRequest reque
     protected static String resolvePrefixFromRequest(FacesContext facesContext,
             Map<String, String[]> requestParameterMap)
     {
-        String firstViewStateKey = requestParameterMap.keySet().stream()
-                .filter(item -> item.contains(ResponseStateManager.VIEW_STATE_PARAM))
-                .findFirst().orElse("");
+        String firstViewStateKey = "";
+        Set<String> keys = requestParameterMap.keySet();
+        for (String item : keys)
+        {
+            if (item.contains(ResponseStateManager.VIEW_STATE_PARAM))
+            {
+                firstViewStateKey = item;
+                break;
+            }
+        }
         if (!firstViewStateKey.isEmpty())
         {
             char sep = facesContext.getNamingContainerSeparatorChar();
diff --git a/impl/src/main/java/org/apache/myfaces/view/facelets/impl/DefaultFacelet.java b/impl/src/main/java/org/apache/myfaces/view/facelets/impl/DefaultFacelet.java
index cb277acb3..45d21da97 100644
--- a/impl/src/main/java/org/apache/myfaces/view/facelets/impl/DefaultFacelet.java
+++ b/impl/src/main/java/org/apache/myfaces/view/facelets/impl/DefaultFacelet.java
@@ -25,13 +25,13 @@
 import java.net.URL;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
-import java.util.Collections;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.WeakHashMap;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -95,7 +95,7 @@ public DefaultFacelet(DefaultFaceletFactory factory, ExpressionFactory el, URL s
         _createTime = System.currentTimeMillis();
         _refreshPeriod = _factory.getRefreshPeriod();
         
-        _relativePaths = Collections.synchronizedMap(new WeakHashMap());
+        _relativePaths = new ConcurrentHashMap<>();
         _isBuildingCompositeComponentMetadata = false;
         _encodingHandler = (root instanceof EncodingHandler);
         this.viewUniqueIdsCacheEnabled = viewUniqueIdsCacheEnabled;
@@ -115,7 +115,7 @@ public DefaultFacelet(DefaultFaceletFactory factory, ExpressionFactory el, URL s
         _createTime = System.currentTimeMillis();
         _refreshPeriod = _factory.getRefreshPeriod();
         
-        _relativePaths = Collections.synchronizedMap(new WeakHashMap());
+        _relativePaths = new ConcurrentHashMap<>();
         _isBuildingCompositeComponentMetadata = isBuildingCompositeComponentMetadata;
         _encodingHandler = (root instanceof EncodingHandler);
         this.viewUniqueIdsCacheEnabled = viewUniqueIdsCacheEnabled;
diff --git a/impl/src/main/java/org/apache/myfaces/view/facelets/impl/DefaultFaceletFactory.java b/impl/src/main/java/org/apache/myfaces/view/facelets/impl/DefaultFaceletFactory.java
index 705ffa2a3..2b18271d3 100644
--- a/impl/src/main/java/org/apache/myfaces/view/facelets/impl/DefaultFaceletFactory.java
+++ b/impl/src/main/java/org/apache/myfaces/view/facelets/impl/DefaultFaceletFactory.java
@@ -26,7 +26,6 @@
 import java.util.Optional;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import java.util.regex.Pattern;
 
 import jakarta.el.ELException;
 import jakarta.enterprise.inject.spi.BeanManager;
@@ -594,12 +593,19 @@ public Facelet compileComponentFacelet(String taglibURI, String tagName, Map<Str
      * @param toRemove
      * @return
      */
-    private String _removeFirst(String string, String toRemove)
+    protected String _removeFirst(String string, String toRemove)
     {
-        // do exactly what String.replaceFirst(toRemove, "") internally does,
-        // except treating the search as literal text and not as regex
-
-        return Pattern.compile(toRemove, Pattern.LITERAL).matcher(string).replaceFirst("");
+        // Literal first occurrence removal (same idea as Pattern.LITERAL + replaceFirst, without regex setup).
+        if (toRemove == null || toRemove.isEmpty())
+        {
+            return string;
+        }
+        int idx = string.indexOf(toRemove);
+        if (idx < 0)
+        {
+            return string;
+        }
+        return string.substring(0, idx) + string.substring(idx + toRemove.length());
     }
 
 }
diff --git a/impl/src/test/java/org/apache/myfaces/renderkit/html/util/JavascriptUtilsTest.java b/impl/src/test/java/org/apache/myfaces/renderkit/html/util/JavascriptUtilsTest.java
new file mode 100644
index 000000000..a4ea3f8a9
--- /dev/null
+++ b/impl/src/test/java/org/apache/myfaces/renderkit/html/util/JavascriptUtilsTest.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.myfaces.renderkit.html.util;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class JavascriptUtilsTest
+{
+    @Test
+    public void testGetValidJavascriptNameTest_SimpleIdentifierUnchanged()
+    {
+        Assertions.assertEquals("fooBar123",
+                JavascriptUtils.getValidJavascriptName("fooBar123", false));
+        Assertions.assertEquals("fooBar123",
+                JavascriptUtils.getValidJavascriptName("fooBar123", true, false));
+    }
+
+    @Test
+    public void testGetValidJavascriptNameTest_ReservedWordAppendsUnderscoreWhenChecking()
+    {
+        Assertions.assertEquals("var_",
+                JavascriptUtils.getValidJavascriptName("var", true));
+        Assertions.assertEquals("var_",
+                JavascriptUtils.getValidJavascriptName("var", true, true));
+    }
+
+    @Test
+    public void testGetValidJavascriptNameTest_ReservedWordUnchangedWhenNotChecking()
+    {
+        Assertions.assertEquals("var",
+                JavascriptUtils.getValidJavascriptName("var", false));
+    }
+
+    @Test
+    public void testGetValidJavascriptNameTest_InvalidCharactersBecomeUnderscorePlusHex()
+    {
+        Assertions.assertEquals("a_2Db",
+                JavascriptUtils.getValidJavascriptName("a-b", false));
+        Assertions.assertEquals("x_2Ey",
+                JavascriptUtils.getValidJavascriptName("x.y", false));
+    }
+
+    @Test
+    public void testGetValidJavascriptNameTest_AllowNamespacesSplitsSegments()
+    {
+        Assertions.assertEquals("a.b",
+                JavascriptUtils.getValidJavascriptName("a.b", true, false));
+        Assertions.assertEquals("a_3Ab.c",
+                JavascriptUtils.getValidJavascriptName("a:b.c", true, false));
+    }
+
+    @Test
+    public void testGetValidJavascriptNameTest_AllowNamespacesFalseTreatsDotsAsInvalid()
+    {
+        Assertions.assertEquals("a_2Eb",
+                JavascriptUtils.getValidJavascriptName("a.b", false, false));
+    }
+
+    @Test
+    public void testGetValidJavascriptNameTest_EmptyString()
+    {
+        Assertions.assertEquals("",
+                JavascriptUtils.getValidJavascriptName("", false));
+    }
+}
diff --git a/impl/src/test/java/org/apache/myfaces/test/core/AbstractMyFacesTestCase.java b/impl/src/test/java/org/apache/myfaces/test/core/AbstractMyFacesTestCase.java
index 2fad3b433..45ab7d7ca 100644
--- a/impl/src/test/java/org/apache/myfaces/test/core/AbstractMyFacesTestCase.java
+++ b/impl/src/test/java/org/apache/myfaces/test/core/AbstractMyFacesTestCase.java
@@ -78,6 +78,7 @@
 import java.net.URI;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -683,7 +684,8 @@ public void executeBeforeRender(FacesContext facesContext)
             PhaseListenerManager phaseManager = (PhaseListenerManager) facesContext.getAttributes().get(PHASE_MANAGER_INSTANCE);
             if (phaseManager == null)
             {
-                phaseManager = new PhaseListenerManager(lifecycle, facesContext, lifecycleImpl.getPhaseListeners());
+                phaseManager = new PhaseListenerManager(lifecycle, facesContext,
+                        Arrays.asList(lifecycleImpl.getPhaseListeners()));
                 facesContext.getAttributes().put(PHASE_MANAGER_INSTANCE, phaseManager);
             }
 
@@ -875,7 +877,8 @@ public void executeAfterRender(FacesContext facesContext)
                 phaseManager = (PhaseListenerManager) facesContext.getAttributes().get(PHASE_MANAGER_INSTANCE);
                 if (phaseManager == null)
                 {
-                    phaseManager = new PhaseListenerManager(lifecycle, facesContext, lifecycleImpl.getPhaseListeners());
+                    phaseManager = new PhaseListenerManager(lifecycle, facesContext,
+                            Arrays.asList(lifecycleImpl.getPhaseListeners()));
                     facesContext.getAttributes().put(PHASE_MANAGER_INSTANCE, phaseManager);
                 }
 
diff --git a/impl/src/test/java/org/apache/myfaces/view/facelets/impl/DefaultFaceletFactoryTest.java b/impl/src/test/java/org/apache/myfaces/view/facelets/impl/DefaultFaceletFactoryTest.java
new file mode 100644
index 000000000..5cc1bac8d
--- /dev/null
+++ b/impl/src/test/java/org/apache/myfaces/view/facelets/impl/DefaultFaceletFactoryTest.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.myfaces.view.facelets.impl;
+
+import java.io.IOException;
+
+import org.apache.myfaces.view.facelets.AbstractFaceletTestCase;
+import org.apache.myfaces.view.facelets.compiler.SAXCompiler;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for {@link DefaultFaceletFactory#_removeFirst(String, String)} (same-package access to protected).
+ */
+public class DefaultFaceletFactoryTest extends AbstractFaceletTestCase
+{
+    @Test
+    public void testRemoveFirstPrefix() throws IOException
+    {
+        DefaultFaceletFactory factory = new DefaultFaceletFactory(new SAXCompiler());
+        Assertions.assertEquals("/y/z", factory._removeFirst("/x/y/z", "/x"));
+    }
+
+    @Test
+    public void testRemoveFirstOnlyFirstOccurrence() throws IOException
+    {
+        DefaultFaceletFactory factory = new DefaultFaceletFactory(new SAXCompiler());
+        Assertions.assertEquals("/a/b/a", factory._removeFirst("/a/b/a/b/a", "/a/b"));
+    }
+
+    @Test
+    public void testRemoveFirstNotFound() throws IOException
+    {
+        DefaultFaceletFactory factory = new DefaultFaceletFactory(new SAXCompiler());
+        Assertions.assertEquals("/unchanged", factory._removeFirst("/unchanged", "/missing"));
+    }
+
+    @Test
+    public void testRemoveFirstEmptyToRemove() throws IOException
+    {
+        DefaultFaceletFactory factory = new DefaultFaceletFactory(new SAXCompiler());
+        Assertions.assertEquals("/same", factory._removeFirst("/same", ""));
+    }
+
+    @Test
+    public void testRemoveFirstNullToRemove() throws IOException
+    {
+        DefaultFaceletFactory factory = new DefaultFaceletFactory(new SAXCompiler());
+        Assertions.assertEquals("/same", factory._removeFirst("/same", null));
+    }
+
+    @Test
+    public void testRemoveFirstRegexMetacharactersAreLiteral() throws IOException
+    {
+        DefaultFaceletFactory factory = new DefaultFaceletFactory(new SAXCompiler());
+        Assertions.assertEquals("prefixsuffix", factory._removeFirst("prefix.+suffix", ".+"));
+    }
+
+    @Test
+    public void testRemoveFirstWholeString() throws IOException
+    {
+        DefaultFaceletFactory factory = new DefaultFaceletFactory(new SAXCompiler());
+        Assertions.assertEquals("", factory._removeFirst("/only", "/only"));
+    }
+}
diff --git a/test/src/main/java/org/apache/myfaces/test/mock/lifecycle/MockLifecycle.java b/test/src/main/java/org/apache/myfaces/test/mock/lifecycle/MockLifecycle.java
index 7fac9a948..174e36619 100644
--- a/test/src/main/java/org/apache/myfaces/test/mock/lifecycle/MockLifecycle.java
+++ b/test/src/main/java/org/apache/myfaces/test/mock/lifecycle/MockLifecycle.java
@@ -44,7 +44,7 @@ public class MockLifecycle extends Lifecycle
     /**
      * <p>List of event listeners for this instance.</p>
      */
-    private List phaseListenerList = new ArrayList();
+    private final List<PhaseListener> phaseListenerList = new ArrayList<>();
     private PhaseExecutor[] lifecycleExecutors;
     private PhaseExecutor renderExecutor;
 
@@ -70,7 +70,7 @@ public void addPhaseListener(PhaseListener listener)
     @Override
     public void execute(FacesContext context) throws FacesException
     {
-        PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this,context, getPhaseListeners());
+        PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, context, phaseListenerList);
         for (int executorIndex = 0; executorIndex < lifecycleExecutors.length; executorIndex++)
         {
             if (executePhase(context, lifecycleExecutors[executorIndex],
@@ -144,7 +144,7 @@ public void render(FacesContext context) throws FacesException
         }
 
         PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this,
-                context, getPhaseListeners());
+                context, phaseListenerList);
 
         try
         {
diff --git a/test/src/main/java/org/apache/myfaces/test/mock/lifecycle/PhaseListenerManager.java b/test/src/main/java/org/apache/myfaces/test/mock/lifecycle/PhaseListenerManager.java
index dc693a32c..89cf70d4a 100644
--- a/test/src/main/java/org/apache/myfaces/test/mock/lifecycle/PhaseListenerManager.java
+++ b/test/src/main/java/org/apache/myfaces/test/mock/lifecycle/PhaseListenerManager.java
@@ -19,10 +19,11 @@
 
 package org.apache.myfaces.test.mock.lifecycle;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.Arrays;
+import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import jakarta.faces.context.FacesContext;
 import jakarta.faces.event.PhaseEvent;
 import jakarta.faces.event.PhaseId;
@@ -44,22 +45,35 @@ class PhaseListenerManager
 
     private Lifecycle lifecycle;
     private FacesContext facesContext;
-    private PhaseListener[] phaseListeners;
+    private List<PhaseListener> phaseListeners;
 
     // Tracks success in the beforePhase.  Listeners that throw an exception
     // in beforePhase or were never called because a previous listener threw
     // an exception should not have its afterPhase called
-    private Map<PhaseId, boolean[]> listenerSuccessMap = new HashMap<PhaseId, boolean[]>();
+    private boolean[] beforePhaseSuccessScratch;
+
+    private int listenerCountForActivePhase;
+
+    private PhaseId activePhaseIdForBeforeSuccess;
+    private PhaseEvent phaseEventForActivePhase;
 
     /** Creates a new instance of PhaseListenerManager */
     PhaseListenerManager(Lifecycle lifecycle, FacesContext facesContext,
-            PhaseListener[] phaseListeners)
+            List<PhaseListener> phaseListeners)
     {
         this.lifecycle = lifecycle;
         this.facesContext = facesContext;
         this.phaseListeners = phaseListeners;
     }
 
+    private void ensureScratch(int minSize)
+    {
+        if (beforePhaseSuccessScratch == null || beforePhaseSuccessScratch.length < minSize)
+        {
+            beforePhaseSuccessScratch = new boolean[minSize];
+        }
+    }
+
     private boolean isListenerForThisPhase(PhaseListener phaseListener,
             PhaseId phaseId)
     {
@@ -70,22 +84,27 @@ private boolean isListenerForThisPhase(PhaseListener phaseListener,
 
     void informPhaseListenersBefore(PhaseId phaseId)
     {
-        boolean[] beforePhaseSuccess = new boolean[phaseListeners.length];
-        listenerSuccessMap.put(phaseId, beforePhaseSuccess);
+        listenerCountForActivePhase = phaseListeners.size();
+        ensureScratch(listenerCountForActivePhase);
+        Arrays.fill(beforePhaseSuccessScratch, 0, listenerCountForActivePhase, false);
+        activePhaseIdForBeforeSuccess = phaseId;
+
+        PhaseEvent event = new PhaseEvent(facesContext, phaseId, lifecycle);
+        phaseEventForActivePhase = event;
 
-        for (int i = 0; i < phaseListeners.length; i++)
+        for (int i = 0; i < listenerCountForActivePhase; i++)
         {
-            PhaseListener phaseListener = phaseListeners[i];
+            PhaseListener phaseListener = phaseListeners.get(i);
             if (isListenerForThisPhase(phaseListener, phaseId))
             {
                 try
                 {
-                    phaseListener.beforePhase(new PhaseEvent(facesContext, phaseId, lifecycle));
-                    beforePhaseSuccess[i] = true;
+                    phaseListener.beforePhase(event);
+                    beforePhaseSuccessScratch[i] = true;
                 }
                 catch (Exception e)
                 {
-                    beforePhaseSuccess[i] = false; // redundant - for clarity
+                    beforePhaseSuccessScratch[i] = false; // redundant - for clarity
                     log.log(Level.SEVERE, "Exception in PhaseListener "
                             + phaseId.toString() + " beforePhase.", e);
                     return;
@@ -96,17 +115,26 @@ void informPhaseListenersBefore(PhaseId phaseId)
 
     void informPhaseListenersAfter(PhaseId phaseId)
     {
-        boolean[] beforePhaseSuccess = listenerSuccessMap.get(phaseId);
+        if (activePhaseIdForBeforeSuccess != phaseId)
+        {
+            return;
+        }
 
-        for (int i = phaseListeners.length - 1; i >= 0; i--)
+        PhaseEvent event = phaseEventForActivePhase;
+
+        for (int i = listenerCountForActivePhase - 1; i >= 0; i--)
         {
-            PhaseListener phaseListener = phaseListeners[i];
+            if (i >= phaseListeners.size())
+            {
+                continue;
+            }
+            PhaseListener phaseListener = phaseListeners.get(i);
             if (isListenerForThisPhase(phaseListener, phaseId)
-                    && beforePhaseSuccess[i])
+                    && beforePhaseSuccessScratch[i])
             {
                 try
                 {
-                    phaseListener.afterPhase(new PhaseEvent(facesContext, phaseId, lifecycle));
+                    phaseListener.afterPhase(event);
                 }
                 catch (Exception e)
                 {
@@ -116,5 +144,7 @@ void informPhaseListenersAfter(PhaseId phaseId)
             }
         }
 
+        activePhaseIdForBeforeSuccess = null;
+        phaseEventForActivePhase = null;
     }
-}
\ No newline at end of file
+}