@@ -440,10 +440,8 @@ impl PomScope {
     /// artifactId (keeping an unresolved reference,
     /// [`interpolate_keeping`]) and version ([`interpolate_strict`]) read
     /// together ([`Self::resolve_all_in_build`]), every reading whose
-    /// coordinates differ from what it reads with no profile active
-    /// ([`ScopedDep::group`] / [`ScopedDep::artifact`]). A profile
-    /// declaration's own profile is always active with it, so what it reads
-    /// there is one too.
+    /// coordinates differ from what it reads with no profile active but
+    /// the one holding it ([`ScopedDep::group`] / [`ScopedDep::artifact`]).
     pub(crate) fn coordinate_alternatives(&self, dep: &ScopedDep) -> Vec<CoordinateAlternative> {
         let (Some(group_text), Some(artifact_text), Some(group), Some(artifact)) = (
             dep.group_text.as_deref(),
@@ -463,22 +461,9 @@ impl PomScope {
         if let Some(version) = dep.version_text.as_deref() {
             texts.push((version, interpolate_strict));
         }
-        let pos = dep.element.start;
-        let (own_base, readings) = self.resolve_all_in_build(&texts, pos);
-        let own: Vec<String> = self
-            .own_profile(pos)
-            .into_iter()
-            .map(|i| self.profile_properties[i].id.clone())
-            .collect();
-        let own_reading = (!own.is_empty()).then(|| {
-            let mut values = own_base;
-            if let Some(v) = values.get_mut(2) {
-                *v = v.take().or_else(|| dep.version_text.clone());
-            }
-            (values, MovedBy::Profiles(own))
-        });
+        let (_, readings) = self.resolve_all_in_build(&texts, dep.element.start);
         let mut out: Vec<CoordinateAlternative> = Vec::new();
-        for (values, by) in own_reading.into_iter().chain(readings) {
+        for (values, by) in readings {
             let mut values = values.into_iter();
             let (Some(Some(g)), Some(Some(a))) = (values.next(), values.next()) else {
                 continue;
@@ -503,13 +488,16 @@ impl PomScope {
         out
     }
 
-    /// `text` (a coordinate) with every `${name}` the build defines with
-    /// no profile active interpolated, an undefined one kept as written
-    /// ([`interpolate_lenient`]). What any profile (a declaration's own
-    /// included) makes of it is [`ScopedDep::coordinate_alternatives`]'
-    /// job, which every coordinate check weighs.
-    fn interpolate_coordinate(&self, text: &str) -> String {
-        interpolate_lenient(text, &|name| self.lookup(name, &[], true))
+    /// `text` (a coordinate of the declaration at `pos`) with every
+    /// `${name}` the build defines interpolated, reading the declaration's
+    /// own profile `<properties>` first when it sits in a profile (as its
+    /// version is: that profile is always active with it), an undefined
+    /// one kept as written ([`interpolate_lenient`]). What other profiles
+    /// make of it is [`Self::coordinate_alternatives`]' job, which every
+    /// coordinate check weighs.
+    fn interpolate_coordinate(&self, text: &str, pos: usize) -> String {
+        let own = self.own_profile(pos);
+        interpolate_lenient(text, &|name| self.lookup(name, &own, true))
     }
 
     /// Inside a plugin / deploy section (never project resolution).
@@ -556,12 +544,11 @@ fn inside(pos: usize, set: &[Element]) -> bool {
 pub(crate) struct ScopedDep {
     pub(crate) element: Element,
     /// `<groupId>` / `<artifactId>` with every `${prop}` the build defines
-    /// with no profile active (user properties, the project model, the
-    /// root `<properties>`) interpolated
-    /// ([`PomScope::interpolate_coordinate`]); an undefined one stays as
-    /// written, so [`may_name`] can tell it apart. What a profile (a
-    /// `<profiles>` declaration's own included) makes of them is
-    /// [`PomScope::coordinate_alternatives`]' job.
+    /// with no profile active but, for a `<profiles>` declaration, its own
+    /// (user properties, the project model, the root `<properties>`)
+    /// interpolated ([`PomScope::interpolate_coordinate`]); an undefined
+    /// one stays as written, so [`may_name`] can tell it apart. What other
+    /// profiles make of them is [`PomScope::coordinate_alternatives`]' job.
     pub(crate) group: Option<String>,
     pub(crate) artifact: Option<String>,
     /// The trimmed `<groupId>` / `<artifactId>` text as written.
@@ -591,10 +578,10 @@ impl PomScope {
                 element: dep,
                 group: group_text
                     .as_deref()
-                    .map(|g| self.interpolate_coordinate(g)),
+                    .map(|g| self.interpolate_coordinate(g, dep.start)),
                 artifact: artifact_text
                     .as_deref()
-                    .map(|a| self.interpolate_coordinate(a)),
+                    .map(|a| self.interpolate_coordinate(a, dep.start)),
                 group_text,
                 artifact_text,
                 version_inner: version.map(|v| {
@@ -1658,7 +1645,7 @@ mod tests {
             deps,
             [
                 (false, "org.a".to_string(), vec![pair("org.b", "x")]),
-                (true, "org.a".to_string(), vec![pair("org.b", "x")]),
+                (true, "org.b".to_string(), vec![]),
             ]
         );
     }
 
@@ -11085,6 +11085,22 @@ mod tests {
             let out = r.files.get("pom.xml").expect("pom rewritten");
             assert!(out.contains(MAVEN_SUFFIXED), "{deps}: pinned: {out}");
         }
+        // A profile declaration whose groupId only its own profile's
+        // `<properties>` define, as another group: it is read under its own
+        // profile, so it never names the GA, and the pin lands.
+        let own = format!(
+            "<project>\n  <dependencies>\n    {pinned}\n  </dependencies>\n  <profiles>\
+             <profile><id>p</id><properties><g>org.other</g></properties><dependencies>{}\
+             </dependencies></profile></profiles>\n</project>\n",
+            decl("${g}", "slf4j-api", "2.0")
+        );
+        let r = rewrite_registry_redirect(
+            &BTreeMap::from([("pom.xml".to_string(), own)]),
+            &[maven_override()],
+        );
+        assert!(warning_codes(&r).is_empty(), "{:?}", r.warnings);
+        let out = r.files.get("pom.xml").expect("pom rewritten");
+        assert!(out.contains(MAVEN_SUFFIXED), "pinned: {out}");
     }
 
     /// A versioned `<profiles>` declaration through an undefined coordinate
 
@@ -2274,7 +2274,7 @@ impl Reactor {
     /// coordinate, which no pin reaches: an executable one is warned about
     /// as `classifier_declared`, as `rewrite_declarations` does (`sources` /
     /// `javadoc` never run; `test-jar` is the `tests` copy), and any other
-    /// `<type>` but `jar` is not the g:a's jar. Text that can never
+    /// literal `<type>` but `jar` is not the g:a's jar (a `${…}` one may be). Text that can never
     /// read the g:a, whatever its properties say ([`may_interpolate_to`]),
     /// is ruled out first, before any inheritor or profile is read.
     fn warn_property_coordinates(
@@ -2312,9 +2312,10 @@ impl Reactor {
                     .is_some_and(|c| !is_executable_classifier(c))
                 || !may_interpolate_to(&g, patch.group_id)
                 || !may_interpolate_to(&a, patch.artifact_id)
+                // A `${…}` type may be `jar`, as discovery reads it.
                 || type_text
                     .as_deref()
-                    .is_some_and(|t| t != "jar" && t != "test-jar")
+                    .is_some_and(|t| t != "jar" && t != "test-jar" && !t.contains("${"))
             {
                 continue;
             }
@@ -6394,6 +6395,32 @@ mod tests {
             }
         }
 
+        // A `${…}` type may be `jar`, as discovery reads it: weighed too.
+        let typed = module(
+            "a",
+            &format!(
+                "{}{}",
+                dep("1.10.0"),
+                other("<version>1.9</version><type>${t}</type>")
+            ),
+        );
+        let files = fs(&[
+            (
+                "pom.xml",
+                &root_with(props, "<lib.group>org.apache.commons</lib.group>"),
+            ),
+            ("a/pom.xml", &typed),
+            ("b/pom.xml", &module("b", "")),
+        ]);
+        let plan = run(&files).unwrap();
+        assert_eq!(
+            reasons(&plan),
+            ["coordinates_overridden"],
+            "{:?}",
+            plan.warnings
+        );
+        assert!(!root_pinned(&plan, &files));
+
         // No version of its own: the pin applies, so the root stays pinned.
         let files = fs(&[
             (
 
@@ -2645,16 +2645,6 @@ mod tests {
                 vec![to_slf4j.clone()],
                 None,
             ),
-            // A profile declaration its own profile's properties retarget.
-            case(
-                h,
-                with(""),
-                vec![format!(
-                    "{to_slf4j}<dependencies>\n{}</dependencies>\n",
-                    other(Some("1.7.36"))
-                )],
-                None,
-            ),
             // Through a user property lower in the chain.
             case(
                 "<h>${corp}</h>",
@@ -2666,6 +2656,26 @@ mod tests {
         for c in &withheld {
             assert_coordinate_case(c, false).await;
         }
+        // A profile declaration its own profile's properties retarget: it
+        // is read under its own profile, so it is a profile declaration of
+        // the GA itself.
+        let own = property_project(
+            h,
+            &with(""),
+            &[&format!(
+                "{to_slf4j}<dependencies>\n{}</dependencies>\n",
+                other(Some("1.7.36"))
+            )],
+        );
+        let out = run(&own).await;
+        assert_refs(&out, &[(FX_PURL, UUID_A, WiringMode::Hosted)]);
+        let kinds: Vec<_> = out.unattested.iter().map(|u| u.kind).collect();
+        assert_eq!(
+            kinds,
+            [UnattestedKind::MavenProfileUnpatched],
+            "{:?}",
+            out.unattested
+        );
         let attested = [
             // No version of its own: the live pin applies.
             case(h, with(&other(None)), vec![to_slf4j.clone()], None),
@@ -2771,6 +2781,19 @@ mod tests {
                 vec![in_props("<x>org.other</x>")],
                 none.clone(),
             ),
+            // A profile declaration whose groupId only its own profile's
+            // `<properties>` define, as another group: whenever it is
+            // read, it names that group.
+            (
+                String::new(),
+                with(""),
+                vec![format!(
+                    "{}<dependencies>\n{}</dependencies>\n",
+                    in_props("<g>org.other</g>"),
+                    dep("${g}", "slf4j-api", Some("2.0"))
+                )],
+                none.clone(),
+            ),
         ] {
             assert_coordinate_case(&case, true).await;
         }