refactor: migrate from bincode to wincode (#334)

## Why

bincode is unmaintained. The author ceased development and published a
[final 3.0.0 release](https://docs.rs/crate/bincode/3.0.0) containing
only a compiler error to inform users. wincode is the recommended
bincode-compatible drop-in replacement.

## Summary
- Replace bincode 2.x with wincode across all 14 crates for in-place
initialization and direct memory writes without intermediate staging
buffers
- Use wincode's foreign type adoption for `Arc<str>` and `Duration`
(manual `SchemaWrite`/`SchemaRead` impls)
- Borrowed zero-copy deserialization preserved for `&NativeStr`,
`&NativePath`, `PathAccess<'a>`, `Payload<'a>`
- Bump cache version from 10 → 11

## Test plan
- [x] `cargo check` passes
- [x] `cargo clippy` passes (no warnings)
- [x] All 23 workspace test suites pass (excluding 3 pre-existing fspy
oxlint failures unrelated to this change)
- [x] E2E snapshot tests pass
- [x] Plan snapshot tests pass
- [x] `fspy_shared` IPC channel tests pass (encoding/decoding
round-trips correctly)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: branchseer

Cargo.lock

@@ -6,7 +6,7 @@ members = ["crates/*"]
 authors = ["Vite+ Authors"]
 edition = "2024"
 license = "MIT"
-rust-version = "1.88.0"
+rust-version = "1.89.0"
 
 [workspace.lints.rust]
 absolute_paths_not_starting_with_crate = "warn"
@@ -44,7 +44,7 @@ assert2 = "0.3.16"
 assertables = "9.8.1"
 async-trait = "0.1.89"
 base64 = "0.22.1"
-bincode = "2.0.1"
+wincode = "0.5.2"
 bindgen = "0.72.1"
 bitflags = "2.10.0"
 # The newest released version (0.3.0) of brush-parser has a bug that reports incorrect locations for some ast nodes.

Cargo.toml

@@ -6,7 +6,7 @@ publish = false
 
 [dependencies]
 allocator-api2 = { workspace = true, features = ["alloc"] }
-bincode = { workspace = true }
+wincode = { workspace = true }
 bstr = { workspace = true, default-features = false }
 bumpalo = { workspace = true }
 const_format = { workspace = true, features = ["fmt"] }

crates/fspy/Cargo.toml

@@ -1,8 +1,7 @@
 use std::io;
 
-use bincode::borrow_decode_from_slice;
 use fspy_shared::ipc::{
-    BINCODE_CONFIG, PathAccess,
+    PathAccess,
     channel::{Receiver, ReceiverLockGuard},
 };
 use tokio::task::spawn_blocking;
@@ -32,11 +31,8 @@ impl OwnedReceiverLockGuard {
     }
 
     pub fn iter_path_accesses(&self) -> impl Iterator<Item = PathAccess<'_>> {
-        self.borrow_lock_guard().iter_frames().map(|frame| {
-            let (path_access, decoded_size) =
-                borrow_decode_from_slice::<PathAccess<'_>, _>(frame, BINCODE_CONFIG).unwrap();
-            assert_eq!(decoded_size, frame.len());
-            path_access
-        })
+        self.borrow_lock_guard()
+            .iter_frames()
+            .map(|frame| wincode::deserialize_exact(frame).unwrap())
     }
 }

crates/fspy/src/ipc.rs

@@ -9,7 +9,7 @@ use std::{
 use const_format::formatcp;
 use fspy_detours_sys::{DetourCopyPayloadToProcess, DetourUpdateProcessWithDll};
 use fspy_shared::{
-    ipc::{BINCODE_CONFIG, PathAccess, channel::channel},
+    ipc::{PathAccess, channel::channel},
     windows::{PAYLOAD_ID, Payload},
 };
 use futures_util::FutureExt;
@@ -109,7 +109,7 @@ impl SpyImpl {
                     channel_conf: channel_conf.clone(),
                     ansi_dll_path_with_nul: ansi_dll_path_with_nul.to_bytes(),
                 };
-                let payload_bytes = bincode::encode_to_vec(payload, BINCODE_CONFIG).unwrap();
+                let payload_bytes = wincode::serialize(&payload).unwrap();
                 // SAFETY: process_handle is valid, PAYLOAD_ID is a static GUID,
                 // payload_bytes is a valid buffer with correct length
                 let success = unsafe {

crates/fspy/src/windows/mod.rs

@@ -8,7 +8,7 @@ crate-type = ["cdylib"]
 
 [target.'cfg(unix)'.dependencies]
 anyhow = { workspace = true }
-bincode = { workspace = true }
+wincode = { workspace = true }
 bstr = { workspace = true, default-features = false }
 ctor = { workspace = true }
 fspy_shared = { workspace = true }

crates/fspy_preload_unix/Cargo.toml

@@ -6,15 +6,15 @@ use std::{
     sync::OnceLock,
 };
 
-use bincode::{enc::write::SizeWriter, encode_into_slice, encode_into_writer};
 use convert::{ToAbsolutePath, ToAccessMode};
-use fspy_shared::ipc::{BINCODE_CONFIG, PathAccess, channel::Sender};
+use fspy_shared::ipc::{PathAccess, channel::Sender};
 use fspy_shared_unix::{
     exec::ExecResolveConfig,
     payload::EncodedPayload,
     spawn::{PreExec, handle_exec},
 };
 use raw_exec::RawExec;
+use wincode::Serialize as _;
 
 pub struct Client {
     encoded_payload: EncodedPayload,
@@ -72,17 +72,18 @@ impl Client {
             return Ok(());
         }
         let path_access = PathAccess { mode, path: path.into() };
-        let mut size_writer = SizeWriter::default();
-        encode_into_writer(path_access, &mut size_writer, BINCODE_CONFIG)?;
+        let serialized_size = usize::try_from(PathAccess::serialized_size(&path_access)?)
+            .expect("serialized size exceeds usize");
 
-        let frame_size = NonZeroUsize::new(size_writer.bytes_written)
+        let frame_size = NonZeroUsize::new(serialized_size)
             .expect("fspy: encoded PathAccess should never be empty");
 
         let mut frame = ipc_sender
             .claim_frame(frame_size)
             .expect("fspy: failed to claim frame in shared memory");
-        let written_size = encode_into_slice(path_access, &mut frame, BINCODE_CONFIG)?;
-        assert_eq!(written_size, size_writer.bytes_written);
+        let mut writer: &mut [u8] = &mut frame;
+        PathAccess::serialize_into(&mut writer, &path_access)?;
+        assert_eq!(writer.len(), 0);
 
         Ok(())
     }

crates/fspy_preload_unix/src/client/mod.rs

@@ -7,7 +7,7 @@ edition.workspace = true
 crate-type = ["cdylib"]
 
 [target.'cfg(target_os = "windows")'.dependencies]
-bincode = { workspace = true }
+wincode = { workspace = true }
 constcat = { workspace = true }
 fspy_detours_sys = { workspace = true }
 fspy_shared = { workspace = true }

crates/fspy_preload_windows/Cargo.toml

@@ -1,9 +1,8 @@
 use std::{cell::SyncUnsafeCell, ffi::CStr, mem::MaybeUninit};
 
-use bincode::{borrow_decode_from_slice, encode_to_vec};
 use fspy_detours_sys::DetourCopyPayloadToProcess;
 use fspy_shared::{
-    ipc::{BINCODE_CONFIG, PathAccess, channel::Sender},
+    ipc::{PathAccess, channel::Sender},
     windows::{PAYLOAD_ID, Payload},
 };
 use winapi::{shared::minwindef::BOOL, um::winnt::HANDLE};
@@ -15,9 +14,7 @@ pub struct Client<'a> {
 
 impl<'a> Client<'a> {
     pub fn from_payload_bytes(payload_bytes: &'a [u8]) -> Self {
-        let (payload, decoded_len) =
-            borrow_decode_from_slice::<'a, Payload, _>(payload_bytes, BINCODE_CONFIG).unwrap();
-        assert_eq!(decoded_len, payload_bytes.len());
+        let payload: Payload<'a> = wincode::deserialize_exact(payload_bytes).unwrap();
 
         let ipc_sender = match payload.channel_conf.sender() {
             Ok(sender) => Some(sender),
@@ -43,11 +40,11 @@ impl<'a> Client<'a> {
         let Some(sender) = &self.ipc_sender else {
             return;
         };
-        sender.write_encoded(&access, BINCODE_CONFIG).expect("failed to send path access");
+        sender.write_encoded(&access).expect("failed to send path access");
     }
 
     pub unsafe fn prepare_child_process(&self, child_handle: HANDLE) -> BOOL {
-        let payload_bytes = encode_to_vec(&self.payload, BINCODE_CONFIG).unwrap();
+        let payload_bytes = wincode::serialize(&self.payload).unwrap();
         // SAFETY: FFI call to DetourCopyPayloadToProcess with valid handle and payload buffer
         unsafe {
             DetourCopyPayloadToProcess(

crates/fspy_preload_windows/src/windows/client.rs

@@ -5,7 +5,7 @@ edition = "2024"
 publish = false
 
 [target.'cfg(target_os = "linux")'.dependencies]
-bincode = { workspace = true }
+wincode = { workspace = true, features = ["derive"] }
 libc = { workspace = true }
 nix = { workspace = true, features = ["process", "fs", "poll", "socket", "uio"] }
 passfd = { workspace = true, default-features = false, optional = true }