Milestone Update v0.7.0

Author: James Gober

CHANGELOG.md

@@ -6,6 +6,52 @@ the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-05-19
+
+Driver trait release. Closes the third (and last) deferral from
+the `0.3.0` design lock. All locked surfaces from the original
+design lock are now shipped.
+
+### Added
+
+- `pub trait Driver` in `pipe_io::driver`, re-exported as
+  `pipe_io::Driver`. Generic executor abstraction with `Send`
+  bounds on the source and its item/error types. Not sealed;
+  external executors (tokio, rayon, custom thread farms) can
+  implement it.
+- `impl Driver for SyncDriver` and (under `std`)
+  `impl Driver for ThreadedDriver`. Both delegate to their existing
+  inherent `run` methods.
+- `Pipeline::run_with<D: Driver>(driver: D)` builder-terminal
+  method. Lets callers select any `Driver` impl explicitly.
+- 6 integration tests in `tests/driver_trait.rs`: sync via trait,
+  threaded via trait, `run_with(SyncDriver)`, `run_with(ThreadedDriver)`,
+  a custom `CountingDriver` impl, and a static check that the
+  built-in and custom drivers all satisfy `Driver`.
+
+### Changed
+
+- `REPS.md` section 4.8 un-defers the `Driver` trait; the
+  trait-based abstraction is now part of the locked surface.
+- `docs/API.md` documents the trait and the `Pipeline::run_with`
+  method.
+- `SyncDriver::run` (inherent method) keeps its looser bound (no
+  `Send` requirement on the source). The trait impl uses the
+  stricter bound. Both compile to the same call.
+
+### Notes
+
+- The trait deliberately carries the stricter `Send` bound so
+  that any `Driver` impl can be a threaded executor. To drive a
+  non-`Send` source on the calling thread, call
+  `SyncDriver::run` directly (inherent method); the trait method
+  is unavailable for non-`Send` sources by design.
+- This is the last design-lock deferral. The locked `1.0.0`
+  surface in `REPS.md` is now fully implemented except for
+  `PipelineBuilder::buffer(capacity)`, which was listed in §4.9
+  but is not yet shipped; it lands in a future release alongside
+  per-stage threading or as a separate `0.8.x` slot.
+
 ## [0.6.0] - 2026-05-19
 
 Dead-letter routing release. Wires up `ErrorPolicy::DeadLetter`
@@ -216,7 +262,8 @@ public surface.
   `.dev/` planning structure (DIRECTIVES, ROADMAP, PROMPTS).
 - Crate name reserved on crates.io.
 
-[Unreleased]: https://github.com/jamesgober/pipe-io/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/jamesgober/pipe-io/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/jamesgober/pipe-io/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/jamesgober/pipe-io/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/jamesgober/pipe-io/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/jamesgober/pipe-io/compare/v0.3.0...v0.4.0

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pipe-io"
-version = "0.6.0"
+version = "0.7.0"
 edition = "2021"
 rust-version = "1.75"
 readme = "README.md"

Cargo.toml

@@ -221,27 +221,39 @@ arriving items will not close until end-of-stream.
 
 ### 4.8 `pipe_io::driver`
 
-A trait-based driver abstraction is deferred past `0.3.0` because
-`SyncDriver` and `ThreadedDriver` have different `Send` bounds on
-the source and item types, and exposing a single unified trait
-locks in the stricter bounds for both. The trait will land once
-the bound difference is reconciled (likely via a sealed
-helper-trait pattern or two separate trait surfaces).
-
-`0.3.x` ships:
-
-- `SyncDriver` - zero-sized marker. Pumps the pipeline on the
-  caller's thread. `no_std`-compatible.
-- `ThreadedDriver` **(std)** - zero-sized marker. Pumps the
-  pipeline on a single background thread; the calling thread
-  blocks on `join`. Per-stage threading is a future enhancement.
+- `trait Driver` - generic executor abstraction. The trait carries
+  `Send` bounds on the source and its item/error types (matching
+  `ThreadedDriver`'s natural requirements). External executors
+  (tokio runtime, rayon pool, custom thread farm, ...) implement
+  this trait. The trait is *not* sealed; consumers can plug in
+  their own drivers.
+
+  ```text
+  trait Driver {
+      fn run<S>(self, pipeline: Pipeline<S>) -> Result<RunStats>
+      where
+          S: Source + Send + 'static,
+          S::Item: Send + 'static,
+          S::Error: Send + 'static;
+  }
+  ```
+
+- `SyncDriver` - pumps the pipeline on the caller's thread.
+  Implements [`Driver`] and additionally exposes an inherent
+  `run` method with looser bounds (no `Send` requirement on the
+  source). Use the inherent method when driving a non-`Send`
+  source on the current thread.
+- `ThreadedDriver` **(std)** - pumps the pipeline on a single
+  background thread; the calling thread blocks on `join`.
+  Implements [`Driver`].
 - `RunStats` - statistics returned by a successful run.
 
 `Pipeline` exposes:
 
-- `.run()` - synchronous; equivalent to `SyncDriver::default().run(...)`.
+- `.run()` - synchronous; equivalent to `SyncDriver::new().run(...)`.
 - `.run_threaded()` **(std)** - threaded; equivalent to
-  `ThreadedDriver::default().run(...)`.
+  `ThreadedDriver::new().run(...)`.
+- `.run_with(driver)` - generic over any `Driver` impl.
 
 ### 4.9 Builder surface (full)
 

REPS.md

@@ -39,6 +39,7 @@
 | `pipe_io::Sink`                     | trait    | Re-export from `pipe_io::sink`.                    |
 | `pipe_io::Emit`                     | trait    | Re-export from `pipe_io::emit`.                    |
 | `pipe_io::EmitError`                | enum     | Re-export from `pipe_io::emit`.                    |
+| `pipe_io::Driver`                   | trait    | Re-export from `pipe_io::driver`.                  |
 | `pipe_io::Batch<T>`                 | struct   | Owned group of items emitted by `.batch()`.        |
 | `pipe_io::BatchPolicy`              | struct   | Batch trigger configuration.                       |
 | `pipe_io::ByteSize`                 | trait    | Opt-in for byte-aware batching.                    |
@@ -244,13 +245,24 @@ pub struct RunStats {
     pub duration: Duration,  // std only
 }
 
+pub trait Driver {
+    fn run<S>(self, pipeline: Pipeline<S>) -> Result<RunStats>
+    where
+        S: Source + Send + 'static,
+        S::Item: Send + 'static,
+        S::Error: Send + 'static;
+}
+
 #[derive(Default, Clone, Copy)]
 pub struct SyncDriver;
 
 impl SyncDriver {
     pub const fn new() -> Self;
+    // Inherent method with looser bound (no Send required); use this
+    // when driving a non-Send source on the current thread.
     pub fn run<S: Source>(self, pipeline: Pipeline<S>) -> Result<RunStats>;
 }
+impl Driver for SyncDriver { /* delegates to inherent run */ }
 
 #[derive(Default, Clone, Copy)]
 pub struct ThreadedDriver;  // std only
@@ -263,11 +275,13 @@ impl ThreadedDriver {
         S::Item: Send + 'static,
         S::Error: Send + 'static;
 }
+impl Driver for ThreadedDriver { /* delegates to inherent run */ }
 ```
 
-A unified `Driver` trait is deferred past `0.3.0`; consumers
-select a driver by calling `Pipeline::run` (sync) or
-`Pipeline::run_threaded` (std).
+Consumers select a driver by calling `Pipeline::run` (sync),
+`Pipeline::run_threaded` (std), or `Pipeline::run_with(driver)`
+for any `Driver` impl. The trait is not sealed; external
+executors (tokio, rayon, custom thread farm) can implement it.
 
 ## `pipe_io::emit`
 
@@ -293,6 +307,8 @@ impl<S: Source> Pipeline<S> {
 
     pub fn run(self) -> Result<RunStats>;
     pub fn run_threaded(self) -> Result<RunStats>;  // std only
+    pub fn run_with<D: Driver>(self, driver: D) -> Result<RunStats>
+        where S: Send, S::Item: Send, S::Error: Send;
 }
 
 impl<T, S, Acc> PipelineBuilder<T, S, Acc>