diff --git a/src/main/java/org/apache/commons/xml/SaxonProvider.java b/src/main/java/org/apache/commons/xml/SaxonProvider.java
index 23c1c2b3..2b600ba6 100644
--- a/src/main/java/org/apache/commons/xml/SaxonProvider.java
+++ b/src/main/java/org/apache/commons/xml/SaxonProvider.java
@@ -43,6 +43,18 @@
  */
 final class SaxonProvider {
 
+    /**
+     * Tells whether the factory class is Saxon's, by package prefix, so public subclasses such as {@code net.sf.saxon.BasicTransformerFactory} route to the
+     * same locked-down {@link Configuration} as the factory registered for JAXP lookup.
+     *
+     * @param factoryClass The factory implementation class.
+     * @return Whether the class lives in Saxon's open-source or commercial packages.
+     */
+    static boolean isSaxon(final Class<?> factoryClass) {
+        final String name = factoryClass.getName();
+        return name.startsWith("net.sf.saxon.") || name.startsWith("com.saxonica.");
+    }
+
     /**
      * A Saxon {@link Configuration} carrying the vendor-specific restrictions that the standard JAXP knobs cannot express.
      *
@@ -123,6 +135,9 @@ static Supplier<Source> emptySourceSupplier() {
     static TransformerFactory configure(final TransformerFactory factory) {
         try {
             return SaxonProviderConfigurer.configure(factory);
+        } catch (final ClassCastException e) {
+            // A Saxon-package factory the configurer cannot lock down; refuse it rather than returning it unhardened.
+            throw new HardeningException("Unsupported Saxon TransformerFactory " + factory.getClass().getName(), e);
         } catch (final LinkageError e) {
             // Unlikely, but protects method execution from missing optional dependency
             throw new IllegalStateException(e);
@@ -132,6 +147,9 @@ static TransformerFactory configure(final TransformerFactory factory) {
     static XPathFactory configure(final XPathFactory factory) {
         try {
             return SaxonProviderConfigurer.configure(factory);
+        } catch (final ClassCastException e) {
+            // A Saxon-package factory the configurer cannot lock down; refuse it rather than returning it unhardened.
+            throw new HardeningException("Unsupported Saxon XPathFactory " + factory.getClass().getName(), e);
         } catch (final LinkageError e) {
             // Unlikely, but protects method execution from missing optional dependency
             throw new IllegalStateException(e);
diff --git a/src/main/java/org/apache/commons/xml/TransformerHardener.java b/src/main/java/org/apache/commons/xml/TransformerHardener.java
index d71585a4..6dbb6233 100644
--- a/src/main/java/org/apache/commons/xml/TransformerHardener.java
+++ b/src/main/java/org/apache/commons/xml/TransformerHardener.java
@@ -17,11 +17,6 @@
 
 package org.apache.commons.xml;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-
 import javax.xml.XMLConstants;
 import javax.xml.transform.Source;
 import javax.xml.transform.Transformer;
@@ -34,7 +29,7 @@
  *
  * <p>Rather than branching on the implementation class, {@link #harden(TransformerFactory)} probes what the factory supports and adapts:</p>
  * <ul>
- *     <li><strong>Saxon</strong> ({@code net.sf.saxon}): recognized by class name and handed to {@link SaxonProvider#configure(TransformerFactory)} for the
+ *     <li><strong>Saxon</strong> ({@code net.sf.saxon}): recognized by package prefix and handed to {@link SaxonProvider#configure(TransformerFactory)} for the
  *         channels the standard JAXP knobs cannot close (reflection-based extension functions, the collection finder, the internal SAX parser). It is then
  *         wrapped in {@link HardeningTransformerFactory} like every other implementation to install the {@link FallbackIgnoreURIResolver} floor; the only
  *         difference is the empty-{@link Source} shape the floor returns, {@code EmptySource} for Saxon rather than the default empty DOM document.</li>
@@ -51,23 +46,15 @@
  */
 final class TransformerHardener {
 
-    /**
-     * Class names of Saxon's {@link TransformerFactory} (open-source and commercial editions), hardened through a Saxon {@code Configuration} rather than the
-     * standard JAXP knobs.
-     */
-    private static final Set<String> SAXON_TRANSFORMER_FACTORIES = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(
-            "net.sf.saxon.TransformerFactoryImpl",
-            "com.saxonica.config.ProfessionalTransformerFactory",
-            "com.saxonica.config.EnterpriseTransformerFactory")));
-
     static TransformerFactory harden(final TransformerFactory factory) {
-        if (SAXON_TRANSFORMER_FACTORIES.contains(factory.getClass().getName())) {
-            // Saxon keeps its vendor Configuration for the channels JAXP cannot close, then goes through the same wrapper as every other impl for the
-            // URIResolver floor; EmptySource is the empty-source shape Saxon's consumers expect.
-            return new HardeningTransformerFactory((SAXTransformerFactory) SaxonProvider.configure(factory), SaxonProvider.emptySourceSupplier());
-        }
         // Required: enables secure processing (XSLTC runtime limits; Xalan's extension-function block).
         setFeature(factory, XMLConstants.FEATURE_SECURE_PROCESSING, true);
+        if (SaxonProvider.isSaxon(factory.getClass())) {
+            // Saxon keeps its vendor Configuration for the channels JAXP cannot close,
+            // then goes through the same wrapper as every other impl for the URIResolver floor;
+            // EmptySource is the empty-source shape Saxon's consumers expect.
+            return new HardeningTransformerFactory((SAXTransformerFactory) SaxonProvider.configure(factory), SaxonProvider.emptySourceSupplier());
+        }
         // Required: source/stylesheet parsing provisions its own SAX reader otherwise; the wrapper routes every Source through a hardened one and installs the
         // ignore-all URIResolver floor (blocking xsl:import/include at compile time and document() at runtime) that a caller-set resolver cannot remove.
         return new HardeningTransformerFactory((SAXTransformerFactory) factory);
diff --git a/src/main/java/org/apache/commons/xml/XPathHardener.java b/src/main/java/org/apache/commons/xml/XPathHardener.java
index 4a995cd8..167088a7 100644
--- a/src/main/java/org/apache/commons/xml/XPathHardener.java
+++ b/src/main/java/org/apache/commons/xml/XPathHardener.java
@@ -17,11 +17,6 @@
 
 package org.apache.commons.xml;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-
 import javax.xml.XMLConstants;
 import javax.xml.xpath.XPathFactory;
 
@@ -32,9 +27,10 @@
  * {@code fn:doc}, {@code fn:collection} and {@code fn:unparsed-text} functions that can reach external resources. Rather than branching on the implementation
  * class, {@link #harden(XPathFactory)} probes what the factory supports and adapts:</p>
  * <ul>
- *     <li><strong>Saxon</strong> ({@code net.sf.saxon}): recognized by class name and handed to {@link SaxonProvider#configure(XPathFactory)}. Its URI-fetching
+ *     <li><strong>Saxon</strong> ({@code net.sf.saxon}): recognized by package prefix and handed to {@link SaxonProvider#configure(XPathFactory)}, so any public
+ *         subclass routes to the same recipe as the registered factory. Its URI-fetching
  *         functions and reflection-based extension calls are reachable only through a locked-down Saxon {@code Configuration}, not the standard JAXP knobs; this
- *         is the XPath counterpart of the Saxon exception in {@link TransformerHardener}, kept as a documented class-name exception because the required
+ *         is the XPath counterpart of the Saxon exception in {@link TransformerHardener}, kept as a documented package-prefix exception because the required
  *         hardening surface is reachable only through a vendor API.</li>
  *     <li><strong>FODP</strong> ({@code jdk.xml.overrideDefaultParser}, set to {@code false}): best-effort. On the stock JDK it pins the internal parser lookup to
  *         the bundled SAX parser, blocking a sysprop swap to a third-party parser (defense-in-depth); Xalan rejects the feature and is left unchanged.</li>
@@ -44,22 +40,13 @@
  */
 final class XPathHardener {
 
-    /**
-     * Class names of Saxon's {@link XPathFactory} (open-source and commercial editions), hardened through a Saxon {@code Configuration} rather than the standard
-     * JAXP knobs. The commercial editions subclass the open-source {@code net.sf.saxon.xpath.XPathFactoryImpl}, so {@link SaxonProvider} handles all three.
-     */
-    private static final Set<String> SAXON_XPATH_FACTORIES = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(
-            "net.sf.saxon.xpath.XPathFactoryImpl",
-            "com.saxonica.config.ProfessionalXPathFactory",
-            "com.saxonica.config.EnterpriseXPathFactory")));
-
     /**
      * {@code jdk.xml.overrideDefaultParser}: pin to the JDK's bundled SAX parser; defense-in-depth against a sysprop swap to a third-party parser.
      */
     private static final String FEATURE_OVERRIDE_DEFAULT_PARSER = "jdk.xml.overrideDefaultParser";
 
     static XPathFactory harden(final XPathFactory factory) {
-        if (SAXON_XPATH_FACTORIES.contains(factory.getClass().getName())) {
+        if (SaxonProvider.isSaxon(factory.getClass())) {
             // Saxon: only a locked-down Configuration can close its URI-fetching functions and extension-function surface.
             return SaxonProvider.configure(factory);
         }
diff --git a/src/test/java/org/apache/commons/xml/SaxonAlternateFactoryTest.java b/src/test/java/org/apache/commons/xml/SaxonAlternateFactoryTest.java
new file mode 100644
index 00000000..36e15a16
--- /dev/null
+++ b/src/test/java/org/apache/commons/xml/SaxonAlternateFactoryTest.java
@@ -0,0 +1,104 @@
+/*
+ * 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
+ *
+ *      https://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.commons.xml;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.StringWriter;
+
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamResult;
+
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Checks that Saxon's alternate public {@code TransformerFactory} entry point routes to the same locked-down {@code Configuration} as the registered one.
+ *
+ * <p>Saxon ships {@code net.sf.saxon.BasicTransformerFactory}, a public subclass of the registered {@code net.sf.saxon.TransformerFactoryImpl}, selectable
+ * through the standard TrAX system property. Recognition by package prefix sends it through {@code SaxonProvider}; a name-based recognition would let it fall
+ * to the generic recipe. The probe uses {@code fn:collection}, which bypasses Saxon's resource-resolution chain and fetches directly: only the empty
+ * {@code CollectionFinder} that {@code SaxonProvider} installs closes it, so the generic recipe (which leaves it open even after wrapping) does not. The
+ * factory is instantiated reflectively and the tests skip when Saxon is not on the classpath, so under the surefire group filters the checks are effective on
+ * the test-saxon and test-saxon-xerces executions.</p>
+ */
+@Tag("trax")
+class SaxonAlternateFactoryTest {
+
+    private static final String BASIC_FACTORY_CLASS = "net.sf.saxon.BasicTransformerFactory";
+
+    /** Instantiates {@code BasicTransformerFactory} reflectively, so this test compiles and loads without Saxon on the classpath. */
+    private static TransformerFactory basicSaxonFactory() {
+        try {
+            return (TransformerFactory) Class.forName(BASIC_FACTORY_CLASS).getDeclaredConstructor().newInstance();
+        } catch (final ReflectiveOperationException e) {
+            throw new AssertionError("Cannot instantiate " + BASIC_FACTORY_CLASS, e);
+        }
+    }
+
+    private static void assumeSaxonPresent() {
+        boolean present;
+        try {
+            Class.forName(BASIC_FACTORY_CLASS);
+            present = true;
+        } catch (final ClassNotFoundException e) {
+            present = false;
+        }
+        Assumptions.assumeTrue(present, "Saxon is not on the classpath");
+    }
+
+    /** A {@code collection()} over the test fixtures whose {@code referenced.xml} carries {@link AttackTestSupport#LEAKED_MARKER}. */
+    private static String collectionStylesheet() {
+        final String collection = AttackTestSupport.resourceUrl("referenced.xml").toString().replaceFirst("referenced\\.xml$", "?select=referenced.xml");
+        return "<?xml version=\"1.0\"?>\n"
+                + "<xsl:stylesheet version=\"3.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">\n"
+                + "  <xsl:template match=\"/\">\n"
+                + "    <leaked><xsl:value-of select=\"string(collection('" + collection + "')/leaked)\"/></leaked>\n"
+                + "  </xsl:template>\n"
+                + "</xsl:stylesheet>\n";
+    }
+
+    private static String transform(final TransformerFactory factory) throws TransformerException {
+        final StringWriter sink = new StringWriter();
+        factory.newTemplates(AttackTestSupport.streamSource(collectionStylesheet())).newTransformer()
+                .transform(AttackTestSupport.streamSource("<root/>"), new StreamResult(sink));
+        return sink.toString();
+    }
+
+    @Test
+    void hardenedBasicFactoryDoesNotLeakCollection() {
+        assumeSaxonPresent();
+        try {
+            final String result = transform(TransformerHardener.harden(basicSaxonFactory()));
+            assertFalse(result.contains(AttackTestSupport.LEAKED_MARKER), "collection() leaked through the alternate Saxon factory:\n" + result);
+        } catch (final TransformerException blocked) {
+            // Throwing is an acceptable outcome since it also prevents leaking the marker.
+        }
+    }
+
+    @Test
+    void unconfiguredBasicFactoryLeaksCollection() throws TransformerException {
+        assumeSaxonPresent();
+        // Leak control: the bare alternate factory resolves the collection, which is exactly what routing it through SaxonProvider exists to prevent.
+        final String result = transform(basicSaxonFactory());
+        assertTrue(result.contains(AttackTestSupport.LEAKED_MARKER), "bare alternate Saxon factory was expected to resolve collection(), got: " + result);
+    }
+}