diff --git a/closed/src/java.base/share/man/java.md b/closed/src/java.base/share/man/java.md
index 1f110c5bff..0b24ce73d8 100644
--- a/closed/src/java.base/share/man/java.md
+++ b/closed/src/java.base/share/man/java.md
@@ -29,7 +29,7 @@ or
 
 `java` \[*options*\] `--module` *module*\[`/`*mainclass*\] \[*args* ...\]
 
-To launch a source-file program:
+To launch a single source-file program:
 
 `java` \[*options*\] *source-file* \[*args* ...\]
 
@@ -60,9 +60,9 @@ To launch a source-file program:
     See [Standard Options for Java].
 
 *source-file*
-:   Only used to launch a source-file program. Specifies the source file
+:   Only used to launch a single source-file program. Specifies the source file
     that contains the main class when using source-file mode. See [Using
-    Source-File Mode to Launch Source-Code Programs]
+    Source-File Mode to Launch Single-File Source-Code Programs]
 
 *args* ...
 :   Optional: Arguments following *mainclass*, *source-file*, `-jar` *jarfile*,
@@ -80,7 +80,7 @@ The method declaration has the following form:
 >   `public static void main(String[] args)`
 
 In source-file mode, the `java` command can launch a class declared in a source
-file. See [Using Source-File Mode to Launch Source-Code Programs]
+file. See [Using Source-File Mode to Launch Single-File Source-Code Programs]
 for a description of using the source-file mode.
 
 > **Note:** You can use the `JDK_JAVA_OPTIONS` launcher environment variable to prepend its
@@ -103,7 +103,7 @@ Arguments after the class file name or the JAR file name are passed to the
 command prompt window to appear. The `javaw` launcher will, however, display a
 dialog box with error information if a launch fails.
 
-## Using Source-File Mode to Launch Source-Code Programs
+## Using Source-File Mode to Launch Single-File Source-Code Programs
 
 To launch a class declared in a source file, run the `java` launcher in
 source-file mode. Entering source-file mode is determined by two items on the
@@ -141,20 +141,20 @@ placed after the name of the source file in the original command line are
 passed to the compiled class when it is executed.
 
 For example, if a file were named `HelloWorld.java` and contained a class named
-`HelloWorld`, then the source-file mode command to launch the class would be:
+`hello.World`, then the source-file mode command to launch the class would be:
 
 >   `java HelloWorld.java`
 
-This use of source-file mode is informally equivalent to using the following two 
-commands:
+The example illustrates that the class can be in a named package, and does not
+need to be in the unnamed package. This use of source-file mode is informally
+equivalent to using the following two commands where `hello.World` is the name
+of the class in the package:
 
 ```
-javac -d <memory> --source-path <source-root> HelloWorld.java
-java --class-path <memory> HelloWorld
+javac -d <memory> HelloWorld.java
+java -cp <memory> hello.World
 ```
 
-where `<source-root>` is computed 
-
 **In source-file mode, any additional command-line options are processed as
 follows:**
 
@@ -177,19 +177,10 @@ follows:**
 **In source-file mode, compilation proceeds as follows:**
 
 -   Any command-line options that are relevant to the compilation environment
-    are taken into account. These include: `--class-path`/`-classpath`/`-cp`,
-    `--module-path`/`-p`, `--add-exports`, `--add-modules`, `--limit-modules`,
-    `--patch-module`, `--upgrade-module-path`, `--enable-preview`.
-
--   The root of the source tree, `<source-root>` is computed from the package
-    of the launched class. For example, if `HelloWorld.java` declared its classes
-    to be in the `hello` package, then the file `HelloWorld.java` is expected
-    to reside in the directory `somedir/hello/`. In this case, `somedir` is
-    computed to be the root of the source tree.
+    are taken into account.
 
--   The root of the source tree serves as the source-path for compilation, so that
-    other source files found in that tree and are needed by `HelloWorld` could be
-    compiled.
+-   No other source files are found and compiled, as if the source path is set
+    to an empty value.
 
 -   Annotation processing is disabled, as if `-proc:none` is in effect.
 
@@ -198,48 +189,43 @@ follows:**
     sets both the source version accepted by compiler and the system API that
     may be used by the code in the source file.
 
--   If a `module-info.java` file exists in the `<source-root>` directory, its 
-    module declaration is used to define a named module that will contain all 
-    the classes compiled from `.java` files in the source tree. If 
-    `module-info.java` does not exist, all the classes compiled from source files
-    will be compiled in the context of the unnamed module.
+-   The source file is compiled in the context of an unnamed module.
 
--   The source file that is launched should contain one or more top-level classes, the first of
+-   The source file should contain one or more top-level classes, the first of
     which is taken as the class to be executed.
 
--   For source file that is launched source file, the compiler does not enforce the optional restriction defined at the end
+-   The compiler does not enforce the optional restriction defined at the end
     of JLS 7.6, that a type in a named package should exist in a file whose
     name is composed from the type name followed by the `.java` extension.
 
--   If a source file contains errors, appropriate error messages are written
+-   If the source file contains errors, appropriate error messages are written
     to the standard error stream, and the launcher exits with a non-zero exit
     code.
 
 **In source-file mode, execution proceeds as follows:**
 
 -   The class to be executed is the first top-level class found in the source
-    file. It must contain a declaration of an entry `main` method.
+    file. It must contain a declaration of the standard
+    `public static void main(String[])` method.
 
 -   The compiled classes are loaded by a custom class loader, that delegates to
     the application class loader. This implies that classes appearing on the
-    application class path cannot refer to any classes declared in source files.
+    application class path cannot refer to any classes declared in the source
+    file.
 
--   If a `module-info.java` file exists in the `<source-root>` directory, then all 
-    the classes compiled from `.java` files in the source tree will be in that
-    module, which will serve as the root module for the execution of the program.
-    If `module-info.java` does not exist, the compiled classes are executed in the 
-    context of an unnamed module, as though `--add-modules=ALL-DEFAULT` is in effect. 
-    This is in addition to any other `--add-module` options that may be have been 
-    specified on the command line.
+-   The compiled classes are executed in the context of an unnamed module, as
+    though `--add-modules=ALL-DEFAULT` is in effect. This is in addition to any
+    other `--add-module` options that may be have been specified on the command
+    line.
 
 -   Any arguments appearing after the name of the file on the command line are
-    passed to the main method in the obvious way.
+    passed to the standard main method in the obvious way.
 
 -   It is an error if there is a class on the application class path whose name
     is the same as that of the class to be executed.
 
-See [JEP XXXXXX: Launch Multi-File Source-Code Programs](
-https://openjdk.org/jeps/XXXX) for complete details.
+See [JEP 330: Launch Single-File Source-Code Programs](
+https://openjdk.org/jeps/330) for complete details.
 
 ## Using the JDK\_JAVA\_OPTIONS Launcher Environment Variable
 
