lumen_runtime/run/

check.rs

use super::*;
use crate::app_layout::AppLayout;
use lumen_modules::language::{Form, LanguageTable, ScriptGrouping};
use lumen_script::{ScriptCompile, ScriptLanguages};

/// Summary returned by [`check_app`].
#[derive(Debug, Clone, Copy)]
pub struct CheckReport {
    /// Number of elements parsed (including root).
    pub element_count: usize,
    /// Whether the markup contained a non-empty `<script>` block.
    pub has_script: bool,
}

/// What a compile takes from outside the app directory: the target it builds
/// for, and what `lumenc` resolved for that target before it started.
///
/// The runtime resolves nothing itself, so a caller with no registry and no
/// add-on in reach passes [`CompileDeps::new`] and the compile reads the app
/// alone.
#[derive(Debug, Clone)]
pub struct CompileDeps {
    /// The target the program is compiled for: it decides which
    /// `[target.<name>.dependencies]` table applies, and the names a script's
    /// compile-time conditions are true for
    /// ([`lumen_modules::Target::cfg_flags`]).
    pub target: lumen_modules::Target,
    /// Script libraries the app imports, as the name a script imports under
    /// and the directory holding its sources.
    pub import_roots: Vec<(String, PathBuf)>,
    /// What the web halves of the modules the app depends on declare. A
    /// module's descriptor is its script surface on every target, so their
    /// functions are declared to the compile and their elements to the
    /// parser whatever the target, and the compiled app carries them. The
    /// functions are declared here and bound, at run time, to whatever the
    /// loaded module registers.
    pub addons: Vec<lumen_ir::addon::Addon>,
    /// What the modules with no web half register for scripts, read by
    /// installing each the way a run does ([`module_surface`]). Empty for a
    /// web build, which cannot take such a module.
    pub modules: ModuleSurface,
}

impl CompileDeps {
    /// A compile for `target` with nothing resolved from outside the app.
    pub fn new(target: lumen_modules::Target) -> Self {
        Self {
            target,
            import_roots: Vec::new(),
            addons: Vec::new(),
            modules: ModuleSurface::default(),
        }
    }
}

/// What a set of modules registers for scripts: the functions a program
/// calls them by, and the language sources compiled ahead of it.
///
/// Each function keeps its name, namespace and signature, and its body is
/// replaced by one that answers the zero of its declared return type (`0`,
/// `false`, the empty string, an empty list or map, null). A compile declares
/// the functions and a check runs the script's `main` once, so a call there
/// answers without doing the module's work.
#[derive(Debug, Clone, Default)]
pub struct ModuleSurface {
    /// The functions, in registration order.
    pub fns: Vec<lumen_script::ScriptFn>,
    /// The language sources, in registration order.
    pub preludes: Vec<lumen_script::ScriptPrelude>,
}

/// What the modules in `deps` register for scripts, read the way a run reads
/// it: each is installed into a scratch app, in headless mode, by the loader a
/// run uses, and its registrations are taken back out. A module compiled into
/// this binary answers from there, and any other is opened from disk, so the
/// surface is the one the app's run binds to.
///
/// `dir` is the app directory and `resolved` what the compiler resolved for
/// the `version` sources. A module that does not load prints the loader's
/// banner and registers nothing, so a call into it fails the compile that
/// follows.
#[cfg(feature = "modules")]
pub fn module_surface(
    dir: &Path,
    deps: &lumen_modules::DependenciesCfg,
    resolved: &lumen_modules::ResolvedModules,
) -> ModuleSurface {
    if deps.0.is_empty() {
        return ModuleSurface::default();
    }
    let app_id = crate::config::LumenToml::load_or_default(dir)
        .ok()
        .and_then(|cfg| cfg.app.id)
        .unwrap_or_else(|| lumen_capability::derive_app_id(dir));
    let mut app = App::new();
    app.world
        .insert_resource(lumen_core::app::RunMode { headless: true });
    let env = crate::modules::InitEnv {
        app_dir: dir.to_path_buf(),
        app_id,
        headless: true,
        hot_reload: false,
    };
    crate::modules::load_modules(&mut app, dir, deps, resolved, &env);
    let Some(registry) = app.world.get_resource::<lumen_script::ScriptFnRegistry>() else {
        return ModuleSurface::default();
    };
    ModuleSurface {
        fns: registry.fns().iter().map(answering_zero).collect(),
        preludes: registry.preludes().to_vec(),
    }
}

/// `f` with a body that answers the zero of its declared return type.
#[cfg(feature = "modules")]
fn answering_zero(f: &lumen_script::ScriptFn) -> lumen_script::ScriptFn {
    let zero = zero_of(&f.sig.ret);
    let mut declared = f.clone();
    declared.body = std::sync::Arc::new(move |_| Ok(zero.clone()));
    declared
}

/// The zero of a declared type.
#[cfg(feature = "modules")]
fn zero_of(ty: &lumen_script::ScriptTy) -> lumen_script::ScriptValue {
    use lumen_script::{ScriptTy, ScriptValue};
    match ty {
        ScriptTy::Bool => ScriptValue::Bool(false),
        ScriptTy::Int => ScriptValue::I64(0),
        ScriptTy::Float => ScriptValue::F64(0.0),
        ScriptTy::Str => ScriptValue::Str(String::new()),
        ScriptTy::Array(_) => ScriptValue::Array(Vec::new()),
        ScriptTy::Map(_) => ScriptValue::Map(Default::default()),
        ScriptTy::Struct(shape) => shape.default_value(),
        ScriptTy::Any | ScriptTy::Unit | ScriptTy::Dynamic => ScriptValue::Unit,
    }
}

/// The functions a compile declares: the add-ons' functions, bound to the
/// body every target without a page binds, and the modules' functions as
/// [`ModuleSurface`] holds them. A compiler declares them; nothing a run
/// registers comes from here, since a run binds the module's own.
#[cfg(feature = "runtime-parse")]
fn declared_fns(deps: &CompileDeps) -> Result<Vec<lumen_script::ScriptFn>, RunError> {
    let mut fns = addon_stubs(&deps.addons)?;
    fns.extend(deps.modules.fns.iter().cloned());
    Ok(fns)
}

/// The add-ons' functions alone, bound to the body every target without a
/// page binds.
#[cfg(feature = "runtime-parse")]
fn addon_stubs(addons: &[lumen_ir::addon::Addon]) -> Result<Vec<lumen_script::ScriptFn>, RunError> {
    let mut fns = Vec::new();
    for addon in addons {
        fns.extend(lumen_script::addon::browser_only_fns(addon, None).map_err(RunError::Script)?);
    }
    Ok(fns)
}

/// Ahead-of-time compile an app directory into a
/// [`lumen_ir::artifact::CompiledApp`]: parse markup + CSS once, run the full
/// cascade, resolve asset / include / import paths, and bake the combined
/// script source. The returned artifact is what `lumenc build` writes to
/// disk and what a parser-free runtime loads via [`RunOptions::artifact`].
///
/// This is the AOT counterpart to [`load_ir`]: same front-end work, on the
/// same discovered page set, but the result is serialized instead of spawned.
/// A multi-page app compiles whole - every page assembled into the one gated
/// tree the run path builds, plus the page set the routing needs. Requires the
/// source parser (`runtime-parse` feature).
///
/// What a script compiler warned about is added to `warnings`, one line each,
/// for the caller to print where it prints its own warnings.
#[cfg(feature = "runtime-parse")]
pub fn compile_app(
    dir: &Path,
    parser: &dyn SourceParser,
    plugins: &dyn crate::compiler_plugins::CompilerPlugins,
    deps: &CompileDeps,
    warnings: &mut Vec<String>,
) -> Result<lumen_ir::artifact::CompiledApp, RunError> {
    compile_app_with_skin(dir, parser, plugins, None, deps, warnings)
}

/// [`compile_app`] with the skin named outright instead of read from
/// `lumen.toml`.
///
/// One caller needs that: a site is built once and served to every OS, so it
/// cannot let `[skin] name = "auto"` resolve against whichever machine ran
/// the build. Everything else compiles an app for the machine it will run
/// on and calls [`compile_app`].
#[cfg(feature = "runtime-parse")]
pub fn compile_app_with_skin(
    dir: &Path,
    parser: &dyn SourceParser,
    plugins: &dyn crate::compiler_plugins::CompilerPlugins,
    skin: Option<&str>,
    deps: &CompileDeps,
    warnings: &mut Vec<String>,
) -> Result<lumen_ir::artifact::CompiledApp, RunError> {
    let cfg = crate::config::LumenToml::load_or_default(dir).map_err(RunError::Config)?;
    register_declared_tags(&cfg, &[deps.target], &deps.addons);
    let stubs = declared_fns(deps)?;
    let layout = AppLayout::resolve(dir, &cfg)?;
    // The same discovery the run path does, so compiling sees the app the way
    // running it does: the entry file it would open, and every sibling page.
    let plan = crate::pages::discover(&layout.src_dir, &cfg);
    let html_path = plan.entry_file.clone();
    let css_path = layout.css_path;
    let asset_roots = cfg.resolved_asset_roots(dir);
    let skin_override = skin.map(str::to_string).or_else(|| cfg.skin.name.clone());
    let table = language_table()?;
    let grouping = ScriptGrouping {
        table: &table,
        engine: cfg.script.engine(),
    };
    // The hosts that read the scripts' markup blocks and compile them: the
    // source-form provider of each language the markup names.
    let registered = language_hosts(
        dir,
        &table,
        &source_languages(parser, grouping, &html_path, None, Some(&plan)),
    );
    let loaded = load_ir(
        parser,
        plugins,
        &html_path,
        &css_path,
        dir,
        &asset_roots,
        skin_override.as_deref(),
        &lumen_ir::css::MediaContext::default(),
        SourceOverrides {
            plan: Some(&plan),
            ..SourceOverrides::default()
        },
        &Languages {
            grouping,
            registered: &registered,
        },
    )?;
    // Which language runs which part of the program, and which module runs
    // it in a shipped app, is decided here, at compile time, from the script
    // files' own extensions and the language descriptors. The runtime cannot
    // rediscover it later: a shipped app carries no script files to read.
    //
    // A language with a bytecode form compiles here, and its source is
    // dropped: a shipped app runs the image on a host with no compiler. The
    // others ship their source, run by the one module they have.
    let uri = html_path.display().to_string();
    let mut scripts = Vec::new();
    for script in grouped_script_sources(&loaded.ir, dir, grouping)? {
        let (language, source, source_map) = (script.language, script.source, script.map);
        let Some(shipped) = table.shipped_provider(&language) else {
            warnings.push(format!(
                "no script host module provides the `{language}` language, so its script \
                 will not run"
            ));
            scripts.push(lumen_ir::artifact::CompiledScript {
                engine: language,
                module: String::new(),
                source,
                bytecode: None,
                source_map,
            });
            continue;
        };
        let module = shipped.module.clone();
        if shipped.form != Form::Bytecode {
            scripts.push(lumen_ir::artifact::CompiledScript {
                engine: language,
                module,
                source,
                bytecode: None,
                source_map,
            });
            continue;
        }
        let compile = registered
            .get(&language)
            .and_then(|l| l.compile)
            .ok_or_else(|| {
                RunError::Script(format!(
                    "no compiler for the `{language}` language is loaded; its host module \
                     ({}) did not load",
                    table
                        .source_provider(&language)
                        .map_or("none in reach", |p| p.module.as_str())
                ))
            })?;
        let flags = deps.target.cfg_flags();
        let against = ScriptCompile {
            uri: &uri,
            source_map: &source_map,
            lib_dir: Some(&layout.lib_dir),
            import_roots: &deps.import_roots,
            cfg_flags: flags,
            fns: &stubs,
            preludes: &deps.modules.preludes,
        };
        let (image, raised) = compile(&source, &against).map_err(RunError::Script)?;
        warnings.extend(raised);
        scripts.push(lumen_ir::artifact::CompiledScript {
            engine: language,
            module,
            source: String::new(),
            bytecode: Some(image),
            source_map: Default::default(),
        });
    }
    // Routing data for a multi-page app. The pages themselves are already in
    // the tree, each behind its gate; this is the part the runtime would
    // otherwise rediscover by listing `.lmn` files.
    let pages = plan.multipage.then(|| lumen_ir::artifact::CompiledPages {
        entry: plan.entry_key.clone(),
        keys: plan.keys(),
    });
    let mut ir = loaded.ir;
    ir.script_source = String::new();
    ir.script_map = lumen_ir::source_map::SourceMap::default();
    ir.external_scripts.clear();
    // Every catalogue travels in the artifact, so an app compiled here reads
    // in its languages with no `locale/` directory beside it. A loose file
    // still wins where there is one. Each is parsed here, so a broken one
    // fails the build rather than the app.
    let fallback: Vec<String> = cfg
        .app
        .fallback_locale
        .iter()
        .map(ToString::to_string)
        .collect();
    let catalogues = lumen_i18n::read_catalogues(&super::locale_dir(dir), |p| std::fs::read(p))
        .and_then(|catalogues| {
            lumen_i18n::Catalogues::parse(&catalogues, &fallback).map(|_| catalogues)
        })
        .map_err(|e| RunError::I18n(e.to_string()))?;
    let i18n = lumen_ir::artifact::CompiledI18n {
        catalogues,
        fallback,
    };
    Ok(lumen_ir::artifact::CompiledApp {
        ir,
        scripts,
        pages,
        // Every fragment the app declares, whether or not this build
        // instantiates it: the artifact carries the declarations, not just
        // their expansions.
        fragments: loaded.fragments,
        i18n,
        addons: deps.addons.clone(),
        // Filled by `lumenc package`, which is what decides the engine an app
        // ships with; a compile alone links none.
        unlinked: Vec::new(),
    })
}

/// The language descriptors in reach, or the reason they disagree.
#[cfg(feature = "runtime-parse")]
fn language_table() -> Result<LanguageTable, RunError> {
    LanguageTable::discover(None).map_err(RunError::Script)
}

/// The languages registered by the source-form host modules of `languages`,
/// installed into a scratch app the way a run installs them. A module that
/// does not load prints the loader's banner and registers nothing.
#[cfg(all(feature = "runtime-parse", feature = "modules"))]
fn language_hosts(dir: &Path, table: &LanguageTable, languages: &[String]) -> ScriptLanguages {
    let modules: Vec<String> = languages
        .iter()
        .filter_map(|language| table.source_provider(language))
        .map(|provider| provider.module.clone())
        .collect();
    hosts_of(dir, &modules)
}

#[cfg(all(feature = "runtime-parse", not(feature = "modules")))]
fn language_hosts(_dir: &Path, _table: &LanguageTable, _languages: &[String]) -> ScriptLanguages {
    ScriptLanguages::default()
}

/// The languages the host modules `modules` register, read by installing
/// each into a scratch app in headless mode.
#[cfg(feature = "modules")]
fn hosts_of(dir: &Path, modules: &[String]) -> ScriptLanguages {
    if modules.is_empty() {
        return ScriptLanguages::default();
    }
    let mut app = App::new();
    app.world
        .insert_resource(lumen_core::app::RunMode { headless: true });
    let env = crate::modules::InitEnv {
        app_dir: dir.to_path_buf(),
        app_id: lumen_capability::derive_app_id(dir),
        headless: true,
        hot_reload: false,
    };
    let deps =
        lumen_modules::language::with_implied(&lumen_modules::DependenciesCfg::default(), modules);
    crate::modules::load_modules(
        &mut app,
        dir,
        &deps,
        &lumen_modules::ResolvedModules::default(),
        &env,
    );
    app.world
        .get_resource::<ScriptLanguages>()
        .cloned()
        .unwrap_or_default()
}

/// The names a compiled program can be called by.
///
/// `None` for a program with no ahead-of-time form, and for one whose
/// language has no host in reach that can read an image back: neither knows
/// what the program exports, and neither can say anything is missing from it.
///
/// A build tool asks this to tell a function the app calls by name from one
/// it will only appear to call: candela exports a function only when every
/// parameter it takes is annotated, and a shipped runtime carries no compiler
/// to fall back on.
///
/// `dir` is the app the program belongs to. `addons` are the browser add-ons
/// the app was compiled against; their functions are declared in the program,
/// so reading it back binds them too.
#[cfg(all(feature = "runtime-parse", feature = "modules"))]
#[must_use]
pub fn script_exports(
    dir: &Path,
    script: &lumen_ir::artifact::CompiledScript,
    addons: &[lumen_ir::addon::Addon],
) -> Option<Result<Vec<String>, String>> {
    let bytecode = script.bytecode.as_deref()?;
    if script.module.is_empty() {
        return None;
    }
    let hosts = hosts_of(dir, std::slice::from_ref(&script.module));
    let read = hosts.get(&script.engine)?.image_exports?;
    let fns = match addon_stubs(addons) {
        Ok(fns) => fns,
        Err(e) => return Some(Err(e.to_string())),
    };
    Some(read(bytecode, &fns))
}

/// Parse `<dir>/src/main.lmn` + optional `<dir>/src/main.css` and validate
/// them without spawning a window. Used by CI / pre-commit hooks.
///
/// Parse-time `LayoutIR.lint_findings` (an unknown attribute, a
/// boolean attribute with an off-list value, bare `{name}`
/// interpolation) are printed to stderr but never fail the build -
/// `check` validates AST shape, not style. Run
/// `lumenc lint --signals <dir>` for the full lint stream.
///
/// `check` is for no one target. `targets` holds what was resolved for each
/// target the app can be built for: the markup is checked once, accepting the
/// elements of every target's add-ons, and the scripts are compiled once per
/// target, each against that target's add-ons, script libraries and
/// `@cfg(...)` flags, so code written for one target is checked the way that
/// target's build compiles it.
///
/// Requires the source parser (`runtime-parse` feature).
#[cfg(feature = "runtime-parse")]
pub fn check_app(
    dir: &Path,
    parser: &dyn SourceParser,
    plugins: &dyn crate::compiler_plugins::CompilerPlugins,
    targets: &[CompileDeps],
) -> Result<CheckReport, RunError> {
    let cfg = crate::config::LumenToml::load_or_default(dir).map_err(RunError::Config)?;
    let mut every_addon: Vec<lumen_ir::addon::Addon> = Vec::new();
    for addon in targets.iter().flat_map(|deps| &deps.addons) {
        if !every_addon.iter().any(|a| a.name == addon.name) {
            every_addon.push(addon.clone());
        }
    }
    let every_target: Vec<lumen_modules::Target> = targets.iter().map(|deps| deps.target).collect();
    register_declared_tags(&cfg, &every_target, &every_addon);
    let layout = AppLayout::resolve(dir, &cfg)?;
    let roots = cfg.resolved_asset_roots(dir);
    // File-based pages: validate the whole assembled multi-page tree (entry +
    // grafted sibling pages + global templates), not just the entry file in
    // isolation - otherwise an entry that `<use>`s a shared `layout` template
    // would falsely fail `check`.
    let plan = crate::pages::discover(&layout.src_dir, &cfg);
    let entry_path = plan.entry_file.clone();
    let table = language_table()?;
    let grouping = ScriptGrouping {
        table: &table,
        engine: cfg.script.engine(),
    };
    let registered = language_hosts(
        dir,
        &table,
        &source_languages(parser, grouping, &entry_path, None, Some(&plan)),
    );
    let LoadResult { ir, .. } = load_ir(
        parser,
        plugins,
        &entry_path,
        &layout.css_path,
        dir,
        &roots,
        cfg.skin.name.as_deref(),
        &lumen_ir::css::MediaContext::default(),
        SourceOverrides {
            plan: Some(&plan),
            ..SourceOverrides::default()
        },
        &Languages {
            grouping,
            registered: &registered,
        },
    )?;
    // Parse-time lint findings already went to stderr from `load_ir`,
    // which every compile path shares.
    let has_script = !ir.script_source.trim().is_empty() || !ir.external_scripts.is_empty();
    // RC6: compile the app's scripts with the same engine settings
    // `lumenc run` uses. Compile-only - the top level is never evaluated, so
    // `check` stays side-effect free. A script that would die at load (parse
    // error, expression-depth overflow, ...) fails the check instead of
    // false-passing while `run` shows a window whose every handler is dead.
    //
    // Check each language's program with its own host's checker, on the
    // same grouping `build_app` runs: one language's checker false-fails on
    // another's syntax, so a mixed app checked as one blob could never pass.
    let uri = entry_path.display().to_string();
    for script in grouped_script_sources(&ir, dir, grouping)? {
        let (language, source) = (script.language, script.source);
        let Some(check) = registered.get(&language).and_then(|l| l.check) else {
            return Err(RunError::Script(format!(
                "{uri}: no script host for the `{language}` language is loaded to check its \
                 script with; install {}",
                table.source_provider(&language).map_or(
                    "a module that provides it".to_string(),
                    |p| format!("the `{}` module", p.module)
                )
            )));
        };
        check_per_target(check, &source, &uri, &script.map, &layout.lib_dir, targets)?;
    }
    Ok(CheckReport {
        element_count: count_elements(&ir.root),
        has_script,
    })
}

/// Compile-check a program once for each of `targets`, each against that
/// target's functions, script libraries, and compile-time conditions.
///
/// Where every target rejects the program the same way, the error is the
/// checker's own, as it is for an app with no target-specific code. Where
/// they disagree, the error names the target whose build it breaks.
#[cfg(feature = "runtime-parse")]
fn check_per_target(
    check: lumen_script::language::CheckFn,
    source: &str,
    uri: &str,
    source_map: &lumen_ir::source_map::SourceMap,
    lib_dir: &Path,
    targets: &[CompileDeps],
) -> Result<(), RunError> {
    let mut failures = Vec::new();
    for deps in targets {
        let stubs = declared_fns(deps)?;
        let against = ScriptCompile {
            uri,
            source_map,
            lib_dir: Some(lib_dir),
            import_roots: &deps.import_roots,
            cfg_flags: deps.target.cfg_flags(),
            fns: &stubs,
            preludes: &deps.modules.preludes,
        };
        if let Err(e) = check(source, &against) {
            failures.push((deps.target, e));
        }
    }
    let Some((target, first)) = failures.first() else {
        return Ok(());
    };
    let agree = failures.len() == targets.len() && failures.iter().all(|(_, e)| e == first);
    Err(RunError::Script(if agree {
        first.clone()
    } else {
        format!("{first} (in the {target} build)")
    }))
}

#[cfg(feature = "runtime-parse")]
fn count_elements(el: &Element) -> usize {
    1 + el.children.iter().map(count_elements).sum::<usize>()
}

/// Walk the IR and rewrite every `src` attribute on tags that load
/// assets (`<image>`) to be absolute, joining the path against the
/// app directory. Author-written relative paths then survive
/// arbitrary cwd shifts at run time.
///
/// Runs on the from-source load and on the artifact load alike, which is what
/// lets a packaged app carry paths relative to itself and still find its
/// files from whichever directory it was started in.
///
/// `dir` may be relative to the working directory, as it is when a user
/// types `lumenc build tracker`; it is made absolute first. A path joined
/// onto a relative `dir` would stay relative, and the artifact load would
/// then join `dir` onto it a second time.
pub(crate) fn resolve_asset_paths(el: &mut Element, dir: &Path, extra_roots: &[PathBuf]) {
    let dir = absolute_dir(dir);
    let extra_roots: Vec<PathBuf> = extra_roots.iter().map(|r| absolute_dir(r)).collect();
    resolve_asset_paths_under(el, &dir, &extra_roots);
}

/// `dir` made absolute against the working directory. A path the platform
/// cannot make absolute (an empty one, or a working directory that is gone)
/// is returned as given.
pub(crate) fn absolute_dir(dir: &Path) -> PathBuf {
    std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf())
}

fn resolve_asset_paths_under(el: &mut Element, dir: &Path, extra_roots: &[PathBuf]) {
    if el.tag == "image"
        && let Some(src) = &el.attrs.src
    {
        let p = Path::new(src);
        if p.is_relative() {
            // Prefer the app dir first; fall back to extra `asset_roots`
            // from lumen.toml in declared order. We only swap to an extra
            // root if a file actually exists there - keeps the default
            // path stable when no overrides are configured.
            let primary = dir.join(p);
            let resolved = if primary.exists() {
                primary
            } else {
                extra_roots
                    .iter()
                    .map(|r| r.join(p))
                    .find(|cand| cand.exists())
                    .unwrap_or(primary)
            };
            if let Some(s) = resolved.to_str() {
                el.attrs.src = Some(s.to_string());
            }
        }
    }
    for child in &mut el.children {
        resolve_asset_paths_under(child, dir, extra_roots);
    }
}

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

    fn image(src: &str) -> Element {
        Element {
            tag: "image".to_string(),
            attrs: Attributes {
                src: Some(src.to_string()),
                ..Default::default()
            },
            ..Default::default()
        }
    }

    /// A relative app directory still yields an absolute `src`, rooted at the
    /// working directory.
    #[test]
    fn a_relative_app_dir_resolves_to_an_absolute_src() {
        let mut el = image("icons/gear.png");
        resolve_asset_paths(&mut el, Path::new("tracker"), &[]);
        let expected = std::env::current_dir()
            .unwrap()
            .join("tracker")
            .join("icons/gear.png");
        assert_eq!(el.attrs.src.as_deref(), expected.to_str());
    }

    /// `lumenc build tracker` then `lumenc run --artifact ... tracker`: the
    /// compile resolves the path against `tracker`, and the artifact load
    /// resolves it against `tracker` again. The second pass must leave it
    /// alone rather than produce `tracker/tracker/icons/gear.png`.
    #[test]
    fn resolving_twice_against_a_relative_dir_does_not_double_it() {
        let mut el = image("icons/gear.png");
        resolve_asset_paths(&mut el, Path::new("tracker"), &[]);
        let once = el.attrs.src.clone();
        resolve_asset_paths(&mut el, Path::new("tracker"), &[]);
        assert_eq!(el.attrs.src, once);
        assert!(Path::new(el.attrs.src.as_deref().unwrap()).is_absolute());
    }
}