lumen_modules/

lib.rs

//! Runtime dependencies: the `[dependencies]` schema in `lumen.toml`, and
//! the loader that brings each declared library into the app at startup.
//!
//! One table declares two kinds, told apart at load by the symbols the file
//! exports (see [`loader`](crate::load_modules)):
//!
//! - An **engine-locked runtime module** is an ordinary
//!   [`lumen_core::app::Plugin`] built as a shared library that links the
//!   engine dynamically (`lumen-dylib`). The loader opens it, verifies it
//!   against the running engine, and calls its install entry, which
//!   registers real systems, components, and resources into the same ECS
//!   worlds the app runs on.
//! - A **portable plugin** is a C-ABI cdylib (`lumen-plugin`) exchanging
//!   serialized bytes: script functions, language preludes, and events. It
//!   needs no dynamic engine and loads into static hosts too.
//!
//! A module the binary was built with takes neither path. It has no file to
//! open, so its constructor put its install entry on the registry before
//! `main`, and the loader answers the declared name from there before it
//! looks for anything on disk. That arm works on every platform, needs no
//! shared engine, and skips both hazards below: the module is this build.
//!
//! Two hazards shape the engine-locked arm, and both are checked before any
//! Rust symbol is touched:
//!
//! - **Build skew.** Nothing detects a layout-changed rebuild naturally: the
//!   dynamic linker resolves happily and `TypeId` equality still passes while
//!   field reads are shifted. The only defense is the C-ABI probe
//!   (`lumen_module_probe_<name>`, spelled from the declared name), compared
//!   against the engine's own `lumen_dylib::BUILD_ID` for exact equality.
//! - **A second engine instance.** If the host process compiled the engine in
//!   (a plain `cargo` binary, a static bundle), dlopening a module maps
//!   `liblumen_engine` a second time; the probe strings would match while
//!   worlds and statics differ. The loader asks the running process for the
//!   engine's exported `lumen_engine_build_id` symbol first and refuses every
//!   module when it is absent.
//!
//! The failure policy is banner-and-continue: any load failure prints an
//! unmissable stderr banner naming the module, the reason, and every probed
//! path, and the app keeps booting without that module. One refusal speaks
//! quietly instead: a name that this build neither compiles in nor can open
//! beside a shared engine gets a single stderr line, because that is a
//! property of how the binary was put together, not a defect in the app. A
//! loaded library is never unloaded: the schedules hold
//! function pointers into it for as long as the app lives.
//!
//! ```toml
//! [dependencies]
//! lumen-audio = { bundled = true }
//! markdown-widgets = { version = "1.2", tags = ["markdown"] }
//! shape-tools = { path = "modules/shape-tools", config = { units = "mm" } }
//! ```
//!
//! The table is unordered, so load order is the sorted key order; declaring
//! order in the file carries no meaning.
//!
//! `tags` is how a module introduces markup when nothing installs it ahead
//! of the parse. A compile reads a web half's elements from its descriptor
//! and installs a module with no web half, which registers its own; for any
//! other module an element the language does not know is refused unless the
//! app said which module answers for it. See [`register_declared_tags`].

use std::collections::BTreeMap;
use std::path::PathBuf;

use serde::Deserialize;

pub mod addon;
pub mod language;
pub mod link_kit;

#[cfg(feature = "loader")]
mod loader;
#[cfg(feature = "loader")]
pub use loader::{
    InitEnv, LoadedKind, LoadedModule, LoadedModules, ModuleFailure, PortablePlugins, engine_dir,
    load_modules,
};

/// The C-ABI entry a portable plugin exports. One name for every plugin: a
/// portable plugin is opened, never linked in, so two of them never share a
/// symbol table.
pub const PLUGIN_ENTRY_SYMBOL: &str = "lumen_plugin_v1";

/// The prefix of the C-ABI probe an engine-locked module exports; the module's
/// declared name completes it. The probe returns the module's NUL-terminated
/// `BUILD_ID`, read before any Rust symbol is touched.
pub const PROBE_PREFIX: &str = "lumen_module_probe_";
/// The prefix of the Rust-ABI install entry, called only after the probe
/// matched exactly.
pub const INSTALL_PREFIX: &str = "lumen_module_install_";
/// The prefix of the registration entry every module exports, opened or
/// linked. Naming it on a link line is what pulls a module out of an archive
/// that nothing else references.
pub const REGISTER_PREFIX: &str = "lumen_module_register_";

/// One module's entry symbol: the prefix, then the declared name with every
/// character a symbol cannot carry replaced by `_`.
///
/// `lumen-module-macros` spells the same names at the module's compile time,
/// from the name its author passed to `lumen_module!`. The two spellings are
/// the contract between a module and the loader: a module declared under a
/// name it was not built with reads as a library exporting nothing. They live
/// here rather than beside the loader because a link kit spells them with no
/// loader in the build at all.
pub fn entry_symbol(prefix: &str, name: &str) -> String {
    let mut symbol = String::with_capacity(prefix.len() + name.len());
    symbol.push_str(prefix);
    symbol.extend(
        name.chars()
            .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' }),
    );
    symbol
}

/// `version`-source resolutions handed to the loader by the compiler, keyed
/// by module name.
///
/// The runtime never resolves a version itself - no semver, no registry, no
/// lock in its graph. `lumenc` asks `lpm` to resolve each `version`
/// requirement before the app builds, and hands the outcome in here: `Ok` is
/// the library file to open, `Err` is the reason resolution failed, which the
/// loader banners in place of its own probe. A module absent from the map
/// falls back to the loader's on-disk probe (the `modules/` directories a
/// build step stages into).
#[derive(Debug, Clone, Default)]
pub struct ResolvedModules(pub BTreeMap<String, Result<PathBuf, String>>);

// The candidate file names of a library, shared with every other loader that
// probes by name. The one copy lives beside the `[[plugins]]` path resolution
// in `lumen-plugin-abi`; the loader's on-disk probe and `lumenc package` both
// read this re-export.
pub use lumen_plugin_abi::config::library_spellings;

/// The markup tags the language itself owns, which no module may claim.
///
/// A module declaring `tags = ["button"]` would not add a tag, it would
/// quietly reinterpret one every app already writes, and whether it won
/// would depend on load order. Refusing the declaration is what keeps a
/// built-in tag meaning one thing.
///
/// The list is spelled here rather than imported because the parser sits
/// above this crate, not below it; `lumenc` owns a test that fails when the
/// two drift.
pub const RESERVED_TAGS: &[&str] = &[
    "a",
    "button",
    "checkbox",
    "column",
    "date-picker",
    "dialog",
    "div",
    "dropdown",
    "for",
    "if",
    "image",
    "input",
    "label",
    "menu",
    "menubar",
    "menuitem",
    "option",
    "overlay",
    "progress",
    "radio",
    "root",
    "row",
    "script",
    "scroll",
    "separator",
    "slider",
    "slot",
    "spacer",
    "switch",
    "tab",
    "tabs",
    "template",
    "textarea",
    "tile",
    "time-picker",
    "title-bar",
    "toggle",
    "tooltip",
];

/// The parsed `[dependencies]` table: one [`DepCfg`] per declared module,
/// sorted by name, which is the load order.
#[derive(Debug, Clone, Default, PartialEq)]
pub struct DependenciesCfg(pub Vec<DepCfg>);

impl DependenciesCfg {
    /// Every tag the table declares, in load order, deduplicated.
    ///
    /// Two modules may name the same tag; the parser only needs to know the
    /// tag exists, and which module answers for it is settled later by which
    /// one adopts the element.
    pub fn declared_tags(&self) -> Vec<&str> {
        let mut tags: Vec<&str> = Vec::new();
        for dep in &self.0 {
            for tag in &dep.tags {
                let tag = tag.as_str();
                if !tags.contains(&tag) {
                    tags.push(tag);
                }
            }
        }
        tags
    }
}

impl DependenciesCfg {
    /// This table with `overlay`'s entries laid over it: an entry `overlay`
    /// declares replaces the one of the same name here, whole, and the rest
    /// of both are kept. Sorted by name, which is the load order.
    ///
    /// This is how `[target.<name>.dependencies]` combines with
    /// `[dependencies]`, the same way cargo combines its target tables.
    #[must_use]
    pub fn merged(&self, overlay: &DependenciesCfg) -> DependenciesCfg {
        let mut deps: Vec<DepCfg> = self
            .0
            .iter()
            .filter(|dep| !overlay.0.iter().any(|o| o.name == dep.name))
            .cloned()
            .collect();
        deps.extend(overlay.0.iter().cloned());
        deps.sort_by(|a, b| a.name.cmp(&b.name));
        DependenciesCfg(deps)
    }
}

/// The kind of platform a build is for.
///
/// Every build is for exactly one, and it decides two things: which
/// `[target.<name>.dependencies]` table is laid over `[dependencies]`, and
/// which names a script's compile-time conditions are true for.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Target {
    /// A site, run by the browser runtime.
    Web,
    /// A desktop app: `lumenc run`, `build`, `bundle` and `package`.
    Desktop,
}

impl Target {
    /// Every target, in the order the tables are documented.
    pub const ALL: [Target; 2] = [Target::Web, Target::Desktop];

    /// The name `lumen.toml` writes it as: `[target.web]`, `[target.desktop]`.
    pub fn name(self) -> &'static str {
        match self {
            Target::Web => "web",
            Target::Desktop => "desktop",
        }
    }

    /// The names a script's compile-time conditions are true for, when a
    /// program is compiled for this target.
    ///
    /// This is the one place the set is written. The compile that honours a
    /// condition takes it from here, so a target that gains a name gains it
    /// everywhere at once.
    pub fn cfg_flags(self) -> &'static [&'static str] {
        match self {
            Target::Web => &["web"],
            Target::Desktop => &["desktop"],
        }
    }
}

impl std::fmt::Display for Target {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.name())
    }
}

/// The `[target]` table: what each target adds to the app's configuration.
#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct TargetTables {
    /// `[target.web]`.
    pub web: TargetCfg,
    /// `[target.desktop]`.
    pub desktop: TargetCfg,
}

impl TargetTables {
    /// The table for `target`.
    pub fn get(&self, target: Target) -> &TargetCfg {
        match target {
            Target::Web => &self.web,
            Target::Desktop => &self.desktop,
        }
    }

    /// The dependencies a build for `target` takes: `base` with that
    /// target's own table laid over it.
    pub fn dependencies_for(&self, base: &DependenciesCfg, target: Target) -> DependenciesCfg {
        base.merged(&self.get(target).dependencies)
    }
}

/// One `[target.<name>]` table.
#[derive(Debug, Clone, Default, PartialEq, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct TargetCfg {
    /// `[target.<name>.dependencies]`: entries of the same shape as
    /// `[dependencies]`, used only by a build for this target.
    pub dependencies: DependenciesCfg,
}

/// Publish the tags an app's `[dependencies]` table declares, so the markup
/// parser accepts them.
///
/// A module that answers for a tag registers it from its `Plugin::build`,
/// which is too late for a build that cannot install the module before it
/// parses, such as one whose library is not built yet. The `tags` key is the
/// declaration that works on every path, and this is what turns it into the
/// parser's answer. Call it after the config is read and before any
/// markup is parsed.
///
/// The registry is process-wide and holds what it is given for the life of
/// the process, which is the same shape a `#[derive(Widget)]` tag has always
/// had. Every tool that calls this handles one app per process, so nothing
/// today sees another app's tags; a process that compiled two apps would let
/// the second parse markup the first declared. That is a missed error rather
/// than a wrong artifact - the tag still resolves to nothing at run time -
/// but it is why scoping the registry per compile is worth doing before
/// anything compiles two apps at once.
pub fn register_declared_tags(deps: &DependenciesCfg) {
    for tag in deps.declared_tags() {
        lumen_widget::register_widget_tag_owned(tag);
    }
}

/// Publish the elements the add-ons `addons` answer for, so the markup parser
/// accepts them. The same registry [`register_declared_tags`] writes to: a
/// compile does not install a module that has a web half, so the descriptor
/// is what tells the parser the element exists.
pub fn register_addon_elements(addons: &[lumen_ir::addon::Addon]) {
    for element in addons.iter().flat_map(|addon| &addon.elements) {
        lumen_widget::register_widget_tag_owned(&element.tag);
    }
}

/// Check one declared tag name, or say why it is refused.
fn validate_tag(module: &str, tag: &str) -> Result<(), String> {
    if tag.is_empty() {
        return Err(format!(
            "dependency '{module}': a tag name must not be empty"
        ));
    }
    if !tag
        .chars()
        .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
    {
        return Err(format!(
            "dependency '{module}': tag '{tag}' must be lowercase letters, digits, and dashes"
        ));
    }
    if RESERVED_TAGS.contains(&tag) {
        return Err(format!(
            "dependency '{module}': tag '{tag}' is a built-in tag and cannot be declared by a \
             module"
        ));
    }
    Ok(())
}

/// One `[dependencies]` entry.
#[derive(Debug, Clone, PartialEq)]
pub struct DepCfg {
    /// Module name - the table key.
    pub name: String,
    /// Where the module's library comes from.
    pub source: ModuleSource,
    /// The module's own configuration, handed to it verbatim at install.
    pub config: toml::Table,
    /// Markup tags this module answers for, so the parser accepts them
    /// before anything is loaded.
    ///
    /// A compile that cannot install the module before it parses has only
    /// this to go on, so a tag such a module introduces has to be declared
    /// for the parse to accept it. Declaring a tag no module answers for
    /// costs an element that renders as an empty box.
    pub tags: Vec<String>,
}

/// Where one module's library comes from. A bare string value is shorthand
/// for [`ModuleSource::Version`].
#[derive(Debug, Clone, PartialEq)]
pub enum ModuleSource {
    /// Ships with the toolchain, beside the running engine.
    Bundled,
    /// A version requirement on a registry package, resolved by `lpm` before
    /// the app builds; the runtime never resolves or fetches one, it only
    /// loads a module already on disk.
    Version(String),
    /// A built library on disk, relative to the app directory unless
    /// absolute. Without an extension, the platform spellings are probed
    /// (`lib<m>.so`, `lib<m>.dylib`, `<m>.dll`, plus underscored variants
    /// for a hyphenated name).
    Path(String),
}

impl<'de> Deserialize<'de> for DependenciesCfg {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        // A BTreeMap so iteration - and therefore load order - is the sorted
        // key order, the only stable order an unordered TOML table has.
        let raw: BTreeMap<String, toml::Value> = BTreeMap::deserialize(deserializer)?;
        let mut deps = Vec::with_capacity(raw.len());
        for (name, value) in raw {
            deps.push(DepCfg::from_entry(name, value).map_err(serde::de::Error::custom)?);
        }
        Ok(DependenciesCfg(deps))
    }
}

impl DepCfg {
    /// Parse one `name = <value>` entry of the `[dependencies]` table.
    fn from_entry(name: String, value: toml::Value) -> Result<DepCfg, String> {
        if name.trim().is_empty() {
            return Err("dependencies: a module name must not be empty".to_string());
        }
        let table = match value {
            toml::Value::String(version) => {
                return Ok(DepCfg {
                    name,
                    source: ModuleSource::Version(version),
                    config: toml::Table::new(),
                    tags: Vec::new(),
                });
            }
            toml::Value::Table(t) => t,
            other => {
                return Err(format!(
                    "dependency '{name}': expected a version string or a table, got {other}"
                ));
            }
        };

        let mut bundled: Option<bool> = None;
        let mut version: Option<String> = None;
        let mut path: Option<String> = None;
        let mut config = toml::Table::new();
        let mut tags: Vec<String> = Vec::new();
        for (key, v) in table {
            match key.as_str() {
                "bundled" => match v.as_bool() {
                    Some(b) => bundled = Some(b),
                    None => {
                        return Err(format!("dependency '{name}': `bundled` must be a boolean"));
                    }
                },
                "version" => match v.as_str() {
                    Some(s) => version = Some(s.to_string()),
                    None => {
                        return Err(format!("dependency '{name}': `version` must be a string"));
                    }
                },
                "path" => match v.as_str() {
                    Some(s) => path = Some(s.to_string()),
                    None => return Err(format!("dependency '{name}': `path` must be a string")),
                },
                "config" => match v {
                    toml::Value::Table(t) => config = t,
                    _ => return Err(format!("dependency '{name}': `config` must be a table")),
                },
                "tags" => match v {
                    toml::Value::Array(items) => {
                        for item in items {
                            let Some(tag) = item.as_str() else {
                                return Err(format!(
                                    "dependency '{name}': `tags` must be an array of strings"
                                ));
                            };
                            validate_tag(&name, tag)?;
                            if !tags.iter().any(|t| t == tag) {
                                tags.push(tag.to_string());
                            }
                        }
                    }
                    _ => {
                        return Err(format!(
                            "dependency '{name}': `tags` must be an array of strings"
                        ));
                    }
                },
                "git" | "rev" | "registry" => {
                    return Err(format!(
                        "dependency '{name}': `{key}` sources are not supported yet; use \
                         `bundled`, `version`, or `path`"
                    ));
                }
                "permissions" => {
                    return Err(format!(
                        "dependency '{name}': capability declarations are not supported yet; a \
                         module is native code running in the app's process, the same trust \
                         model as [[hooks]]"
                    ));
                }
                other => {
                    return Err(format!(
                        "unknown key `{other}` in dependency '{name}': this key needs a newer \
                         toolchain"
                    ));
                }
            }
        }

        if bundled == Some(false) {
            return Err(format!(
                "dependency '{name}': `bundled = false` declares nothing; drop the key or set \
                 it to true"
            ));
        }
        let declared: Vec<&str> = [
            bundled.map(|_| "bundled"),
            version.as_ref().map(|_| "version"),
            path.as_ref().map(|_| "path"),
        ]
        .into_iter()
        .flatten()
        .collect();
        let source = match (bundled, version, path) {
            (Some(true), None, None) => ModuleSource::Bundled,
            (None, Some(v), None) => ModuleSource::Version(v),
            (None, None, Some(p)) => ModuleSource::Path(p),
            (None, None, None) => {
                return Err(format!(
                    "dependency '{name}': a source is required - `bundled`, `version`, or `path`"
                ));
            }
            _ => {
                return Err(format!(
                    "dependency '{name}': {} are {} sources; declare exactly one",
                    declared.join(" and "),
                    declared.len()
                ));
            }
        };
        Ok(DepCfg {
            name,
            source,
            config,
            tags,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn parse(doc: &str) -> Result<DependenciesCfg, String> {
        toml::from_str::<DependenciesCfg>(doc).map_err(|e| e.to_string())
    }

    #[test]
    fn a_target_prints_as_the_name_lumen_toml_writes() {
        for target in Target::ALL {
            assert_eq!(target.to_string(), target.name());
            assert_eq!(target.cfg_flags(), [target.name()]);
        }
    }

    #[test]
    fn a_bare_string_is_a_version() {
        let deps = parse("md = \"1.2\"\n").unwrap();
        assert_eq!(deps.0.len(), 1);
        assert_eq!(deps.0[0].name, "md");
        assert_eq!(deps.0[0].source, ModuleSource::Version("1.2".into()));
        assert!(deps.0[0].config.is_empty());
    }

    #[test]
    fn bundled_true_parses() {
        let deps = parse("fs = { bundled = true }\n").unwrap();
        assert_eq!(deps.0[0].source, ModuleSource::Bundled);
    }

    #[test]
    fn bundled_false_is_refused() {
        let err = parse("fs = { bundled = false }\n").unwrap_err();
        assert!(err.contains("declares nothing"), "{err}");
    }

    #[test]
    fn path_with_config_parses() {
        let deps =
            parse("shape = { path = \"modules/shape\", config = { units = \"mm\" } }\n").unwrap();
        assert_eq!(deps.0[0].source, ModuleSource::Path("modules/shape".into()));
        assert_eq!(
            deps.0[0].config.get("units").and_then(|v| v.as_str()),
            Some("mm")
        );
    }

    #[test]
    fn permissions_are_refused_with_the_trust_model() {
        let err = parse("x = { path = \"m\", permissions = [\"fs\"] }\n").unwrap_err();
        assert!(err.contains("capability declarations"), "{err}");
        assert!(err.contains("[[hooks]]"), "{err}");
    }

    #[test]
    fn reserved_sources_are_refused_with_the_reason() {
        for key in ["git", "rev", "registry"] {
            let err = parse(&format!("x = {{ {key} = \"v\" }}\n")).unwrap_err();
            assert!(err.contains("not supported yet"), "{key}: {err}");
        }
    }

    #[test]
    fn an_unknown_key_names_the_toolchain() {
        let err = parse("y = { path = \"m\", checksum = \"abc\" }\n").unwrap_err();
        assert!(
            err.contains("unknown key `checksum` in dependency 'y'"),
            "{err}"
        );
        assert!(err.contains("needs a newer toolchain"), "{err}");
    }

    #[test]
    fn two_sources_are_refused() {
        let err = parse("x = { path = \"m\", version = \"1\" }\n").unwrap_err();
        assert!(err.contains("declare exactly one"), "{err}");
    }

    #[test]
    fn no_source_is_refused() {
        let err = parse("x = { config = { a = 1 } }\n").unwrap_err();
        assert!(err.contains("a source is required"), "{err}");
    }

    #[test]
    fn tags_parse_and_deduplicate_in_load_order() {
        let deps = parse(
            "zeta = { bundled = true, tags = [\"gauge\", \"gauge\"] }\n\
             alpha = { bundled = true, tags = [\"spark-line\"] }\n",
        )
        .unwrap();
        assert_eq!(deps.declared_tags(), ["spark-line", "gauge"]);
    }

    #[test]
    fn a_dep_without_tags_declares_none() {
        let deps = parse("md = \"1.2\"\n").unwrap();
        assert!(deps.0[0].tags.is_empty());
        assert!(deps.declared_tags().is_empty());
    }

    #[test]
    fn tags_must_be_an_array_of_strings() {
        let err = parse("x = { bundled = true, tags = \"gauge\" }\n").unwrap_err();
        assert!(err.contains("array of strings"), "{err}");
        let err = parse("x = { bundled = true, tags = [1] }\n").unwrap_err();
        assert!(err.contains("array of strings"), "{err}");
    }

    #[test]
    fn a_tag_outside_the_allowed_characters_is_refused() {
        for bad in ["Gauge", "spark_line", "spark line", ""] {
            let err =
                parse(&format!("x = {{ bundled = true, tags = [\"{bad}\"] }}\n")).unwrap_err();
            assert!(
                err.contains("lowercase letters") || err.contains("must not be empty"),
                "{bad}: {err}"
            );
        }
    }

    #[test]
    fn a_built_in_tag_cannot_be_claimed() {
        let err = parse("x = { bundled = true, tags = [\"button\"] }\n").unwrap_err();
        assert!(err.contains("built-in tag"), "{err}");
    }

    fn targets(doc: &str) -> Result<(DependenciesCfg, TargetTables), String> {
        #[derive(Deserialize)]
        struct Doc {
            #[serde(default)]
            dependencies: DependenciesCfg,
            #[serde(default)]
            target: TargetTables,
        }
        let doc: Doc = toml::from_str(doc).map_err(|e| e.to_string())?;
        Ok((doc.dependencies, doc.target))
    }

    #[test]
    fn a_target_table_is_laid_over_the_shared_one() {
        let (base, tables) = targets(
            "[dependencies]\n\
             shared = { path = \"a\" }\n\
             both = { path = \"everywhere\" }\n\
             [target.web.dependencies]\n\
             both = { path = \"browser\" }\n\
             page-only = { path = \"p\" }\n\
             [target.desktop.dependencies]\n\
             window-only = { path = \"w\" }\n",
        )
        .unwrap();
        let web = tables.dependencies_for(&base, Target::Web);
        let names: Vec<&str> = web.0.iter().map(|d| d.name.as_str()).collect();
        assert_eq!(names, ["both", "page-only", "shared"]);
        assert_eq!(web.0[0].source, ModuleSource::Path("browser".into()));

        let desktop = tables.dependencies_for(&base, Target::Desktop);
        let names: Vec<&str> = desktop.0.iter().map(|d| d.name.as_str()).collect();
        assert_eq!(names, ["both", "shared", "window-only"]);
        assert_eq!(desktop.0[0].source, ModuleSource::Path("everywhere".into()));
    }

    #[test]
    fn a_target_lumen_does_not_build_for_is_refused() {
        let err = targets("[target.mobile.dependencies]\nx = \"1\"\n").unwrap_err();
        assert!(err.contains("unknown field `mobile`"), "{err}");
    }

    #[test]
    fn each_target_names_itself_as_its_condition() {
        assert_eq!(Target::Web.cfg_flags(), ["web"]);
        assert_eq!(Target::Desktop.cfg_flags(), ["desktop"]);
        for target in Target::ALL {
            assert!(target.cfg_flags().contains(&target.name()));
        }
    }

    #[test]
    fn load_order_is_sorted_by_name() {
        let deps = parse("zeta = \"1\"\nalpha = \"1\"\nmid = \"1\"\n").unwrap();
        let names: Vec<&str> = deps.0.iter().map(|d| d.name.as_str()).collect();
        assert_eq!(names, ["alpha", "mid", "zeta"]);
    }
}