6 files changed, 31 insertions, 31 deletions
diff --git a/mingling_pathf/README.md b/mingling_pathf/README.md
index 89d1811..9706f49 100644
--- a/mingling_pathf/README.md
+++ b/mingling_pathf/README.md
@@ -7,7 +7,7 @@
 
 ## Overview
 
-`mingling_pathf` provides the `pathf` feature for Mingling. It automatically analyzes the full module paths of all Mingling types in a crate at build-time (types defined via `pack!`, `#[derive(Groupped)]`, `#[chain]`, `#[renderer]`, etc.), and generates a mapping from type names to module paths for consumption by `gen_program!()` at compile-time.
+`mingling_pathf` provides the `pathf` feature for Mingling. It automatically analyzes the full module paths of all Mingling types in a crate at build-time (types defined via `pack!`, `#[derive(Grouped)]`, `#[chain]`, `#[renderer]`, etc.), and generates a mapping from type names to module paths for consumption by `gen_program!()` at compile-time.
 
 When enabled, `gen_program!()` uses full module paths for type references in the generated dispatch code (e.g., `downcast::<myapp::sub::ResultMyName>()`), eliminating the need to `use` all types in the module where `gen_program!()` is called. This allows for a more flexible module organization without the constraint of centralized `use` statements.
 
diff --git a/mingling_pathf/src/pattern_analyzer.rs b/mingling_pathf/src/pattern_analyzer.rs
index 3765971..5bbc3b4 100644
--- a/mingling_pathf/src/pattern_analyzer.rs
+++ b/mingling_pathf/src/pattern_analyzer.rs
@@ -31,7 +31,7 @@ pub fn init_with_config(config: PathfinderConfig) -> PatternAnalyzer {
     analyzer.add_pattern(BasicStructPattern);
     analyzer.add_pattern(PackPattern);
     analyzer.add_pattern(GroupPattern);
-    analyzer.add_pattern(GrouppedDerivePattern);
+    analyzer.add_pattern(GroupedDerivePattern);
     analyzer.add_pattern(ChainPattern);
     analyzer.add_pattern(RendererPattern);
     analyzer.add_pattern(HelpPattern);
diff --git a/mingling_pathf/src/patterns.rs b/mingling_pathf/src/patterns.rs
index 9801e9b..9845b73 100644
--- a/mingling_pathf/src/patterns.rs
+++ b/mingling_pathf/src/patterns.rs
@@ -6,7 +6,7 @@ pub use completion::*;
 pub use dispatcher::*;
 pub use dispatcher_clap::*;
 pub use group::*;
-pub use groupped_derive::*;
+pub use grouped_derive::*;
 pub use help::*;
 pub use pack::*;
 pub use renderer::*;
@@ -17,7 +17,7 @@ mod completion;
 mod dispatcher;
 mod dispatcher_clap;
 mod group;
-mod groupped_derive;
+mod grouped_derive;
 mod help;
 mod pack;
 mod renderer;
diff --git a/mingling_pathf/src/patterns/groupped_derive.rs b/mingling_pathf/src/patterns/grouped_derive.rs
index 91daaef..9522c1f 100644
--- a/mingling_pathf/src/patterns/groupped_derive.rs
+++ b/mingling_pathf/src/patterns/grouped_derive.rs
@@ -1,5 +1,5 @@
-//! The `GrouppedDerivePattern` matches structs, enums, and unions annotated with
-//! `#[derive(Groupped)]` or `#[derive(GrouppedSerialize)]` (or any combination
+//! The `GroupedDerivePattern` matches structs, enums, and unions annotated with
+//! `#[derive(Grouped)]` or `#[derive(GroupedSerialize)]` (or any combination
 //! with other derives). It also recurses into `mod` items to find nested types.
 //! This is used to track grouped items for code generation or analysis.
 
@@ -7,17 +7,17 @@ use syn::Item;
 
 use crate::pattern_analyzer::{AnalyzeItem, AnalyzePattern};
 
-/// Matches `#[derive(Groupped)]` and `#[derive(GrouppedSerialize)]`.
+/// Matches `#[derive(Grouped)]` and `#[derive(GroupedSerialize)]`.
 ///
 /// Covers the forms:
-/// - `#[derive(Groupped)] struct T { ... }`
-/// - `#[derive(Groupped, Serialize, ...)] struct T { ... }`
-/// - `#[derive(GrouppedSerialize)] struct T { ... }`
-pub struct GrouppedDerivePattern;
+/// - `#[derive(Grouped)] struct T { ... }`
+/// - `#[derive(Grouped, Serialize, ...)] struct T { ... }`
+/// - `#[derive(GroupedSerialize)] struct T { ... }`
+pub struct GroupedDerivePattern;
 
-impl AnalyzePattern for GrouppedDerivePattern {
+impl AnalyzePattern for GroupedDerivePattern {
     fn contains(&self, content: &str) -> bool {
-        content.contains("Groupped")
+        content.contains("Grouped")
     }
 
     fn analyze(&self, content: &str) -> Vec<AnalyzeItem> {
@@ -29,19 +29,19 @@ impl AnalyzePattern for GrouppedDerivePattern {
 
         for item in &syntax.items {
             match item {
-                Item::Struct(s) if has_groupped_derive(&s.attrs) => {
+                Item::Struct(s) if has_grouped_derive(&s.attrs) => {
                     items.push(AnalyzeItem {
                         module: String::new(),
                         item_name: s.ident.to_string(),
                     });
                 }
-                Item::Enum(e) if has_groupped_derive(&e.attrs) => {
+                Item::Enum(e) if has_grouped_derive(&e.attrs) => {
                     items.push(AnalyzeItem {
                         module: String::new(),
                         item_name: e.ident.to_string(),
                     });
                 }
-                Item::Union(u) if has_groupped_derive(&u.attrs) => {
+                Item::Union(u) if has_grouped_derive(&u.attrs) => {
                     items.push(AnalyzeItem {
                         module: String::new(),
                         item_name: u.ident.to_string(),
@@ -51,13 +51,13 @@ impl AnalyzePattern for GrouppedDerivePattern {
                     if let Some((_, nested)) = &item_mod.content {
                         for n in nested {
                             match n {
-                                Item::Struct(s) if has_groupped_derive(&s.attrs) => {
+                                Item::Struct(s) if has_grouped_derive(&s.attrs) => {
                                     items.push(AnalyzeItem {
                                         module: item_mod.ident.to_string(),
                                         item_name: s.ident.to_string(),
                                     });
                                 }
-                                Item::Enum(e) if has_groupped_derive(&e.attrs) => {
+                                Item::Enum(e) if has_grouped_derive(&e.attrs) => {
                                     items.push(AnalyzeItem {
                                         module: item_mod.ident.to_string(),
                                         item_name: e.ident.to_string(),
@@ -76,10 +76,10 @@ impl AnalyzePattern for GrouppedDerivePattern {
     }
 }
 
-fn has_groupped_derive(attrs: &[syn::Attribute]) -> bool {
+fn has_grouped_derive(attrs: &[syn::Attribute]) -> bool {
     attrs.iter().any(|attr| {
         if attr.path().is_ident("derive") {
-            // Correctly parse comma-separated paths in #[derive(Groupped, Debug, ...)]
+            // Correctly parse comma-separated paths in #[derive(Grouped, Debug, ...)]
             attr.parse_args_with(|input: syn::parse::ParseStream| {
                 let paths =
                     syn::punctuated::Punctuated::<syn::Path, syn::Token![,]>::parse_terminated(
@@ -87,7 +87,7 @@ fn has_groupped_derive(attrs: &[syn::Attribute]) -> bool {
                     )?;
                 Ok(paths.iter().any(|p| {
                     let name = p.segments.last().unwrap().ident.to_string();
-                    name == "Groupped" || name == "GrouppedSerialize"
+                    name == "Grouped" || name == "GroupedSerialize"
                 }))
             })
             .unwrap_or(false)
diff --git a/mingling_pathf/test/src/lib.rs b/mingling_pathf/test/src/lib.rs
index 824cbbf..7e7cbd5 100644
--- a/mingling_pathf/test/src/lib.rs
+++ b/mingling_pathf/test/src/lib.rs
@@ -222,11 +222,11 @@ fn test_group_analyze() {
 }
 
 #[test]
-fn test_groupped_derive_analyze() {
+fn test_grouped_derive_analyze() {
     let analyzer = mingling_pathf::pattern_analyzer::init();
     let file = current_dir()
         .unwrap()
-        .join("src/test_files/test_groupped_derive.rs");
+        .join("src/test_files/test_grouped_derive.rs");
 
     let r = analyzer.analyze_file(file).unwrap();
     let required: Vec<&str> = vec![
diff --git a/mingling_pathf/test/src/test_files/test_groupped_derive.rs b/mingling_pathf/test/src/test_files/test_grouped_derive.rs
index 913587c..20055e9 100644
--- a/mingling_pathf/test/src/test_files/test_groupped_derive.rs
+++ b/mingling_pathf/test/src/test_files/test_grouped_derive.rs
@@ -1,42 +1,42 @@
-#[derive(Groupped)]
+#[derive(Grouped)]
 struct Derived1 {
     value: String,
 }
 
-#[derive(Groupped, Debug, Clone)]
+#[derive(Grouped, Debug, Clone)]
 struct Derived2 {
     value: i32,
 }
 
-#[derive(GrouppedSerialize)]
+#[derive(GroupedSerialize)]
 struct Derived3 {
     value: bool,
 }
 
-#[derive(Groupped)]
+#[derive(Grouped)]
 enum EnumDerived1 {
     A,
     B,
 }
 
-#[derive(GrouppedSerialize)]
+#[derive(GroupedSerialize)]
 enum EnumDerived2 {
     X(String),
     Y(i32),
 }
 
 pub mod sub {
-    #[derive(Groupped)]
+    #[derive(Grouped)]
     struct Derived1 {
         value: String,
     }
 
-    #[derive(GrouppedSerialize)]
+    #[derive(GroupedSerialize)]
     struct Derived3 {
         value: bool,
     }
 
-    #[derive(Groupped)]
+    #[derive(Grouped)]
     enum EnumDerived1 {
         A,
     }