msri 0.2.3__tar.gz → 0.2.4__tar.gz

{msri-0.2.3 → msri-0.2.4}/Cargo.lock

@@ -107,7 +107,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -118,7 +118,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -159,9 +159,9 @@ checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
 name = "autocfg"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
 [[package]]
 name = "aws-lc-rs"
@@ -351,7 +351,7 @@ dependencies = [
  "maybe-owned",
  "rustix",
  "rustix-linux-procfs",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
  "winx",
 ]
 
@@ -624,6 +624,15 @@ dependencies = [
  "parking_lot_core",
 ]
 
+[[package]]
+name = "defmt"
+version = "0.3.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4deef977660e373c458df605a913d4ab121db0ccd18d1ad6976dff7d37cddb53"
+dependencies = [
+ "defmt 1.1.1",
+]
+
 [[package]]
 name = "defmt"
 version = "1.1.1"
@@ -771,15 +780,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "faster-hex"
-version = "0.10.0"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73"
+checksum = "04839bdf9d8c10f66806fad16b852fc72aab80873aebc3cb69d85b4fa41543ed"
 dependencies = [
+ "autocfg",
+ "defmt 0.3.101",
  "heapless",
  "serde",
 ]
@@ -2236,7 +2247,7 @@ version = "0.2.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc"
 dependencies = [
- "defmt",
+ "defmt 1.1.1",
  "jiff-core",
  "jiff-static",
  "jiff-tzdb-platform",
@@ -2253,7 +2264,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09"
 dependencies = [
- "defmt",
+ "defmt 1.1.1",
 ]
 
 [[package]]
@@ -2506,9 +2517,9 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.1.1"
+version = "1.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+checksum = "1788edb87fdc09c7e26304471e2f5be8cdefb1b6930d6e3985fc02ff53bf86ee"
 dependencies = [
  "libc",
  "wasi",
@@ -2517,7 +2528,7 @@ dependencies = [
 
 [[package]]
 name = "missouri"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "assert_cmd",
  "bollard",
@@ -2779,9 +2790,9 @@ dependencies = [
 
 [[package]]
 name = "pulldown-cmark"
-version = "0.13.4"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9f068eba8e7071c5f9511831b44f32c740d5adf574e990f946ddb53db2f314e"
+checksum = "278e9268c93b9e498a2da46c34d90ba93a3255eb99009646398f34bc73ab36eb"
 dependencies = [
  "bitflags 2.11.0",
  "memchr",
@@ -2810,9 +2821,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.17"
+version = "0.11.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04759210543be93709136e28212294a659ef5001836ff4eab4d663e4529bba83"
+checksum = "0e750cca55fe4f0439a15d0bb529da9651e79993e8e72c61a899a36d462befbe"
 dependencies = [
  "aws-lc-rs",
  "bytes",
@@ -2842,7 +2853,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3055,7 +3066,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3070,9 +3081,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.43"
+version = "0.23.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06"
+checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf"
 dependencies = [
  "aws-lc-rs",
  "once_cell",
@@ -3122,7 +3133,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3133,9 +3144,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.14"
+version = "0.103.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0527518605e68109d875e248ea259b6758801cf165e4b2c2733ae3b51f12535a"
+checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -3398,7 +3409,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -3503,7 +3514,7 @@ dependencies = [
  "getrandom 0.4.1",
  "once_cell",
  "rustix",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3618,9 +3629,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.50.0"
+version = "1.54.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
+checksum = "b52fd3255258d26fac7264ab5a76b53c13367136dc011d3d6ad4f8ed070396a3"
 dependencies = [
  "bytes",
  "libc",
@@ -4007,9 +4018,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-root-certs"
-version = "1.0.9"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
+checksum = "e49d0e65abc00c142e8f9428da991da9f1a250c39be97459901eb12b9b49f62a"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -4036,7 +4047,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]

{msri-0.2.3 → msri-0.2.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "missouri"
-version = "0.2.3"
+version = "0.2.4"
 edition = "2024"
 # 1.88, read from the dependency graph rather than from the edition.
 # Edition 2024 needs 1.85, and a locked dependency here asks for 1.88.

{msri-0.2.3 → msri-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: msri
-Version: 0.2.3
+Version: 0.2.4
 License-File: LICENSE
 Summary: Show-me-state: e2e testing as directed graphs of filesystem states
 Home-Page: https://github.com/cjohnhanson/missouri
@@ -59,8 +59,8 @@ environment variable from the host. Declare every variable a test needs
 in the test config. The test then behaves the same on your machine and in
 CI.
 
-For stronger isolation, missouri also runs a command inside a nix shell
-or a Docker container.
+A `packages` list gives each command programs from nixpkgs. With
+`docker: true`, missouri runs a command inside a Docker container.
 
 ## Beyond filesystem diffs
 
@@ -72,42 +72,50 @@ running. An agent assertion hands a judgment call to an LLM.
 
 ## Install
 
-The package is `msri` on PyPI and npm, because `missouri` was taken. On
-npm it carries the scope, `@cjohnhanson/msri`, because the registry
-refuses `msri` as too close to names it already holds. The command is
-`missouri` everywhere, and both names install together.
+The command is `missouri`, whichever package you install.
 
-```sh
-cargo install --locked missouri
-brew install cjohnhanson/tap/missouri
-uv tool install msri
-npm install -g @cjohnhanson/msri
-```
+**[Archives of precompiled binaries are available for macOS and
+Linux.](https://github.com/cjohnhanson/missouri/releases)** The Linux
+binaries are static executables. Each archive holds the binary, its man
+pages, the README and the licence. There is no Windows build.
 
-`cargo install` builds from source. It needs Rust 1.88 and a C
-compiler. The other three carry a prebuilt binary for macOS and Linux,
-x86-64 and arm64, published by a tagged release.
+| Package manager | Package | Command |
+| --- | --- | --- |
+| [Homebrew](https://brew.sh) | [cjohnhanson/tap/missouri](https://github.com/cjohnhanson/homebrew-tap) | `brew install cjohnhanson/tap/missouri` |
+| [Cargo](https://doc.rust-lang.org/cargo/) | [missouri](https://crates.io/crates/missouri) | `cargo install --locked missouri` |
+| [uv](https://docs.astral.sh/uv/) | [msri](https://pypi.org/project/msri/) | `uv tool install msri` |
+| [npm](https://www.npmjs.com) | [@cjohnhanson/msri](https://www.npmjs.com/package/@cjohnhanson/msri) | `npm install -g @cjohnhanson/msri` |
 
-To build the unreleased `main` branch:
+On Debian or Ubuntu, download the `.deb` from the [releases
+page](https://github.com/cjohnhanson/missouri/releases) and install it:
 
-```sh
-cargo install --locked --git https://github.com/cjohnhanson/missouri
+```
+wget https://github.com/cjohnhanson/missouri/releases/download/v0.2.3/missouri_0.2.3-1_amd64.deb
+sudo dpkg -i missouri_0.2.3-1_amd64.deb
 ```
 
-Or run it without installing:
+To run it once without installing anything:
 
-```sh
+```
 uvx msri run
 npx @cjohnhanson/msri run
 ```
 
-From that point the [releases
-page](https://github.com/cjohnhanson/missouri/releases) also carries
-prebuilt archives and a `.deb`. Each archive holds the binary and the man
-page. Install a `.deb` with `dpkg -i`: it
-is a file, not a repository, so `apt-get install` does not reach it.
+### Building
+
+missouri is written in Rust, so you need a [Rust
+installation](https://www.rust-lang.org/) to compile it. missouri
+compiles with Rust 1.88 or newer. A C compiler is needed as well, which
+`aws-lc-sys` uses for its cryptography.
 
-Check the install with `missouri --version`.
+To build missouri:
+
+```
+git clone https://github.com/cjohnhanson/missouri
+cd missouri
+cargo build --release
+./target/release/missouri --version
+```
 
 ## Usage
 

{msri-0.2.3 → msri-0.2.4}/README.md

@@ -49,8 +49,8 @@ environment variable from the host. Declare every variable a test needs
 in the test config. The test then behaves the same on your machine and in
 CI.
 
-For stronger isolation, missouri also runs a command inside a nix shell
-or a Docker container.
+A `packages` list gives each command programs from nixpkgs. With
+`docker: true`, missouri runs a command inside a Docker container.
 
 ## Beyond filesystem diffs
 
@@ -62,42 +62,50 @@ running. An agent assertion hands a judgment call to an LLM.
 
 ## Install
 
-The package is `msri` on PyPI and npm, because `missouri` was taken. On
-npm it carries the scope, `@cjohnhanson/msri`, because the registry
-refuses `msri` as too close to names it already holds. The command is
-`missouri` everywhere, and both names install together.
+The command is `missouri`, whichever package you install.
 
-```sh
-cargo install --locked missouri
-brew install cjohnhanson/tap/missouri
-uv tool install msri
-npm install -g @cjohnhanson/msri
-```
+**[Archives of precompiled binaries are available for macOS and
+Linux.](https://github.com/cjohnhanson/missouri/releases)** The Linux
+binaries are static executables. Each archive holds the binary, its man
+pages, the README and the licence. There is no Windows build.
 
-`cargo install` builds from source. It needs Rust 1.88 and a C
-compiler. The other three carry a prebuilt binary for macOS and Linux,
-x86-64 and arm64, published by a tagged release.
+| Package manager | Package | Command |
+| --- | --- | --- |
+| [Homebrew](https://brew.sh) | [cjohnhanson/tap/missouri](https://github.com/cjohnhanson/homebrew-tap) | `brew install cjohnhanson/tap/missouri` |
+| [Cargo](https://doc.rust-lang.org/cargo/) | [missouri](https://crates.io/crates/missouri) | `cargo install --locked missouri` |
+| [uv](https://docs.astral.sh/uv/) | [msri](https://pypi.org/project/msri/) | `uv tool install msri` |
+| [npm](https://www.npmjs.com) | [@cjohnhanson/msri](https://www.npmjs.com/package/@cjohnhanson/msri) | `npm install -g @cjohnhanson/msri` |
 
-To build the unreleased `main` branch:
+On Debian or Ubuntu, download the `.deb` from the [releases
+page](https://github.com/cjohnhanson/missouri/releases) and install it:
 
-```sh
-cargo install --locked --git https://github.com/cjohnhanson/missouri
+```
+wget https://github.com/cjohnhanson/missouri/releases/download/v0.2.3/missouri_0.2.3-1_amd64.deb
+sudo dpkg -i missouri_0.2.3-1_amd64.deb
 ```
 
-Or run it without installing:
+To run it once without installing anything:
 
-```sh
+```
 uvx msri run
 npx @cjohnhanson/msri run
 ```
 
-From that point the [releases
-page](https://github.com/cjohnhanson/missouri/releases) also carries
-prebuilt archives and a `.deb`. Each archive holds the binary and the man
-page. Install a `.deb` with `dpkg -i`: it
-is a file, not a repository, so `apt-get install` does not reach it.
+### Building
+
+missouri is written in Rust, so you need a [Rust
+installation](https://www.rust-lang.org/) to compile it. missouri
+compiles with Rust 1.88 or newer. A C compiler is needed as well, which
+`aws-lc-sys` uses for its cryptography.
 
-Check the install with `missouri --version`.
+To build missouri:
+
+```
+git clone https://github.com/cjohnhanson/missouri
+cd missouri
+cargo build --release
+./target/release/missouri --version
+```
 
 ## Usage
 

{msri-0.2.3 → msri-0.2.4}/SECURITY.md

@@ -49,5 +49,5 @@ Out of scope:
 
 Missouri runs a transition command on the host, as the user who started
 missouri, unless the project config sets `docker: true`. A `packages`
-list puts the command in a nix shell, which supplies programs and does
-not confine them. Neither is a vulnerability.
+list puts programs from nixpkgs on the command's `PATH` without
+confining the command. Neither is a vulnerability.

{msri-0.2.3 → msri-0.2.4}/docs/cli-reference.md

@@ -260,9 +260,9 @@ setup:
   - command: "db-seed"
     shell: false
 
-# Nix packages to provide through `nix shell`.
-# When this list is not empty, every command runs inside a nix shell
-# with these packages.
+# Nixpkgs packages for transition, assertion, and comparator commands.
+# Commands use the environment from one warm-up `nix shell`.
+# If missouri cannot read that environment, each command runs inside its own `nix shell`.
 packages:
   - python3
   - uv
@@ -508,7 +508,9 @@ When you set `test_dir`, missouri looks for the project bin in the test director
 
 ### Sandbox and packages
 
-When the project config sets `packages`, every command runs inside `nix shell nixpkgs#pkg1 nixpkgs#pkg2 ... --command`. Missouri resolves the nixpkgs flake reference to a pinned commit hash during a warm-up phase. The warm-up runs before parallel execution starts. This keeps parallel paths from competing for the registry file.
+When the project config sets `packages`, missouri gets the packages from nixpkgs through `nix shell`. For each suite, missouri runs warm-up once before the paths run in parallel. During warm-up, missouri resolves the `nixpkgs` flake reference to a pinned commit hash. Parallel commands never read the flake registry. During warm-up, missouri runs `/usr/bin/env -0` inside one `nix shell` with the packages. If `/usr/bin/env` is missing or does not accept `-0`, Missouri cannot read the environment during warm-up. The warm-up step records the environment that `nix shell` gives a command. This environment puts the package directories first in `PATH`. It also includes any other variables that `nix shell` sets. During the run, missouri roots those store paths to prevent garbage collection from deleting them.
+
+With this environment, each transition, assertion, and comparator command runs without its own `nix shell`. Each command sees the same `PATH` as a command inside `nix shell`. The command's stderr contains no messages from nix itself. Nix writes nothing to the cache under the command's `HOME`. If missouri cannot read the environment from warm-up, it prints a warning. In this case, missouri runs each command inside its own `nix shell`. This fallback takes more time. The warning names `MISSOURI_SANDBOX=preinstalled` as the way to skip nix when the packages are already on `PATH`.
 
 The `MISSOURI_SANDBOX` environment variable overrides the sandbox behavior:
 

{msri-0.2.3 → msri-0.2.4}/docs/what-is-missouri.md

@@ -183,8 +183,9 @@ model.
 A Docker-based e2e test gives you isolation, but a container costs time,
 and a container does not model a state graph well. Missouri gets its
 isolation from temp directories and `env_clear`, which is cheaper and
-needs no container runtime. For stronger isolation, missouri also runs a
-command inside a nix shell, or inside a Docker container of its own.
+needs no container runtime. Each command gets programs from nixpkgs
+through a `packages` list. With `docker: true`, each command runs inside
+a Docker container.
 
 ## Getting started
 

{msri-0.2.3 → msri-0.2.4}/src/executor.rs

@@ -155,6 +155,49 @@ pub struct NixBackend {
     /// Pinned nixpkgs flake URL (resolved during warm-up).
     /// When set, used instead of bare `nixpkgs` to avoid registry lookups.
     pinned_nixpkgs: Option<String>,
+    /// The environment one `nix shell` gives a child, captured during
+    /// warm-up. When set, each command runs without its own `nix shell`.
+    resolved: Option<NixEnv>,
+    /// Holds the out-links that root the captured store paths for the
+    /// run, so a garbage collection cannot delete them.
+    gc_roots: Option<TempDir>,
+}
+
+/// What `nix shell` adds to a child's environment: the directories it
+/// puts in front of PATH, and any other variable.
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct NixEnv {
+    path_prefix: String,
+    extra: Vec<(String, String)>,
+}
+
+/// The PATH the capture runs with. It names no directory, so the text in
+/// front of it in the captured PATH is what `nix shell` added.
+const CAPTURE_MARKER: &str = "/nonexistent/missouri-path-marker";
+
+/// Read the output of `nix shell ... --command /usr/bin/env -0`, run with
+/// a cleared environment and `marker` as PATH. `None` when the output does
+/// not have that shape.
+fn parse_capture(output: &[u8], marker: &str) -> Option<NixEnv> {
+    let text = std::str::from_utf8(output).ok()?;
+    let mut path_prefix = None;
+    let mut extra = Vec::new();
+    for entry in text.split('\0').filter(|entry| !entry.is_empty()) {
+        let (key, value) = entry.split_once('=')?;
+        if key == "PATH" {
+            let prefix = value.strip_suffix(marker)?.strip_suffix(':')?;
+            if prefix.is_empty() {
+                return None;
+            }
+            path_prefix = Some(prefix.to_string());
+        } else {
+            extra.push((key.to_string(), value.to_string()));
+        }
+    }
+    Some(NixEnv {
+        path_prefix: path_prefix?,
+        extra,
+    })
 }
 
 impl NixBackend {
@@ -212,8 +255,127 @@ impl NixBackend {
             let stderr = String::from_utf8_lossy(&output.stderr);
             return Err(format!("nix cache warm failed: {stderr}"));
         }
+
+        match self.capture_env() {
+            Ok((env, roots)) => {
+                self.resolved = Some(env);
+                self.gc_roots = Some(roots);
+            }
+            Err(reason) => eprintln!(
+                "warning: warm-up could not read the nix environment ({reason}), so each command \
+                 runs in its own nix shell. If the packages are already on PATH, set \
+                 MISSOURI_SANDBOX=preinstalled."
+            ),
+        }
         Ok(())
     }
+
+    /// Run one `nix shell` that prints its child's environment, then root
+    /// the store paths it put on PATH for the rest of the run.
+    fn capture_env(&self) -> Result<(NixEnv, TempDir), String> {
+        let mut args = self.nix_prefix_args();
+        args.extend(["/usr/bin/env".into(), "-0".into()]);
+        let output = std::process::Command::new(self.nix_bin.as_str())
+            .args(&args)
+            .env_clear()
+            .env("PATH", CAPTURE_MARKER)
+            .output()
+            .map_err(|e| format!("nix shell did not start: {e}"))?;
+        if !output.status.success() {
+            return Err("nix shell failed".to_string());
+        }
+        let env = parse_capture(&output.stdout, CAPTURE_MARKER)
+            .ok_or("nix shell printed no PATH of its own")?;
+
+        // The roots last as long as this directory. A run that is killed
+        // never removes it, so its roots stay in the temp directory until
+        // something cleans that up.
+        let roots = TempDir::new().map_err(|e| format!("no temp directory: {e}"))?;
+        let mut store_paths: Vec<&str> = env
+            .path_prefix
+            .split(':')
+            .map(|dir| Utf8Path::new(dir).parent().map_or(dir, |p| p.as_str()))
+            .collect();
+        store_paths.sort_unstable();
+        store_paths.dedup();
+        let link = roots.path().join("root");
+        let output = std::process::Command::new(self.nix_bin.as_str())
+            .args([
+                "build",
+                "--extra-experimental-features",
+                "nix-command flakes",
+            ])
+            .arg("--out-link")
+            .arg(&link)
+            .args(&store_paths)
+            .output()
+            .map_err(|e| format!("nix build did not start: {e}"))?;
+        if !output.status.success() {
+            return Err("nix build failed".to_string());
+        }
+        Ok((env, roots))
+    }
+
+    /// A command that runs `sh -c <wrapped>` with the packages on PATH:
+    /// directly when warm-up captured the environment, else inside its own
+    /// `nix shell`. `path_env` is the PATH missouri built for the command.
+    fn sh_command(
+        &self,
+        wrapped: String,
+        work_dir: &Utf8Path,
+        env: &BTreeMap<String, String>,
+        path_env: &str,
+    ) -> Command {
+        let Some(resolved) = &self.resolved else {
+            let mut args = self.nix_prefix_args();
+            args.extend(["sh".into(), "-c".into(), wrapped]);
+            let mut cmd = Command::new(self.nix_bin.as_str());
+            cmd.args(&args)
+                .current_dir(work_dir.as_std_path())
+                .env_clear()
+                .envs(env.iter())
+                .env("PATH", path_env);
+            return cmd;
+        };
+        // The PATH `nix shell` gives its child. Command looks `sh` up on the
+        // PATH set here, as `nix shell` does.
+        let path = if path_env.is_empty() {
+            resolved.path_prefix.clone()
+        } else {
+            format!("{}:{path_env}", resolved.path_prefix)
+        };
+        let mut cmd = Command::new("sh");
+        cmd.args(["-c", &wrapped])
+            .current_dir(work_dir.as_std_path())
+            .env_clear()
+            .envs(env.iter())
+            .env("PATH", path);
+        for (key, value) in &resolved.extra {
+            if !env.contains_key(key) {
+                cmd.env(key, value);
+            }
+        }
+        // nix shell raises the soft open-file limit of the command it runs
+        // to the hard limit. The child does the same here; missouri's own
+        // limit stays as it is.
+        // SAFETY: the closure runs in the child between fork and exec, and
+        // calls only getrlimit and setrlimit, which are async-signal-safe.
+        unsafe {
+            std::os::unix::process::CommandExt::pre_exec(&mut cmd, || {
+                let mut limit = libc::rlimit {
+                    rlim_cur: 0,
+                    rlim_max: 0,
+                };
+                if libc::getrlimit(libc::RLIMIT_NOFILE, &mut limit) == 0 {
+                    limit.rlim_cur = limit.rlim_max;
+                    // A failure leaves the limit as it was, as under nix.
+                    libc::setrlimit(libc::RLIMIT_NOFILE, &limit);
+                }
+                Ok(())
+            });
+        }
+        cmd
+    }
 }
 
 impl Backend for NixBackend {
@@ -245,15 +407,7 @@ impl Backend for NixBackend {
         } else {
             format!("export PATH=\"{project_dirs}:$PATH\"; {command}")
         };
-        let mut args = self.nix_prefix_args();
-        args.extend(["sh".into(), "-c".into(), wrapped]);
-        let mut cmd = Command::new(self.nix_bin.as_str());
-        cmd.args(&args)
-            .current_dir(work_dir.as_std_path())
-            .env_clear()
-            .envs(env.iter())
-            .env("PATH", path_env);
-        cmd
+        self.sh_command(wrapped, work_dir, env, path_env)
     }
 
     fn build_direct_command(
@@ -270,15 +424,7 @@ impl Backend for NixBackend {
             .collect::<Vec<_>>()
             .join(" ");
         let wrapped = format!("export PATH=\"{path_env}:$PATH\"; {inner}");
-        let mut args = self.nix_prefix_args();
-        args.extend(["sh".into(), "-c".into(), wrapped]);
-        let mut cmd = Command::new(self.nix_bin.as_str());
-        cmd.args(&args)
-            .current_dir(work_dir.as_std_path())
-            .env_clear()
-            .envs(env.iter())
-            .env("PATH", path_env);
-        cmd
+        self.sh_command(wrapped, work_dir, env, path_env)
     }
 }
 
@@ -731,6 +877,8 @@ pub fn detect_sandbox(graph: &StateGraph) -> error::Result<Box<dyn Backend>> {
                 nix_bin,
                 packages: packages.clone(),
                 pinned_nixpkgs: None,
+                resolved: None,
+                gc_roots: None,
             };
             backend
                 .warm_cache()
@@ -2726,6 +2874,125 @@ transitions:
         assert!(result.unwrap().as_str().ends_with("nix"));
     }
 
+    #[test]
+    fn a_capture_gives_the_path_prefix() {
+        let out = b"PATH=/nix/store/a-jq/bin:/nix/store/b-jq-man/bin:/m\0";
+        let env = parse_capture(out, "/m").unwrap();
+        assert_eq!(
+            env.path_prefix,
+            "/nix/store/a-jq/bin:/nix/store/b-jq-man/bin"
+        );
+        assert!(env.extra.is_empty());
+    }
+
+    #[test]
+    fn a_capture_keeps_each_variable_nix_added() {
+        let out = b"__CF_USER_TEXT_ENCODING=0x1F5:0x0:0x0\0PATH=/nix/store/a-jq/bin:/m\0";
+        let env = parse_capture(out, "/m").unwrap();
+        assert_eq!(
+            env.extra,
+            vec![(
+                "__CF_USER_TEXT_ENCODING".to_string(),
+                "0x1F5:0x0:0x0".to_string()
+            )]
+        );
+    }
+
+    #[test]
+    fn a_capture_without_the_marker_is_refused() {
+        assert_eq!(
+            parse_capture(b"PATH=/nix/store/a-jq/bin:/usr/bin\0", "/m"),
+            None
+        );
+        assert_eq!(parse_capture(b"PATH=/m\0", "/m"), None);
+        assert_eq!(parse_capture(b"PATH=:/m\0", "/m"), None);
+        assert_eq!(parse_capture(b"HOME=/h\0", "/m"), None);
+        assert_eq!(parse_capture(b"not an environment", "/m"), None);
+    }
+
+    #[test]
+    fn a_capture_that_is_not_utf8_is_refused() {
+        assert_eq!(
+            parse_capture(b"PATH=/nix/store/a-jq/bin:/m\0X=\xff\0", "/m"),
+            None
+        );
+    }
+
+    #[test]
+    fn a_resolved_backend_runs_sh_with_the_packages_in_front_of_path() {
+        let backend = NixBackend {
+            nix_bin: Utf8PathBuf::from("/nonexistent/nix"),
+            packages: vec!["jq".into()],
+            pinned_nixpkgs: None,
+            resolved: Some(NixEnv {
+                path_prefix: "/pkg/bin".into(),
+                extra: vec![("ADDED".into(), "1".into()), ("KEPT".into(), "nix".into())],
+            }),
+            gc_roots: None,
+        };
+        let env = BTreeMap::from([("KEPT".to_string(), "state".to_string())]);
+        let cmd = backend.build_shell_command("true", Utf8Path::new("/"), &env, "/usr/bin:/bin");
+        let program = cmd.get_program().to_string_lossy().into_owned();
+        assert_eq!(program, "sh");
+        let args: Vec<String> = cmd
+            .get_args()
+            .map(|a| a.to_string_lossy().into_owned())
+            .collect();
+        assert_eq!(args, vec!["-c".to_string(), "true".to_string()]);
+        let envs: BTreeMap<String, Option<String>> = cmd
+            .get_envs()
+            .map(|(k, v)| {
+                (
+                    k.to_string_lossy().into_owned(),
+                    v.map(|v| v.to_string_lossy().into_owned()),
+                )
+            })
+            .collect();
+        assert_eq!(envs["PATH"].as_deref(), Some("/pkg/bin:/usr/bin:/bin"));
+        assert_eq!(envs["ADDED"].as_deref(), Some("1"));
+        assert_eq!(envs["KEPT"].as_deref(), Some("state"));
+    }
+
+    fn resolved_backend(path_prefix: &str) -> NixBackend {
+        NixBackend {
+            nix_bin: Utf8PathBuf::from("/nonexistent/nix"),
+            packages: vec!["jq".into()],
+            pinned_nixpkgs: None,
+            resolved: Some(NixEnv {
+                path_prefix: path_prefix.into(),
+                extra: Vec::new(),
+            }),
+            gc_roots: None,
+        }
+    }
+
+    #[test]
+    fn a_resolved_backend_runs_the_sh_a_package_ships() {
+        let pkg = tempfile::tempdir().unwrap();
+        let pkg_bin = Utf8Path::from_path(pkg.path()).unwrap();
+        let sh = pkg_bin.join("sh");
+        fs::write(&sh, "#!/bin/sh\necho package-sh\n").unwrap();
+        fs::set_permissions(&sh, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
+        let backend = resolved_backend(pkg_bin.as_str());
+        let output = backend
+            .build_shell_command("true", pkg_bin, &BTreeMap::new(), "/usr/bin:/bin")
+            .output()
+            .unwrap();
+        assert_eq!(String::from_utf8_lossy(&output.stdout), "package-sh\n");
+    }
+
+    #[test]
+    fn an_empty_command_path_leaves_no_trailing_colon() {
+        let backend = resolved_backend("/pkg/bin");
+        let cmd = backend.build_shell_command("true", Utf8Path::new("/"), &BTreeMap::new(), "");
+        let path = cmd
+            .get_envs()
+            .find(|(k, _)| *k == "PATH")
+            .and_then(|(_, v)| v)
+            .map(|v| v.to_string_lossy().into_owned());
+        assert_eq!(path.as_deref(), Some("/pkg/bin"));
+    }
+
     #[test]
     fn bare_backend_shell_command_runs() {
         let backend = BareBackend;

msri-0.2.4/tests/nix_once.rs

@@ -0,0 +1,302 @@
+//! A suite that lists `packages` resolves them with one `nix shell` call,
+//! not one call per command. A stand-in `nix` on PATH logs every call,
+//! so the tests count calls without a nix daemon.
+
+use std::fs;
+use std::os::unix::fs::PermissionsExt;
+use std::path::{Path, PathBuf};
+
+/// How the stand-in `nix` answers warm-up.
+#[derive(Clone, Copy, PartialEq)]
+enum Nix {
+    /// Like nix: the capture prints the environment, the build succeeds.
+    Good,
+    /// The capture prints output that holds no PATH.
+    UnreadableCapture,
+    /// The capture prints a good environment, then exits 1.
+    CaptureExits1,
+    /// The build that roots the store paths exits 1.
+    BuildFails,
+}
+
+/// The stand-in answers `flake metadata` with a pinned URL, answers
+/// `build` by its mode, and runs `shell ... --command <cmd>` the way nix
+/// does: the package's `bin` in front of PATH, then exec.
+fn write_fake_nix(dir: &Path, log: &Path, pkg_bin: &Path, mode: Nix) {
+    let mode = match mode {
+        Nix::Good => "good",
+        Nix::UnreadableCapture => "unreadable",
+        Nix::CaptureExits1 => "capture-exits-1",
+        Nix::BuildFails => "build-fails",
+    };
+    let script = format!(
+        r#"#!/bin/sh
+printf '%s\n' "$*" >> '{log}'
+case "$1" in
+flake) printf '{{"url":"fake:pinned"}}\n'; exit 0 ;;
+build) [ '{mode}' = build-fails ] && exit 1; exit 0 ;;
+shell)
+	while [ $# -gt 0 ] && [ "$1" != "--command" ]; do shift; done
+	shift
+	PATH='{pkg_bin}':"$PATH"
+	export PATH
+	if [ "$1" = /usr/bin/env ]; then
+		[ '{mode}' = unreadable ] && {{ printf 'not an environment'; exit 0; }}
+		[ '{mode}' = capture-exits-1 ] && {{ "$@"; exit 1; }}
+	fi
+	ulimit -Sn "$(ulimit -Hn)"
+	exec "$@" ;;
+esac
+exit 2
+"#,
+        log = log.display(),
+        pkg_bin = pkg_bin.display(),
+    );
+    let nix = dir.join("nix");
+    fs::write(&nix, script).unwrap();
+    fs::set_permissions(&nix, fs::Permissions::from_mode(0o755)).unwrap();
+}
+
+fn executable(path: &Path, body: &str) {
+    fs::write(path, body).unwrap();
+    fs::set_permissions(path, fs::Permissions::from_mode(0o755)).unwrap();
+}
+
+/// A suite with one package, `hello`. Its `hello-pkg` prints `hi`, and
+/// its `cmp-pkg` compares two files and logs that it ran. A shell
+/// transition, a shell assertion, a `shell: false` assertion, and a file
+/// comparator each call a program of the package.
+fn write_suite(root: &Path) {
+    fs::create_dir_all(root.join(".missouri")).unwrap();
+    fs::write(
+        root.join(".missouri/missouri.yml"),
+        "packages:\n  - hello\n",
+    )
+    .unwrap();
+    fs::create_dir_all(root.join("a/.missouri")).unwrap();
+    fs::write(
+        root.join("a/.missouri/missouri.yml"),
+        r#"transitions:
+  - name: "greet"
+    command: "hello-pkg > out.txt"
+    target: "../b"
+    comparators:
+      files:
+        - path: "out.txt"
+          command: "cmp-pkg"
+"#,
+    )
+    .unwrap();
+    fs::create_dir_all(root.join("b/.missouri")).unwrap();
+    fs::write(
+        root.join("b/.missouri/missouri.yml"),
+        r#"assertions:
+  - name: "the package is on PATH"
+    command: "hello-pkg"
+    stdout: "hi\n"
+  - name: "the package is on PATH without a shell"
+    command: "hello-pkg"
+    shell: false
+    stdout: "hi\n"
+  - name: "the soft open-file limit is the hard limit, as nix shell sets it"
+    command: "test \"$(ulimit -Sn)\" = \"$(ulimit -Hn)\""
+"#,
+    )
+    .unwrap();
+    fs::write(root.join("b/out.txt"), "hi\n").unwrap();
+}
+
+struct Run {
+    passed: bool,
+    stdout: String,
+    stderr: String,
+    nix_calls: Vec<String>,
+    comparator_runs: usize,
+    pkg_dir: PathBuf,
+}
+
+fn run_suite(mode: Nix) -> Run {
+    let tmp = tempfile::tempdir().unwrap();
+    let fake = tmp.path().join("fake-bin");
+    let pkg_dir = tmp.path().join("pkg");
+    let pkg_bin = pkg_dir.join("bin");
+    let suite = tmp.path().join("suite");
+    let log = tmp.path().join("nix-calls.log");
+    let comparator_log = tmp.path().join("comparator.log");
+    fs::create_dir_all(&fake).unwrap();
+    fs::create_dir_all(&pkg_bin).unwrap();
+    executable(&pkg_bin.join("hello-pkg"), "#!/bin/sh\necho hi\n");
+    executable(
+        &pkg_bin.join("cmp-pkg"),
+        &format!(
+            "#!/bin/sh\necho ran >> '{}'\nexec cmp -s \"$1\" \"$2\"\n",
+            comparator_log.display()
+        ),
+    );
+    write_fake_nix(&fake, &log, &pkg_bin, mode);
+    write_suite(&suite);
+
+    let path = format!("{}:/usr/bin:/bin", fake.display());
+    // missouri starts with a low soft open-file limit, so a command that
+    // inherits it fails the limit assertion.
+    let output = std::process::Command::new("/bin/sh")
+        .args(["-c", "ulimit -Sn 256 && exec \"$0\" run -d \"$1\""])
+        .arg(env!("CARGO_BIN_EXE_missouri"))
+        .arg(&suite)
+        .env_clear()
+        .env("PATH", path)
+        .output()
+        .unwrap();
+    Run {
+        passed: output.status.success(),
+        stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
+        stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
+        nix_calls: fs::read_to_string(&log)
+            .unwrap_or_default()
+            .lines()
+            .map(String::from)
+            .collect(),
+        comparator_runs: fs::read_to_string(&comparator_log)
+            .unwrap_or_default()
+            .lines()
+            .count(),
+        // The directory outlives the run only as a name to compare with.
+        pkg_dir,
+    }
+}
+
+/// The verdict lines of a run, with each duration removed: the PASS or
+/// FAIL line of each path, and the summary of counts. Both runs write the
+/// same colour codes, so the lines keep them.
+fn verdict(stdout: &str) -> Vec<String> {
+    stdout
+        .lines()
+        .filter(|line| line.contains("PASS") || line.contains("FAIL") || line.contains(" passed, "))
+        .map(|line| match line.rfind(" in ") {
+            Some(at) if line.contains(" passed, ") => line[..at].to_string(),
+            _ => line
+                .rsplit_once(' ')
+                .map_or(line, |(head, _)| head)
+                .to_string(),
+        })
+        .collect()
+}
+
+fn calls_naming<'a>(run: &'a Run, program: &str) -> Vec<&'a String> {
+    run.nix_calls
+        .iter()
+        .filter(|call| call.starts_with("shell") && call.contains(program))
+        .collect()
+}
+
+fn assert_fallback(mode: Nix) {
+    let good = run_suite(Nix::Good);
+    let run = run_suite(mode);
+    assert!(
+        run.passed,
+        "the suite failed\nstdout:\n{}\nstderr:\n{}",
+        run.stdout, run.stderr
+    );
+    let warnings: Vec<&str> = run
+        .stderr
+        .lines()
+        .filter(|line| line.contains("warning"))
+        .collect();
+    assert_eq!(
+        warnings.len(),
+        1,
+        "expected one warning line: {}",
+        run.stderr
+    );
+    assert!(
+        warnings[0].starts_with("warning: warm-up could not read the nix environment")
+            && warnings[0].contains("MISSOURI_SANDBOX=preinstalled"),
+        "unexpected warning: {}",
+        warnings[0]
+    );
+    assert_eq!(
+        calls_naming(&run, "hello-pkg").len(),
+        3,
+        "expected the transition and both assertions through nix: {:?}",
+        run.nix_calls
+    );
+    assert_eq!(
+        calls_naming(&run, "cmp-pkg").len(),
+        1,
+        "expected the comparator through nix: {:?}",
+        run.nix_calls
+    );
+    assert_eq!(verdict(&run.stdout), verdict(&good.stdout));
+}
+
+#[test]
+fn a_suite_resolves_its_packages_once_and_runs_no_command_through_nix() {
+    let run = run_suite(Nix::Good);
+    assert!(
+        run.passed,
+        "the suite failed\nstdout:\n{}\nstderr:\n{}",
+        run.stdout, run.stderr
+    );
+    for program in ["hello-pkg", "cmp-pkg"] {
+        let per_command = calls_naming(&run, program);
+        assert!(
+            per_command.is_empty(),
+            "{program} ran through nix: {per_command:?}"
+        );
+    }
+    assert_eq!(run.comparator_runs, 1, "the comparator did not run");
+    let shells = run
+        .nix_calls
+        .iter()
+        .filter(|call| call.starts_with("shell"))
+        .count();
+    assert_eq!(
+        shells, 2,
+        "expected the warm-up and the capture only: {:?}",
+        run.nix_calls
+    );
+    assert!(
+        !run.stderr.contains("warning"),
+        "no warning on a good capture: {}",
+        run.stderr
+    );
+}
+
+#[test]
+fn warm_up_roots_the_store_path_of_each_package_directory() {
+    let run = run_suite(Nix::Good);
+    let builds: Vec<Vec<&str>> = run
+        .nix_calls
+        .iter()
+        .filter(|call| call.starts_with("build"))
+        .map(|call| call.split_whitespace().collect())
+        .collect();
+    assert_eq!(builds.len(), 1, "expected one build: {:?}", run.nix_calls);
+    let words = &builds[0];
+    let store_dir = run.pkg_dir.to_str().unwrap();
+    let bin_dir = run.pkg_dir.join("bin");
+    assert!(words.contains(&"--out-link"), "no --out-link: {words:?}");
+    assert!(
+        words.contains(&store_dir),
+        "the store path {store_dir} is not rooted: {words:?}"
+    );
+    assert!(
+        !words.contains(&bin_dir.to_str().unwrap()),
+        "a bin directory is rooted instead of its store path: {words:?}"
+    );
+}
+
+#[test]
+fn an_unreadable_capture_warns_and_wraps_each_command_with_the_same_verdict() {
+    assert_fallback(Nix::UnreadableCapture);
+}
+
+#[test]
+fn a_capture_that_exits_1_warns_and_wraps_each_command_with_the_same_verdict() {
+    assert_fallback(Nix::CaptureExits1);
+}
+
+#[test]
+fn a_failed_root_build_warns_and_wraps_each_command_with_the_same_verdict() {
+    assert_fallback(Nix::BuildFails);
+}