[GR-50397] [GR-50882] Update Native Image documentation.

PullRequest: graal/16260

Author: olyagpl

docs/reference-manual/embedding/embed-languages.md

@@ -30,12 +30,12 @@ The GraalVM Polyglot API lets you embed and run code from guest languages in JVM
 Throughout this section, you will learn how to create a host application in Java that runs on GraalVM and directly calls a guest language.
 You can use the tabs beneath each code example to choose between JavaScript, R, Ruby, and Python.
 
-> Note: The usage description for polyglot embeddings was revised with the GraalVM for JDK 21 (23.1.0) release. If you are still using an older GraalVM version, ensure the correct version of the documentation is displayed. More information on the change can be found in the [release notes](https://www.graalvm.org/release-notes/JDK_21/).
+> Note: The usage description for polyglot embeddings was revised with the GraalVM for JDK 21 (23.1.1) release. If you are still using an older GraalVM version, ensure the correct version of the documentation is displayed. More information on the change can be found in the [release notes](https://www.graalvm.org/release-notes/JDK_21/).
 
 
 ## Dependency Setup
 
-Since Polyglot version 23.1, all necessary artifacts can be downloaded directly from Maven Central.
+Since GraalVM Polyglot API version 23.1.0, all necessary artifacts can be downloaded directly from Maven Central.
 All artifacts relevant to embedders can be found in the Maven dependency group [`org.graalvm.polyglot`](https://central.sonatype.com/namespace/org.graalvm.polyglot).
 See the [polyglot embedding demonstration](https://github.com/graalvm/polyglot-embedding-demo) on GitHub for a complete runnable example.
 
@@ -45,32 +45,34 @@ Here is an example Maven dependency setup that you can put into your project:
 <dependency> 
 	<groupId>org.graalvm.polyglot</groupId> 
 	<artifactId>polyglot</artifactId> 
-	<version>23.1.0</version> 
+	<version>23.1.1</version> 
 </dependency>
 <dependency> 
 	<groupId>org.graalvm.polyglot</groupId> 
 	<!-- Select language: js, ruby, python, java, llvm, wasm, languages-->
 	<artifactId>js</artifactId> 
-	<version>23.1.0</version> 
+	<version>23.1.1</version> 
 	<type>pom</type>
 </dependency>
 <!-- add additional languages if needed -->
 <dependency> 
 	<groupId>org.graalvm.polyglot</groupId> 
 	<!-- Select tools: profiler, inspect, coverage, dap, tools -->
 	<artifactId>tools</artifactId> 
-	<version>23.1.0</version> 
+	<version>23.1.1</version> 
 	<type>pom</type>
 </dependency>
-<!-- add additional tools if needed -->
+<!-- add specific tools if needed -->
 ```
 
 Language and tool dependencies use the [GraalVM Free Terms and Conditions (GFTC)](https://www.oracle.com/downloads/licenses/graal-free-license.html) license
 To use community-licensed versions instead, add the `-community` suffix to each artifact (e.g., `js-community`).
 To access [polyglot isolate](#polyglot-isolates) artifacts, use the `-isolate` suffix instead (e.g. `js-isolate`).
 
-The artifacts `languages` and `tools` include all available languages and tools as dependencies. 
-This artifact might grow or shrink between major releases. We recommend selecting only the needed languages for a production deployment.
+The artifacts `polyglot` and `tools` include all available languages and tools as dependencies. 
+This artifact might grow or shrink between major releases. We recommend selecting only the needed language(s) for a production deployment.
+
+> The `pom` type is a requirement for language or tool dependencies.
 
 Additionally, your _module-info.java_ file should require `org.graalvm.polyglot` when using Java modules.
 
@@ -727,7 +729,7 @@ public class PolyglotIsolate {
 			  .allowHostAccess(HostAccess.SCOPED)
 			  .option("engine.SpawnIsolate", "true").build()) {
 			  
-			Value function = context.eval("js", "x => x+1")
+			Value function = context.eval("js", "x => x+1");
 			assert function.canExecute();
 			int x = function.execute(41).asInt();
 			assert x == 42;

docs/reference-manual/java-on-truffle/HotSwap.md

@@ -240,22 +240,22 @@ Download, unzip and open the project in your IDE.
 Before you proceed, make sure that you have Java on Truffle [installed](README.md#install-java-on-truffle) and set the GraalVM as the project SDK.
 
 1. In your IDE navigate to the root `build.gradle` within the sample project. Add:
-```groovy
-run.jvmArgs+="-truffle"
-```
+    ```
+    run.jvmArgs+="-truffle"
+    ```
 
 2. Also add maven local repository where we previously published the enhanced Micronaut framework. For example:
-```groovy
-repositories {
-  mavenLocal()
-  ...
-}
-```
+    ```
+    repositories {
+    mavenLocal()
+    ...
+    }
+    ```
 
 3. In `gradle.properties` update the Micronaut version that you published. For example:
-```groovy
-micronautVersion=2.5.8-SNAPSHOT
-```
+    ```
+    micronautVersion=2.5.8-SNAPSHOT
+    ```
 Now you are all setup.
 
 4. Execute`assemble` task and create a run configuration using the defined `run` gradle task.