feat(minimald): support min materialize within a session - #1054

crates/minimald/src/session_sop.rs (1)

797-834: 🚀 Performance & Scalability | 🔵 Trivial | ⚡ Quick win

Consider a larger byte pipeline for multi-hundred-MiB images.

4 KiB BufWriter × a depth-3 channel means ~12 KiB in flight and one blocking_send + Vec allocation per 4 KiB, i.e. tens of thousands of hand-offs for a sizeable OCI tar. Bumping the buffer to 64–256 KiB (channel depth unchanged) cuts the cross-thread traffic without weakening the backpressure property this design relies on.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/minimald/src/session_sop.rs` around lines 797 - 834, Increase the
BufWriter capacity used in the Materialize sink within the spawn_blocking
assembly flow from 4 KiB to a substantially larger buffer, such as 64–256 KiB,
while keeping the byte channel depth at 3 to preserve backpressure.

crates/op/src/materialize.rs (1)

220-234: 🗄️ Data Integrity & Integration | 🔵 Trivial | ⚡ Quick win

Consider atomic writes for Sink::Path destinations.

std::fs::File::create (OCI path) and std::fs::copy (raw-file path) write directly to the final destination path. If materialization fails partway (I/O error, disk full, process killed), the destination is left holding a partial/corrupt artifact rather than either the old file or nothing — a caller polling for the output path's existence could be misled.

♻️ Suggested direction (write-to-temp + rename)

-Sink::Path(path) => {
-    let file = std::fs::File::create(&path).map_err(|e| {
-        Error::Other(anyhow!("creating {}: {e}", path.display()))
-    })?;
-    let mut w = image.write(opts, Counted::new(file), &events).await?;
-    w.flush()?;
-    w.bytes
-}
+Sink::Path(path) => {
+    let tmp = tmp_path_for(&path);
+    let file = std::fs::File::create(&tmp).map_err(|e| {
+        Error::Other(anyhow!("creating {}: {e}", tmp.display()))
+    })?;
+    let mut w = image.write(opts, Counted::new(file), &events).await?;
+    w.flush()?;
+    std::fs::rename(&tmp, &path)
+        .map_err(|e| Error::Other(anyhow!("finalizing {}: {e}", path.display())))?;
+    w.bytes
+}

A similar temp+rename pattern would apply to deliver_file's Sink::Path arm.

Also applies to: 295-320

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/op/src/materialize.rs` around lines 220 - 234, Make `Sink::Path`
writes atomic in both the materialization match block and `deliver_file`: write
the OCI or raw-file output to a temporary file in the destination directory,
then rename it to the final path only after the write or copy succeeds. Preserve
the existing error context and ensure temporary artifacts are cleaned up when
the operation fails.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes