refactor(fspy): rename CollectedAccesses and drop its async wrapper

Nothing is collected anymore — frames are borrowed in place — and the
async wrapper descended from the file-lock era, when acquiring the trace
could block until every sender exited. Closing is now bounded by the
number of reported records and runs inline, so the type becomes
ChannelAccesses with a TryFrom<Receiver> conversion.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: wan9chi

crates/fspy/src/ipc.rs

@@ -4,30 +4,33 @@ use fspy_shared::ipc::{
     PathAccess,
     channel::{Frames, Receiver},
 };
-use tokio::task::spawn_blocking;
 
 // Shared memory size for storing path accesses.
 // 4 GiB is large enough to store path accesses in almost any realistic scenario.
 // This doesn't allocate physical memory until it's actually used.
 pub const SHM_CAPACITY: usize = 4 * 1024 * 1024 * 1024;
 
-/// The validated path accesses collected from a closed IPC channel.
-pub struct CollectedAccesses {
+/// The path accesses a run reported through the IPC channel.
+pub struct ChannelAccesses {
     frames: Frames,
 }
 
-impl CollectedAccesses {
-    /// Closes the channel and validates the collected trace.
+impl TryFrom<Receiver> for ChannelAccesses {
+    type Error = io::Error;
+
+    /// Closes the channel and rejects traces that cannot back the run's
+    /// file accesses.
     ///
-    /// Never waits for tracked processes: closing rejects new records and
+    /// Never waits for tracked processes — closing rejects new records and
     /// atomically ignores unfinished ones (see
-    /// [`fspy_shared::ipc::channel::Receiver::close`]).
+    /// [`fspy_shared::ipc::channel::Receiver::close`]) — and its work is
+    /// bounded by the number of reported records, so it runs inline.
     ///
-    /// Fails when the trace cannot back the run's file accesses: a record
-    /// was lost before close, or the shared-memory metadata was corrupted.
-    /// Failing here — instead of returning a silently short trace — keeps
-    /// the tracking result trustworthy for caching.
-    pub fn collect(receiver: Receiver) -> io::Result<Self> {
+    /// Fails when a record was lost before close or the shared-memory
+    /// metadata was corrupted. Failing here — instead of returning a
+    /// silently short trace — keeps the tracking result trustworthy for
+    /// caching.
+    fn try_from(receiver: Receiver) -> io::Result<Self> {
         let frames = receiver.close()?;
         if !frames.is_complete() {
             return Err(io::Error::new(
@@ -37,11 +40,9 @@ impl CollectedAccesses {
         }
         Ok(Self { frames })
     }
+}
 
-    pub async fn collect_async(receiver: Receiver) -> io::Result<Self> {
-        spawn_blocking(move || Self::collect(receiver)).await.expect("collect task panicked")
-    }
-
+impl ChannelAccesses {
     pub fn iter_path_accesses(&self) -> impl Iterator<Item = PathAccess<'_>> {
         self.frames.iter().map(|frame| {
             wincode::deserialize_exact(frame)

crates/fspy/src/unix/mod.rs

@@ -25,7 +25,7 @@ use tokio::task::spawn_blocking;
 use tokio_util::sync::CancellationToken;
 
 #[cfg(not(target_env = "musl"))]
-use crate::ipc::{CollectedAccesses, SHM_CAPACITY};
+use crate::ipc::{ChannelAccesses, SHM_CAPACITY};
 use crate::{ChildTermination, Command, TrackedChild, arena::PathAccessArena, error::SpawnError};
 
 #[derive(Debug)]
@@ -162,7 +162,7 @@ impl SpyImpl {
                 // Close the ipc channel after the child has exited.
                 // We are not interested in path accesses from descendants after the main child has exited.
                 #[cfg(not(target_env = "musl"))]
-                let ipc_accesses = CollectedAccesses::collect_async(ipc_receiver).await?;
+                let ipc_accesses = ChannelAccesses::try_from(ipc_receiver)?;
                 let path_accesses = PathAccessIterable {
                     arenas,
                     #[cfg(not(target_env = "musl"))]
@@ -180,7 +180,7 @@ impl SpyImpl {
 pub struct PathAccessIterable {
     arenas: Vec<PathAccessArena>,
     #[cfg(not(target_env = "musl"))]
-    ipc_accesses: CollectedAccesses,
+    ipc_accesses: ChannelAccesses,
 }
 
 impl PathAccessIterable {

crates/fspy/src/windows/mod.rs

@@ -24,14 +24,14 @@ use crate::{
     ChildTermination, TrackedChild,
     command::Command,
     error::SpawnError,
-    ipc::{CollectedAccesses, SHM_CAPACITY},
+    ipc::{ChannelAccesses, SHM_CAPACITY},
 };
 
 const INTERPOSE_CDYLIB: Artifact =
     artifact!("fspy_preload", "CARGO_CDYLIB_FILE_FSPY_PRELOAD_WINDOWS");
 
 pub struct PathAccessIterable {
-    ipc_accesses: CollectedAccesses,
+    ipc_accesses: ChannelAccesses,
 }
 
 impl PathAccessIterable {
@@ -169,7 +169,7 @@ impl SpyImpl {
                 };
                 // Close the ipc channel after the child has exited.
                 // We are not interested in path accesses from descendants after the main child has exited.
-                let ipc_accesses = CollectedAccesses::collect_async(receiver).await?;
+                let ipc_accesses = ChannelAccesses::try_from(receiver)?;
                 let path_accesses = PathAccessIterable { ipc_accesses };
 
                 io::Result::Ok(ChildTermination { status, path_accesses })