call it standalone

Author: KristofferC

base/client.jl

@@ -277,7 +277,7 @@ function exec_options(opts)
 
     if arg_is_program && PROGRAM_FILE != "-" && Base.active_project(false) === nothing
         script_path = abspath(PROGRAM_FILE)
-        Base.is_script(script_path) && Base.set_active_project(script_path)
+        Base.is_standalone_script(script_path) && Base.set_active_project(script_path)
     end
 
     # Load Distributed module only if any of the Distributed options have been specified.
@@ -347,12 +347,12 @@ function exec_options(opts)
                 include_string(Main, read(stdin, String), "stdin")
             else
                 abs_script_path = abspath(PROGRAM_FILE)
-                if is_script(abs_script_path)
-                    set_script_state(abs_script_path)
+                if is_standalone_script(abs_script_path)
+                    set_standalone_script_state(abs_script_path)
                     try
                         include(Main, PROGRAM_FILE)
                     finally
-                        global script_state_global = nothing
+                        global standalone_script_state_global = nothing
                     end
                 else
                     include(Main, PROGRAM_FILE)

base/initdefs.jl

@@ -288,8 +288,8 @@ function load_path_expand(env::AbstractString)::Union{String, Nothing}
             program_file = program_file != C_NULL ? unsafe_string(program_file) : nothing
             isnothing(program_file) && return nothing # User did not pass a script
 
-            # Check if the program file itself is a script first
-            if env == "@script" && Base.is_script(program_file)
+            # Check if the program file itself is a standalone script first
+            if env == "@script" && Base.is_standalone_script(program_file)
                 return abspath(program_file)
             end
 
@@ -333,7 +333,7 @@ load_path_expand(::Nothing) = nothing
     active_project()
 
 Return the path of the active project (either a `Project.toml` file or a julia
-file when using a [script](@ref scripts)).
+file when using a [standalone script](@ref standalone-scripts)).
 See also [`Base.set_active_project`](@ref).
 """
 function active_project(search_load_path::Bool=true)
@@ -364,7 +364,7 @@ end
     set_active_project(projfile::Union{AbstractString,Nothing})
 
 Set the active `Project.toml` file to `projfile`. The `projfile` can be a path to a traditional
-`Project.toml` file, a [script](@ref scripts) with inline metadata, or `nothing`
+`Project.toml` file, a [standalone script](@ref standalone-scripts) with inline metadata, or `nothing`
 to clear the active project. See also [`Base.active_project`](@ref).
 
 !!! compat "Julia 1.8"
@@ -386,7 +386,7 @@ end
     active_manifest(project_file::AbstractString)
 
 Return the path of the active manifest file, or the manifest file that would be used for a given `project_file`.
-When a [script](@ref scripts) is active, this returns the script path itself.
+When a [standalone script](@ref standalone-scripts) is active, this returns the script path itself.
 
 In a stacked environment (where multiple environments exist in the load path), this returns the manifest
 file for the primary (active) environment only, not the manifests from other environments in the stack.

base/loading.jl

@@ -323,36 +323,36 @@ function extract_inline_section(path::String, type::Symbol)
     end
 end
 
-function is_script(path::String)::Bool
+function is_standalone_script(path::String)::Bool
     for line in eachline(path)
         stripped = lstrip(line)
-        # Only whitespace and comments allowed before #!script
+        # Only whitespace and comments allowed before #!standalone
         if !isempty(stripped) && !startswith(stripped, '#')
             return false
         end
-        if startswith(stripped, "#!script")
+        if startswith(stripped, "#!standalone")
             return true
         end
     end
     return false
 end
 
 
-struct ScriptState
+struct StandaloneScriptState
     path::String
     pkg::PkgId
 end
 
-script_state_global::Union{ScriptState, Nothing} = nothing
+standalone_script_state_global::Union{StandaloneScriptState, Nothing} = nothing
 
-function set_script_state(abs_path::Union{Nothing, String})
+function set_standalone_script_state(abs_path::Union{Nothing, String})
     pkg = project_file_name_uuid(abs_path, splitext(basename(abs_path))[1])
 
     # Verify the project and manifest delimiters:
     parsed_toml(abs_path)
     parsed_toml(abs_path; manifest=true)
 
-    global script_state_global = ScriptState(abs_path, pkg)
+    global standalone_script_state_global = StandaloneScriptState(abs_path, pkg)
 end
 
 
@@ -385,7 +385,7 @@ function parsed_toml(toml_file::AbstractString, toml_cache::TOMLCache, toml_lock
                      manifest::Bool=false, project::Bool=!manifest)
     manifest && project && throw(ArgumentError("cannot request both project and manifest TOML"))
     lock(toml_lock) do
-        # Script?
+        # Standalone script?
         if endswith(toml_file, ".jl") && isfile_casesensitive(toml_file)
             kind = manifest ? :manifest : :project
             cache_key = "$(toml_file)::$(kind)"
@@ -451,8 +451,8 @@ Same as [`Base.identify_package`](@ref) except that the path to the environment
 is also returned, except when the identity is not identified.
 """
 function identify_package_env(where::Module, name::String)
-    if where === Main && script_state_global !== nothing
-        return identify_package_env(script_state_global.pkg, name)
+    if where === Main && standalone_script_state_global !== nothing
+        return identify_package_env(standalone_script_state_global.pkg, name)
     end
     return identify_package_env(PkgId(where), name)
 end
@@ -780,7 +780,12 @@ function env_project_file(env::String)::Union{Bool,String}
     elseif basename(env) in project_names && isfile_casesensitive(env)
         project_file = env
     elseif endswith(env, ".jl") && isfile_casesensitive(env)
-        project_file = is_script(env) ? env : false
+        if is_standalone_script(env)
+            project_file = env
+        end
+            #else
+        #    error("$env is missing #!standalone marker")
+        #end
     else
         project_file = false
     end
@@ -1038,7 +1043,7 @@ function project_file_manifest_path(project_file::String)::Union{Nothing,String}
         end
     end
     if manifest_path === nothing && endswith(project_file, ".jl") && has_file
-        # script: manifest is the same file as the project file
+        # standalone script: manifest is the same file as the project file
         manifest_path = project_file
     end
     if manifest_path === nothing

doc/src/manual/code-loading.md

@@ -397,13 +397,13 @@ are stored in the manifest file in the section for that package. The dependency
 a package are the same as for its "parent" except that the listed triggers are also considered as
 dependencies.
 
-### [Scripts](@id scripts)
+### [Standalone Scripts](@id standalone-scripts)
 
-Julia also understands *scripts* that can embed their own `Project.toml` (and optionally `Manifest.toml`) so they can be executed as self-contained environments. A script is identified by a `#!script` marker at the top of the file (only whitespace and comments may appear before it). The embedded project and manifest data are placed inside comment fences named `#!project` and `#!manifest`:
+Julia also understands *standalone scripts* that can embed their own `Project.toml` (and optionally `Manifest.toml`) so they can be executed as self-contained environments. A standalone script is identified by a `#!standalone` marker at the top of the file (only whitespace and comments may appear before it). The embedded project and manifest data are placed inside comment fences named `#!project` and `#!manifest`:
 
 ```julia
 #!/usr/bin/env julia
-#!script
+#!standalone
 
 using Markdown
 println(md"# Hello, single-file world!")
@@ -424,9 +424,9 @@ println(md"# Hello, single-file world!")
 #!manifest end
 ```
 
-Lines inside the fenced blocks should be commented with `#` (as in the example) or be plain TOML lines. The `#!script` marker must appear at the top of the file, with only whitespace and comments (including an optional shebang) allowed before it. The `#!project` and `#!manifest` sections can appear anywhere in the file (by convention at the bottom), but `#!project` must come before `#!manifest` if both are present.
+Lines inside the fenced blocks should be commented with `#` (as in the example) or be plain TOML lines. The `#!standalone` marker must appear at the top of the file, with only whitespace and comments (including an optional shebang) allowed before it. The `#!project` and `#!manifest` sections can appear anywhere in the file (by convention at the bottom), but `#!project` must come before `#!manifest` if both are present.
 
-Running `julia hello.jl` automatically activates the embedded project if the file contains a `#!script` marker. The dependency loading rules for such a script is the same as for a package with the same project and manifest file. The `--project=@script` flag also expands to the script itself if the `#!script` marker is present. Using `--project=script.jl` explicitly requires that the script contains the `#!script` marker.
+Running `julia hello.jl` automatically activates the embedded project if the file contains a `#!standalone` marker. The dependency loading rules for such a standalone script is the same as for a package with the same project and manifest file. The `--project=@script` flag also expands to the script itself if the `#!standalone` marker is present. Using `--project=script.jl` explicitly requires that the script contains the `#!standalone` marker.
 
 ### [Workspaces](@id workspaces)
 

test/loading.jl

@@ -1871,7 +1871,7 @@ module M58272_to end
 @eval M58272_to import ..M58272_1: M58272_2.y, x
 @test @eval M58272_to x === 1
 
-@testset "Scripts" begin
+@testset "Standalone Scripts" begin
     # Test with line-by-line comment syntax and path dependencies
     script = joinpath(@__DIR__, "project", "scripts", "script.jl")
     output = read(`$(Base.julia_cmd()) --startup-file=no $script`, String)
@@ -1893,14 +1893,14 @@ module M58272_to end
     @test occursin("✓ Random.rand()", output_cm)
     @test occursin("✓ All checks passed!", output_cm)
 
-    # Test @script behavior with script
+    # Test @script behavior with standalone script
     # When using --project=@script, it should use the script file as the project
     output_script = read(`$(Base.julia_cmd()) --startup-file=no --project=@script $script`, String)
     @test occursin("Active project: $script", output_script)
     @test occursin("Active manifest: $script", output_script)
     @test occursin("✓ Random (stdlib) loaded successfully", output_script)
 
-    # Test that regular Julia files (without #!script) can be set as active project
+    # Test that regular Julia files (without #!standalone) can be set as active project
     regular_script = joinpath(@__DIR__, "project", "scripts", "regular_script.jl")
 
     # Running the script with --project= should set it as active project
@@ -1921,7 +1921,7 @@ module M58272_to end
     @test !success(result)
     @test occursin("Package Rot13 not found in current path", String(take!(err_output)))
 
-    # Test 1: #!script marker not at top (has code before it) - runs as regular script
+    # Test 1: #!standalone marker not at top (has code before it) - runs as regular script
     invalid_project_not_first = joinpath(@__DIR__, "project", "scripts", "invalid_project_not_first.jl")
     result = run(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no $invalid_project_not_first`)))
     @test success(result)
@@ -1933,22 +1933,22 @@ module M58272_to end
     @test !success(result)
     @test occursin("#!manifest section must come after #!project section", String(take!(err_output)))
 
-    # Test 3: Code before #!script marker with --project - should error
+    # Test 3: Code before #!standalone marker with --project - should error
     invalid_both = joinpath(@__DIR__, "project", "scripts", "invalid_both.jl")
     err_output = IOBuffer()
     result = run(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no --project=$invalid_both -e "using Test"`), stderr=err_output))
     @test !success(result)
-    @test occursin("is missing #!script marker", String(take!(err_output)))
+    @test occursin("is missing #!standalone marker", String(take!(err_output)))
 
     # Test 4: Code between sections is now valid
     valid_code_between = joinpath(@__DIR__, "project", "scripts", "valid_code_between.jl")
     result = run(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no $valid_code_between`)))
     @test success(result)
 
-    # Test 5: Using --project on a non-script file errors when loading packages
+    # Test 5: Using --project on a non-standalone script file errors when loading packages
     regular_script = joinpath(@__DIR__, "project", "scripts", "regular_script.jl")
     err_output = IOBuffer()
     result = run(pipeline(ignorestatus(`$(Base.julia_cmd()) --startup-file=no --project=$regular_script -e "using Test"`), stderr=err_output))
     @test !success(result)
-    @test occursin("is missing #!script marker", String(take!(err_output)))
+    @test occursin("is missing #!standalone marker", String(take!(err_output)))
 end

test/project/scripts/invalid_both.jl

@@ -2,7 +2,7 @@ function foo()
     return 42
 end
 
-#!script
+#!standalone
 
 #!project begin
 #!project end

test/project/scripts/invalid_manifest_not_last.jl

@@ -1,4 +1,4 @@
-#!script
+#!standalone
 
 #!manifest begin
 # julia_version = "1.11.0"

test/project/scripts/invalid_project_not_first.jl

@@ -1,8 +1,8 @@
-# Some code before #!script marker
+# Some code before #!standalone marker
 
 x = 1
 
-#!script
+#!standalone
 
 #!project begin
 # name = "Test"

test/project/scripts/script.jl

@@ -1,5 +1,5 @@
 #!/usr/bin/env julia
-#!script
+#!standalone
 
 #!project begin
 # name = "PortableScriptTest"
@@ -15,7 +15,7 @@ using Random
 using Test
 using Rot13
 
-# Verify the script environment is active
+# Verify the standalone script environment is active
 println("Active project: ", Base.active_project())
 println("Active manifest: ", Base.active_manifest())
 println()

test/project/scripts/script_custom_manifest.jl

@@ -1,5 +1,5 @@
 #!/usr/bin/env julia
-#!script
+#!standalone
 
 #!project begin
 # name = "PortableScriptCustomManifestTest"