diff --git a/jaxb-api/pom.xml b/jaxb-api/pom.xml
index 6b2ab44..ac5ce58 100644
--- a/jaxb-api/pom.xml
+++ b/jaxb-api/pom.xml
@@ -88,6 +88,7 @@
                         <release>11</release>
                         <nodeprecated>false</nodeprecated>
                         <notimestamp>true</notimestamp>
+                        <nosince>true</nosince>
                         <use>false</use>
                         <author>true</author>
                         <version>true</version>
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/Binder.java b/jaxb-api/src/main/java/jakarta/xml/bind/Binder.java
index 153d18c..6543729 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/Binder.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/Binder.java
@@ -15,18 +15,18 @@
 import javax.xml.validation.Schema;
 
 /**
- * Enable synchronization between XML infoset nodes and JAXB objects 
+ * Enable synchronization between XML infoset nodes and Jakarta XML Binding objects 
  * representing same XML document.
  *
  * <p>
  * An instance of this class maintains the association between XML nodes of
- * an infoset preserving view and a JAXB representation of an XML document. 
+ * an infoset preserving view and a Jakarta XML Binding representation of an XML document. 
  * Navigation between the two views is provided by the methods
  * {@link #getXMLNode(Object)} and {@link #getJAXBNode(Object)}.
  * 
  * <p>
  * Modifications can be made to either the infoset preserving view or the 
- * JAXB representation of the document while the other view remains 
+ * Jakarta XML Binding representation of the document while the other view remains 
  * unmodified. The binder is able to synchronize the changes made in the 
  * modified view back into the other view using the appropriate
  * Binder update methods, {@link #updateXML(Object, Object)} or 
@@ -36,11 +36,11 @@
  * A typical usage scenario is the following:
  * <ul>
  *   <li>load XML document into an XML infoset representation</li>
- *   <li>{@link #unmarshal(Object)} XML infoset view to JAXB view.
+ *   <li>{@link #unmarshal(Object)} XML infoset view to Jakarta XML Binding view.
  *       (Note to conserve resources, it is possible to only unmarshal a
- *       subtree of the XML infoset view to the JAXB view.)</li>
- *   <li>application access/updates JAXB view of XML document.</li>
- *   <li>{@link #updateXML(Object)} synchronizes modifications to JAXB view 
+ *       subtree of the XML infoset view to the Jakarta XML Binding view.)</li>
+ *   <li>application access/updates Jakarta XML Binding view of XML document.</li>
+ *   <li>{@link #updateXML(Object)} synchronizes modifications to Jakarta XML Binding view 
  *       back into the XML infoset view. Update operation preserves as 
  *       much of original XML infoset as possible (i.e. comments, PI, ...)</li>
  * </ul>
@@ -65,12 +65,12 @@
  */
 public abstract class Binder<XmlNode> {
     /**
-     * Unmarshal XML infoset view to a JAXB object tree.
+     * Unmarshal XML infoset view to a Jakarta XML Binding object tree.
      *
      * <p>
      * This method is similar to {@link Unmarshaller#unmarshal(Node)}
      * with the addition of maintaining the association between XML nodes 
-     * and the produced JAXB objects, enabling future update operations,
+     * and the produced Jakarta XML Binding objects, enabling future update operations,
      * {@link #updateXML(Object, Object)} or {@link #updateJAXB(Object)}.
      *
      * <p>
@@ -81,15 +81,15 @@
      * This method throws {@link UnmarshalException} when the Binder's
      * {@link JAXBContext} does not have a mapping for the XML element name
      * or the type, specifiable via {@code @xsi:type}, of {@code xmlNode}
-     * to a JAXB mapped class. The method {@link #unmarshal(Object, Class)} 
-     * enables an application to specify the JAXB mapped class that
+     * to a Jakarta XML Binding mapped class. The method {@link #unmarshal(Object, Class)} 
+     * enables an application to specify the Jakarta XML Binding mapped class that
      * the {@code xmlNode} should be mapped to.
      *
      * @param xmlNode 
      *      the document/element to unmarshal XML data from.
      *
      * @return
-     *      the newly created root object of the JAXB object tree.
+     *      the newly created root object of the Jakarta XML Binding object tree.
      *
      * @throws JAXBException
      *      If any unexpected errors occur while unmarshalling
@@ -105,7 +105,7 @@
 
     /**
      * Unmarshal XML root element by provided {@code declaredType}
-     * to a JAXB object tree.
+     * to a Jakarta XML Binding object tree.
      *
      * <p>
      * Implements <a href="Unmarshaller.html#unmarshalByDeclaredType">Unmarshal by Declared Type</a>
@@ -113,7 +113,7 @@
      * <p>
      * This method is similar to {@link Unmarshaller#unmarshal(Node, Class)}
      * with the addition of maintaining the association between XML nodes 
-     * and the produced JAXB objects, enabling future update operations,
+     * and the produced Jakarta XML Binding objects, enabling future update operations,
      * {@link #updateXML(Object, Object)} or {@link #updateJAXB(Object)}.
      *
      * <p>
@@ -123,10 +123,10 @@
      * @param xmlNode 
      *      the document/element to unmarshal XML data from.
      * @param declaredType
-     *      appropriate JAXB mapped class to hold {@code node}'s XML data.
+     *      appropriate Jakarta XML Binding mapped class to hold {@code node}'s XML data.
      *
      * @return
-     * <a href="JAXBElement.html">JAXB Element</a> representation 
+     * <a href="JAXBElement.html">JAXBElement</a> representation 
      * of {@code node}
      *
      * @throws JAXBException
@@ -145,11 +145,11 @@
 	throws JAXBException;
 
     /**
-     * Marshal a JAXB object tree to a new XML document.
+     * Marshal a Jakarta XML Binding object tree to a new XML document.
      *
      * <p>
      * This method is similar to {@link Marshaller#marshal(Object, Node)}
-     * with the addition of maintaining the association between JAXB objects 
+     * with the addition of maintaining the association between Jakarta XML Binding objects 
      * and the produced XML nodes,
      * enabling future update operations such as 
      * {@link #updateXML(Object, Object)} or {@link #updateJAXB(Object)}.
@@ -177,25 +177,25 @@
     public abstract void marshal( Object jaxbObject, XmlNode xmlNode ) throws JAXBException;
 
     /**
-     * Gets the XML element associated with the given JAXB object.
+     * Gets the XML element associated with the given Jakarta XML Binding object.
      *
      * <p>
-     * Once a JAXB object tree is associated with an XML fragment,
+     * Once a Jakarta XML Binding object tree is associated with an XML fragment,
      * this method enables navigation between the two trees.
      *
      * <p>
-     * An association between an XML element and a JAXB object is
+     * An association between an XML element and a Jakarta XML Binding object is
      * established by the bind methods and the update methods.
      * Note that this association is partial; not all XML elements
-     * have associated JAXB objects, and not all JAXB objects have
+     * have associated Jakarta XML Binding objects, and not all Jakarta XML Binding objects have
      * associated XML elements.
      *
      * @param jaxbObject An instance that is reachable from a prior 
      *                   call to a bind or update method that returned
-     *                   a JAXB object tree.
+     *                   a Jakarta XML Binding object tree.
      *
      * @return
-     *      null if the specified JAXB object is not known to this
+     *      null if the specified Jakarta XML Binding object is not known to this
      *      {@link Binder}, or if it is not associated with an
      *      XML element.
      *
@@ -205,23 +205,23 @@
     public abstract XmlNode getXMLNode( Object jaxbObject );
 
     /**
-     * Gets the JAXB object associated with the given XML element.
+     * Gets the Jakarta XML Binding object associated with the given XML element.
      *
      * <p>
-     * Once a JAXB object tree is associated with an XML fragment,
+     * Once a Jakarta XML Binding object tree is associated with an XML fragment,
      * this method enables navigation between the two trees.
      *
      * <p>
-     * An association between an XML element and a JAXB object is
+     * An association between an XML element and a Jakarta XML Binding object is
      * established by the unmarshal, marshal and update methods.
      * Note that this association is partial; not all XML elements
-     * have associated JAXB objects, and not all JAXB objects have
+     * have associated Jakarta XML Binding objects, and not all Jakarta XML Binding objects have
      * associated XML elements.
      *
      * @return
      *      null if the specified XML node is not known to this
      *      {@link Binder}, or if it is not associated with a
-     *      JAXB object.
+     *      Jakarta XML Binding object.
      *
      * @throws IllegalArgumentException
      *      If the node parameter is null
@@ -229,7 +229,7 @@
     public abstract Object getJAXBNode( XmlNode xmlNode );
 
     /**
-     * Takes an JAXB object and updates
+     * Takes an Jakarta XML Binding object and updates
      * its associated XML node and its descendants.
      *
      * <p>
@@ -246,7 +246,7 @@
     public abstract XmlNode updateXML( Object jaxbObject ) throws JAXBException;
 
     /**
-     * Changes in JAXB object tree are updated in its associated XML parse tree.
+     * Changes in Jakarta XML Binding object tree are updated in its associated XML parse tree.
      *
      * <p>
      * This operation can be thought of as an "in-place" marshalling.
@@ -256,14 +256,14 @@
      *
      * <p>
      * For example, unknown elements/attributes in XML that were not bound
-     * to JAXB will be left untouched (whereas a marshalling operation
+     * to Jakarta XML Binding will be left untouched (whereas a marshalling operation
      * would create a new tree that doesn't contain any of those.)
      *
      * <p>
      * As a side-effect, this operation updates the association between
-     * XML nodes and JAXB objects.
+     * XML nodes and Jakarta XML Binding objects.
      *
-     * @param jaxbObject root of potentially modified JAXB object tree
+     * @param jaxbObject root of potentially modified Jakarta XML Binding object tree
      * @param xmlNode    root of update target XML parse tree
      *
      * @return
@@ -280,20 +280,20 @@
     public abstract XmlNode updateXML( Object jaxbObject, XmlNode xmlNode ) throws JAXBException;
 
     /**
-     * Takes an XML node and updates its associated JAXB object and its descendants.
+     * Takes an XML node and updates its associated Jakarta XML Binding object and its descendants.
      *
      * <p>
      * This operation can be thought of as an "in-place" unmarshalling.
-     * The difference is that instead of creating a whole new JAXB tree,
-     * this operation updates an existing tree, reusing as much JAXB objects
+     * The difference is that instead of creating a whole new Jakarta XML Binding tree,
+     * this operation updates an existing tree, reusing as much Jakarta XML Binding objects
      * as possible.
      *
      * <p>
      * As a side-effect, this operation updates the association between
-     * XML nodes and JAXB objects.
+     * XML nodes and Jakarta XML Binding objects.
      *
      * @return
-     *      Returns the updated JAXB object. Typically, this is the same
+     *      Returns the updated Jakarta XML Binding object. Typically, this is the same
      *      object that was returned from earlier
      *      {@link #marshal(Object,Object)} or
      *      {@link #updateJAXB(Object)} method invocation,
@@ -302,7 +302,7 @@
      *      element has changed.
      * 
      * @throws JAXBException
-     *      If any unexpected problem occurs updating corresponding JAXB mapped content.
+     *      If any unexpected problem occurs updating corresponding Jakarta XML Binding mapped content.
      * @throws IllegalArgumentException
      *      If node parameter is null
      */
@@ -330,7 +330,7 @@
     /**
      * Allow an application to register a {@code ValidationEventHandler}.
      * <p>
-     * The {@code ValidationEventHandler} will be called by the JAXB Provider
+     * The {@code ValidationEventHandler} will be called by the Jakarta XML Binding Provider
      * if any validation errors are encountered during calls to any of the
      * Binder unmarshal, marshal and update methods.  
      * 
@@ -359,7 +359,7 @@
      * 
      * Set the particular property in the underlying implementation of
      * {@code Binder}.  This method can only be used to set one of
-     * the standard JAXB defined unmarshal/marshal properties 
+     * the standard Jakarta XML Binding defined unmarshal/marshal properties 
      * or a provider specific property for binder, unmarshal or marshal.
      * Attempting to set an undefined property will result in
      * a PropertyException being thrown.  See 
@@ -384,7 +384,7 @@
      * Get the particular property in the underlying implementation of
      * {@code Binder}.  This method can only
      * be used to get one of
-     * the standard JAXB defined unmarshal/marshal properties 
+     * the standard Jakarta XML Binding defined unmarshal/marshal properties 
      * or a provider specific property for binder, unmarshal or marshal.  
      * Attempting to get an undefined property will result in
      * a PropertyException being thrown.  See 
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/ContextFinder.java b/jaxb-api/src/main/java/jakarta/xml/bind/ContextFinder.java
index cbef2ed..704d3df 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/ContextFinder.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/ContextFinder.java
@@ -29,7 +29,7 @@
 
 /**
  * This class is package private and therefore is not exposed as part of the
- * JAXB API.
+ * Jakarta XML Binding API.
  *
  * This code is designed to implement the JAXB 1.0 spec pluggability feature
  *
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/DataBindingException.java b/jaxb-api/src/main/java/jakarta/xml/bind/DataBindingException.java
index acd1f02..062352a 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/DataBindingException.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/DataBindingException.java
@@ -11,7 +11,7 @@
 package jakarta.xml.bind;
 
 /**
- * Exception that represents a failure in a JAXB operation.
+ * Exception that represents a failure in a Jakarta XML Binding operation.
  *
  * <p>
  * This exception differs from {@link JAXBException} in that
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverter.java b/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverter.java
index c1322b2..89ffd77 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverter.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverter.java
@@ -24,7 +24,7 @@
  * </p>
  * <p>
  * This class makes it easier to write parse and print methods. It defines
- * static parse and print methods that provide access to a JAXB provider's 
+ * static parse and print methods that provide access to a Jakarta XML Binding provider's 
  * implementation of parse and print methods. These methods are invoked by 
  * custom parse and print methods. For example, the binding of xsd:dateTime 
  * to a long can be customized using parse and print methods as follows:
@@ -54,7 +54,7 @@
  * a parse or a print method in a javaType binding declaration.
  * </p>
  * <p>
- * JAXB Providers are required to call the 
+ * Jakarta XML Binding Providers are required to call the 
  * {@link #setDatatypeConverter(DatatypeConverterInterface) 
  * setDatatypeConverter} api at some point before the first marshal or unmarshal 
  * operation (perhaps during the call to JAXBContext.newInstance).  This step is 
@@ -89,10 +89,10 @@
     }
     
     /**
-     * This method is for JAXB provider use only.
+     * This method is for Jakarta XML Binding provider use only.
      * <p>
-     * JAXB Providers are required to call this method at some point before
-     * allowing any of the JAXB client marshal or unmarshal operations to
+     * Jakarta XML Binding Providers are required to call this method at some point before
+     * allowing any of the Jakarta XML Binding client marshal or unmarshal operations to
      * occur.  This is necessary to configure the datatype converter that 
      * should be used to perform the print and parse conversions.
      * 
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverterImpl.java b/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverterImpl.java
index bf73e9f..ef7bd09 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverterImpl.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverterImpl.java
@@ -22,7 +22,7 @@
 import javax.xml.datatype.DatatypeConfigurationException;
 
 /**
- * This class is the JAXB RI's default implementation of the
+ * This class is the Jakarta XML Binding CI's default implementation of the
  * {@link DatatypeConverterInterface}.
  *
  * <p>
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverterInterface.java b/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverterInterface.java
index 45eb7d3..f5da27e 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverterInterface.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/DatatypeConverterInterface.java
@@ -12,9 +12,9 @@
 
 /**
  * <p>
- * The DatatypeConverterInterface is for JAXB provider use only. A
- * JAXB provider must supply a class that implements this interface.
- * JAXB Providers are required to call the
+ * The DatatypeConverterInterface is for Jakarta XML Binding provider use only. A
+ * Jakarta XML Binding provider must supply a class that implements this interface.
+ * Jakarta XML Binding Providers are required to call the
  * {@link DatatypeConverter#setDatatypeConverter(DatatypeConverterInterface)
  * DatatypeConverter.setDatatypeConverter} api at
  * some point before the first marshal or unmarshal operation (perhaps during
@@ -27,7 +27,7 @@
  * <p>
  * This interface defines the parse and print methods. There is one
  * parse and print method for each XML schema datatype specified in the
- * the default binding Table 5-1 in the JAXB specification.
+ * the default binding Table 5-1 in the Jakarta XML Binding specification.
  *
  * <p>
  * The parse and print methods defined here are invoked by the static parse
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/JAXB.java b/jaxb-api/src/main/java/jakarta/xml/bind/JAXB.java
index 42854cd..54ff0e9 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/JAXB.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/JAXB.java
@@ -30,25 +30,25 @@
 import java.net.URLConnection;
 
 /**
- * Class that defines convenience methods for common, simple use of JAXB.
+ * Class that defines convenience methods for common, simple use of Jakarta XML Binding.
  *
  * <p>
  * Methods defined in this class are convenience methods that combine several basic operations
  * in the {@link JAXBContext}, {@link Unmarshaller}, and {@link Marshaller}.
  *
  * They are designed
- * to be the prefered methods for developers new to JAXB. They have
+ * to be the prefered methods for developers new to Jakarta XML Binding. They have
  * the following characterstics:
  *
  * <ol>
  *  <li>Generally speaking, the performance is not necessarily optimal.
  *      It is expected that people who need to write performance
- *      critical code will use the rest of the JAXB API directly.
+ *      critical code will use the rest of the Jakarta XML Binding API directly.
  *  <li>Errors that happen during the processing is wrapped into
  *      {@link DataBindingException} (which will have {@link JAXBException}
  *      as its {@link Throwable#getCause() cause}. It is expected that
  *      people who prefer the checked exception would use
- *      the rest of the JAXB API directly.
+ *      the rest of the Jakarta XML Binding API directly.
  * </ol>
  *
  * <p>
@@ -469,18 +469,18 @@
      * <p>
      * This method is a convenience method that combines several basic operations
      * in the {@link JAXBContext} and {@link Marshaller}. This method is designed
-     * to be the prefered method for developers new to JAXB. This method
+     * to be the prefered method for developers new to Jakarta XML Binding. This method
      * has the following characterstics:
      *
      * <ol>
      *  <li>Generally speaking, the performance is not necessarily optimal.
      *      It is expected that those people who need to write performance
-     *      critical code will use the rest of the JAXB API directly.
+     *      critical code will use the rest of the Jakarta XML Binding API directly.
      *  <li>Errors that happen during the processing is wrapped into
      *      {@link DataBindingException} (which will have {@link JAXBException}
      *      as its {@link Throwable#getCause() cause}. It is expected that
      *      those people who prefer the checked exception would use
-     *      the rest of the JAXB API directly.
+     *      the rest of the Jakarta XML Binding API directly.
      * </ol>
      *
      * @param jaxbObject
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBContext.java b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBContext.java
index 4f92225..e9611db 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBContext.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBContext.java
@@ -20,8 +20,8 @@
 
 /**
  * The {@code JAXBContext} class provides the client's entry point to the
- * JAXB API. It provides an abstraction for managing the XML/Java binding
- * information necessary to implement the JAXB binding framework operations:
+ * Jakarta XML Binding API. It provides an abstraction for managing the XML/Java binding
+ * information necessary to implement the Jakarta XML Binding binding framework operations:
  * unmarshal, marshal and validate.
  *
  * <p>A client application normally obtains new instances of this class using
@@ -32,8 +32,8 @@
  * <li>{@link #newInstance(String, ClassLoader) JAXBContext.newInstance( "com.acme.foo:com.acme.bar" )} <br>
  * The JAXBContext instance is initialized from a list of colon
  * separated Java package names. Each java package contains
- * JAXB mapped classes, schema-derived classes and/or user annotated
- * classes. Additionally, the java package may contain JAXB package annotations
+ * Jakarta XML Binding mapped classes, schema-derived classes and/or user annotated
+ * classes. Additionally, the java package may contain Jakarta XML Binding package annotations
  * that must be processed. (see JLS, Section 7.4.1 "Named Packages").
  * </li>
  * <li>{@link #newInstance(Class...) JAXBContext.newInstance( com.acme.foo.Foo.class )} <br>
@@ -45,8 +45,8 @@
  *
  * <p><i>
  * The following JAXB 1.0 requirement is only required for schema to
- * java interface/implementation binding. It does not apply to JAXB annotated
- * classes. JAXB Providers must generate a {@code jaxb.properties} file in
+ * java interface/implementation binding. It does not apply to Jakarta XML Binding annotated
+ * classes. Jakarta XML Binding Providers must generate a {@code jaxb.properties} file in
  * each package containing schema derived classes.  The property file must
  * contain a property named {@code jakarta.xml.bind.context.factory} whose
  * value is the name of the class that implements the {@code createContext}
@@ -93,10 +93,10 @@
  *
  * <p>
  * The client application may also generate Java content trees explicitly rather
- * than unmarshalling existing XML data.  For all JAXB-annotated value classes,
+ * than unmarshalling existing XML data.  For all Jakarta XML Binding-annotated value classes,
  * an application can create content using constructors.
  * For schema-derived interface/implementation classes and for the
- * creation of elements that are not bound to a JAXB-annotated
+ * creation of elements that are not bound to a Jakarta XML Binding-annotated
  * class, an application needs to have access and knowledge about each of
  * the schema derived {@code ObjectFactory} classes that exist in each of
  * java packages contained in the {@code contextPath}.  For each schema
@@ -162,20 +162,20 @@
  * Validation has been changed significantly since JAXB 1.0.  The {@link Validator}
  * class has been deprecated and made optional.  This means that you are advised
  * not to use this class and, in fact, it may not even be available depending on
- * your JAXB provider.  JAXB 1.0 client applications that rely on {@code Validator}
+ * your Jakarta XML Binding provider.  JAXB 1.0 client applications that rely on {@code Validator}
  * will still work properly when deployed with the JAXB 1.0 runtime system.
  *
- * In JAXB 2.0, the {@link Unmarshaller} has included convenince methods that expose
+ * In Jakarta XML Binding, the {@link Unmarshaller} has included convenience methods that expose
  * the JAXP 1.3 {@link javax.xml.validation} framework.  Please refer to the
  * {@link Unmarshaller#setSchema(javax.xml.validation.Schema)} API for more
  * information.
  *
  *
- * <h3>JAXB Runtime Binding Framework Compatibility</h3>
+ * <h3>Jakarta XML Binding Runtime Framework Compatibility</h3>
  * <p>
  * The following JAXB 1.0 restriction only applies to binding schema to
  * interfaces/implementation classes.
- * Since this binding does not require a common runtime system, a JAXB
+ * Since this binding does not require a common runtime system, a Jakarta XML Binding
  * client application must not attempt to mix runtime objects ({@code JAXBContext,
  * Marshaller}, etc. ) from different providers.  This does not
  * mean that the client application isn't portable, it simply means that a
@@ -183,7 +183,7 @@
  * used to compile the schema.
  *
  *
- * <h3>Discovery of JAXB implementation</h3>
+ * <h3>Discovery of Jakarta XML Binding implementation</h3>
  * <p>
  * To create an instance of {@link JAXBContext}, one of {@code JAXBContext.newInstance(...)} methods is invoked. After
  * JAX-B implementation is discovered, call is delegated to appropriate provider's method {@code createContext(...)}
@@ -209,7 +209,7 @@
  * then loaded by the associated class loader discussed above.
  *
  * <p>
- * This phase of the look up allows some packages to force the use of a certain JAXB implementation.
+ * This phase of the look up allows some packages to force the use of a certain Jakarta XML Binding implementation.
  * (For example, perhaps the schema compiler has generated some vendor extension in the code.)
  *
  * <p>
@@ -219,7 +219,7 @@
  * If the system property {@link #JAXB_CONTEXT_FACTORY} exists, then its value is assumed to be the provider
  * factory class. If no such property exists, properties {@code "jakarta.xml.bind.context.factory"} and
  * {@code "jakarta.xml.bind.JAXBContext"} are checked too (in this order), for backwards compatibility reasons. This phase
- * of the look up enables per-JVM override of the JAXB implementation.
+ * of the look up enables per-JVM override of the Jakarta XML Binding implementation.
  *
  * <li>
  * Provider of {@link jakarta.xml.bind.JAXBContextFactory} is loaded using the service-provider loading
@@ -242,7 +242,7 @@
  *
  * <li>
  * Finally, if all the steps above fail, then the rest of the look up is unspecified. That said,
- * the recommended behavior is to simply look for some hard-coded platform default JAXB implementation.
+ * the recommended behavior is to simply look for some hard-coded platform default Jakarta XML Binding implementation.
  * This phase of the look up is so that Java SE can have its own JAXB implementation as the last resort.
  * </ol>
  *
@@ -326,7 +326,7 @@
      *   <li>an ambiguity among global elements contained in the contextPath</li>
      *   <li>failure to locate a value for the context factory provider property</li>
      *   <li>mixing schema derived packages from different providers on the same contextPath</li>
-     *   <li>packages are not open to {@code java.xml.bind} module</li>
+     *   <li>packages are not open to {@code jakarta.xml.bind} module</li>
      * </ol>
      */
     public static JAXBContext newInstance( String contextPath )
@@ -342,16 +342,16 @@
      * <p>
      * The client application must supply a context path which is a list of
      * colon (':', \u005Cu003A) separated java package names that contain
-     * schema-derived classes and/or fully qualified JAXB-annotated classes.
+     * schema-derived classes and/or fully qualified Jakarta XML Binding-annotated classes.
      * Schema-derived
      * code is registered with the JAXBContext by the
      * ObjectFactory.class generated per package.
      * Alternatively than being listed in the context path, programmer
-     * annotated JAXB mapped classes can be listed in a
+     * annotated Jakarta XML Binding mapped classes can be listed in a
      * {@code jaxb.index} resource file, format described below.
      * Note that a java package can contain both schema-derived classes and
-     * user annotated JAXB classes. Additionally, the java package may
-     * contain JAXB package annotations  that must be processed. (see JLS,
+     * user annotated Jakarta XML Binding classes. Additionally, the java package may
+     * contain Jakarta XML Binding package annotations  that must be processed. (see JLS,
      * Section 7.4.1 "Named Packages").
      * </p>
      *
@@ -390,11 +390,11 @@
      * To maintain compatibility with JAXB 1.0 schema to java
      * interface/implementation binding, enabled by schema customization
      * {@code <jaxb:globalBindings valueClass="false">},
-     * the JAXB provider will ensure that each package on the context path
+     * the Jakarta XML Binding provider will ensure that each package on the context path
      * has a {@code jaxb.properties} file which contains a value for the
      * {@code jakarta.xml.bind.context.factory} property and that all values
      * resolve to the same provider.  This requirement does not apply to
-     * JAXB annotated classes.
+     * Jakarta XML Binding annotated classes.
      *
      * <p>
      * If there are any global XML element name collisions across the various
@@ -402,19 +402,19 @@
      * will be thrown.
      *
      * <p>
-     * Mixing generated interface/impl bindings from multiple JAXB Providers
+     * Mixing generated interface/impl bindings from multiple Jakarta XML Binding Providers
      * in the same context path may result in a {@code JAXBException}
      * being thrown.
      *
      * <p>
-     * The steps involved in discovering the JAXB implementation is discussed in the class javadoc.
+     * The steps involved in discovering the Jakarta XML Binding implementation is discussed in the class javadoc.
      *
      * @param contextPath
      *      List of java package names that contain schema
-     *      derived class and/or java to schema (JAXB-annotated)
+     *      derived class and/or java to schema (Jakarta XML Binding-annotated)
      *      mapped classes.
      *      Packages in {@code contextPath} that are in named modules must be
-     *      {@code open} to at least the {@code java.xml.bind} module.
+     *      {@code open} to at least the {@code jakarta.xml.bind} module.
      * @param classLoader
      *      This class loader will be used to locate the implementation
      *      classes.
@@ -427,7 +427,7 @@
      *   <li>an ambiguity among global elements contained in the contextPath</li>
      *   <li>failure to locate a value for the context factory provider property</li>
      *   <li>mixing schema derived packages from different providers on the same contextPath</li>
-     *   <li>packages are not open to {@code java.xml.bind} module</li>
+     *   <li>packages are not open to {@code jakarta.xml.bind} module</li>
      * </ol>
      */
     public static JAXBContext newInstance( String contextPath, ClassLoader classLoader ) throws JAXBException {
@@ -449,10 +449,10 @@
      *
      * @param contextPath
      *      List of java package names that contain schema
-     *      derived class and/or java to schema (JAXB-annotated)
+     *      derived class and/or java to schema (Jakarta XML Binding-annotated)
      *      mapped classes.
      *      Packages in {@code contextPath} that are in named modules must be
-     *      {@code open} to at least the {@code java.xml.bind} module.
+     *      {@code open} to at least the {@code jakarta.xml.bind} module.
      * @param classLoader
      *      This class loader will be used to locate the implementation classes.
      * @param properties
@@ -467,7 +467,7 @@
      *   <li>an ambiguity among global elements contained in the contextPath</li>
      *   <li>failure to locate a value for the context factory provider property</li>
      *   <li>mixing schema derived packages from different providers on the same contextPath</li>
-     *   <li>packages are not open to {@code java.xml.bind} module</li>
+     *   <li>packages are not open to {@code jakarta.xml.bind} module</li>
      * </ol>
      * @since 1.6, JAXB 2.0
      */
@@ -476,7 +476,7 @@
                                            Map<String,?>  properties  ) throws JAXBException {
 
         return ContextFinder.find(
-                        /* The default property name according to the JAXB spec */
+                        /* The default property name according to the Jakarta XML Binding spec */
                 JAXB_CONTEXT_FACTORY,
 
                         /* the context path supplied by the client app */
@@ -531,11 +531,11 @@
 //     *      if an error was encountered while creating the
 //     *      {@code JAXBContext}, such as (but not limited to):
 //     * <ol>
-//     *  <li>No JAXB implementation was discovered
-//     *  <li>Classes use JAXB annotations incorrectly
+//     *  <li>No Jakarta XML Binding implementation was discovered
+//     *  <li>Classes use Jakarta XML Binding annotations incorrectly
 //     *  <li>Classes have colliding annotations (i.e., two classes with the same type name)
 //     *  <li>Specified external bindings are incorrect
-//     *  <li>The JAXB implementation was unable to locate
+//     *  <li>The Jakarta XML Binding implementation was unable to locate
 //     *      provider-specific out-of-band information (such as additional
 //     *      files generated at the development time.)
 //     * </ol>
@@ -596,12 +596,12 @@
      * (see JLS, Section 7.4.1 "Named Packages").
      *
      * <p>
-     * The steps involved in discovering the JAXB implementation is discussed in the class javadoc.
+     * The steps involved in discovering the Jakarta XML Binding implementation is discussed in the class javadoc.
      *
      * @param classesToBeBound
      *      List of java classes to be recognized by the new {@link JAXBContext}.
      *      Classes in {@code classesToBeBound} that are in named modules must be in a package
-     *      that is {@code open} to at least the {@code java.xml.bind} module.
+     *      that is {@code open} to at least the {@code jakarta.xml.bind} module.
      *      Can be empty, in which case a {@link JAXBContext} that only knows about
      *      spec-defined classes will be returned.
      *
@@ -612,13 +612,13 @@
      *      if an error was encountered while creating the
      *      {@code JAXBContext}, such as (but not limited to):
      * <ol>
-     *  <li>No JAXB implementation was discovered
-     *  <li>Classes use JAXB annotations incorrectly
+     *  <li>No Jakarta XML Binding implementation was discovered
+     *  <li>Classes use Jakarta XML Binding annotations incorrectly
      *  <li>Classes have colliding annotations (i.e., two classes with the same type name)
-     *  <li>The JAXB implementation was unable to locate
+     *  <li>The Jakarta XML Binding implementation was unable to locate
      *      provider-specific out-of-band information (such as additional
      *      files generated at the development time.)
-     *  <li>{@code classesToBeBound} are not open to {@code java.xml.bind} module
+     *  <li>{@code classesToBeBound} are not open to {@code jakarta.xml.bind} module
      * </ol>
      *
      * @throws IllegalArgumentException
@@ -646,7 +646,7 @@
      * @param classesToBeBound
      *      List of java classes to be recognized by the new {@link JAXBContext}.
      *      Classes in {@code classesToBeBound} that are in named modules must be in a package
-     *      that is {@code open} to at least the {@code java.xml.bind} module.
+     *      that is {@code open} to at least the {@code jakarta.xml.bind} module.
      *      Can be empty, in which case a {@link JAXBContext} that only knows about
      *      spec-defined classes will be returned.
      * @param properties
@@ -660,13 +660,13 @@
      *      if an error was encountered while creating the
      *      {@code JAXBContext}, such as (but not limited to):
      * <ol>
-     *  <li>No JAXB implementation was discovered
-     *  <li>Classes use JAXB annotations incorrectly
+     *  <li>No Jakarta XML Binding implementation was discovered
+     *  <li>Classes use Jakarta XML Binding annotations incorrectly
      *  <li>Classes have colliding annotations (i.e., two classes with the same type name)
-     *  <li>The JAXB implementation was unable to locate
+     *  <li>The Jakarta XML Binding implementation was unable to locate
      *      provider-specific out-of-band information (such as additional
      *      files generated at the development time.)
-     *  <li>{@code classesToBeBound} are not open to {@code java.xml.bind} module
+     *  <li>{@code classesToBeBound} are not open to {@code jakarta.xml.bind} module
      * </ol>
      *
      * @throws IllegalArgumentException
@@ -716,7 +716,7 @@
 
 
     /**
-     * {@link Validator} has been made optional and deprecated in JAXB 2.0.  Please
+     * {@link Validator} has been made optional and deprecated in Jakarta XML Binding.  Please
      * refer to the javadoc for {@link Validator} for more detail.
      * <p>
      * Create a {@code Validator} object that can be used to validate a
@@ -764,7 +764,7 @@
 
     /**
      * Creates a {@code JAXBIntrospector} object that can be used to
-     * introspect JAXB objects.
+     * introspect Jakarta XML Binding objects.
      *
      * @return
      *      always return a non-null valid {@code JAXBIntrospector} object.
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBContextFactory.java b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBContextFactory.java
index 8b2ccaf..b9e87a0 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBContextFactory.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBContextFactory.java
@@ -31,7 +31,7 @@
      * @param classesToBeBound
      *      List of java classes to be recognized by the new {@link JAXBContext}.
      *      Classes in {@code classesToBeBound} that are in named modules must be in a package
-     *      that is {@code open} to at least the {@code java.xml.bind} module.
+     *      that is {@code open} to at least the {@code jakarta.xml.bind} module.
      *      Can be empty, in which case a {@link JAXBContext} that only knows about
      *      spec-defined classes will be returned.
      * @param properties
@@ -45,13 +45,13 @@
      *      if an error was encountered while creating the
      *      {@code JAXBContext}, such as (but not limited to):
      * <ol>
-     *  <li>No JAXB implementation was discovered
-     *  <li>Classes use JAXB annotations incorrectly
+     *  <li>No Jakarta XML Binding implementation was discovered
+     *  <li>Classes use Jakarta XML Binding annotations incorrectly
      *  <li>Classes have colliding annotations (i.e., two classes with the same type name)
-     *  <li>The JAXB implementation was unable to locate
+     *  <li>The Jakarta XML Binding implementation was unable to locate
      *      provider-specific out-of-band information (such as additional
      *      files generated at the development time.)
-     *  <li>{@code classesToBeBound} are not open to {@code java.xml.bind} module
+     *  <li>{@code classesToBeBound} are not open to {@code jakarta.xml.bind} module
      * </ol>
      *
      * @throws IllegalArgumentException
@@ -76,7 +76,7 @@
      * @param contextPath
      *      List of java package names that contain schema derived classes.
      *      Classes in {@code classesToBeBound} that are in named modules must be in a package
-     *      that is {@code open} to at least the {@code java.xml.bind} module.
+     *      that is {@code open} to at least the {@code jakarta.xml.bind} module.
      * @param classLoader
      *      This class loader will be used to locate the implementation classes.
      * @param properties
@@ -91,7 +91,7 @@
      *   <li>an ambiguity among global elements contained in the contextPath</li>
      *   <li>failure to locate a value for the context factory provider property</li>
      *   <li>mixing schema derived packages from different providers on the same contextPath</li>
-     *   <li>packages are not open to {@code java.xml.bind} module</li>
+     *   <li>packages are not open to {@code jakarta.xml.bind} module</li>
      * </ol>
      *
      * @since 9, JAXB 2.3
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBElement.java b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBElement.java
index 6b247ce..a760132 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBElement.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBElement.java
@@ -14,7 +14,7 @@
 import java.io.Serializable;
 
 /**
- * <p>JAXB representation of an Xml Element.</p>
+ * <p>Jakarta XML Binding representation of an Xml Element.</p>
  *
  * <p>This class represents information about an Xml Element from both the element 
  * declaration within a schema and the element instance value within an xml document
@@ -28,7 +28,7 @@
  * </ul>
  * 
  * <p>The {@code declaredType} and {@code scope} property are the
- * JAXB class binding for the xml type definition.
+ * Jakarta XML Binding class binding for the xml type definition.
  * </p>
  * 
  * <p><b>{@code Scope}</b> is either {@link GlobalScope} or the Java class representing the
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBException.java b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBException.java
index 659c9f1..e53709d 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBException.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBException.java
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 
 /**
- * This is the root exception class for all JAXB exceptions.
+ * This is the root exception class for all Jakarta XML Binding exceptions.
  *
  * @author <ul><li>Ryan Shoemaker, Sun Microsystems, Inc.</li></ul>
  * @see JAXBContext
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBIntrospector.java b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBIntrospector.java
index 0c4f951..2a3062e 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBIntrospector.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBIntrospector.java
@@ -13,13 +13,13 @@
 import  javax.xml.namespace.QName;
 
 /**
- * Provide access to JAXB xml binding data for a JAXB object.
+ * Provide access to Jakarta XML Binding xml binding data for a Jakarta XML Binding object.
  *
  * <p>
  * Intially, the intent of this class is to just conceptualize how 
- * a JAXB application developer can access xml binding information, 
+ * a Jakarta XML Binding application developer can access xml binding information, 
  * independent if binding model is java to schema or schema to java.
- * Since accessing the XML element name related to a JAXB element is
+ * Since accessing the XML element name related to a Jakarta XML Binding element is
  * a highly requested feature, demonstrate access to this
  * binding information.
  *
@@ -32,8 +32,8 @@
 public abstract class JAXBIntrospector {
 
     /** 
-     * <p>Return true if <code>object</code> represents a JAXB element.</p>
-     * <p>Parameter <code>object</code> is a JAXB element for following cases:
+     * <p>Return true if <code>object</code> represents a Jakarta XML Binding element.</p>
+     * <p>Parameter <code>object</code> is a Jakarta XML Binding element for following cases:
      * <ol>
      *   <li>It is an instance of <code>jakarta.xml.bind.JAXBElement</code>.</li>
      *   <li>The class of <code>object</code> is annotated with 
@@ -51,12 +51,12 @@
      * @param jaxbElement is an object that {@link #isElement(Object)} returned true.
      *                    
      * @return xml element qname associated with jaxbElement;
-     *         null if <code>jaxbElement</code> is not a JAXB Element.
+     *         null if <code>jaxbElement</code> is not a JAXBElement.
      */
     public abstract QName getElementName(Object jaxbElement);
 
     /**
-     * <p>Get the element value of a JAXB element.</p>
+     * <p>Get the element value of a Jakarta XML Binding element.</p>
      *
      * <p>Convenience method to abstract whether working with either 
      *    a jakarta.xml.bind.JAXBElement instance or an instance of
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBPermission.java b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBPermission.java
index 5d7a1cd..1a5d3cf 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/JAXBPermission.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/JAXBPermission.java
@@ -13,13 +13,13 @@
 import java.security.BasicPermission;
 
 /**
- * This class is for JAXB permissions. A {@code JAXBPermission}
+ * This class is for Jakarta XML Binding permissions. A {@code JAXBPermission}
  * contains a name (also referred to as a "target name") but
  * no actions list; you either have the named permission
  * or you don't.
  *
  * <P>
- * The target name is the name of the JAXB permission (see below).
+ * The target name is the name of the Jakarta XML Binding permission (see below).
  *
  * <P>
  * The following table lists all the possible {@code JAXBPermission} target names,
@@ -46,7 +46,7 @@
  *   </td>
  *   <td>
  *     Malicious code can set {@link DatatypeConverterInterface}, which has
- *     VM-wide singleton semantics,  before a genuine JAXB implementation sets one.
+ *     VM-wide singleton semantics,  before a genuine Jakarta XML Binding implementation sets one.
  *     This allows malicious code to gain access to objects that it may otherwise
  *     not have access to, such as {@link java.awt.Frame#getFrames()} that belongs to
  *     another application running in the same JVM.
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/Marshaller.java b/jaxb-api/src/main/java/jakarta/xml/bind/Marshaller.java
index 5c890be..3065db5 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/Marshaller.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/Marshaller.java
@@ -135,15 +135,15 @@
  *
  * <p>
  * <a id="elementMarshalling"></a>
- * <b>Marshalling content tree rooted by a JAXB element</b><br>
+ * <b>Marshalling content tree rooted by a Jakarta XML Binding element</b><br>
  * <blockquote>
  * The first parameter of the overloaded
  * {@code Marshaller.marshal(java.lang.Object, ...)} methods must be a
- * JAXB element as computed by 
+ * Jakarta XML Binding element as computed by 
  * {@link JAXBIntrospector#isElement(java.lang.Object)};
  * otherwise, a {@code Marshaller.marshal} method must throw a
  * {@link MarshalException}. There exist two mechanisms 
- * to enable marshalling an instance that is not a JAXB element.
+ * to enable marshalling an instance that is not a Jakarta XML Binding element.
  * One method is to wrap the instance as a value of a {@link JAXBElement}, 
  * and pass the wrapper element as the first parameter to
  * a {@code Marshaller.marshal} method. For java to schema binding, it
@@ -170,12 +170,12 @@
  * Client applications are not required to validate the Java content tree prior
  * to calling any of the marshal API's.  Furthermore, there is no requirement 
  * that the Java content tree be valid with respect to its original schema in
- * order to marshal it back into XML data.  Different JAXB Providers will 
+ * order to marshal it back into XML data.  Different Jakarta XML Binding Providers will 
  * support marshalling invalid Java content trees at varying levels, however
- * all JAXB Providers must be able to marshal a valid content tree back to 
- * XML data.  A JAXB Provider must throw a {@code MarshalException} when it
+ * all Jakarta XML Binding Providers must be able to marshal a valid content tree back to 
+ * XML data.  A Jakarta XML Binding Provider must throw a {@code MarshalException} when it
  * is unable to complete the marshal operation due to invalid content.  Some
- * JAXB Providers will fully allow marshalling invalid content, others will fail
+ * Jakarta XML Binding Providers will fully allow marshalling invalid content, others will fail
  * on the first validation error.
  * <p>
  * Even when schema validation is not explictly enabled for the marshal operation,
@@ -184,7 +184,7 @@
  * event handler.  If the client application has not registered an event handler
  * prior to invoking one of the marshal API's, then events will be delivered to
  * a default event handler which will terminate the marshal operation after
- * encountering the first error or fatal error. Note that for JAXB 2.0 and
+ * encountering the first error or fatal error. Note that for Jakarta XML Binding and
  * later versions, {@link jakarta.xml.bind.helpers.DefaultValidationEventHandler} is
  * no longer used.
  * 
@@ -195,7 +195,7 @@
  * <b>Supported Properties</b><br>
  * <blockquote>
  * <p>
- * All JAXB Providers are required to support the following set of properties.
+ * All Jakarta XML Binding Providers are required to support the following set of properties.
  * Some providers may support additional properties.
  * <dl>
  *   <dt>{@code jaxb.encoding} - value must be a java.lang.String</dt>
@@ -262,12 +262,12 @@
  * "The {@link Marshaller} provides two styles of callback mechanisms
  * that allow application specific processing during key points in the
  * unmarshalling process.  In 'class defined' event callbacks, application
- * specific code placed in JAXB mapped classes is triggered during
+ * specific code placed in Jakarta XML Binding mapped classes is triggered during
  * marshalling.  'External listeners' allow for centralized processing
  * of marshal events in one callback method rather than by type event callbacks.
  *
  * <p>
- * Class defined event callback methods allow any JAXB mapped class to specify 
+ * Class defined event callback methods allow any Jakarta XML Binding mapped class to specify 
  * its own specific callback methods by defining methods with the following method signatures:
  * <blockquote>
  * <pre>
@@ -341,7 +341,7 @@
      * {@code javax.xml.transform.Result}.
      * 
      * <p>
-     * All JAXB Providers must at least support
+     * All Jakarta XML Binding Providers must at least support
      * {@link javax.xml.transform.dom.DOMResult},
      * {@link javax.xml.transform.sax.SAXResult}, and
      * {@link javax.xml.transform.stream.StreamResult}. It can 
@@ -359,7 +359,7 @@
      *      returns false from its {@code handleEvent} method or the
      *      {@code Marshaller} is unable to marshal {@code jaxbElement} (or any
      *      object reachable from {@code jaxbElement}).  See <a href="#elementMarshalling">
-     *      Marshalling a JAXB element</a>.
+     *      Marshalling a Jakarta XML Binding element</a>.
      * @throws IllegalArgumentException
      *      If any of the method parameters are null
      */
@@ -381,7 +381,7 @@
      *      returns false from its {@code handleEvent} method or the
      *      {@code Marshaller} is unable to marshal {@code jaxbElement} (or any
      *      object reachable from {@code jaxbElement}).  See <a href="#elementMarshalling">
-     *      Marshalling a JAXB element</a>.
+     *      Marshalling a Jakarta XML Binding element</a>.
      * @throws IllegalArgumentException
      *      If any of the method parameters are null
      */
@@ -403,7 +403,7 @@
      *      returns false from its {@code handleEvent} method or the
      *      {@code Marshaller} is unable to marshal {@code jaxbElement} (or any
      *      object reachable from {@code jaxbElement}).  See <a href="#elementMarshalling">
-     *      Marshalling a JAXB element</a>.
+     *      Marshalling a Jakarta XML Binding element</a>.
      * @throws IllegalArgumentException
      *      If any of the method parameters are null
      * @since 1.6, JAXB 2.1
@@ -426,7 +426,7 @@
      *      returns false from its {@code handleEvent} method or the
      *      {@code Marshaller} is unable to marshal {@code jaxbElement} (or any
      *      object reachable from {@code jaxbElement}).  See <a href="#elementMarshalling">
-     *      Marshalling a JAXB element</a>.
+     *      Marshalling a Jakarta XML Binding element</a>.
      * @throws IllegalArgumentException
      *      If any of the method parameters are null
      */
@@ -448,7 +448,7 @@
      *      returns false from its {@code handleEvent} method or the
      *      {@code Marshaller} is unable to marshal {@code jaxbElement} (or any
      *      object reachable from {@code jaxbElement}).  See <a href="#elementMarshalling">
-     *      Marshalling a JAXB element</a>.
+     *      Marshalling a Jakarta XML Binding element</a>.
      * @throws IllegalArgumentException
      *      If any of the method parameters are null
      */
@@ -474,7 +474,7 @@
      *      returns false from its {@code handleEvent} method or the
      *      {@code Marshaller} is unable to marshal {@code jaxbElement} (or any
      *      object reachable from {@code jaxbElement}).  See <a href="#elementMarshalling">
-     *      Marshalling a JAXB element</a>.
+     *      Marshalling a Jakarta XML Binding element</a>.
      * @throws IllegalArgumentException
      *      If any of the method parameters are null
      */
@@ -497,7 +497,7 @@
      *      returns false from its {@code handleEvent} method or the
      *      {@code Marshaller} is unable to marshal {@code jaxbElement} (or any
      *      object reachable from {@code jaxbElement}).  See <a href="#elementMarshalling">
-     *      Marshalling a JAXB element</a>.
+     *      Marshalling a Jakarta XML Binding element</a>.
      * @throws IllegalArgumentException
      *      If any of the method parameters are null
      * @since 1.6, JAXB 2.0
@@ -521,7 +521,7 @@
      *      returns false from its {@code handleEvent} method or the
      *      {@code Marshaller} is unable to marshal {@code jaxbElement} (or any
      *      object reachable from {@code jaxbElement}).  See <a href="#elementMarshalling">
-     *      Marshalling a JAXB element</a>.
+     *      Marshalling a Jakarta XML Binding element</a>.
      * @throws IllegalArgumentException
      *      If any of the method parameters are null
      * @since 1.6, JAXB 2.0
@@ -537,12 +537,12 @@
      * Use {@link #marshal(Object, org.w3c.dom.Node)} to force
      * a deep copy of the content tree to a DOM representation.
      * 
-     * @param contentTree - JAXB Java representation of XML content
+     * @param contentTree - Jakarta XML Binding Java representation of XML content
      * 
      * @return the DOM tree view of the contentTree
      * 
      * @throws UnsupportedOperationException
-     *      If the JAXB provider implementation does not support a
+     *      If the Jakarta XML Binding provider implementation does not support a
      *      DOM view of the content tree
      * 
      * @throws IllegalArgumentException
@@ -558,7 +558,7 @@
     /**
      * Set the particular property in the underlying implementation of 
      * {@code Marshaller}.  This method can only be used to set one of
-     * the standard JAXB defined properties above or a provider specific
+     * the standard Jakarta XML Binding defined properties above or a provider specific
      * property.  Attempting to set an undefined property will result in
      * a PropertyException being thrown.  See <a href="#supportedProps">
      * Supported Properties</a>.
@@ -579,7 +579,7 @@
     /**
      * Get the particular property in the underlying implementation of 
      * {@code Marshaller}.  This method can only be used to get one of
-     * the standard JAXB defined properties above or a provider specific
+     * the standard Jakarta XML Binding defined properties above or a provider specific
      * property.  Attempting to get an undefined property will result in
      * a PropertyException being thrown.  See <a href="#supportedProps">
      * Supported Properties</a>.
@@ -598,7 +598,7 @@
     /**
      * Allow an application to register a validation event handler.
      * <p>
-     * The validation event handler will be called by the JAXB Provider if any
+     * The validation event handler will be called by the Jakarta XML Binding Provider if any
      * validation errors are encountered during calls to any of the marshal
      * API's.  If the client application does not register a validation event 
      * handler before invoking one of the marshal methods, then validation 
@@ -763,7 +763,7 @@
          * Note that if the class of {@code source} defines its own {@code beforeMarshal} method,
          * the class specific callback method is invoked just before this method is invoked.
          *
-         * @param source instance of JAXB mapped class prior to marshalling from it.
+         * @param source instance of Jakarta XML Binding mapped class prior to marshalling from it.
          */
         public void beforeMarshal(Object source) {
         }
@@ -777,7 +777,7 @@
          * Note that if the class of {@code source} defines its own {@code afterMarshal} method,
          * the class specific callback method is invoked just before this method is invoked.
          *
-         * @param source instance of JAXB mapped class after marshalling it.
+         * @param source instance of Jakarta XML Binding mapped class after marshalling it.
          */
         public void afterMarshal(Object source) {
         }
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/ModuleUtil.java b/jaxb-api/src/main/java/jakarta/xml/bind/ModuleUtil.java
index f1c8d0d..a23eb1d 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/ModuleUtil.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/ModuleUtil.java
@@ -27,8 +27,8 @@
      * in their jar files.
      *
      * <p>
-     * When the user bundles his own JAXB implementation, we'd like to use it, and we
-     * want the platform default to be used only when there's no other JAXB provider.
+     * When the user bundles his own Jakarta XML Binding implementation, we'd like to use it, and we
+     * want the platform default to be used only when there's no other Jakarta XML Binding provider.
      *
      * <p>
      * For this reason, we have to hard-code the class name into the API.
@@ -52,7 +52,7 @@
     }
 
     /**
-     * Implementation may be defined in other module than {@code java.xml.bind}. In that case openness
+     * Implementation may be defined in other module than {@code jakarta.xml.bind}. In that case openness
      * {@linkplain java.lang.Module#isOpen open} of classes should be delegated to implementation module.
      *
      * @param classes used to resolve module for {@linkplain java.lang.Module#addOpens(String, java.lang.Module)}
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/SchemaOutputResolver.java b/jaxb-api/src/main/java/jakarta/xml/bind/SchemaOutputResolver.java
index 5253608..adff627 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/SchemaOutputResolver.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/SchemaOutputResolver.java
@@ -14,7 +14,7 @@
 import java.io.IOException;
 
 /**
- * Controls where a JAXB implementation puts the generates
+ * Controls where a Jakarta XML Binding implementation puts the generates
  * schema files.
  *
  * <p>
@@ -43,7 +43,7 @@
      *      The namespace URI that the schema declares.
      *      Can be the empty string, but never be null.
      * @param suggestedFileName
-     *      A JAXB implementation generates an unique file name (like "schema1.xsd")
+     *      A Jakarta XML Binding implementation generates an unique file name (like "schema1.xsd")
      *      for the convenience of the callee. This name can be
      *      used for the file name of the schema, or the callee can just
      *      ignore this name and come up with its own name.
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/ServiceLoaderUtil.java b/jaxb-api/src/main/java/jakarta/xml/bind/ServiceLoaderUtil.java
index d943ea5..b3dc516 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/ServiceLoaderUtil.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/ServiceLoaderUtil.java
@@ -18,9 +18,9 @@
 import java.util.logging.Logger;
 
 /**
- * Shared ServiceLoader/FactoryFinder Utils shared among SAAJ, JAXB and JAXWS
- * - this class must be duplicated to all those projects, but it's
- * basically generic code and we want to have it everywhere same.
+ * Shared ServiceLoader/FactoryFinder Utils shared among Jakarta SOAP with Attachments, Jakarta XML Binding
+ * and Jakarta XML Web Services.
+ * Class duplicated to all those projects.
  *
  * @author Miroslav.Kos@oracle.com
  */
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/TypeConstraintException.java b/jaxb-api/src/main/java/jakarta/xml/bind/TypeConstraintException.java
index 41142b4..b30b533 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/TypeConstraintException.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/TypeConstraintException.java
@@ -17,7 +17,7 @@
  * <p>
  * This exception can be thrown by the generated setter methods of the schema
  * derived Java content classes.  However, since fail-fast validation is
- * an optional feature for JAXB Providers to support, not all setter methods
+ * an optional feature for Jakarta XML Binding Providers to support, not all setter methods
  * will throw this exception when a type constraint is violated.
  * 
  * <p>
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/UnmarshalException.java b/jaxb-api/src/main/java/jakarta/xml/bind/UnmarshalException.java
index 226edfb..7a181c6 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/UnmarshalException.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/UnmarshalException.java
@@ -12,7 +12,7 @@
 
 /**
  * This exception indicates that an error has occurred while performing
- * an unmarshal operation that prevents the JAXB Provider from completing
+ * an unmarshal operation that prevents the Jakarta XML Binding Provider from completing
  * the operation.
  * 
  * <p>
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/Unmarshaller.java b/jaxb-api/src/main/java/jakarta/xml/bind/Unmarshaller.java
index 1f078ea..102db70 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/Unmarshaller.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/Unmarshaller.java
@@ -114,13 +114,13 @@
  *       SAXSource source = 
  *           new SAXSource( xmlReader, new InputSource( "http://..." ) );
  *
- *       // Setup JAXB to unmarshal
+ *       // Setup Jakarta XML Binding to unmarshal
  *       JAXBContext jc = JAXBContext.newInstance( "com.acme.foo" );
  *       Unmarshaller u = jc.createUnmarshaller();
  *       ValidationEventCollector vec = new ValidationEventCollector();
  *       u.setEventHandler( vec );
  *       
- *       // turn off the JAXB provider's default validation mechanism to 
+ *       // turn off the Jakarta XML Binding provider's default validation mechanism to 
  *       // avoid duplicate validation
  *       u.setValidating( false )
  *
@@ -171,7 +171,7 @@
  * unmarshalling methods described by  
  * <a href="#unmarshalGlobal">Unmarshal root element that is declared globally</a>.
  * These unmarshal methods utilize {@link JAXBContext}'s mapping of global XML element
- * declarations and type definitions to JAXB mapped classes to initiate the 
+ * declarations and type definitions to Jakarta XML Binding mapped classes to initiate the 
  * unmarshalling of the root element of  XML data.  When the {@link JAXBContext}'s 
  * mappings are not sufficient to unmarshal the root element of XML data, 
  * the application can assist the unmarshalling process by using the 
@@ -182,7 +182,7 @@
  * 
  * <blockquote>
  * An unmarshal method never returns null. If the unmarshal process is unable to unmarshal
- * the root of XML content to a JAXB mapped object, a fatal error is reported that
+ * the root of XML content to a Jakarta XML Binding mapped object, a fatal error is reported that
  * terminates processing by throwing JAXBException.
  * </blockquote>
  *
@@ -194,11 +194,11 @@
  * {@link JAXBContext} to unmarshal the root element of an XML data. The {@link JAXBContext} 
  * instance is the one that was used to create this {@code Unmarshaller}. The {@link JAXBContext}
  * instance maintains a mapping of globally declared XML element and type definition names to 
- * JAXB mapped classes. The unmarshal method checks if {@link JAXBContext} has a mapping
- * from the root element's XML name and/or {@code @xsi:type} to a JAXB mapped class.  If it does, it umarshalls the
- * XML data using the appropriate JAXB mapped class. Note that when the root element name is unknown and the root
+ * Jakarta XML Binding mapped classes. The unmarshal method checks if {@link JAXBContext} has a mapping
+ * from the root element's XML name and/or {@code @xsi:type} to a Jakarta XML Binding mapped class.  If it does, it umarshalls the
+ * XML data using the appropriate Jakarta XML Binding mapped class. Note that when the root element name is unknown and the root
  * element has an {@code @xsi:type}, the XML data is unmarshalled
- * using that JAXB mapped class as the value of a {@link JAXBElement}.
+ * using that Jakarta XML Binding mapped class as the value of a {@link JAXBElement}.
  * When the {@link JAXBContext} object does not have a mapping for the root element's name
  * nor its {@code @xsi:type}, if it exists,
  * then the unmarshal operation will abort immediately by throwing a {@link UnmarshalException 
@@ -220,7 +220,7 @@
  * deserializing the root element when using these unmarshal methods. 
  * Additionally, when the root element of XML data has an {@code xsi:type} attribute and
  * that attribute's value references a type definition that is mapped 
- * to a JAXB mapped class by {@link JAXBContext}, that the root 
+ * to a Jakarta XML Binding mapped class by {@link JAXBContext}, that the root 
  * element's {@code xsi:type} attribute takes
  * precedence over the unmarshal methods {@code declaredType} parameter.
  * These methods always return a {@code JAXBElement<declaredType>}
@@ -289,7 +289,7 @@
  *       Element  fooSubtree = ...; // traverse DOM till reach xml element foo, constrained by a 
  *                                  // local element declaration in schema.
  * 
- *       // FooType is the JAXB mapping of the type of local element declaration foo.
+ *       // FooType is the Jakarta XML Binding mapping of the type of local element declaration foo.
  *       JAXBElement<FooType> foo = u.unmarshal( fooSubtree, FooType.class);
  *    }</pre>
  * </blockquote>
@@ -298,8 +298,8 @@
  * <b>Support for SAX2.0 Compliant Parsers</b><br>
  * <blockquote>
  * A client application has the ability to select the SAX2.0 compliant parser
- * of their choice.  If a SAX parser is not selected, then the JAXB Provider's
- * default parser will be used.  Even though the JAXB Provider's default parser
+ * of their choice.  If a SAX parser is not selected, then the Jakarta XML Binding Provider's
+ * default parser will be used.  Even though the Jakarta XML Binding Provider's default parser
  * is not required to be SAX2.0 compliant, all providers are required to allow
  * a client application to specify their own SAX2.0 parser.  Some providers may
  * require the client application to specify the SAX2.0 parser at schema compile
@@ -318,14 +318,14 @@
  * {@link #unmarshal(javax.xml.transform.Source) unmarshal(Source)}  API.
  * 
  * <p>
- * Since unmarshalling invalid XML content is defined in JAXB 2.0, 
+ * Since unmarshalling invalid XML content is defined in Jakarta XML Binding, 
  * the Unmarshaller default validation event handler was made more lenient
  * than in JAXB 1.0.  When schema-derived code generated
  * by JAXB 1.0 binding compiler is registered with {@link JAXBContext}, 
  * the default unmarshal validation handler is 
  * {@link jakarta.xml.bind.helpers.DefaultValidationEventHandler} and it
  * terminates the marshal  operation after encountering either a fatal error or an error. 
- * For a JAXB 2.0 client application, there is no explicitly defined default
+ * For a Jakarta XML Binding client application, there is no explicitly defined default
  * validation handler and the default event handling only 
  * terminates the unmarshal operation after encountering a fatal error.
  * 
@@ -337,7 +337,7 @@
  * <blockquote>
  * <p>
  * There currently are not any properties required to be supported by all 
- * JAXB Providers on Unmarshaller.  However, some providers may support 
+ * Jakarta XML Binding Providers on Unmarshaller.  However, some providers may support 
  * their own set of provider specific properties.
  * </blockquote>
  * 
@@ -348,11 +348,11 @@
  * The {@link Unmarshaller} provides two styles of callback mechanisms
  * that allow application specific processing during key points in the
  * unmarshalling process.  In 'class defined' event callbacks, application
- * specific code placed in JAXB mapped classes is triggered during
+ * specific code placed in Jakarta XML Binding mapped classes is triggered during
  * unmarshalling.  'External listeners' allow for centralized processing
  * of unmarshal events in one callback method rather than by type event callbacks.
  * <p>
- * 'Class defined' event callback methods allow any JAXB mapped class to specify 
+ * 'Class defined' event callback methods allow any Jakarta XML Binding mapped class to specify 
  * its own specific callback methods by defining methods with the following method signature:
  * <blockquote>
  * <pre>
@@ -371,7 +371,7 @@
  * The external listener callback mechanism enables the registration of a {@link Listener} 
  * instance with an {@link Unmarshaller#setListener(Listener)}. The external listener receives all callback events, 
  * allowing for more centralized processing than per class defined callback methods.  The external listener 
- * receives events when unmarshalling process is marshalling to a JAXB element or to JAXB mapped class.
+ * receives events when unmarshalling process is marshalling to a Jakarta XML Binding element or to Jakarta XML Binding mapped class.
  * <p>
  * The 'class defined' and external listener event callback methods are independent of each other,
  * both can be called for one event.  The invocation ordering when both listener callback methods exist is
@@ -529,7 +529,7 @@
     public Object unmarshal( org.w3c.dom.Node node ) throws JAXBException;
 
     /**
-     * Unmarshal XML data by JAXB mapped {@code declaredType}
+     * Unmarshal XML data by Jakarta XML Binding mapped {@code declaredType}
      * and return the resulting content tree.
      *
      * <p>
@@ -539,9 +539,9 @@
      *      the document/element to unmarshal XML data from.
      *      The caller must support at least Document and Element.
      * @param declaredType
-     *      appropriate JAXB mapped class to hold {@code node}'s XML data.
+     *      appropriate Jakarta XML Binding mapped class to hold {@code node}'s XML data.
      * 
-     * @return <a href="#unmarshalDeclaredTypeReturn">JAXB Element</a> representation of {@code node}
+     * @return <a href="#unmarshalDeclaredTypeReturn">JAXBElement</a> representation of {@code node}
      * 
      * @throws JAXBException 
      *     If any unexpected errors occur while unmarshalling
@@ -568,33 +568,33 @@
      * <b>SAX 2.0 Parser Pluggability</b>
      * <p>
      * A client application can choose not to use the default parser mechanism
-     * supplied with their JAXB provider.  Any SAX 2.0 compliant parser can be
-     * substituted for the JAXB provider's default mechanism.  To do so, the
+     * supplied with their Jakarta XML Binding provider.  Any SAX 2.0 compliant parser can be
+     * substituted for the Jakarta XML Binding provider's default mechanism.  To do so, the
      * client application must properly configure a {@code SAXSource} containing
      * an {@code XMLReader} implemented by the SAX 2.0 parser provider.  If the
      * {@code XMLReader} has an {@code org.xml.sax.ErrorHandler} registered
-     * on it, it will be replaced by the JAXB Provider so that validation errors
+     * on it, it will be replaced by the Jakarta XML Binding Provider so that validation errors
      * can be reported via the {@code ValidationEventHandler} mechanism of
-     * JAXB.  If the {@code SAXSource} does not contain an {@code XMLReader},
-     * then the JAXB provider's default parser mechanism will be used.
+     * Jakarta XML Binding.  If the {@code SAXSource} does not contain an {@code XMLReader},
+     * then the Jakarta XML Binding provider's default parser mechanism will be used.
      * <p>
-     * This parser replacement mechanism can also be used to replace the JAXB
+     * This parser replacement mechanism can also be used to replace the Jakarta XML Binding
      * provider's unmarshal-time validation engine.  The client application 
      * must properly configure their SAX 2.0 compliant parser to perform
      * validation (as shown in the example above).  Any {@code SAXParserExceptions}
      * encountered by the parser during the unmarshal operation will be
-     * processed by the JAXB provider and converted into JAXB 
+     * processed by the Jakarta XML Binding provider and converted into Jakarta XML Binding 
      * {@code ValidationEvent} objects which will be reported back to the
      * client via the {@code ValidationEventHandler} registered with the
      * {@code Unmarshaller}.  <i>Note:</i> specifying a substitute validating
      * SAX 2.0 parser for unmarshalling does not necessarily replace the 
-     * validation engine used by the JAXB provider for performing on-demand 
+     * validation engine used by the Jakarta XML Binding provider for performing on-demand 
      * validation.
      * <p>
      * The only way for a client application to specify an alternate parser
      * mechanism to be used during unmarshal is via the 
      * {@code unmarshal(SAXSource)} API.  All other forms of the unmarshal
-     * method (File, URL, Node, etc) will use the JAXB provider's default 
+     * method (File, URL, Node, etc) will use the Jakarta XML Binding provider's default 
      * parser and validator mechanisms.
      *
      * @param source the XML Source to unmarshal XML data from (providers are
@@ -629,8 +629,8 @@
      * @param source the XML Source to unmarshal XML data from (providers are
      *        only required to support SAXSource, DOMSource, and StreamSource)
      * @param declaredType 
-     *      appropriate JAXB mapped class to hold {@code source}'s xml root element
-     * @return Java content rooted by <a href="#unmarshalDeclaredTypeReturn">JAXB Element</a>
+     *      appropriate Jakarta XML Binding mapped class to hold {@code source}'s xml root element
+     * @return Java content rooted by <a href="#unmarshalDeclaredTypeReturn">JAXBElement</a>
      *
      * @throws JAXBException 
      *     If any unexpected errors occur while unmarshalling
@@ -684,7 +684,7 @@
         throws JAXBException;
     
     /**
-     * Unmarshal root element to JAXB mapped {@code declaredType}
+     * Unmarshal root element to Jakarta XML Binding mapped {@code declaredType}
      * and return the resulting content tree.
      * 
      * <p>
@@ -699,9 +699,9 @@
      * @param reader
      *      The parser to be read. 
      * @param declaredType
-     *      appropriate JAXB mapped class to hold {@code reader}'s START_ELEMENT XML data.
+     *      appropriate Jakarta XML Binding mapped class to hold {@code reader}'s START_ELEMENT XML data.
      * 
-     * @return   content tree rooted by <a href="#unmarshalDeclaredTypeReturn">JAXB Element representation</a>
+     * @return   content tree rooted by <a href="#unmarshalDeclaredTypeReturn">JAXBElement</a> representation
      * 
      * @throws JAXBException 
      *     If any unexpected errors occur while unmarshalling
@@ -754,7 +754,7 @@
         throws JAXBException;
     
     /**
-     * Unmarshal root element to JAXB mapped {@code declaredType}
+     * Unmarshal root element to Jakarta XML Binding mapped {@code declaredType}
      * and return the resulting content tree.
      * 
      * <p>
@@ -770,9 +770,9 @@
      * @param reader
      *      The parser to be read. 
      * @param declaredType
-     *      appropriate JAXB mapped class to hold {@code reader}'s START_ELEMENT XML data.
+     *      appropriate Jakarta XML Binding mapped class to hold {@code reader}'s START_ELEMENT XML data.
      * 
-     * @return   content tree rooted by <a href="#unmarshalDeclaredTypeReturn">JAXB Element representation</a>
+     * @return   content tree rooted by <a href="#unmarshalDeclaredTypeReturn">JAXBElement</a> representation
      * 
      * @throws JAXBException 
      *     If any unexpected errors occur while unmarshalling
@@ -792,7 +792,7 @@
      * an XML pipeline.
      * 
      * <p>
-     * The JAXB Provider can return the same handler object for multiple 
+     * The Jakarta XML Binding Provider can return the same handler object for multiple 
      * invocations of this method. In other words, this method does not 
      * necessarily create a new instance of {@code UnmarshallerHandler}. If the
      * application needs to use more than one {@code UnmarshallerHandler}, it
@@ -811,14 +811,14 @@
      * This method may only be invoked before or after calling one of the
      * unmarshal methods.
      * <p>
-     * This method only controls the JAXB Provider's default unmarshal-time
+     * This method only controls the Jakarta XML Binding Provider's default unmarshal-time
      * validation mechanism - it has no impact on clients that specify their 
      * own validating SAX 2.0 compliant parser.  Clients that specify their
-     * own unmarshal-time validation mechanism may wish to turn off the JAXB
+     * own unmarshal-time validation mechanism may wish to turn off the Jakarta XML Binding
      * Provider's default validation mechanism via this API to avoid "double
      * validation".
      * <p>
-     * This method is deprecated as of JAXB 2.0 - please use the new
+     * This method is deprecated as of Jakarta XML Binding - please use the new
      * {@link #setSchema(javax.xml.validation.Schema)} API.
      *
      * @param validating true if the Unmarshaller should validate during 
@@ -827,7 +827,7 @@
      *         validation at unmarshal time
      * @throws UnsupportedOperationException could be thrown if this method is
      *         invoked on an Unmarshaller created from a JAXBContext referencing
-     *         JAXB 2.0 mapped classes
+     *         Jakarta XML Binding mapped classes
      * @deprecated since JAXB2.0, please see {@link #setSchema(javax.xml.validation.Schema)}
      */
     public void setValidating( boolean validating ) 
@@ -837,10 +837,10 @@
      * Indicates whether or not the {@code Unmarshaller} is configured to
      * validate during unmarshal operations.
      * <p>
-     * This API returns the state of the JAXB Provider's default unmarshal-time
+     * This API returns the state of the Jakarta XML Binding Provider's default unmarshal-time
      * validation mechanism. 
      * <p>
-     * This method is deprecated as of JAXB 2.0 - please use the new
+     * This method is deprecated as of Jakarta XML Binding - please use the new
      * {@link #getSchema()} API.
      *
      * @return true if the Unmarshaller is configured to validate during 
@@ -849,7 +849,7 @@
      *         flag
      * @throws UnsupportedOperationException could be thrown if this method is
      *         invoked on an Unmarshaller created from a JAXBContext referencing
-     *         JAXB 2.0 mapped classes
+     *         Jakarta XML Binding mapped classes
      * @deprecated since JAXB2.0, please see {@link #getSchema()}
      */
     public boolean isValidating() 
@@ -858,7 +858,7 @@
     /**
      * Allow an application to register a {@code ValidationEventHandler}.
      * <p>
-     * The {@code ValidationEventHandler} will be called by the JAXB Provider
+     * The {@code ValidationEventHandler} will be called by the Jakarta XML Binding Provider
      * if any validation errors are encountered during calls to any of the 
      * unmarshal methods.  If the client application does not register a 
      * {@code ValidationEventHandler} before invoking the unmarshal methods,
@@ -891,7 +891,7 @@
     /**
      * Set the particular property in the underlying implementation of 
      * {@code Unmarshaller}.  This method can only be used to set one of
-     * the standard JAXB defined properties above or a provider specific
+     * the standard Jakarta XML Binding defined properties above or a provider specific
      * property.  Attempting to set an undefined property will result in
      * a PropertyException being thrown.  See <a href="#supportedProps">
      * Supported Properties</a>.
@@ -912,7 +912,7 @@
     /**
      * Get the particular property in the underlying implementation of 
      * {@code Unmarshaller}.  This method can only be used to get one of
-     * the standard JAXB defined properties above or a provider specific
+     * the standard Jakarta XML Binding defined properties above or a provider specific
      * property.  Attempting to get an undefined property will result in
      * a PropertyException being thrown.  See <a href="#supportedProps">
      * Supported Properties</a>.
@@ -1047,9 +1047,9 @@
      * for unmarshal events.
      * </p>
      * <p>
-     * This class enables pre and post processing of an instance of a JAXB mapped class
+     * This class enables pre and post processing of an instance of a Jakarta XML Binding mapped class
      * as XML data is unmarshalled into it. The event callbacks are called when unmarshalling
-     * XML content into a JAXBElement instance or a JAXB mapped class that represents a complex type definition.
+     * XML content into a JAXBElement instance or a Jakarta XML Binding mapped class that represents a complex type definition.
      * The event callbacks are not called when unmarshalling to an instance of a
      * Java datatype that represents a simple type definition.
      * </p>
@@ -1073,8 +1073,8 @@
          * if the class of {@code target} defines its own {@code beforeUnmarshal} method,
          * the class specific callback method is invoked before this method is invoked.
          *
-         * @param target non-null instance of JAXB mapped class prior to unmarshalling into it.
-         * @param parent instance of JAXB mapped class that will eventually reference {@code target}.
+         * @param target non-null instance of Jakarta XML Binding mapped class prior to unmarshalling into it.
+         * @param parent instance of Jakarta XML Binding mapped class that will eventually reference {@code target}.
          *               {@code null} when {@code target} is root element.
          */
         public void beforeUnmarshal(Object target, Object parent) {
@@ -1091,8 +1091,8 @@
          * Note that if the class of {@code target} defines its own {@code afterUnmarshal} method,
          * the class specific callback method is invoked before this method is invoked.
          *
-         * @param target non-null instance of JAXB mapped class prior to unmarshalling into it.
-         * @param parent instance of JAXB mapped class that will reference {@code target}.
+         * @param target non-null instance of Jakarta XML Binding mapped class prior to unmarshalling into it.
+         * @param parent instance of Jakarta XML Binding mapped class that will reference {@code target}.
          *               {@code null} when {@code target} is root element.
          */
         public void afterUnmarshal(Object target, Object parent) {
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/UnmarshallerHandler.java b/jaxb-api/src/main/java/jakarta/xml/bind/UnmarshallerHandler.java
index 11e4edf..dbf455c 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/UnmarshallerHandler.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/UnmarshallerHandler.java
@@ -16,7 +16,7 @@
  * Unmarshaller implemented as SAX ContentHandler.
  * 
  * <p>
- * Applications can use this interface to use their JAXB provider as a component 
+ * Applications can use this interface to use their Jakarta XML Binding provider as a component 
  * in an XML pipeline.  For example:
  * 
  * <pre>
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/ValidationEventHandler.java b/jaxb-api/src/main/java/jakarta/xml/bind/ValidationEventHandler.java
index 3ad067a..bd96cec 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/ValidationEventHandler.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/ValidationEventHandler.java
@@ -19,13 +19,13 @@
  * {@link Unmarshaller#setEventHandler(ValidationEventHandler) Unmarshaller}, 
  * the {@link Validator#setEventHandler(ValidationEventHandler) Validator}, or 
  * the {@link Marshaller#setEventHandler(ValidationEventHandler) Marshaller}.  
- * The JAXB Provider will then report validation errors and warnings encountered
+ * The Jakarta XML Binding Provider will then report validation errors and warnings encountered
  * during the unmarshal, marshal, and validate operations to these event 
  * handlers.
  *
  * <p>
  * If the {@code handleEvent} method throws an unchecked runtime exception,
- * the JAXB Provider must treat that as if the method returned false, effectively
+ * the Jakarta XML Binding Provider must treat that as if the method returned false, effectively
  * terminating whatever operation was in progress at the time (unmarshal, 
  * validate, or marshal).
  * 
@@ -63,13 +63,13 @@
      * indicates where the error or warning occurred.
      *
      * <p>
-     * If an unchecked runtime exception is thrown from this method, the JAXB
+     * If an unchecked runtime exception is thrown from this method, the Jakarta XML Binding
      * provider will treat it as if the method returned false and interrupt
      * the current unmarshal, validate, or marshal operation.
      * 
      * @param event the encapsulated validation event information.  It is a 
      * provider error if this parameter is null.
-     * @return true if the JAXB Provider should attempt to continue the current
+     * @return true if the Jakarta XML Binding Provider should attempt to continue the current
      *         unmarshal, validate, or marshal operation after handling this 
      *         warning/error, false if the provider should terminate the current 
      *         operation with the appropriate {@code UnmarshalException},
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/Validator.java b/jaxb-api/src/main/java/jakarta/xml/bind/Validator.java
index 127cb82..3a19801 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/Validator.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/Validator.java
@@ -11,7 +11,7 @@
 package jakarta.xml.bind;
 
 /**
- * As of JAXB 2.0, this class is deprecated and optional.
+ * As of Jakarta XML Binding, this class is deprecated and optional.
  * <p>
  * The {@code Validator} class is responsible for controlling the validation
  * of content trees during runtime.
@@ -44,8 +44,8 @@
  *        <dd> This form of validation enables a client application to receive 
  *             immediate feedback about modifications to the Java content tree 
  *             that violate type constraints on Java Properties as defined in 
- *             the specification.  JAXB Providers are not required support
- *             this type of validation.  Of the JAXB Providers that do support
+ *             the specification.  Jakarta XML Binding Providers are not required support
+ *             this type of validation.  Of the Jakarta XML Binding Providers that do support
  *             this type of validation, some may require you to decide at schema
  *             compile time whether or not a client application will be allowed
  *             to request fail-fast validation at runtime.
@@ -111,9 +111,9 @@
  * <p>
  * Validation events are handled differently depending on how the client 
  * application is configured to process them as described in the previous
- * section.  However, there are certain cases where a JAXB Provider indicates
+ * section.  However, there are certain cases where a Jakarta XML Binding Provider indicates
  * that it is no longer able to reliably detect and report errors.  In these
- * cases, the JAXB Provider will set the severity of the ValidationEvent to
+ * cases, the Jakarta XML Binding Provider will set the severity of the ValidationEvent to
  * FATAL_ERROR to indicate that the unmarshal, validate, or marshal operations 
  * should be terminated.  The default event handler and 
  * {@code ValidationEventCollector} utility class must terminate processing
@@ -128,7 +128,7 @@
  * <blockquote>
  * <p>
  * There currently are not any properties required to be supported by all 
- * JAXB Providers on Validator.  However, some providers may support 
+ * Jakarta XML Binding Providers on Validator.  However, some providers may support 
  * their own set of provider specific properties.
  * </blockquote>
  * 
@@ -147,7 +147,7 @@
     /**
      * Allow an application to register a validation event handler.
      * <p>
-     * The validation event handler will be called by the JAXB Provider if any
+     * The validation event handler will be called by the Jakarta XML Binding Provider if any
      * validation errors are encountered during calls to 
      * {@link #validate(Object) validate}.  If the client application does not 
      * register a validation event handler before invoking the validate method, 
@@ -228,7 +228,7 @@
     /**
      * Set the particular property in the underlying implementation of 
      * {@code Validator}.  This method can only be used to set one of
-     * the standard JAXB defined properties above or a provider specific
+     * the standard Jakarta XML Binding defined properties above or a provider specific
      * property.  Attempting to set an undefined property will result in
      * a PropertyException being thrown.  See <a href="#supportedProps">
      * Supported Properties</a>.
@@ -250,7 +250,7 @@
     /**
      * Get the particular property in the underlying implementation of 
      * {@code Validator}.  This method can only be used to get one of
-     * the standard JAXB defined properties above or a provider specific
+     * the standard Jakarta XML Binding defined properties above or a provider specific
      * property.  Attempting to get an undefined property will result in
      * a PropertyException being thrown.  See <a href="#supportedProps">
      * Supported Properties</a>.
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/DomHandler.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/DomHandler.java
index 23b1eef..dac01db 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/DomHandler.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/DomHandler.java
@@ -25,12 +25,12 @@
  *
  * <p>
  * Implementations hide how a portion of XML is converted into/from such
- * DOM-like representation, allowing JAXB providers to work with arbitrary
+ * DOM-like representation, allowing Jakarta XML Binding providers to work with arbitrary
  * such library.
  *
  * <P>
  * This interface is intended to be implemented by library writers
- * and consumed by JAXB providers. None of those methods are intended to
+ * and consumed by Jakarta XML Binding providers. None of those methods are intended to
  * be called from applications.
  *
  * @author Kohsuke Kawaguchi
@@ -38,12 +38,12 @@
  */
 public interface DomHandler<ElementT,ResultT extends Result> {
     /**
-     * When a JAXB provider needs to unmarshal a part of a document into an
+     * When a Jakarta XML Binding provider needs to unmarshal a part of a document into an
      * infoset representation, it first calls this method to create a
      * {@link Result} object.
      *
      * <p>
-     * A JAXB provider will then send a portion of the XML
+     * A Jakarta XML Binding provider will then send a portion of the XML
      * into the given result. Such a portion always form a subtree
      * of the whole XML document rooted at an element.
      *
@@ -65,7 +65,7 @@
 
     /**
      * Once the portion is sent to the {@link Result}. This method is called
-     * by a JAXB provider to obtain the unmarshalled element representation.
+     * by a Jakarta XML Binding provider to obtain the unmarshalled element representation.
      *
      * <p>
      * Multiple invocations of this method may return different objects.
@@ -82,13 +82,13 @@
     ElementT getElement(ResultT rt);
 
     /**
-     * This method is called when a JAXB provider needs to marshal an element
+     * This method is called when a Jakarta XML Binding provider needs to marshal an element
      * to XML.
      *
      * <p>
      * If non-null, the returned {@link Source} must contain a whole document
      * rooted at one element, which will then be weaved into a bigger document
-     * that the JAXB provider is marshalling.
+     * that the Jakarta XML Binding provider is marshalling.
      *
      * @param errorHandler
      *      Receives any errors happened during the process of converting
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/W3CDomHandler.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/W3CDomHandler.java
index 9dcb964..5c3385d 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/W3CDomHandler.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/W3CDomHandler.java
@@ -34,7 +34,7 @@
     /**
      * Default constructor.
      *
-     * It is up to a JAXB provider to decide which DOM implementation
+     * It is up to a Jakarta XML Binding provider to decide which DOM implementation
      * to use or how that is configured.
      */
     public W3CDomHandler() {
@@ -46,7 +46,7 @@
      * to be used.
      *
      * @param builder
-     *      must not be null. JAXB uses this {@link DocumentBuilder} to create
+     *      must not be null. Jakarta XML Binding uses this {@link DocumentBuilder} to create
      *      a new element.
      */
     public W3CDomHandler(DocumentBuilder builder) {
@@ -83,7 +83,7 @@
             return (Element)n.getChildNodes().item(0);
 
         // if the result object contains something strange,
-        // it is not a user problem, but it is a JAXB provider's problem.
+        // it is not a user problem, but it is a Jakarta XML Binding provider's problem.
         // That's why we throw a runtime exception.
         throw new IllegalStateException(n.toString());
     }
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAccessOrder.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAccessOrder.java
index d476841..6ce3dd5 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAccessOrder.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAccessOrder.java
@@ -12,7 +12,7 @@
 
 /**
  * Used by XmlAccessorOrder to control the ordering of properties and
- * fields in a JAXB bound class.
+ * fields in a Jakarta XML Binding bound class.
  *
  * @author Sekhar Vajjhala, Sun Microsystems, Inc.
  * @since 1.6, JAXB 2.0
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAccessType.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAccessType.java
index 8ca6a30..d7f9596 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAccessType.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAccessType.java
@@ -23,19 +23,19 @@
 
 public enum XmlAccessType {
     /**
-     * Every getter/setter pair in a JAXB-bound class will be automatically
+     * Every getter/setter pair in a Jakarta XML Binding-bound class will be automatically
      * bound to XML, unless annotated by {@link XmlTransient}.
      *
      * Fields are bound to XML only when they are explicitly annotated
-     * by some of the JAXB annotations.
+     * by some of the Jakarta XML Binding annotations.
      */
     PROPERTY,
     /**
-     * Every non static, non transient field in a JAXB-bound class will be automatically
+     * Every non static, non transient field in a Jakarta XML Binding-bound class will be automatically
      * bound to XML, unless annotated by {@link XmlTransient}.
      *
      * Getter/setter pairs are bound to XML only when they are explicitly annotated
-     * by some of the JAXB annotations.
+     * by some of the Jakarta XML Binding annotations.
      */
     FIELD,
     /**
@@ -44,12 +44,12 @@
      *
      * Fields or getter/setter pairs that are private, protected, or 
      * defaulted to package-only access are bound to XML only when they are
-     * explicitly annotated by the appropriate JAXB annotations.
+     * explicitly annotated by the appropriate Jakarta XML Binding annotations.
      */
     PUBLIC_MEMBER,
     /**
      * None of the fields or properties is bound to XML unless they
-     * are specifically  annotated with some of the JAXB annotations.
+     * are specifically  annotated with some of the Jakarta XML Binding annotations.
      */
     NONE
 }
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAnyElement.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAnyElement.java
index 0d451f0..1ba25a5 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAnyElement.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlAnyElement.java
@@ -24,11 +24,11 @@
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Maps a JavaBean property to XML infoset representation and/or JAXB element.
+ * Maps a JavaBean property to XML infoset representation and/or JAXBElement.
  *
  * <p>
  * This annotation serves as a "catch-all" property while unmarshalling
- * xml content into a instance of a JAXB annotated class. It typically
+ * xml content into a instance of a Jakarta XML Binding annotated class. It typically
  * annotates a multi-valued JavaBean property, but it can occur on
  * single value JavaBean property. During unmarshalling, each xml element
  * that does not match a static &#64;XmlElement or &#64;XmlElementRef
@@ -40,7 +40,7 @@
  * &#64;XmlAnyElement
  * public {@link Element}[] others;
  *
- * // Collection of {@link Element} or JAXB elements.
+ * // Collection of {@link Element} or JAXBElements.
  * &#64;XmlAnyElement(lax="true")
  * public {@link Object}[] others;
  *
@@ -250,18 +250,18 @@
      * is known to {@link JAXBContext} (for example, there's a class with
      * {@link XmlRootElement} that has the same tag name, or there's
      * {@link XmlElementDecl} that has the same tag name),
-     * the unmarshaller will eagerly unmarshal this element to the JAXB object,
+     * the unmarshaller will eagerly unmarshal this element to the Jakarta XML Binding object,
      * instead of unmarshalling it to DOM. Additionally, if the element is
      * unknown but it has a known xsi:type, the unmarshaller eagerly unmarshals
      * the element to a {@link JAXBElement}, with the unknown element name and
-     * the JAXBElement value is set to an instance of the JAXB mapping of the
+     * the JAXBElement value is set to an instance of the Jakarta XML Binding mapping of the
      * known xsi:type.
      * </dd>
      * </dl>
      *
      * <p>
      * As a result, after the unmarshalling, the property can become heterogeneous;
-     * it can have both DOM nodes and some JAXB objects at the same time.
+     * it can have both DOM nodes and some Jakarta XML Binding objects at the same time.
      *
      * <p>
      * This can be used to emulate the "lax" wildcard semantics of the W3C XML Schema.
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlElementRef.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlElementRef.java
index ba4ebbd..3eefb42 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlElementRef.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlElementRef.java
@@ -39,7 +39,7 @@
  * that were not statically specified in the content model of a
  * schema using substitution groups. Schema derived code provides
  * support for substitution groups using an <i>element property</i>,
- * (section 5.5.5, "Element Property" of JAXB 2.0 specification). An
+ * (section 5.5.5, "Element Property" of Jakarta XML Binding specification). An
  * element property method signature is of the form:
  * <pre>{@code
  *     public void setTerm(JAXBElement<? extends Operator>);
@@ -267,7 +267,7 @@
      * for a multivalued property.
      *
      * <p>
-     * For compatibility with JAXB 2.1, this property defaults to {@code true},
+     * For compatibility with Jakarta XML Binding, this property defaults to {@code true},
      * despite the fact that {@link XmlElement#required()} defaults to false.
      *
      * @since 1.7, JAXB 2.2
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlInlineBinaryData.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlInlineBinaryData.java
index a39d294..4e1c0ee 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlInlineBinaryData.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlInlineBinaryData.java
@@ -29,8 +29,8 @@
  * When XOP encoding is enabled as described in {@link AttachmentMarshaller#isXOPPackage()},
  * this annotation disables datatypes such as {@link java.awt.Image} or {@link Source}
  * or {@code byte[]} that are bound to base64-encoded binary from being considered for
- * XOP encoding. If a JAXB property is annotated with this annotation or if
- * the JAXB property's base type is annotated with this annotation, 
+ * XOP encoding. If a Jakarta XML Binding property is annotated with this annotation or if
+ * the Jakarta XML Binding property's base type is annotated with this annotation, 
  * neither 
  * {@link AttachmentMarshaller#addMtomAttachment(DataHandler, String, String)}
  * nor 
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlMixed.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlMixed.java
index 601ce77..d29b5ef 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlMixed.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlMixed.java
@@ -36,7 +36,7 @@
  * <li>Children element information items are added as instances of
  * {@link JAXBElement} or instances with a class that is annotated with
  * &#64;XmlRootElement.</li>
- * <li>Unknown content that is not be bound to a JAXB mapped class is inserted
+ * <li>Unknown content that is not be bound to a Jakarta XML Binding mapped class is inserted
  * as {@link Element}. (Assumes property annotated with &#64;XmlAnyElement)</li>
  * </ul>
  *
@@ -89,7 +89,7 @@
  * Monitor</productName> shipped from our warehouse. ....
  * </letterBody>
  * }</pre>
- * that can be constructed using following JAXB API calls.
+ * that can be constructed using following Jakarta XML Binding API calls.
  * <pre>{@code
  * LetterBody lb = ObjectFactory.createLetterBody();
  * JAXBElement<LetterBody> lbe = ObjectFactory.createLetterBody(lb);
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlSchema.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlSchema.java
index 61e23a6..b660a93 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlSchema.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlSchema.java
@@ -36,7 +36,7 @@
  *   <li> There can only be one package declaration as noted in JSR
  *        175, section III, "Annotations". </li>
  *   <li> JSR 175 recommends package-info.java for package level
- *        annotations. JAXB Providers that follow this recommendation
+ *        annotations. Jakarta XML Binding Providers that follow this recommendation
  *        will allow the package level annotations to be defined in
  *        package-info.java.
  * </ul>
@@ -110,7 +110,7 @@
     /**
      * Customize the namespace URI, prefix associations. By default,
      * the namespace prefixes for a XML namespace are generated by a
-     * JAXB Provider in an implementation dependent way.
+     * Jakarta XML Binding Provider in an implementation dependent way.
      */
     XmlNs[]  xmlns() default {};
 
@@ -136,7 +136,7 @@
      * has a schema already available exeternally, available at this location.
      *
      * <p>
-     * This instructs the JAXB schema generators to simply refer to
+     * This instructs the Jakarta XML Binding schema generators to simply refer to
      * the pointed schema, as opposed to generating components into the schema.
      * This schema is assumed to match what would be otherwise produced
      * by the schema generator (same element names, same type names...)
@@ -154,7 +154,7 @@
      * unspecified (and thus it's the responsibility of the reader of the generate
      * schema to locate it.) Finally, the default value of this property
      * {@code "##generate"} indicates that the schema generator is going
-     * to generate components for this namespace (as it did in JAXB 2.0.)
+     * to generate components for this namespace (as it did in Jakarta XML Binding.)
      *
      * <p>
      * Multiple {@link XmlSchema} annotations on multiple packages are allowed
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlSeeAlso.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlSeeAlso.java
index 4617703..8d8e468 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlSeeAlso.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlSeeAlso.java
@@ -17,11 +17,11 @@
 import java.lang.annotation.Target;
 
 /**
- * Instructs JAXB to also bind other classes when binding this class.
+ * Instructs Jakarta XML Binding to also bind other classes when binding this class.
  *
  * <p>
  * Java makes it impractical/impossible to list all sub-classes of
- * a given class. This often gets in a way of JAXB users, as it JAXB
+ * a given class. This often gets in a way of Jakarta XML Binding users, as it Jakarta XML Binding
  * cannot automatically list up the classes that need to be known
  * to {@link JAXBContext}.
  *
@@ -51,7 +51,7 @@
  *
  * <p>
  * This would allow you to do {@code JAXBContext.newInstance(Animal.class)}.
- * By the help of this annotation, JAXB implementations will be able to
+ * By the help of this annotation, Jakarta XML Binding implementations will be able to
  * correctly bind {@code Dog} and {@code Cat}.
  *
  * @author Kohsuke Kawaguchi
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlTransient.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlTransient.java
index 55c8171..7492beb 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlTransient.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/XmlTransient.java
@@ -43,7 +43,7 @@
  * </ul>
  *
  * <p>{@code @XmlTransient} is mutually exclusive with all other
- * JAXB defined annotations. </p>
+ * Jakarta XML Binding defined annotations. </p>
  * 
  * <p>See "Package Specification" in jakarta.xml.bind.package javadoc for
  * additional common information.</p>
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/adapters/XmlAdapter.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/adapters/XmlAdapter.java
index 7e71fcf..9ef60a4 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/adapters/XmlAdapter.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/adapters/XmlAdapter.java
@@ -30,17 +30,17 @@
  *
  * <p>
  * This abstract class defines methods for adapting a bound type to a value
- * type or vice versa. The methods are invoked by the JAXB binding
+ * type or vice versa. The methods are invoked by the Jakarta XML Binding binding
  * framework during marshaling and unmarshalling:
  *
  * <ul>
- *   <li> <b> XmlAdapter.marshal(...): </b> During marshalling, JAXB
+ *   <li> <b> XmlAdapter.marshal(...): </b> During marshalling, Jakarta XML Binding
  *        binding framework invokes XmlAdapter.marshal(..) to adapt a
  *        bound type to value type, which is then marshaled to XML 
  *        representation. </li> 
  *
  *   <li> <b> XmlAdapter.unmarshal(...): </b> During unmarshalling,
- *        JAXB binding framework first unmarshals XML representation
+ *        Jakarta XML Binding binding framework first unmarshals XML representation
  *        to a value type and then invokes XmlAdapter.unmarshal(..) to
  *        adapt the value type to a bound type. </li> 
  * </ul>
@@ -137,11 +137,11 @@
  * }</pre>
  *
  * @param <BoundType>
- *      The type that JAXB doesn't know how to handle. An adapter is written
+ *      The type that Jakarta XML Binding doesn't know how to handle. An adapter is written
  *      to allow this type to be used as an in-memory representation through
  *      the {@code ValueType}.
  * @param <ValueType>
- *      The type that JAXB knows how to handle out of the box.
+ *      The type that Jakarta XML Binding knows how to handle out of the box.
  *
  * @author <ul><li>Sekhar Vajjhala, Sun Microsystems Inc.</li> <li> Kohsuke Kawaguchi, Sun Microsystems Inc.</li></ul>
  * @see XmlJavaTypeAdapter
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/package-info.java b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/package-info.java
index d3f587b..d47bf5c 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/annotation/package-info.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/annotation/package-info.java
@@ -14,7 +14,7 @@
  * References in this document to JAXB refer to the Jakarta XML Binding unless otherwise noted.
  *
  * <h2>Package Specification</h2>
- * <p>The following table shows the JAXB mapping annotations
+ * <p>The following table shows the Jakarta XML Binding mapping annotations
  * that can be associated with each program element. </p>
  * <p>
  * <table class="striped">
@@ -22,7 +22,7 @@
  *   <thead>
  *     <tr>
  *       <th scope="col">Program Element</th>
- *       <th scope="col">JAXB annotation</th>
+ *       <th scope="col">Jakarta XML Binding annotation</th>
  *     </tr>
  *   </thead>
  *   <tbody style="text-align:left">
@@ -124,7 +124,7 @@
  * mean either a top level class or a nested static
  * class.
  * <p>
- * <b>mapping annotation:</b>A JAXB 2.0 defined program
+ * <b>mapping annotation:</b>A Jakarta XML Binding defined program
  * annotation based on the JSR 175 programming annotation
  * facility.
  * <h3>Common Usage Constraints</h3>
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/attachment/AttachmentMarshaller.java b/jaxb-api/src/main/java/jakarta/xml/bind/attachment/AttachmentMarshaller.java
index 75048df..4fd991f 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/attachment/AttachmentMarshaller.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/attachment/AttachmentMarshaller.java
@@ -14,11 +14,11 @@
 import jakarta.xml.bind.Marshaller;
 
 /**
- * <p>Enable JAXB marshalling to optimize storage of binary data.
+ * <p>Enable Jakarta XML Binding marshalling to optimize storage of binary data.
  *
  * <p>This API enables an efficient cooperative creation of optimized
- * binary data formats between a JAXB marshalling process and a MIME-based package
- * processor. A JAXB implementation marshals the root body of a MIME-based package,
+ * binary data formats between a Jakarta XML Binding marshalling process and a MIME-based package
+ * processor. A Jakarta XML Binding implementation marshals the root body of a MIME-based package,
  * delegating the creation of referenceable MIME parts to
  * the MIME-based package processor that implements this abstraction.
  *
@@ -28,7 +28,7 @@
  *
  * <p>WS-I Attachment Profile 1.0 is supported by
  * {@link #addSwaRefAttachment(DataHandler)} being called by the
- * marshaller for each JAXB property related to
+ * marshaller for each Jakarta XML Binding property related to
  * {http://ws-i.org/profiles/basic/1.1/xsd}swaRef.
  *
  *
@@ -48,7 +48,7 @@
      * <p>Consider MIME content {@code data} for optimized binary storage as an attachment.
      *
      * <p>
-     * This method is called by JAXB marshal process when {@link #isXOPPackage()} is
+     * This method is called by Jakarta XML Binding marshal process when {@link #isXOPPackage()} is
      * {@code true}, for each element whose datatype is "base64Binary", as described in
      * Step 3 in
      * <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/#creating_xop_packages">Creating XOP Packages</a>.
@@ -59,14 +59,14 @@
      * of the binary data as a MIME part, it is responsible for attaching {@code data} to the
      * MIME-based package, and then assigning an unique content-id, cid, that identifies
      * the MIME part within the MIME message. This method returns the cid,
-     * which enables the JAXB marshaller to marshal a XOP element that refers to that cid in place
-     * of marshalling the binary data. When the method returns null, the JAXB marshaller
+     * which enables the Jakarta XML Binding marshaller to marshal a XOP element that refers to that cid in place
+     * of marshalling the binary data. When the method returns null, the Jakarta XML Binding marshaller
      * inlines {@code data} as base64binary data.
      *
      * <p>
      * The caller of this method is required to meet the following constraint.
      * If the element infoset item containing {@code data} has the attribute
-     * {@code xmime:contentType} or if the JAXB property/field representing
+     * {@code xmime:contentType} or if the Jakarta XML Binding property/field representing
      * {@code data} is annotated with a known MIME type,
      * {@code data.getContentType()} should be set to that MIME type.
      *
@@ -119,7 +119,7 @@
      *       must be non-negative and no larger than array.length
      *
      * @param mimeType
-     *      If the data has an associated MIME type known to JAXB, that is passed
+     *      If the data has an associated MIME type known to Jakarta XML Binding, that is passed
      *      as this parameter. If none is known, "application/octet-stream".
      *      This parameter may never be null.
      *
@@ -138,7 +138,7 @@
     public abstract String addMtomAttachment(byte[] data, int offset, int length, String mimeType, String elementNamespace, String elementLocalName);
 
     /**
-     * <p>Read-only property that returns true if JAXB marshaller should enable XOP creation.
+     * <p>Read-only property that returns true if Jakarta XML Binding marshaller should enable XOP creation.
      *
      * <p>This value must not change during the marshalling process. When this
      * value is true, the {@code addMtomAttachment(...)} method
@@ -167,7 +167,7 @@
     * <p>Add MIME {@code data} as an attachment and return attachment's content-id, cid.
     *
     * <p>
-    * This method is called by JAXB marshal process for each element/attribute typed as
+    * This method is called by Jakarta XML Binding marshal process for each element/attribute typed as
     * {http://ws-i.org/profiles/basic/1.1/xsd}swaRef. The MIME-based package processor
     * implementing this method is responsible for attaching the specified data to a
     * MIME attachment, and generating a content-id, cid, that uniquely identifies the attachment
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/attachment/AttachmentUnmarshaller.java b/jaxb-api/src/main/java/jakarta/xml/bind/attachment/AttachmentUnmarshaller.java
index da4f992..884ef84 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/attachment/AttachmentUnmarshaller.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/attachment/AttachmentUnmarshaller.java
@@ -13,11 +13,11 @@
 import jakarta.activation.DataHandler;
 
 /**
- * <p>Enables JAXB unmarshalling of a root document containing optimized binary data formats.</p>
+ * <p>Enables Jakarta XML Binding unmarshalling of a root document containing optimized binary data formats.</p>
  *
  * <p>This API enables an efficient cooperative processing of optimized
- * binary data formats between a JAXB 2.0 implementation and MIME-based package
- * processor (MTOM/XOP and WS-I AP 1.0). JAXB unmarshals the body of a package, delegating the 
+ * binary data formats between a Jakarta XML Binding implementation and MIME-based package
+ * processor (MTOM/XOP and WS-I AP 1.0). Jakarta XML Binding unmarshals the body of a package, delegating the 
  * understanding of the packaging format being used to a MIME-based 
  * package processor that implements this abstract class.</p>
  *
@@ -111,7 +111,7 @@
     public abstract byte[] getAttachmentAsByteArray(String cid);
 
     /**
-     * <p>Read-only property that returns true if JAXB unmarshaller needs to perform XOP processing.</p>
+     * <p>Read-only property that returns true if Jakarta XML Binding unmarshaller needs to perform XOP processing.</p>
      *
      * <p>This method returns {@code true} when the constraints specified
      * in  <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/#identifying_xop_documents">Identifying XOP Documents</a> are met.
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/AbstractMarshallerImpl.java b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/AbstractMarshallerImpl.java
index 4282fe5..4b1b15f 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/AbstractMarshallerImpl.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/AbstractMarshallerImpl.java
@@ -40,7 +40,7 @@
  * {@link jakarta.xml.bind.Marshaller} interface.
  * 
  * <p>
- * The only methods that a JAXB Provider has to implement are
+ * The only methods that a Jakarta XML Binding Provider has to implement are
  * {@link Marshaller#marshal(Object, javax.xml.transform.Result) marshal(Object, javax.xml.transform.Result)},
  * {@link Marshaller#marshal(Object, javax.xml.transform.Result) marshal(Object, javax.xml.stream.XMLStreamWriter)}, and
  * {@link Marshaller#marshal(Object, javax.xml.transform.Result) marshal(Object, javax.xml.stream.XMLEventWriter)}.
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/AbstractUnmarshallerImpl.java b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/AbstractUnmarshallerImpl.java
index 840ee5d..c2a5077 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/AbstractUnmarshallerImpl.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/AbstractUnmarshallerImpl.java
@@ -43,7 +43,7 @@
  * {@link jakarta.xml.bind.Unmarshaller}interface.
  * 
  * <p>
- * A JAXB Provider has to implement five methods (getUnmarshallerHandler,
+ * A Jakarta XML Binding Provider has to implement five methods (getUnmarshallerHandler,
  * unmarshal(Node), unmarshal(XMLReader,InputSource),
  * unmarshal(XMLStreamReader), and unmarshal(XMLEventReader).
  * 
@@ -219,7 +219,7 @@
     /**
      * Allow an application to register a validation event handler.
      * <p>
-     * The validation event handler will be called by the JAXB Provider if any
+     * The validation event handler will be called by the Jakarta XML Binding Provider if any
      * validation errors are encountered during calls to any of the
      * {@code unmarshal} methods.  If the client application does not register
      * a validation event handler before invoking the unmarshal methods, then
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/DefaultValidationEventHandler.java b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/DefaultValidationEventHandler.java
index 64e683c..6ecd1f5 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/DefaultValidationEventHandler.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/DefaultValidationEventHandler.java
@@ -28,8 +28,8 @@
  * error or fatal error.
  * 
  * <p>
- * This handler is not the default handler for JAXB mapped classes following 
- * JAXB 2.0 or later versions. Default validation event handling has changed 
+ * This handler is not the default handler for Jakarta XML Binding mapped classes following 
+ * Jakarta XML Binding or later versions. Default validation event handling has changed 
  * and is specified in  {@link jakarta.xml.bind.Unmarshaller} and
  * {@link jakarta.xml.bind.Marshaller}.
  *
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/NotIdentifiableEventImpl.java b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/NotIdentifiableEventImpl.java
index 702f998..e1b4af1 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/NotIdentifiableEventImpl.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/NotIdentifiableEventImpl.java
@@ -16,7 +16,7 @@
  * Default implementation of the NotIdentifiableEvent interface.
  * 
  * <p>
- * JAXB providers are allowed to use whatever class that implements
+ * Jakarta XML Binding providers are allowed to use whatever class that implements
  * the ValidationEvent interface. This class is just provided for a
  * convenience.
  *
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ParseConversionEventImpl.java b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ParseConversionEventImpl.java
index e5f2e95..7618ed2 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ParseConversionEventImpl.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ParseConversionEventImpl.java
@@ -17,7 +17,7 @@
  * Default implementation of the ParseConversionEvent interface.
  * 
  * <p>
- * JAXB providers are allowed to use whatever class that implements
+ * Jakarta XML Binding providers are allowed to use whatever class that implements
  * the ValidationEvent interface. This class is just provided for a
  * convenience.
  *
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/PrintConversionEventImpl.java b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/PrintConversionEventImpl.java
index a8e18f6..cbb9902 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/PrintConversionEventImpl.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/PrintConversionEventImpl.java
@@ -17,7 +17,7 @@
  * Default implementation of the PrintConversionEvent interface.
  * 
  * <p>
- * JAXB providers are allowed to use whatever class that implements
+ * Jakarta XML Binding providers are allowed to use whatever class that implements
  * the ValidationEvent interface. This class is just provided for a
  * convenience.
  *
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ValidationEventImpl.java b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ValidationEventImpl.java
index caeea3f..85522ab 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ValidationEventImpl.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ValidationEventImpl.java
@@ -19,7 +19,7 @@
  * Default implementation of the ValidationEvent interface.
  * 
  * <p>
- * JAXB providers are allowed to use whatever class that implements
+ * Jakarta XML Binding providers are allowed to use whatever class that implements
  * the ValidationEvent interface. This class is just provided for a
  * convenience.
  *
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ValidationEventLocatorImpl.java b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ValidationEventLocatorImpl.java
index 54001dc..71dd36b 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ValidationEventLocatorImpl.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/helpers/ValidationEventLocatorImpl.java
@@ -23,7 +23,7 @@
  * Default implementation of the ValidationEventLocator interface.
  * 
  * <p>
- * JAXB providers are allowed to use whatever class that implements
+ * Jakarta XML Binding providers are allowed to use whatever class that implements
  * the ValidationEventLocator interface. This class is just provided for a
  * convenience.
  *
@@ -108,7 +108,7 @@
     }
 
     /** 
-     * Constructs an object that points to a JAXB content object. 
+     * Constructs an object that points to a Jakarta XML Binding content object. 
      * 
      * The object's Object becomes available. ColumnNumber, LineNumber, Node, 
      * Offset, and URL are not available.
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/util/JAXBResult.java b/jaxb-api/src/main/java/jakarta/xml/bind/util/JAXBResult.java
index 2f7d8c1..7a62338 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/util/JAXBResult.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/util/JAXBResult.java
@@ -18,14 +18,14 @@
 
 /**
  * JAXP {@link javax.xml.transform.Result} implementation
- * that unmarshals a JAXB object.
+ * that unmarshals a Jakarta XML Binding object.
  * 
  * <p>
- * This utility class is useful to combine JAXB with
+ * This utility class is useful to combine Jakarta XML Binding with
  * other Java/XML technologies.
  * 
  * <p>
- * The following example shows how to use JAXB to unmarshal a document
+ * The following example shows how to use Jakarta XML Binding to unmarshal a document
  * resulting from an XSLT transformation.
  * 
  * <blockquote>
diff --git a/jaxb-api/src/main/java/jakarta/xml/bind/util/JAXBSource.java b/jaxb-api/src/main/java/jakarta/xml/bind/util/JAXBSource.java
index cc51826..79287d5 100644
--- a/jaxb-api/src/main/java/jakarta/xml/bind/util/JAXBSource.java
+++ b/jaxb-api/src/main/java/jakarta/xml/bind/util/JAXBSource.java
@@ -30,14 +30,14 @@
 
 /**
  * JAXP {@link javax.xml.transform.Source} implementation
- * that marshals a JAXB-generated object.
+ * that marshals a Jakarta XML Binding-generated object.
  * 
  * <p>
- * This utility class is useful to combine JAXB with
+ * This utility class is useful to combine Jakarta XML Binding with
  * other Java/XML technologies.
  * 
  * <p>
- * The following example shows how to use JAXB to marshal a document
+ * The following example shows how to use Jakarta XML Binding to marshal a document
  * for transformation by XSLT.
  * 
  * <blockquote>
@@ -84,7 +84,7 @@
      *      <code>contentObject</code>. This context is used
      *      to create a new instance of marshaller and must not be null.
      * @param   contentObject
-     *      An instance of a JAXB-generated class, which will be
+     *      An instance of a Jakarta XML Binding-generated class, which will be
      *      used as a {@link javax.xml.transform.Source} (by marshalling it into XML).  It must
      *      not be null.
      * @throws JAXBException if an error is encountered while creating the
@@ -112,7 +112,7 @@
      *      created from a JAXBContext that was used to build
      *      <code>contentObject</code> and must not be null.
      * @param   contentObject
-     *      An instance of a JAXB-generated class, which will be
+     *      An instance of a Jakarta XML Binding-generated class, which will be
      *      used as a {@link javax.xml.transform.Source} (by marshalling it into XML).  It must
      *      not be null.
      * @throws JAXBException if an error is encountered while creating the
diff --git a/jaxb-api/src/main/mr-jar/jakarta/xml/bind/ModuleUtil.java b/jaxb-api/src/main/mr-jar/jakarta/xml/bind/ModuleUtil.java
index 150a6df..ff62117 100644
--- a/jaxb-api/src/main/mr-jar/jakarta/xml/bind/ModuleUtil.java
+++ b/jaxb-api/src/main/mr-jar/jakarta/xml/bind/ModuleUtil.java
@@ -21,7 +21,7 @@
 import java.util.logging.Logger;
 
 /**
- * Propagates openness of JAXB annottated classess packages to JAXB impl module.
+ * Propagates openness of Jakarta XML Binding annottated classess packages to Jakarta XML Binding impl module.
  *
  * @author Roman Grigoriadi
  */
@@ -30,7 +30,7 @@
     private static Logger logger = Logger.getLogger("jakarta.xml.bind");
 
     /**
-     * JAXB-RI default context factory.
+     * Jakarta XML Binding-RI default context factory.
      */
     // NOTICE: .toString() is used to prevent constant inlining by Java Compiler
     static final String DEFAULT_FACTORY_CLASS = "com.sun.xml.bind.v2.ContextFactory".toString();
@@ -111,13 +111,13 @@
     }
 
     /**
-     * Implementation may be defined in other module than {@code java.xml.bind}. In that case openness
+     * Implementation may be defined in other module than {@code jakarta.xml.bind}. In that case openness
      * {@linkplain Module#isOpen open} of classes should be delegated to implementation module.
      *
      * @param classes used to resolve module for {@linkplain Module#addOpens(String, Module)}
      * @param factorySPI used to resolve {@link Module} of the implementation.
      *
-     * @throws JAXBException if ony of a classes package is not open to {@code java.xml.bind} module.
+     * @throws JAXBException if ony of a classes package is not open to {@code jakarta.xml.bind} module.
      */
     public static void delegateAddOpensToImplModule(Class[] classes, Class<?> factorySPI) throws JAXBException {
         final Module implModule = factorySPI.getModule();
@@ -134,7 +134,7 @@
             if (!classModule.isNamed() || classModule.getName().equals("java.base")) {
                 continue;
             }
-            //report error if they are not open to java.xml.bind
+            //report error if they are not open to jakarta.xml.bind
             if (!classModule.isOpen(packageName, jaxbModule)) {
                 throw new JAXBException(Messages.format(Messages.JAXB_CLASSES_NOT_OPEN,
                                                         packageName, jaxbClass.getName(), classModule.getName()));
diff --git a/jaxb-api/src/main/resources/jakarta/xml/bind/Messages.properties b/jaxb-api/src/main/resources/jakarta/xml/bind/Messages.properties
index 60f7aa5..dc6180b 100644
--- a/jaxb-api/src/main/resources/jakarta/xml/bind/Messages.properties
+++ b/jaxb-api/src/main/resources/jakarta/xml/bind/Messages.properties
@@ -12,7 +12,7 @@
 	Provider {0} not found
 
 ContextFinder.DefaultProviderNotFound = \
-	Implementation of JAXB-API has not been found on module path or classpath.
+	Implementation of Jakarta XML Binding-API has not been found on module path or classpath.
 	
 ContextFinder.CouldNotInstantiate = \
 	Provider {0} could not be instantiated: {1}	
@@ -21,7 +21,7 @@
 	Unable to locate jaxb.properties for package {0}
 	
 ContextFinder.CantMixProviders = \
-	You may not mix JAXB Providers on the context path
+	You may not mix Jakarta XML Binding Providers on the context path
 	
 ContextFinder.MissingProperty = \
 	jaxb.properties in package {0} does not contain the {1} property.
@@ -44,4 +44,4 @@
     ClassCastException: attempting to cast {0} to {1}.  Please make sure that you are specifying the proper ClassLoader.    
 
 JAXBClasses.notOpen = \
-    Package {0} with JAXB class {1} defined in a module {2} must be open to at least java.xml.bind module.
+    Package {0} with Jakarta XML Binding class {1} defined in a module {2} must be open to at least jakarta.xml.bind module.