17 files changed, 878 insertions, 40 deletions

diff --git a/mingling/src/constants.rs b/mingling/src/constants.rs
new file mode 100644
index 0000000..65d02e8
--- /dev/null
+++ b/mingling/src/constants.rs
@@ -0,0 +1,8 @@
+#[cfg(feature = "picker")]
+mod picker;
+
+#[cfg(feature = "picker")]
+pub use picker::*;
+
+mod exit_codes;
+pub use exit_codes::*;
diff --git a/mingling/src/constants/exit_codes.rs b/mingling/src/constants/exit_codes.rs
new file mode 100644
index 0000000..2359f42
--- /dev/null
+++ b/mingling/src/constants/exit_codes.rs
@@ -0,0 +1,14 @@
+/// Exit code indicating successful command execution.
+pub const EXIT_SUCCESS: i32 = 0;
+
+/// Exit code for general errors.
+pub const EXIT_GENERAL_ERR: i32 = 1;
+
+/// Exit code for incorrect command usage (or invalid arguments).
+pub const EXIT_USAGE_ERR: i32 = 2;
+
+/// Exit code indicating permission denied (or the command is not executable).
+pub const EXIT_PERM_DENIED: i32 = 126;
+
+/// Exit code for command not found (or PATH error).
+pub const EXIT_CMD_NOT_FOUND: i32 = 127;
diff --git a/mingling/src/constants/picker.rs b/mingling/src/constants/picker.rs
new file mode 100644
index 0000000..f2a448b
--- /dev/null
+++ b/mingling/src/constants/picker.rs
@@ -0,0 +1,129 @@
+use std::marker::PhantomData;
+
+use arg_picker::{PickerArg, PickerArgs, value::Flag};
+
+/// Remaining positional arguments (anything not consumed as an option).
+/// - `full`: `[]` (empty — not triggered by any `--` prefix).
+/// - `short`: (none)
+/// - `positional`: `false` (this is a meta‑argument that collects everything left).
+///   This constant is used internally to access any leftover arguments after
+///   all defined flags/options have been processed.
+pub const REMAINS: PickerArg<PickerArgs> = PickerArg::<PickerArgs> {
+    full: &[],
+    short: None,
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// Help flag: display usage information.
+/// - `full`: `["help"]`
+/// - `short`: `'h'`
+pub const HELP_FLAG: PickerArg<Flag> = PickerArg::<Flag> {
+    full: &["help"],
+    short: Some('h'),
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// Quiet flag: suppress output.
+/// - `full`: `["quiet"]`
+/// - `short`: `'q'`
+pub const QUIET_FLAG: PickerArg<Flag> = PickerArg::<Flag> {
+    full: &["quiet"],
+    short: Some('q'),
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// Confirm flag: require user confirmation before proceeding.
+/// - `full`: `["confirm"]`
+/// - `short`: `'C'`
+pub const CONFIRM_FLAG: PickerArg<Flag> = PickerArg::<Flag> {
+    full: &["confirm"],
+    short: Some('C'),
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// Renderer flag: explicitly specify the Structural Renderer argument.
+/// - `full`: `["renderer"]`
+/// - `short`: (none)
+#[cfg(feature = "structural_renderer")]
+pub const RENDERER_ARG: PickerArg<String> = PickerArg::<String> {
+    full: &["renderer"],
+    short: None,
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// JSON flag: enable JSON output format.
+/// - `full`: `["json"]`
+/// - `short`: (none)
+///   Available only when the `json_serde_fmt` feature is enabled.
+#[cfg(feature = "json_serde_fmt")]
+pub const JSON_FLAG: PickerArg<Flag> = PickerArg::<Flag> {
+    full: &["json"],
+    short: None,
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// JSON pretty flag: enable pretty-printed JSON output format.
+/// - `full`: `["json_pretty"]`
+/// - `short`: (none)
+///   Available only when the `json_serde_fmt` feature is enabled.
+#[cfg(feature = "json_serde_fmt")]
+pub const JSON_PRETTY_FLAG: PickerArg<Flag> = PickerArg::<Flag> {
+    full: &["json_pretty"],
+    short: None,
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// YAML flag: enable YAML output format.
+/// - `full`: `["yaml"]`
+/// - `short`: (none)
+///   Available only when the `yaml_serde_fmt` feature is enabled.
+#[cfg(feature = "yaml_serde_fmt")]
+pub const YAML_FLAG: PickerArg<Flag> = PickerArg::<Flag> {
+    full: &["yaml"],
+    short: None,
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// TOML flag: enable TOML output format.
+/// - `full`: `["toml"]`
+/// - `short`: (none)
+///   Available only when the `toml_serde_fmt` feature is enabled.
+#[cfg(feature = "toml_serde_fmt")]
+pub const TOML_FLAG: PickerArg<Flag> = PickerArg::<Flag> {
+    full: &["toml"],
+    short: None,
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// RON flag: enable RON output format.
+/// - `full`: `["ron"]`
+/// - `short`: (none)
+///   Available only when the `ron_serde_fmt` feature is enabled.
+#[cfg(feature = "ron_serde_fmt")]
+pub const RON_FLAG: PickerArg<Flag> = PickerArg::<Flag> {
+    full: &["ron"],
+    short: None,
+    positional: false,
+    internal_type: PhantomData,
+};
+
+/// RON pretty flag: enable pretty-printed RON output format.
+/// - `full`: `["ron_pretty"]`
+/// - `short`: (none)
+///   Available only when the `ron_serde_fmt` feature is enabled.
+#[cfg(feature = "ron_serde_fmt")]
+pub const RON_PRETTY_FLAG: PickerArg<Flag> = PickerArg::<Flag> {
+    full: &["ron_pretty"],
+    short: None,
+    positional: false,
+    internal_type: PhantomData,
+};
diff --git a/mingling/src/example_docs.rs b/mingling/src/example_docs.rs
index 4699a50..bdefb5a 100644
--- a/mingling/src/example_docs.rs
+++ b/mingling/src/example_docs.rs
@@ -66,7 +66,7 @@
 ///         // Convert into ResultFile
 ///         .into();
 ///     // --------- IMPORTANT ---------
-///     result
+///     result.into()
 /// }
 ///
 /// pack!(ErrorNoNameProvided = ());
@@ -124,6 +124,251 @@
 /// }
 /// ```
 pub mod example_argument_parse {}
+/// Example Argument Picker
+///
+///  > Demonstrates how to use Mingling's `picker` feature and `Picker` to extract typed arguments from the command line.
+///
+///  Run:
+///  ```bash
+///  cargo run --manifest-path examples/example-argument-picker/Cargo.toml --quiet -- calc 1 + 1
+///  cargo run --manifest-path examples/example-argument-picker/Cargo.toml --quiet -- calc 7 * 7
+///  cargo run --manifest-path examples/example-argument-picker/Cargo.toml --quiet -- calc
+///  cargo run --manifest-path examples/example-argument-picker/Cargo.toml --quiet -- calc 1
+///  cargo run --manifest-path examples/example-argument-picker/Cargo.toml --quiet -- calc 1 +
+///  cargo run --manifest-path examples/example-argument-picker/Cargo.toml --quiet -- calc 4 / 3
+///  cargo run --manifest-path examples/example-argument-picker/Cargo.toml --quiet -- calc 4 / 3 --round
+///  ```
+///
+///  Output:
+///  ```plaintext
+///  Result: 2
+///  Result: 49
+///  Error: First number (number_a) was not provided.
+///  Error: Operator was not provided.
+///  Error: Second number (number_b) was not provided.
+///  Result: 1.3333334
+///  Result: 1
+///  ```
+///
+/// Source code (./Cargo.toml)
+/// ```toml
+/// [package]
+/// name = "example-argument-picker"
+/// version = "0.1.0"
+/// edition = "2024"
+///
+/// [dependencies.mingling]
+/// path = "../../mingling"
+///
+/// # Enable `picker` features
+/// features = ["picker", "extra_macros"]
+///
+/// [workspace]
+/// ```
+///
+/// Source code (./src/main.rs)
+/// ```ignore
+/// use mingling::{
+///     consts::REMAINS,
+///     macros::route,
+///     picker::{
+///         IntoPicker, PickerArgResult, SinglePickable,
+///         parselib::{ParserStyle, UNIX_STYLE},
+///         value::Flag,
+///     },
+///     prelude::*,
+/// };
+///
+/// // --------- IMPORTANT ---------
+/// // Use picker::BasicProgramSetup instead of the original BasicProgramSetup
+/// // It uses arg-picker to rewrite the logic of the original BasicProgramSetup
+/// use mingling::setup::picker::BasicProgramSetup;
+///
+/// // --------- IMPORTANT ---------
+///
+/// dispatcher!("calc", CMDCalculate => EntryCalculate);
+///
+/// pack_err!(ErrorNumberANotProvided);
+/// pack_err!(ErrorNumberBNotProvided);
+/// pack_err!(ErrorNumberOperatorNotProvided);
+/// pack_err!(ErrorDivisionByZero);
+///
+/// pack!(StateAdd = (f32, f32));
+/// pack!(StateSubtract = (f32, f32));
+/// pack!(StateMultiply = (f32, f32));
+/// pack!(StateDivide = (f32, f32));
+///
+/// pack!(ResultNumber = f32);
+///
+/// #[derive(Grouped)]
+/// struct StateCalculate {
+///     number_a: f32,
+///     operator: Operator,
+///     number_b: f32,
+/// }
+///
+/// #[derive(Debug, PartialEq, Eq)]
+/// enum Operator {
+///     Plus,
+///     Dash,
+///     Slash,
+///     Star,
+/// }
+///
+/// // --------- IMPORTANT ---------
+/// // Define SinglePickable for type Operator
+/// // This allows the type to be picked as an argument
+/// impl SinglePickable for Operator {
+///     fn pick_single(str: Option<&str>) -> PickerArgResult<Self> {
+///         let Some(str) = str else {
+///             return PickerArgResult::NotFound;
+///         };
+///         let op = match str.chars().next() {
+///             Some('+') => Operator::Plus,
+///             Some('-') => Operator::Dash,
+///             Some('*') => Operator::Star,
+///             Some('/') => Operator::Slash,
+///             _ => return PickerArgResult::NotFound,
+///         };
+///         PickerArgResult::Parsed(op)
+///     }
+/// }
+/// // --------- IMPORTANT ---------
+///
+/// #[derive(Default, Clone)]
+/// struct ResNumberDisplaySetting {
+///     round: bool,
+/// }
+///
+/// fn main() {
+///     let mut program = ThisProgram::new();
+///
+///     // Use ParserStyle to manage the arg-picker theme
+///     ParserStyle::set_global_style(&UNIX_STYLE);
+///
+///     // Enable picker::BasicProgramSetup
+///     program.with_setup(BasicProgramSetup);
+///
+///     // --------- IMPORTANT ---------
+///     // Pre-process global arguments before executing commands
+///     let (round, args) = program
+///         .take_args()
+///         //     Use arg![round: Flag] to indicate the `--round` | `-R` flag
+///         //     |
+///         //     vvvvvvvvvvvvvvvv
+///         .pick(&arg![round: Flag, 'R'])
+///         //    Use REMAINS to extract remaining arguments
+///         //    |
+///         //    vvvvvvvv
+///         .pick(&REMAINS)
+///         // Since Flag and REMAINS will not fail to parse,
+///         //   we can safely unwrap here
+///         .unwrap();
+///     program.replace_args(args.into());
+///
+///     program.with_resource(ResNumberDisplaySetting { round: *round });
+///     // --------- IMPORTANT ---------
+///
+///     program.with_dispatcher(CMDCalculate);
+///     program.exec_and_exit();
+/// }
+///
+/// #[chain]
+/// fn handle_calc(args: EntryCalculate) -> Next {
+///     // --------- IMPORTANT ---------
+///     let (number_a, operator, number_b) = route!(
+///         //                 Use the arg! macro to define a positional argument of type f32
+///         //                 |
+///         //                 vvvvvvvvvv
+///         args.pick_or_route(&arg![f32], || ErrorNumberANotProvided::default().to_chain())
+///             .pick_or_route(&arg![Operator], || {
+///                 ErrorNumberOperatorNotProvided::default().to_chain()
+///             }) //                         Returns a routable type when not found or fails to parse
+///             //                            |
+///             //                            vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+///             .pick_or_route(&arg![f32], || ErrorNumberBNotProvided::default().to_chain())
+///             // Use `to_result` to parse arguments
+///             //   and convert to Result<(Tuple, ...), Route> type
+///             .to_result()
+///     );
+///     // --------- IMPORTANT ---------
+///
+///     if operator == Operator::Slash && number_b == 0. {
+///         return ErrorDivisionByZero::default().to_chain();
+///     }
+///
+///     StateCalculate {
+///         number_a,
+///         operator,
+///         number_b,
+///     }
+///     .to_chain()
+/// }
+///
+/// #[chain]
+/// fn handle_state_calculate(state: StateCalculate) -> Next {
+///     match (state.operator, state.number_a, state.number_b) {
+///         (Operator::Plus, a, b) => StateAdd::new((a, b)).to_chain(),
+///         (Operator::Dash, a, b) => StateSubtract::new((a, b)).to_chain(),
+///         (Operator::Slash, a, b) => StateDivide::new((a, b)).to_chain(),
+///         (Operator::Star, a, b) => StateMultiply::new((a, b)).to_chain(),
+///     }
+/// }
+///
+/// #[chain]
+/// fn handle_state_add(state_add: StateAdd) -> ResultNumber {
+///     let (a, b) = state_add.inner;
+///     ResultNumber::new(a + b)
+/// }
+///
+/// #[chain]
+/// fn handle_state_subtract(state_subtract: StateSubtract) -> ResultNumber {
+///     let (a, b) = state_subtract.inner;
+///     ResultNumber::new(a - b)
+/// }
+///
+/// #[chain]
+/// fn handle_state_multiply(state_multiply: StateMultiply) -> ResultNumber {
+///     let (a, b) = state_multiply.inner;
+///     ResultNumber::new(a * b)
+/// }
+///
+/// #[chain]
+/// fn handle_state_divide(state_divide: StateDivide) -> ResultNumber {
+///     let (a, b) = state_divide.inner;
+///     ResultNumber::new(a / b)
+/// }
+///
+/// #[renderer]
+/// fn render_result_number(result: ResultNumber, setting: &ResNumberDisplaySetting) -> String {
+///     let round = setting.round;
+///     let result = if round { result.round() } else { result.inner };
+///     format!("Result: {}", result)
+/// }
+///
+/// #[renderer]
+/// fn render_error_division_by_zero(_: ErrorDivisionByZero) -> String {
+///     "Error: Division by zero is not allowed!".to_string()
+/// }
+///
+/// #[renderer]
+/// fn render_error_number_a_not_provided(_: ErrorNumberANotProvided) -> String {
+///     "Error: First number (number_a) was not provided.".to_string()
+/// }
+///
+/// #[renderer]
+/// fn render_error_number_b_not_provided(_: ErrorNumberBNotProvided) -> String {
+///     "Error: Second number (number_b) was not provided.".to_string()
+/// }
+///
+/// #[renderer]
+/// fn render_error_number_operator_not_provided(_: ErrorNumberOperatorNotProvided) -> String {
+///     "Error: Operator was not provided.".to_string()
+/// }
+///
+/// gen_program!();
+/// ```
+pub mod example_argument_picker {}
 /// Example Async Runtime Support
 ///
 ///  > This example shows how to drive an async runtime using the `async` feature
@@ -199,7 +444,7 @@ pub mod example_argument_parse {}
 /// //  vvvvv_ `async` keyword can be used directly here
 /// pub async fn handle_download(args: EntryDownload) -> Next {
 ///     let file_name = args.pick(()).unpack();
-///     fake_download(file_name).await
+///     fake_download(file_name).await.into()
 /// }
 ///
 /// /// Renders the downloaded file name.
@@ -292,7 +537,7 @@ pub mod example_async_support {}
 ///         .cloned()
 ///         .unwrap_or_else(|| "World".to_string())
 ///         .into();
-///     name
+///     name.into()
 /// }
 ///
 /// // Define renderer `render_name`, used to render `ResultName`
@@ -378,7 +623,7 @@ pub mod example_basic {}
 ///
 /// Source code (./src/main.rs)
 /// ```ignore
-/// use mingling::{Groupped, macros::dispatcher_clap, prelude::*, setup::BasicProgramSetup};
+/// use mingling::{Grouped, macros::dispatcher_clap, prelude::*, setup::BasicProgramSetup};
 /// use std::io::Write;
 ///
 /// fn main() {
@@ -407,10 +652,10 @@ pub mod example_basic {}
 /// // Implement Clap Parser, and bind to Dispatcher
 /// //        _______________________________ Default trait, provides fallback on parse failure
 /// //       /         ______________________ clap::Parser, parsing logic implemented by Clap
-/// //       |        /              ________ Implement mingling::Groupped
+/// //       |        /              ________ Implement mingling::Grouped
 /// //       |        |             /           to ensure Mingling can recognize the type
-/// //       vvvvvvv  vvvvvvvvvvvv  vvvvvvvv
-/// #[derive(Default, clap::Parser, Groupped)]
+/// //       vvvvvvv  vvvvvvvvvvvv  vvvvvvv
+/// #[derive(Default, clap::Parser, Grouped)]
 /// #[dispatcher_clap(
 ///     "greet", CMDGreet,        // Bind EntryGreet to "greet" command
 ///     help = true,              // Generate clap help for EntryGreet
@@ -672,7 +917,7 @@ pub mod example_combine_pathf_dispatch_tree {}
 ///         .pick_or((), "World")
 ///         .unpack()
 ///         .into();
-///     result
+///     result.into()
 /// }
 ///
 /// /// Renders the greeting with the result name and repeat count.
@@ -724,15 +969,15 @@ pub mod example_completion {}
 ///
 /// Source code (./src/main.rs)
 /// ```ignore
-/// use mingling::{macros::route, parser::Pickable, prelude::*, Groupped};
+/// use mingling::{macros::route, parser::Pickable, prelude::*, Grouped};
 /// use std::io::Write;
 ///
 /// // Define types that can be recognized by Mingling
 /// //               ________________________ `Pickable` trait needs to implement Default
-/// //              /                ________ The Groupped derive macro registers an ID for this type
+/// //              /                ________ The Grouped derive macro registers an ID for this type
 /// //              |               /           Mingling uses this ID to identify the type
-/// //              vvvvvvv         vvvvvvvv
-/// #[derive(Debug, Default, Clone, Groupped)]
+/// //              vvvvvvv         vvvvvvv
+/// #[derive(Debug, Default, Clone, Grouped)]
 /// pub struct Address {
 ///     pub ip: [u8; 4],
 ///     pub port: u16,
@@ -963,7 +1208,7 @@ pub mod example_dispatch_tree {}
 /// Source code (./src/main.rs)
 /// ```ignore
 /// use mingling::{
-///     macros::suggest_enum, parser::PickableEnum, prelude::*, EnumTag, Groupped, ShellContext,
+///     macros::suggest_enum, parser::PickableEnum, prelude::*, EnumTag, Grouped, ShellContext,
 ///     Suggest,
 /// };
 /// use std::io::Write;
@@ -972,7 +1217,7 @@ pub mod example_dispatch_tree {}
 /// //                        ________ adds metadata to the enum, enabling it to:
 /// //                       /         1. Be used by the `suggest_enum!(Enum)` macro under the `comp` feature for autocompletion
 /// //                       vvvvvvv   2. Implement the `PickableEnum` trait
-/// #[derive(Debug, Default, EnumTag, Groupped)]
+/// #[derive(Debug, Default, EnumTag, Grouped)]
 /// pub enum ProgrammingLanguages {
 ///     #[enum_desc("An efficient and flexible compiled language widely used for system programming")]
 ///     C,
@@ -1026,7 +1271,7 @@ pub mod example_dispatch_tree {}
 /// fn handle_language_selection(args: EntryLanguageSelection) -> Next {
 ///     // You can use Picker to directly parse ProgrammingLanguages
 ///     let lang: ProgrammingLanguages = args.pick(()).unpack();
-///     lang
+///     lang.into()
 /// }
 ///
 /// /// Renders the selected programming language with its name and description.
@@ -1428,7 +1673,7 @@ pub mod example_help {}
 ///         .cloned()
 ///         .unwrap_or_else(|| "World".to_string())
 ///         .into();
-///     name
+///     name.into()
 /// }
 ///
 /// /// Renders the greeting message with the provided name.
@@ -1691,7 +1936,7 @@ pub mod example_lazy_resources {}
 /// /// Renderer for parse errors — using the outside `ParseIntError` type.
 /// ///
 /// /// The `ParseIntError` type is registered via `group!` above, so it implements
-/// /// `Groupped<ThisProgram>` and can be used directly in a `#[renderer]` function.
+/// /// `Grouped<ThisProgram>` and can be used directly in a `#[renderer]` function.
 /// #[renderer]
 /// fn render_parse_error(err: ParseIntError) -> RenderResult {
 ///     let mut render_result = RenderResult::new();
@@ -1967,7 +2212,7 @@ pub mod example_pack_err {}
 ///             // Panic happens here, will be caught
 ///             panic!("{}", s)
 ///         }
-///         None => NotPanic::default(),
+///         None => NotPanic::default().into(),
 ///     }
 /// }
 ///
@@ -2161,7 +2406,7 @@ pub mod example_pathfinder {}
 /// #[chain]
 /// fn parse_cd_args(prev: EntryCd) -> Next {
 ///     let join = prev.pick(()).unpack();
-///     StateChangeDirectory::new(join)
+///     StateChangeDirectory::new(join).into()
 /// }
 ///
 /// // Execute directory change
@@ -2323,7 +2568,7 @@ pub mod example_repl_basic {}
 ///     current_dir.current_dir = current_dir
 ///         .current_dir
 ///         .join(args.pick::<String>(()).unpack());
-///     EntryCurrent::default()
+///     EntryCurrent::default().into()
 /// }
 ///
 /// // Define renderer for output current path       _____________ Injected resource
@@ -2436,7 +2681,7 @@ pub mod example_setup {}
 /// Source code (./src/main.rs)
 /// ```ignore
 /// use mingling::prelude::*;
-/// use mingling::{Groupped, StructuralData, parser::Picker, setup::StructuralRendererSetup};
+/// use mingling::{parser::Picker, setup::StructuralRendererSetup, Grouped, StructuralData};
 /// use serde::Serialize;
 /// use std::io::Write;
 ///
@@ -2453,12 +2698,12 @@ pub mod example_setup {}
 /// // --------- IMPORTANT ---------
 /// // For beautiful output structure, do not use `pack!` to wrap the types that need to be output.
 /// // Instead, manually implement
-/// //        __________________________________ Mark as structured data so it can be rendered
-/// //       /              ____________________ Implement serde::Serialize
-/// //       |             /           _________ Implement mingling::Groupped
-/// //       |             |          /            to ensure Mingling can recognize the type
-/// //       vvvvvvvvvvvv  vvvvvvvvv  vvvvvvvv
-/// #[derive(StructuralData, Serialize, Groupped)]
+/// //        ____________________________________ Mark as structured data so it can be rendered
+/// //       /                ____________________ Implement serde::Serialize
+/// //       |               /           _________ Implement mingling::Grouped
+/// //       |               |          /            to ensure Mingling can recognize the type
+/// //       vvvvvvvvvvvv    vvvvvvvvv  vvvvvvv
+/// #[derive(StructuralData, Serialize, Grouped)]
 /// struct Info {
 ///     #[serde(rename = "member_name")]
 ///     name: String,
diff --git a/mingling/src/lib.md b/mingling/src/lib.md
index cd89b96..03fa61d 100644
--- a/mingling/src/lib.md
+++ b/mingling/src/lib.md
@@ -40,7 +40,7 @@ fn handle_greet(args: EntryGreet) -> Next {
         .cloned()
         .unwrap_or_else(|| "World".to_string())
         .into();
-    name
+    name.into()
 }
 
 #[renderer]
diff --git a/mingling/src/lib.rs b/mingling/src/lib.rs
index 718d282..f4bc9dc 100644
--- a/mingling/src/lib.rs
+++ b/mingling/src/lib.rs
@@ -16,12 +16,13 @@ pub mod parser;
 
 /// `Mingling` argument parser (Picker2)
 #[cfg(feature = "picker")]
-pub mod picker {
-    pub use arg_picker::*;
+pub mod picker;
 
-    pub mod parselib {
-        pub use arg_picker::parselib::*;
-    }
+mod constants;
+
+/// Constants used throughout the Mingling framework.
+pub mod consts {
+    pub use crate::constants::*;
 }
 
 /// Re-export of all macros from `mingling_macros`.
@@ -117,9 +118,9 @@ pub mod macros {
 #[cfg(feature = "macros")]
 pub use mingling_macros::EnumTag;
 
-/// derive macro Groupped
+/// derive macro Grouped
 #[cfg(feature = "macros")]
-pub use mingling_macros::Groupped;
+pub use mingling_macros::Grouped;
 
 /// derive macro `StructuralData` — marks a type as supporting structured output
 #[cfg(feature = "structural_renderer")]
@@ -170,9 +171,9 @@ pub mod res;
 /// use mingling::prelude::*;
 /// ```
 pub mod prelude {
-    /// Re-export of the `Groupped` derive macro for grouping types.
+    /// Re-export of the `Grouped` derive macro for grouping types.
     #[cfg(feature = "core")]
-    pub use crate::Groupped;
+    pub use crate::Grouped;
     /// Re-export of the `RenderResult` struct for outputting rendering result
     #[cfg(feature = "core")]
     pub use crate::RenderResult;
@@ -217,7 +218,10 @@ pub mod prelude {
     pub use crate::parser::AsPicker;
 
     #[cfg(feature = "picker")]
-    pub use arg_picker::prelude::*;
+    pub use arg_picker::prelude::arg;
+
+    #[cfg(feature = "picker")]
+    pub use crate::picker::EntryPicker;
 
     /// Used to enable the `writeln!` macro for `RenderResult`
     #[cfg(feature = "core")]
diff --git a/mingling/src/parser/picker.rs b/mingling/src/parser/picker.rs
index 601cd3f..ca4561c 100644
--- a/mingling/src/parser/picker.rs
+++ b/mingling/src/parser/picker.rs
@@ -743,6 +743,10 @@ where
     }
 }
 
+/// Trait for types that can be converted into a `Picker` to extract values from command-line arguments.
+///
+/// This trait provides a convenient way to convert a value (such as `Vec<String>`, `&[String]`, etc.)
+/// into a `Picker` and immediately start extracting values associated with specific flags.
 pub trait AsPicker
 where
     Self: Into<Vec<String>>,
diff --git a/mingling/src/picker.rs b/mingling/src/picker.rs
new file mode 100644
index 0000000..f370656
--- /dev/null
+++ b/mingling/src/picker.rs
@@ -0,0 +1,13 @@
+/// Provides the specific parsing logic for command-line arguments and common utilities,
+/// as well as customization of command-line argument styles.
+pub mod parselib {
+    pub use arg_picker::parselib::*;
+}
+
+pub use arg_picker::*;
+
+mod entry_picker;
+pub use entry_picker::*;
+
+mod global;
+pub use global::*;
diff --git a/mingling/src/picker/entry_picker.rs b/mingling/src/picker/entry_picker.rs
new file mode 100644
index 0000000..7364c50
--- /dev/null
+++ b/mingling/src/picker/entry_picker.rs
@@ -0,0 +1,126 @@
+use mingling_core::{ChainProcess, Grouped, ProgramCollect};
+
+use crate::{picker::Pickable, picker::Picker, picker::PickerArg, picker::PickerPattern1};
+
+/// Trait for converting Mingling entry types (types that implement `Grouped<R>` and `Into<Vec<String>>`)
+/// into [`Picker`] instances for a given route type `R`.
+///
+/// This trait provides a bridge between entry definitions created with the `mingling` framework
+/// and the picker argument system used for CLI argument parsing and routing.
+///
+/// # Type Parameters
+///
+/// * `'a` — The lifetime of the picker and its references to argument definitions.
+/// * `This` — The program type used for dispatching runtime routes; must implement [`ProgramCollect`].
+/// * `Route` — The route type used for dispatching; must implement [`Grouped<This>`].
+pub trait EntryPicker<'a, This> {
+    /// Converts `self` into a [`Picker`] for the given route type `Route`.
+    fn to_picker(self) -> Picker<'a, ChainProcess<This>>;
+
+    /// Starts building a picker pattern with the first argument.
+    ///
+    /// Returns a [`PickerPattern1`] that can be further chained with additional
+    /// arguments, defaults, routes, and post-processing.
+    ///
+    /// # Type Parameters
+    ///
+    /// * `Next` — The nominal type of the first argument; must implement [`Pickable`].
+    ///
+    /// # Parameters
+    ///
+    /// * `arg` — The argument definition, typically obtained from [`crate::macros::arg`].
+    fn pick<Next>(
+        self,
+        arg: impl Into<&'a PickerArg<'a, Next>>,
+    ) -> PickerPattern1<'a, Next, ChainProcess<This>>
+    where
+        Self: Sized,
+        Next: Pickable<'a> + Default + Sized,
+    {
+        let picker = Self::to_picker(self);
+        Picker::build_pattern1(picker.into_args(), arg.into(), None)
+    }
+
+    /// Starts building a picker pattern with the first argument, using a default value provider.
+    ///
+    /// This is a shorthand for calling `.pick(arg).or(func)`.
+    ///
+    /// # Type Parameters
+    ///
+    /// * `Next` — The nominal type of the first argument; must implement [`Pickable`].
+    ///
+    /// # Parameters
+    ///
+    /// * `arg` — The argument definition, typically obtained from [`crate::macros::arg`].
+    /// * `func` — A closure that provides a default value if the arg is not provided by the user.
+    fn pick_or<Next, F>(
+        self,
+        arg: impl Into<&'a PickerArg<'a, Next>>,
+        func: F,
+    ) -> PickerPattern1<'a, Next, ChainProcess<This>>
+    where
+        Self: Sized,
+        Next: Pickable<'a> + Default + Sized,
+        F: FnMut() -> Next + 'static,
+    {
+        self.pick(arg).or(func)
+    }
+
+    /// Starts building a picker pattern with the first argument, using a default value.
+    ///
+    /// This is a shorthand for calling `.pick(arg).or_default()`.
+    ///
+    /// # Type Parameters
+    ///
+    /// * `Next` — The nominal type of the first argument; must implement [`Pickable`] and [`Default`].
+    ///
+    /// # Parameters
+    ///
+    /// * `arg` — The argument definition, typically obtained from [`crate::macros::arg`].
+    fn pick_or_default<Next>(
+        self,
+        arg: impl Into<&'a PickerArg<'a, Next>>,
+    ) -> PickerPattern1<'a, Next, ChainProcess<This>>
+    where
+        Self: Sized,
+        Next: Pickable<'a> + Default + Sized,
+    {
+        self.pick(arg).or_default()
+    }
+
+    /// Starts building a picker pattern with the first argument, using a route if the arg is not provided.
+    ///
+    /// This is a shorthand for calling `.pick(arg).or_route(func)`.
+    ///
+    /// # Type Parameters
+    ///
+    /// * `Next` — The nominal type of the first argument; must implement [`Pickable`].
+    ///
+    /// # Parameters
+    ///
+    /// * `arg` — The argument definition, typically obtained from [`crate::macros::arg`].
+    /// * `func` — A closure that produces a route value if the arg is not provided by the user.
+    fn pick_or_route<Next, F>(
+        self,
+        arg: impl Into<&'a PickerArg<'a, Next>>,
+        func: F,
+    ) -> PickerPattern1<'a, Next, ChainProcess<This>>
+    where
+        Self: Sized,
+        Next: Pickable<'a> + Default + Sized,
+        F: FnMut() -> ChainProcess<This> + 'static,
+    {
+        self.pick(arg).or_route(func)
+    }
+}
+
+impl<'a, This, Bind> EntryPicker<'a, This> for Bind
+where
+    This: ProgramCollect<Enum = This>,
+    Bind: Grouped<This> + Into<Vec<String>>,
+{
+    fn to_picker(self) -> Picker<'a, ChainProcess<This>> {
+        let args = self.into();
+        Picker::from(args)
+    }
+}
diff --git a/mingling/src/picker/global.rs b/mingling/src/picker/global.rs
new file mode 100644
index 0000000..c203524
--- /dev/null
+++ b/mingling/src/picker/global.rs
@@ -0,0 +1,35 @@
+use arg_picker::{IntoPicker, Pickable, PickerArg, value::Flag};
+use mingling_core::{Program, ProgramCollect};
+
+use crate::consts::REMAINS;
+
+/// Picks a global flag from the program's arguments.
+///
+/// This function takes ownership of the program's current arguments, picks the specified `flag`
+/// from them, and then returns the remaining arguments back to the program. It returns the
+/// boolean value of the flag.
+pub fn pick_global_flag<C>(program: &mut Program<C>, flag: &PickerArg<Flag>) -> bool
+where
+    C: ProgramCollect<Enum = C>,
+{
+    let args = program.take_args();
+    let (flag, args) = args.pick(flag).pick(&REMAINS).unwrap();
+    program.replace_args(args.into());
+    *flag
+}
+
+/// Picks a global argument from the program's arguments.
+///
+/// This function takes ownership of the program's current arguments, picks the specified `arg`
+/// from them, and then returns the remaining arguments back to the program. It returns the
+/// picked argument value, or `None` if the argument was not present.
+pub fn pick_global_argument<C, A>(program: &mut Program<C>, arg: &PickerArg<A>) -> Option<A>
+where
+    A: for<'a> Pickable<'a> + Default,
+    C: ProgramCollect<Enum = C>,
+{
+    let args = program.take_args();
+    let (arg, remains) = args.pick(arg).pick(&REMAINS).unpack();
+    program.replace_args(remains.unwrap().into());
+    arg
+}
diff --git a/mingling/src/setups.rs b/mingling/src/setups.rs
index e572cf5..6fd728a 100644
--- a/mingling/src/setups.rs
+++ b/mingling/src/setups.rs
@@ -7,6 +7,13 @@ pub use dirs::*;
 mod exit_code;
 pub use exit_code::*;
 
+/// Picker's `ProgramSetup` variant.
+///
+/// Internally does not use its own argument parsing,
+/// but relies on `arg_picker`'s argument parsing capability.
+#[cfg(feature = "picker")]
+pub mod picker;
+
 #[cfg(feature = "structural_renderer")]
 mod structural_renderer;
 
diff --git a/mingling/src/setups/basic.rs b/mingling/src/setups/basic.rs
index 6a69733..e081c3e 100644
--- a/mingling/src/setups/basic.rs
+++ b/mingling/src/setups/basic.rs
@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use mingling_core::{Flag, Program, ProgramCollect, setup::ProgramSetup};
 
 /// Performs basic program initialization:
@@ -5,6 +7,12 @@ use mingling_core::{Flag, Program, ProgramCollect, setup::ProgramSetup};
 /// - Collects `--quiet` flag to control message rendering
 /// - Collects `--help` flag to enable help mode
 /// - Collects `--confirm` flag to skip user confirmation
+#[cfg_attr(
+    feature = "picker",
+    deprecated(
+        note = "When the `picker` feature is enabled, you can use `mingling::setup::picker::BasicProgramSetup` instead"
+    )
+)]
 pub struct BasicProgramSetup;
 
 impl<C> ProgramSetup<C> for BasicProgramSetup
@@ -21,6 +29,12 @@ where
 /// Provides setup for parsing the user help flag
 ///
 /// The default value is `--help / -h`
+#[cfg_attr(
+    feature = "picker",
+    deprecated(
+        note = "When the `picker` feature is enabled, you can use `mingling::setup::picker::HelpFlagSetup` instead"
+    )
+)]
 pub struct HelpFlagSetup {
     flag: Flag,
 }
@@ -54,6 +68,12 @@ impl Default for HelpFlagSetup {
 /// Provides setup for parsing the quiet flag
 ///
 /// The default value is `--quiet / -q`
+#[cfg_attr(
+    feature = "picker",
+    deprecated(
+        note = "When the `picker` feature is enabled, you can use `mingling::setup::picker::QuietFlagSetup` instead"
+    )
+)]
 pub struct QuietFlagSetup {
     flag: Flag,
 }
@@ -88,6 +108,12 @@ impl Default for QuietFlagSetup {
 /// Provides setup for parsing the confirm flag
 ///
 /// The default value is `--confirm / -C`
+#[cfg_attr(
+    feature = "picker",
+    deprecated(
+        note = "When the `picker` feature is enabled, you can use `mingling::setup::picker::ConfirmFlagSetup` instead"
+    )
+)]
 pub struct ConfirmFlagSetup {
     flag: Flag,
 }
diff --git a/mingling/src/setups/exit_code.rs b/mingling/src/setups/exit_code.rs
index 025ed8a..6b8a1ef 100644
--- a/mingling/src/setups/exit_code.rs
+++ b/mingling/src/setups/exit_code.rs
@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use mingling_core::{
     ProgramCollect,
-    hook::{ProgramControlUnit, ProgramHook},
+    hook::{ProgramControlUnit, ProgramControls, ProgramHook},
     setup::ProgramSetup,
     this,
 };
@@ -39,7 +39,14 @@ where
         // Insert hook to override exit code before program ends
         program.with_hook(ProgramHook::empty().on_finish(|_| {
             let this = this::<C>().res_or_default::<ResExitCode>();
-            ProgramControlUnit::OverrideExitCode(this.exit_code)
+            let ec = this.exit_code;
+
+            // Only override when ResExitCode has been modified
+            if ec != 0 {
+                ProgramControlUnit::OverrideExitCode(this.exit_code).into()
+            } else {
+                ProgramControls::Empty
+            }
         }));
     }
 }
diff --git a/mingling/src/setups/picker.rs b/mingling/src/setups/picker.rs
new file mode 100644
index 0000000..0b7bd33
--- /dev/null
+++ b/mingling/src/setups/picker.rs
@@ -0,0 +1,7 @@
+mod basic;
+pub use basic::*;
+
+#[cfg(feature = "structural_renderer")]
+mod structural_renderer;
+#[cfg(feature = "structural_renderer")]
+pub use structural_renderer::*;
diff --git a/mingling/src/setups/picker/basic.rs b/mingling/src/setups/picker/basic.rs
new file mode 100644
index 0000000..c9f82b3
--- /dev/null
+++ b/mingling/src/setups/picker/basic.rs
@@ -0,0 +1,123 @@
+use arg_picker::{PickerArg, value::Flag};
+use mingling_core::{Program, ProgramCollect, setup::ProgramSetup};
+
+use crate::{
+    consts::{CONFIRM_FLAG, HELP_FLAG, QUIET_FLAG},
+    picker::pick_global_flag,
+};
+
+/// Performs basic program initialization:
+///
+/// - Collects `--quiet` flag to control message rendering
+/// - Collects `--help` flag to enable help mode
+/// - Collects `--confirm` flag to skip user confirmation
+pub struct BasicProgramSetup;
+
+impl<C> ProgramSetup<C> for BasicProgramSetup
+where
+    C: ProgramCollect<Enum = C>,
+{
+    fn setup(self, program: &mut Program<C>) {
+        program.with_setup(HelpFlagSetup::default());
+        program.with_setup(QuietFlagSetup::default());
+        program.with_setup(ConfirmFlagSetup::default());
+    }
+}
+
+/// Provides setup for parsing the user help flag
+///
+/// The default value is `--help / -h`
+pub struct HelpFlagSetup<'a> {
+    flag: &'a PickerArg<'a, Flag>,
+}
+
+impl<'a> HelpFlagSetup<'a> {
+    /// Creates a new `HelpFlagSetup` with the given flag aliases.
+    pub fn new(flag: &'a PickerArg<Flag>) -> Self {
+        Self { flag }
+    }
+}
+
+impl<'a, C> ProgramSetup<C> for HelpFlagSetup<'a>
+where
+    C: ProgramCollect<Enum = C>,
+{
+    fn setup(self, program: &mut Program<C>) {
+        let help = pick_global_flag(program, self.flag);
+        if help {
+            program.user_context.help = true;
+        }
+    }
+}
+
+impl<'a> Default for HelpFlagSetup<'a> {
+    fn default() -> Self {
+        Self { flag: &HELP_FLAG }
+    }
+}
+
+/// Provides setup for parsing the quiet flag
+///
+/// The default value is `--quiet / -q`
+pub struct QuietFlagSetup<'a> {
+    flag: &'a PickerArg<'a, Flag>,
+}
+
+impl<'a> QuietFlagSetup<'a> {
+    /// Creates a new `QuietFlagSetup` with the given flag aliases.
+    pub fn new(flag: &'a PickerArg<Flag>) -> Self {
+        Self { flag }
+    }
+}
+
+impl<'a, C> ProgramSetup<C> for QuietFlagSetup<'a>
+where
+    C: ProgramCollect<Enum = C>,
+{
+    fn setup(self, program: &mut Program<C>) {
+        let help = pick_global_flag(program, self.flag);
+        if help {
+            program.stdout_setting.quiet = true;
+        }
+    }
+}
+
+impl<'a> Default for QuietFlagSetup<'a> {
+    fn default() -> Self {
+        Self { flag: &QUIET_FLAG }
+    }
+}
+
+/// Provides setup for parsing the confirm flag
+///
+/// The default value is `--confirm / -C`
+pub struct ConfirmFlagSetup<'a> {
+    flag: &'a PickerArg<'a, Flag>,
+}
+
+impl<'a> ConfirmFlagSetup<'a> {
+    /// Creates a new `ConfirmFlagSetup` with the given flag aliases.
+    pub fn new(flag: &'a PickerArg<Flag>) -> Self {
+        Self { flag }
+    }
+}
+
+impl<'a, C> ProgramSetup<C> for ConfirmFlagSetup<'a>
+where
+    C: ProgramCollect<Enum = C>,
+{
+    fn setup(self, program: &mut Program<C>) {
+        let help = pick_global_flag(program, self.flag);
+        if help {
+            program.user_context.confirm = true;
+        }
+    }
+}
+
+impl<'a> Default for ConfirmFlagSetup<'a> {
+    fn default() -> Self {
+        Self {
+            flag: &CONFIRM_FLAG,
+        }
+    }
+}
diff --git a/mingling/src/setups/picker/structural_renderer.rs b/mingling/src/setups/picker/structural_renderer.rs
new file mode 100644
index 0000000..1fa48fd
--- /dev/null
+++ b/mingling/src/setups/picker/structural_renderer.rs
@@ -0,0 +1,76 @@
+use mingling_core::{Program, ProgramCollect, setup::ProgramSetup};
+
+use crate::{
+    consts::RENDERER_ARG,
+    picker::{pick_global_argument, pick_global_flag},
+};
+
+/// Sets up the structural renderer for the program:
+///
+/// - Adds a `--renderer` global argument to specify the renderer type
+pub struct StructuralRendererSimpleSetup;
+
+impl<C> ProgramSetup<C> for StructuralRendererSimpleSetup
+where
+    C: ProgramCollect<Enum = C>,
+{
+    fn setup(self, program: &mut Program<C>) {
+        if let Some(renderer) = pick_global_argument(program, &RENDERER_ARG) {
+            program.structural_renderer_name = renderer.into();
+        }
+    }
+}
+
+/// Sets up the structural renderer for the program:
+///
+/// - Adds global flags to specify the renderer type:
+///   * `--json` for JSON output
+///   * `--json-pretty` for pretty-printed JSON output
+///   * `--yaml` for YAML output
+///   * `--toml` for TOML output
+///   * `--ron` for RON output
+///   * `--ron-pretty` for pretty-printed RON output
+///
+/// # Flag priority
+///
+/// If multiple flags are specified, the last matching flag in the following
+/// declaration order takes precedence:
+///   1. `--json`
+///   2. `--json-pretty`
+///   3. `--yaml`
+///   4. `--toml`
+///   5. `--ron`
+///   6. `--ron-pretty`
+pub struct StructuralRendererSetup;
+
+impl<C> ProgramSetup<C> for StructuralRendererSetup
+where
+    C: ProgramCollect<Enum = C>,
+{
+    fn setup(self, program: &mut Program<C>) {
+        #[cfg(feature = "json_serde_fmt")]
+        if pick_global_flag(program, &crate::consts::JSON_FLAG) {
+            program.structural_renderer_name = crate::StructuralRendererSetting::Json;
+        }
+        #[cfg(feature = "json_serde_fmt")]
+        if pick_global_flag(program, &crate::consts::JSON_PRETTY_FLAG) {
+            program.structural_renderer_name = crate::StructuralRendererSetting::JsonPretty;
+        }
+        #[cfg(feature = "yaml_serde_fmt")]
+        if pick_global_flag(program, &crate::consts::YAML_FLAG) {
+            program.structural_renderer_name = crate::StructuralRendererSetting::Yaml;
+        }
+        #[cfg(feature = "toml_serde_fmt")]
+        if pick_global_flag(program, &crate::consts::TOML_FLAG) {
+            program.structural_renderer_name = crate::StructuralRendererSetting::Toml;
+        }
+        #[cfg(feature = "ron_serde_fmt")]
+        if pick_global_flag(program, &crate::consts::RON_FLAG) {
+            program.structural_renderer_name = crate::StructuralRendererSetting::Ron;
+        }
+        #[cfg(feature = "ron_serde_fmt")]
+        if pick_global_flag(program, &crate::consts::RON_PRETTY_FLAG) {
+            program.structural_renderer_name = crate::StructuralRendererSetting::RonPretty;
+        }
+    }
+}
diff --git a/mingling/src/setups/structural_renderer.rs b/mingling/src/setups/structural_renderer.rs
index af3ed91..0ab2347 100644
--- a/mingling/src/setups/structural_renderer.rs
+++ b/mingling/src/setups/structural_renderer.rs
@@ -1,8 +1,16 @@
+#![allow(deprecated)]
+
 use mingling_core::{Program, ProgramCollect, setup::ProgramSetup};
 
 /// Sets up the structural renderer for the program:
 ///
 /// - Adds a `--renderer` global argument to specify the renderer type
+#[cfg_attr(
+    feature = "picker",
+    deprecated(
+        note = "When the `picker` feature is enabled, you can use `mingling::setup::picker::StructuralRendererSimpleSetup` instead"
+    )
+)]
 pub struct StructuralRendererSimpleSetup;
 
 impl<C> ProgramSetup<C> for StructuralRendererSimpleSetup
@@ -25,6 +33,12 @@ where
 ///   * `--toml` for TOML output
 ///   * `--ron` for RON output
 ///   * `--ron-pretty` for pretty-printed RON output
+#[cfg_attr(
+    feature = "picker",
+    deprecated(
+        note = "When the `picker` feature is enabled, you can use `mingling::setup::picker::StructuralRendererSetup` instead"
+    )
+)]
 pub struct StructuralRendererSetup;
 
 impl<C> ProgramSetup<C> for StructuralRendererSetup