refactor(fspy-shared): make the payload a borrowed view

The payload and its channel configuration are now views over storage
their producer owns, the model the Windows preload already had with its
static Detours page:

- ChannelConf borrows its path in C-string form (the new IpcCStr, an
  IpcStr that keeps its NUL terminator): channel() returns only the
  Receiver, Receiver::conf() borrows the keeper's C string, and a unix
  sender attaches by borrowing the path straight from the conf — no
  allocation at all. Windows still re-aligns the wide path through a
  caller-provided allocator. IpcStr sheds the APIs whose last users
  this replaces (from_os_c_str, to_os_c_string_in, to_boxed).
- The unix Payload and EncodedPayload borrow every path and the encoded
  string. The supervisor lends its session paths per spawn instead of
  cloning boxes. seccomp_payload stays owned until fspy_seccomp_unotify
  grows borrowed types.
- decode_payload_from_env leaks its allocations into the allocator the
  caller lends, whose borrow bounds the payload.
- The preload ctor owns the attach storage — one page-backed bump from
  fspy_nostd_alloc::page_bump(), held in ManuallyDrop and never
  dropped — and lends it to from_env, which is safe code end to end:
  decode leaks the payload into the bump and the sender borrows its
  path from the decoded bytes. The ctor's
  Client::assume_process_lifetime is the attach's single unsafe step,
  reasoning against the bump the ctor itself owns. One mapping serves
  the whole attach unless the payload outgrows the chunk, nothing
  comes from the global allocator, and nothing borrows the mutable
  process environment.
- The Windows preload deserializes its payload zero-copy from the
  static page and forwards those original bytes to children instead of
  re-serializing per spawn.

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

Author: wan9chi

Cargo.lock

@@ -11,11 +11,9 @@ use fspy_seccomp_unotify::supervisor::supervise;
 use fspy_shared::ipc::PathAccess;
 #[cfg(not(target_env = "musl"))]
 use fspy_shared::ipc::{IpcStr, channel::channel};
-#[cfg(target_os = "macos")]
-use fspy_shared_unix::payload::Artifacts;
 use fspy_shared_unix::{
     exec::ExecResolveConfig,
-    payload::{Payload, encode_payload},
+    payload::{EncodedPayload, Payload, encode_payload},
     spawn::handle_exec,
 };
 use futures_util::FutureExt;
@@ -29,9 +27,15 @@ use crate::ipc::ChannelAccesses;
 use crate::{ChildTermination, Command, TrackedChild, arena::PathAccessArena, error::SpawnError};
 
 #[derive(Debug)]
+#[cfg_attr(
+    target_os = "macos",
+    expect(clippy::struct_field_names, reason = "each field names a distinct injected path")
+)]
 pub struct SpyImpl {
     #[cfg(target_os = "macos")]
-    artifacts: Artifacts,
+    bash_path: Box<IpcStr>,
+    #[cfg(target_os = "macos")]
+    coreutils_path: Box<IpcStr>,
 
     #[cfg(not(target_env = "musl"))]
     preload_path: Box<IpcStr>,
@@ -58,15 +62,19 @@ impl SpyImpl {
             #[cfg(not(target_env = "musl"))]
             preload_path,
             #[cfg(target_os = "macos")]
-            artifacts: {
-                let coreutils_path =
-                    macos_artifacts::COREUTILS_BINARY.materialize().executable().at(dir)?;
-                let bash_path = macos_artifacts::OILS_BINARY.materialize().executable().at(dir)?;
-                Artifacts {
-                    bash_path: bash_path.as_path().into(),
-                    coreutils_path: coreutils_path.as_path().into(),
-                }
-            },
+            bash_path: macos_artifacts::OILS_BINARY
+                .materialize()
+                .executable()
+                .at(dir)?
+                .as_path()
+                .into(),
+            #[cfg(target_os = "macos")]
+            coreutils_path: macos_artifacts::COREUTILS_BINARY
+                .materialize()
+                .executable()
+                .at(dir)?
+                .as_path()
+                .into(),
         })
     }
 
@@ -79,25 +87,30 @@ impl SpyImpl {
         let supervisor = supervise::<SyscallHandler>().map_err(SpawnError::Supervisor)?;
 
         #[cfg(not(target_env = "musl"))]
-        let (ipc_channel_conf, ipc_receiver) =
-            channel(crate::ipc::shm_capacity(), allocator_api2::alloc::Global)
-                .map_err(SpawnError::ChannelCreation)?;
+        let ipc_receiver = channel(crate::ipc::shm_capacity(), allocator_api2::alloc::Global)
+            .map_err(SpawnError::ChannelCreation)?;
 
         let payload = Payload {
             #[cfg(not(target_env = "musl"))]
-            ipc_channel_conf,
-
-            #[cfg(target_os = "macos")]
-            artifacts: self.artifacts.clone(),
+            ipc_channel_conf: ipc_receiver.conf(),
+            #[cfg(target_env = "musl")]
+            ipc_channel_conf: core::marker::PhantomData,
 
             #[cfg(not(target_env = "musl"))]
-            preload_path: self.preload_path.clone(),
+            preload_path: &self.preload_path,
+
+            #[cfg(target_os = "macos")]
+            artifacts: fspy_shared_unix::payload::Artifacts {
+                bash_path: &self.bash_path,
+                coreutils_path: &self.coreutils_path,
+            },
 
             #[cfg(target_os = "linux")]
             seccomp_payload: supervisor.payload().clone(),
         };
 
-        let encoded_payload = encode_payload(payload);
+        let encoded_string = encode_payload(&payload);
+        let encoded_payload = EncodedPayload { payload, encoded_string: encoded_string.as_ref() };
 
         let mut exec = command.get_exec();
         let mut exec_resolve_accesses = PathAccessArena::default();

crates/fspy/src/unix/mod.rs

@@ -83,9 +83,8 @@ impl SpyImpl {
 
         command.creation_flags(CREATE_SUSPENDED);
 
-        let (channel_conf, receiver) =
-            channel(crate::ipc::shm_capacity(), allocator_api2::alloc::Global)
-                .map_err(SpawnError::ChannelCreation)?;
+        let receiver = channel(crate::ipc::shm_capacity(), allocator_api2::alloc::Global)
+            .map_err(SpawnError::ChannelCreation)?;
 
         let mut spawn_success = false;
         let spawn_success = &mut spawn_success;
@@ -105,7 +104,7 @@ impl SpyImpl {
                 }
 
                 let payload = Payload {
-                    channel_conf: channel_conf.clone(),
+                    channel_conf: receiver.conf(),
                     ansi_dll_path_with_nul: ansi_dll_path_with_nul.to_bytes(),
                 };
                 let payload_bytes = wincode::serialize(&payload).unwrap();

crates/fspy/src/windows/mod.rs

@@ -20,28 +20,33 @@ use fspy_shared_unix::{
 };
 use raw_exec::RawExec;
 
-pub struct Client {
-    encoded_payload: EncodedPayload,
+pub struct Client<'a> {
+    encoded_payload: EncodedPayload<'a>,
     ipc_sender: Option<Sender>,
 }
 
 // SAFETY: construction owns every field, later methods borrow them immutably,
 // and the sender synchronizes its shared-memory access.
 #[cfg(target_os = "macos")]
-unsafe impl Sync for Client {}
+unsafe impl Sync for Client<'_> {}
 // SAFETY: ownership of every field can move with the client, and the sender
 // synchronizes its shared-memory access.
 #[cfg(target_os = "macos")]
-unsafe impl Send for Client {}
+unsafe impl Send for Client<'_> {}
 
-impl Debug for Client {
+impl Debug for Client<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Client").finish()
     }
 }
 
-impl Client {
-    /// Constructs a client from the encoded payload in the process environment.
+impl<'a> Client<'a> {
+    /// Constructs a client from the encoded payload in the process
+    /// environment, leaking the payload's storage into `allocator`.
+    ///
+    /// That storage is all the attach needs: the channel's path travels in
+    /// C-string form inside the payload, so attaching the sender borrows
+    /// it and allocates nothing further.
     ///
     /// # Panics
     ///
@@ -50,19 +55,33 @@ impl Client {
     /// [`ChannelConf::sender`](fspy_shared::ipc::channel::ChannelConf::sender)).
     pub fn from_env(
         envs: impl Iterator<Item = fspy_nostd::env::Entry>,
-        allocator: impl Allocator,
+        allocator: &'a impl Allocator,
     ) -> Self {
-        let encoded_payload = decode_payload_from_env(envs).unwrap();
+        let encoded_payload = decode_payload_from_env(envs, allocator).unwrap();
 
         // `None` when the channel is already over, which happens when this
         // process starts after the root target exited. Nothing is said
         // about it: a preload library writing to the traced process's
         // stderr corrupts whatever that process is printing.
-        let ipc_sender = encoded_payload.payload.ipc_channel_conf.sender(allocator);
+        let ipc_sender = encoded_payload.payload.ipc_channel_conf.sender();
 
         Self { encoded_payload, ipc_sender }
     }
 
+    /// Extends the client's borrows to the process lifetime.
+    ///
+    /// # Safety
+    ///
+    /// The storage the client borrows from must never be freed for the
+    /// rest of the process — for example, allocations from a bump
+    /// allocator that is leaked instead of dropped.
+    #[must_use]
+    pub unsafe fn assume_process_lifetime(self) -> Client<'static> {
+        // SAFETY: the types differ only in their lifetime parameter, and the
+        // caller guarantees the backing storage is never freed.
+        unsafe { core::mem::transmute(self) }
+    }
+
     fn send(&self, mode: fspy_shared::ipc::AccessMode, path: &Path) {
         let Some(ipc_sender) = &self.ipc_sender else {
             return;