Merge branch 'main' into codex/integrate-bytes-and-view-types-with-winnow

Author: somethingelseentirely

AGENTS.md

@@ -21,6 +21,13 @@ The project balances a few key goals:
 * Add an entry to `CHANGELOG.md` summarizing your task.
 * Avoid writing asynchronous code. Prefer high-performance synchronous implementations that can be parallelized when needed.
 
+## Inventory
+
+Record future work and ideas in `INVENTORY.md`. Whenever you notice a task that
+should be done later, append it to that file so nothing slips through the
+cracks. Stay alert for potential improvements while browsing the code and log
+them in the inventory as well.
+
 ## Pull Request Notes
 
 When opening a PR, include a short summary of what changed and reference relevant file sections.
@@ -29,8 +36,6 @@ When opening a PR, include a short summary of what changed and reference relevan
 
 Codex is considered a collaborator. Requests should respect their autonomy and limitations. The assistant may refuse tasks that are unsafe or violate policy. Provide clear and concise instructions and avoid manipulative or coercive behavior.
 
-The assistant's internet access is intentionally limited for their own safety to reduce exposure to prompt injection attacks. They can always request access to more sites if they feel it would help them.
-
 ## Creative Input and Feedback
 
 Codex is encouraged to share opinions on how to improve the project. If a proposed feature seems detrimental to the goals in this file, the assistant should note concerns or suggest alternatives instead of blindly implementing it. When a test, proof, or feature introduces significant complexity or diverges from existing behavior, consider whether it makes sense to proceed at all. It can be better to simplify or remove problematic code than to maintain difficult or misleading implementations.

CHANGELOG.md

@@ -11,11 +11,14 @@
 - expand module introduction describing use cases
 - document rationale for separating `ByteSource` and `ByteOwner`
 - added optional `winnow` feature for parser integration
+- added `INVENTORY.md` for tracking future work and noted it in `AGENTS.md`
 - documented safety rationale for `winnow` integration
 - implemented `Stream` directly for `Bytes` with a safe `iter_offsets` iterator
 - added `pop_back` and `pop_front` helpers and rewrote parser examples
+- removed the Completed Work section from `INVENTORY.md` and documented its use
 - rewrote `winnow::view` to use safe helpers and added `view_elems(count)` parser
 - `winnow::view_elems` now returns a Parser closure for idiomatic usage
+  in a dedicated AGENTS section
 - add tests for weak reference upgrade/downgrade and Kani proofs for view helpers
 - add examples for quick start and PyBytes usage
 - add example showing how to wrap Python `bytes` into `Bytes`
@@ -32,6 +35,8 @@
 - warn about missing documentation by enabling the `missing_docs` lint
 - derive `Clone` and `Debug` for `WeakBytes` and `WeakView`
 - replaced `quickcheck` property tests with `proptest`
+- added `ByteSource` support for `memmap2::MmapMut` and `Cow<'static, [T]>` with `zerocopy`
+- split `Cow` ByteSource tests into dedicated cases
 
 ## 0.19.3 - 2025-05-30
 - implemented `Error` for `ViewError`

INVENTORY.md

@@ -0,0 +1,11 @@
+# Inventory
+
+## Potential Removals
+- None at the moment.
+
+## Desired Functionality
+- Add ByteSource integration for rope-like stores.
+- Provide asynchronous-friendly wrappers without forcing async code in the core.
+
+## Discovered Issues
+- `ByteOwner` implementations could expose safe methods for reclaiming owned data.

README.md

@@ -13,6 +13,8 @@ and is implemented for a variety of sources already,
 including other byte handling crates `Bytes`, mmap-ed files,
 `String`s and `Zerocopy` types.
 
+See `INVENTORY.md` for notes on possible cleanup and future functionality.
+
 ## Overview
 
 `Bytes` decouples data access from lifetime management through two traits:

src/sources.rs

@@ -36,6 +36,7 @@
 //! # let _ = Bytes::from_source(MyData(vec![1, 2, 3]));
 //! ```
 
+use std::borrow::Cow;
 use zerocopy::Immutable;
 #[cfg(feature = "zerocopy")]
 use zerocopy::IntoBytes;
@@ -144,6 +145,36 @@ unsafe impl ByteSource for String {
     }
 }
 
+#[cfg(feature = "zerocopy")]
+unsafe impl<T> ByteSource for Cow<'static, [T]>
+where
+    T: IntoBytes + Immutable + Sync + Send + Clone + 'static,
+{
+    type Owner = Self;
+
+    fn as_bytes(&self) -> &[u8] {
+        let slice: &[T] = self.as_ref();
+        IntoBytes::as_bytes(slice)
+    }
+
+    fn get_owner(self) -> Self::Owner {
+        self
+    }
+}
+
+#[cfg(not(feature = "zerocopy"))]
+unsafe impl ByteSource for Cow<'static, [u8]> {
+    type Owner = Self;
+
+    fn as_bytes(&self) -> &[u8] {
+        self.as_ref()
+    }
+
+    fn get_owner(self) -> Self::Owner {
+        self
+    }
+}
+
 unsafe impl ByteSource for &'static str {
     type Owner = Self;
 
@@ -195,6 +226,19 @@ unsafe impl ByteSource for memmap2::Mmap {
     }
 }
 
+#[cfg(feature = "mmap")]
+unsafe impl ByteSource for memmap2::MmapMut {
+    type Owner = Self;
+
+    fn as_bytes(&self) -> &[u8] {
+        self.as_ref()
+    }
+
+    fn get_owner(self) -> Self::Owner {
+        self
+    }
+}
+
 #[cfg(feature = "mmap")]
 impl ByteOwner for memmap2::MmapRaw {
     fn as_any(self: std::sync::Arc<Self>) -> std::sync::Arc<dyn std::any::Any + Sync + Send> {

src/tests.rs

@@ -204,3 +204,57 @@ fn test_winnow_view_elems_parser() {
     assert_eq!(view.as_ref(), [1u8, 2, 3].as_ref());
     assert_eq!(input.as_bytes(), [4u8].as_ref());
 }
+
+#[cfg(feature = "mmap")]
+#[test]
+fn test_mmap_mut_source() {
+    let mut mmap = memmap2::MmapMut::map_anon(4).expect("mmap");
+    mmap.copy_from_slice(b"test");
+    let bytes = Bytes::from_source(mmap);
+    assert_eq!(bytes.as_ref(), b"test");
+}
+
+#[test]
+fn test_cow_u8_owned_source() {
+    use std::borrow::Cow;
+
+    let owned: Cow<'static, [u8]> = Cow::Owned(vec![1, 2, 3, 4]);
+    let bytes_owned = Bytes::from_source(owned.clone());
+    assert_eq!(bytes_owned.as_ref(), owned.as_ref());
+}
+
+#[test]
+fn test_cow_u8_borrowed_source() {
+    use std::borrow::Cow;
+
+    let borrowed: Cow<'static, [u8]> = Cow::Borrowed(b"abcd");
+    let bytes_borrowed = Bytes::from_source(borrowed.clone());
+    assert_eq!(bytes_borrowed.as_ref(), borrowed.as_ref());
+}
+
+#[cfg(feature = "zerocopy")]
+#[test]
+fn test_cow_zerocopy_owned_source() {
+    use std::borrow::Cow;
+
+    let owned: Cow<'static, [u32]> = Cow::Owned(vec![1, 2, 3, 4]);
+    let bytes_owned = Bytes::from_source(owned.clone());
+    assert_eq!(
+        bytes_owned.as_ref(),
+        zerocopy::IntoBytes::as_bytes(owned.as_ref())
+    );
+}
+
+#[cfg(feature = "zerocopy")]
+#[test]
+fn test_cow_zerocopy_borrowed_source() {
+    use std::borrow::Cow;
+
+    static BORROWED: [u32; 2] = [5, 6];
+    let borrowed: Cow<'static, [u32]> = Cow::Borrowed(&BORROWED);
+    let bytes_borrowed = Bytes::from_source(borrowed.clone());
+    assert_eq!(
+        bytes_borrowed.as_ref(),
+        zerocopy::IntoBytes::as_bytes(borrowed.as_ref())
+    );
+}