Method resolve_module_source

src/compilation_pipeline.rs:388–451

(
        &self,
        path: &str,
        base_source_path: Option<&Path>,
    )

                raw_path.to_path_buf()
            } else {
                let base_dir = base_source_path
                    .and_then(Path::parent)
                    .map(Path::to_path_buf)
                    .unwrap_or_else(|| PathBuf::from("."));
                base_dir.join(raw_path)
            };

            // Prefer the embedded table so bundled programs resolve identically on every
            // platform (the browser cannot canonicalize); the virtual source_path re-derives.
            let normalized = normalize_lexical(&candidate);
            if let Some(key) = programs_key(&normalized)
                && let Some(source) = crate::userspace::source_by_path(&key)
            {
                return Ok(Some(ResolvedModuleSource {
                    source: source.to_owned(),
                    source_path: Some(PathBuf::from(&key)),
                    key,
                    is_stdlib: false,
                }));
            }

            // Native fallback: raw on-disk paths outside the bundled `programs/` tree.
            let canonical = candidate.canonicalize().map_err(|err| {
                format!(
                    "cannot resolve import(\"{path}\") from `{}`: {err}",
                    base_source_path
                        .map(|p| p.display().to_string())
                        .unwrap_or_else(|| ".".to_owned())
                )
            })?;
            let source = fs::read_to_string(&canonical).map_err(|err| {
                format!(
                    "cannot read import(\"{path}\") at `{}`: {err}",
                    canonical.display()
                )
            })?;
            return Ok(Some(ResolvedModuleSource {
                key: canonical.display().to_string(),
                source,
                source_path: Some(canonical),
                is_stdlib: false,
            }));
        }

        let key = Self::module_key(path);
        Ok(self
            .resolve_registry_module_source(key)
            .map(|source| ResolvedModuleSource {
                key: key.to_owned(),
                source,
                // A registry module keeps its repo-relative path so its compiled
                // line table (and the debugger) can point at the real file.
                source_path: self.registry_module_path(key).map(PathBuf::from),
                is_stdlib: self.is_stdlib_module_for_target(key),
            }))
    }

    fn registry_module_path(&self, key: &str) -> Option<&'static str> {