Restore global/local import distinction and known-module auto-download

Global `import` is once again only accepted for known modules; local-only
modules require `local import`. Known modules absent locally are downloaded
into the user data directory, mirroring the Haskell `loadModule`/`findLoad`
behaviour.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: luispedro

ChangeLog

@@ -23,6 +23,11 @@ Version 1.6.0-beta2 2026-07-04 by luispedro
 	* External module commands now see `NGLESS_NR_CORES` set to the configured
 	worker thread count (`--jobs`/`--threads`, or the `batch` scheduler's
 	allotment) instead of a hard-coded 1.
+	* Restored the distinction between global and local module imports. A plain
+	`import` is again only accepted for known modules (`igc`, `om-rgc`, `motus`,
+	the gut-catalog modules, ...); importing a local-only module now requires
+	`local import`. Known modules that are not present locally are auto-downloaded
+	again.
 	* Removed the deprecated `strand` argument to `count()`; use `sense`
 	(`{both}`/`{sense}`/`{antisense}`) instead. `strand=True` is equivalent to
 	`sense={sense}`.

src/cli.rs

@@ -930,6 +930,22 @@ fn run_script(opts: &RunOpts) -> NgResult<i32> {
                 extra_funcs.extend(fs)
             }
             None => {
+                // A plain (global) `import` is only allowed for known modules; local-only modules
+                // must be brought in with `local import` (mirrors `loadModule`'s `isGlobalImport`
+                // gate in `NGLess/ExternalModules.hs`).
+                if matches!(m, crate::ast::ModInfo::Import { .. })
+                    && !crate::external_modules::is_known_module(m.name())
+                {
+                    let suggestion = crate::suggestion::suggestion_message(
+                        m.name(),
+                        crate::external_modules::KNOWN_MODULES,
+                    );
+                    return Err(NgError::script(format!(
+                        "Module '{}' is not known.\n\t{suggestion}\n\tTo import local modules, use \
+                         \"local import\"",
+                        m.name(),
+                    )));
+                }
                 let em = crate::external_modules::find_load(
                     m.name(),
                     m.version(),

src/external_modules.rs

@@ -642,8 +642,74 @@ pub fn module_env(module_dir: &Path, temp_dir: &Path) -> Vec<(String, String)> {
     env
 }
 
+/// Modules that NGLess knows how to fetch from the download server (mirrors `knownModules` in
+/// `NGLess/Modules.hs`). A plain (global) `import` is only allowed for these; any other name must be
+/// brought in with `local import`. When one of these is requested but not present locally,
+/// `find_load` auto-downloads it.
+pub const KNOWN_MODULES: &[&str] = &[
+    "example-cmd",
+    "gmgc",
+    "igc",
+    "om-rgc",
+    "DogGutCatalog",
+    "MouseGutCatalog",
+    "PigGutCatalog",
+    "specI",
+    "motus",
+];
+
+/// Whether `name` is a known (downloadable, globally importable) module.
+pub fn is_known_module(name: &str) -> bool {
+    KNOWN_MODULES.contains(&name)
+}
+
+/// Download a known external module into the user data directory (mirrors `downloadModule`). Returns
+/// the module directory (`<user-data>/Modules/<name>.ngm/<version>`).
+fn download_module(name: &str, version: &str) -> NgResult<PathBuf> {
+    let data_dir = crate::reference::user_data_directory().ok_or_else(|| {
+        NgError::new(
+            NgErrorType::SystemError,
+            format!("Cannot download module '{name}': no user data directory is configured."),
+        )
+    })?;
+    let nameversion = Path::new(&format!("{name}.ngm")).join(version);
+    let destdir = data_dir.join("Modules").join(&nameversion);
+    let base_url = crate::reference::download_base_url();
+    let url = format!(
+        "{}/Modules/{}.tar.gz",
+        base_url.trim_end_matches('/'),
+        nameversion.to_string_lossy()
+    );
+    crate::reference::download_expand_tar(&url, &data_dir)?;
+    Ok(destdir)
+}
+
+/// Load a module from a directory containing `module.yaml`, checking the version is compatible.
+fn load_from_dir(name: &str, version: &str, dir: PathBuf) -> NgResult<ExternalModule> {
+    let yaml = dir.join("module.yaml");
+    let text = std::fs::read_to_string(&yaml).map_err(|e| {
+        NgError::new(
+            NgErrorType::SystemError,
+            format!("Could not read module file {}: {e}", yaml.display()),
+        )
+    })?;
+    let raw: RawModule = serde_yaml::from_str(&text).map_err(|e| {
+        NgError::new(
+            NgErrorType::SystemError,
+            format!(
+                "Could not load module file {}. Error was `{e}`",
+                yaml.display()
+            ),
+        )
+    })?;
+    let module = ExternalModule::from_raw(raw, dir)?;
+    check_compatible(name, version, &module)?;
+    Ok(module)
+}
+
 /// Find and load an external module (mirrors `findLoad`). Searches the current directory, then the
-/// global and user data directories, for `Modules/<name>.ngm/<version>/module.yaml`.
+/// global and user data directories, for `Modules/<name>.ngm/<version>/module.yaml`. If the module
+/// is not found locally but is a [`known module`](KNOWN_MODULES), it is downloaded first.
 pub fn find_load(name: &str, version: &str, data_dirs: &[String]) -> NgResult<ExternalModule> {
     let modpath = Path::new("Modules")
         .join(format!("{name}.ngm"))
@@ -663,26 +729,15 @@ pub fn find_load(name: &str, version: &str, data_dirs: &[String]) -> NgResult<Ex
         );
         searched.push(yaml.clone());
         if yaml.is_file() {
-            let text = std::fs::read_to_string(&yaml).map_err(|e| {
-                NgError::new(
-                    NgErrorType::SystemError,
-                    format!("Could not read module file {}: {e}", yaml.display()),
-                )
-            })?;
-            let raw: RawModule = serde_yaml::from_str(&text).map_err(|e| {
-                NgError::new(
-                    NgErrorType::SystemError,
-                    format!(
-                        "Could not load module file {}. Error was `{e}`",
-                        yaml.display()
-                    ),
-                )
-            })?;
-            let module = ExternalModule::from_raw(raw, dir)?;
-            check_compatible(name, version, &module)?;
-            return Ok(module);
+            return load_from_dir(name, version, dir);
         }
     }
+    // Not found locally: a known module is downloaded into the user data directory and loaded from
+    // there (mirrors `findLoad`'s `downloadModule` fallback).
+    if is_known_module(name) {
+        let dir = download_module(name, version)?;
+        return load_from_dir(name, version, dir);
+    }
     let locations = searched
         .iter()
         .map(|p| format!("\t{}", p.display()))

src/reference.rs

@@ -649,7 +649,7 @@ fn write_targz(oname: &str, entries: &[(PathBuf, String)]) -> NgResult<()> {
 /// The user data directory (mirrors `nConfUserDataDirectory`): defaults to
 /// `$XDG_DATA_HOME/ngless/data` or `$HOME/.local/share/ngless/data`, overridable via the
 /// `user-data-directory` config key.
-fn user_data_directory() -> Option<PathBuf> {
+pub fn user_data_directory() -> Option<PathBuf> {
     let dir = &crate::configuration::global().user_data_directory;
     if dir.is_empty() {
         None