work in progress.

Author: gouslu

rust/otap-dataflow/crates/engine/src/capability/registry/storage.rs

@@ -142,8 +142,9 @@ impl Default for CapabilityRegistry {
 
 impl std::fmt::Debug for CapabilityRegistry {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        // The entry values are type-erased (`dyn Any` / `dyn SharedCapabilityFactory`)
-        // and can't be printed. Summarize the shape instead.
+        // The entry values hold type-erased produce closures
+        // (`dyn SharedProduce` / `dyn LocalProduce`) and can't be
+        // printed. Summarize the shape instead.
         f.debug_struct("CapabilityRegistry")
             .field("local_capabilities", &self.local.len())
             .field("shared_capabilities", &self.shared.len())

rust/otap-dataflow/crates/engine/src/capability/registry/tests.rs

@@ -748,7 +748,7 @@ fn test_end_to_end_shared_fresh_policy_mints_independent_instances() {
 
     let bundle = ExtensionWrapper::builder(name.clone(), user_config, &runtime_config)
         .passive()
-        .factory()
+        .fresh()
         .shared::<FreshImpl, _>(move || {
             let _ = counter_for_closure.fetch_add(1, Ordering::SeqCst);
             FreshImpl(Arc::clone(&counter_for_closure), "fresh")

rust/otap-dataflow/crates/engine/src/extension/builder.rs

@@ -25,7 +25,7 @@
 //! // Passive extension, fresh-per-consumer policy.
 //! builder
 //!     .passive()
-//!     .factory()
+//!     .fresh()
 //!     .shared(|| MyShared::new(cfg.clone()))
 //!     .local(|| Rc::new(MyLocal::new(cfg.clone())))
 //!     .build()?;
@@ -36,7 +36,7 @@
 //! | Axis            | Methods                                                                    |
 //! |-----------------|----------------------------------------------------------------------------|
 //! | Lifecycle       | `.active()` / `.passive()`                                                 |
-//! | Instance policy | *(implicit Cloned for Active)* `.cloned()` / `.factory()` *(Passive only)* |
+//! | Instance policy | *(implicit Cloned for Active)* `.cloned()` / `.fresh()` *(Passive only)* |
 //! | Side            | `.shared(...)` / `.local(...)` *(repeatable, register once each)*          |
 //!
 //! **Why the lifecycle and policy are sealed per bundle.** "This
@@ -50,10 +50,10 @@
 //! strategy across both sides makes the extension's behavior
 //! predictable and eliminates a combinatorial footgun.
 //!
-//! **Active + Factory is unrepresentable.** Active extensions have a
+//! **Active + Fresh is unrepresentable.** Active extensions have a
 //! single engine-driven event loop; minting fresh instances per
 //! consumer doesn't compose with that. The `.active()` stage provides
-//! no `.factory()` method — the invalid combination is a compile-time
+//! no `.fresh()` method — the invalid combination is a compile-time
 //! error.
 
 use super::{ExtensionBundle, ExtensionLifecycle, ExtensionWrapper};
@@ -176,8 +176,8 @@ impl PassiveStage {
     /// Select the **fresh-per-consumer** instance policy: each consumer
     /// receives a freshly-constructed instance from the stored closure.
     #[must_use]
-    pub fn factory(self) -> PassiveFactoryStage {
-        PassiveFactoryStage {
+    pub fn fresh(self) -> PassiveFreshStage {
+        PassiveFreshStage {
             parent: self.parent,
         }
     }
@@ -234,13 +234,13 @@ impl PassiveClonedStage {
     }
 }
 
-/// Passive + Factory (fresh-per-consumer) stage.
+/// Passive + Fresh (fresh-per-consumer) stage.
 #[doc(hidden)]
-pub struct PassiveFactoryStage {
+pub struct PassiveFreshStage {
     parent: ExtensionBundleBuilder,
 }
 
-impl PassiveFactoryStage {
+impl PassiveFreshStage {
     /// Register the shared (Send) variant via a factory closure.
     /// Each consumer receives a freshly-constructed instance.
     ///
@@ -337,7 +337,7 @@ impl ExtensionBundleBuilder {
     /// event loop is spawned; the extension exposes capabilities only.
     ///
     /// Continue with [`PassiveStage::cloned`] (clone-per-consumer)
-    /// or [`PassiveStage::factory`] (fresh-per-consumer).
+    /// or [`PassiveStage::fresh`] (fresh-per-consumer).
     #[must_use]
     pub fn passive(self) -> PassiveStage {
         PassiveStage { parent: self }

rust/otap-dataflow/crates/engine/src/extension/mod.rs

@@ -9,7 +9,7 @@
 //! | Submodule   | Contents                                                                 |
 //! |-------------|--------------------------------------------------------------------------|
 //! | [`wrapper`] | [`ControlChannel`], [`EffectHandler`], [`ExtensionLifecycle`], [`ExtensionWrapper`], [`ExtensionBundle`] |
-//! | [`builder`] | Typestate chain: [`ExtensionBundleBuilder`], [`ActiveStage`], [`PassiveStage`], [`PassiveClonedStage`], [`PassiveFactoryStage`], plus [`SharedDecomposed`] / [`LocalDecomposed`] |
+//! | [`builder`] | Typestate chain: [`ExtensionBundleBuilder`], [`ActiveStage`], [`PassiveStage`], [`PassiveClonedStage`], [`PassiveFreshStage`], plus [`SharedDecomposed`] / [`LocalDecomposed`] |
 //!
 //! For the local (!Send) and shared (Send) Extension traits, see
 //! [`local::extension`](crate::local::extension) and
@@ -22,7 +22,7 @@ pub mod wrapper;
 mod tests;
 
 pub use builder::{
-    ActiveStage, ExtensionBundleBuilder, LocalDecomposed, PassiveClonedStage, PassiveFactoryStage,
+    ActiveStage, ExtensionBundleBuilder, LocalDecomposed, PassiveClonedStage, PassiveFreshStage,
     PassiveStage, SharedDecomposed,
 };
 pub use wrapper::{

rust/otap-dataflow/crates/engine/src/extension/tests.rs

@@ -517,11 +517,11 @@ fn test_dual_passive() {
 }
 
 #[test]
-fn test_dual_passive_factory() {
+fn test_dual_passive_fresh() {
     let (n, u, c) = ext_config("dpf");
     let mut set = ExtensionWrapper::builder(n, u, &c)
         .passive()
-        .factory()
+        .fresh()
         .local(|| std::rc::Rc::new(42u32))
         .shared(|| "data".to_string())
         .build()

rust/otap-dataflow/crates/engine/src/extension/wrapper.rs

@@ -238,10 +238,10 @@ pub enum ExtensionLifecycle<E, R> {
 /// capability trait object.
 ///
 /// The instance policy chosen at the builder (`.cloned(...)` vs
-/// `.factory(...)`) is baked into the stored closure:
-/// - **ClonePerConsumer** — the closure captures a prototype `E: Clone`
+/// `.fresh(...)`) is baked into the stored closure:
+/// - **Cloned** — the closure captures a prototype `E: Clone`
 ///   and returns `e.clone()` on each call.
-/// - **FreshPerConsumer** — the closure captures the user-supplied
+/// - **Fresh** — the closure captures the user-supplied
 ///   `Fn() -> E` and invokes it on each call.
 ///
 /// `SharedInstanceFactory` is [`Clone`]: one extension may provide