refactor!: replace pack! macros with derive-based pipeline types

Remove the `pack!`, `pack_err!`, `pack_structural!`, and
`pack_err_structural!` macros, replacing all pipeline type definitions
with `#[derive(Grouped)]` and `#[derive(Grouped, Wrap)]` attributes.
This changes the generated struct shape from named-field structs with an
`inner` field to tuple structs accessed via `.0`, and removes the
auto-generated `name` and `info` fields from error types.

6 files changed, 91 insertions, 76 deletions

diff --git a/mingling_cli/src/pkg_mgr/cmd_install.rs b/mingling_cli/src/pkg_mgr/cmd_install.rs
index 731ba98..8b2f3b7 100644
--- a/mingling_cli/src/pkg_mgr/cmd_install.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_install.rs
@@ -2,8 +2,8 @@ use std::{env, fs, io, path::PathBuf, process::Command};
 
 use cargo_metadata::TargetKind;
 use mingling::{
-    Grouped, LazyRes, RenderResult, Routable, ShellContext, Suggest,
-    macros::{arg, chain, command, completion, metadata, pack_err, renderer, routeify, suggest},
+    Grouped, LazyRes, RenderResult, Routable, ShellContext, Suggest, Wrap,
+    macros::{arg, chain, command, completion, metadata, renderer, routeify, suggest},
     metadata::Description,
     picker::{EntryPicker, PickerArg, value::Flag},
 };
@@ -15,9 +15,14 @@ use crate::{
     println_cargo,
 };
 
-pack_err!(ErrorBuildFailed = String);
-pack_err!(ErrorBinaryNotFound = String);
-pack_err!(ErrorPkgEnableFailed = String);
+#[derive(Grouped, Wrap)]
+pub struct ErrorBuildFailed(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorBinaryNotFound(String);
+
+#[derive(Grouped, Wrap)]
+pub struct ErrorPkgEnableFailed(String);
 
 /// Flag: `--enable` — run `mling pkg-enable` after a successful install
 /// to enable the package being installed.
@@ -75,13 +80,13 @@ pub fn install(
     let metadata = metadata.get_ref().data();
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let root_package = metadata
         .root_package()
         .or_else(|| metadata.workspace_packages().first().copied())
-        .ok_or(ErrorRootPackageNotFound::default())?;
+        .ok_or(ErrorRootPackageNotFound)?;
 
     StateInstallBuild {
         workspace_root: metadata.workspace_root.clone().into_std_path_buf(),
@@ -103,11 +108,9 @@ pub fn handle_state_install_build(state: StateInstallBuild) -> Next {
         .args(["build", "--release"])
         .current_dir(&state.workspace_root)
         .status()
-        .map_err(|e| {
-            ErrorBuildFailed::new(format!("failed to run `cargo build --release`: {e}"))
-        })?;
+        .map_err(|e| ErrorBuildFailed(format!("failed to run `cargo build --release`: {e}")))?;
     if !status.success() {
-        return ErrorBuildFailed::new(format!("`cargo build --release` failed with {status}"))
+        return ErrorBuildFailed(format!("`cargo build --release` failed with {status}"))
             .to_chain();
     }
 
@@ -146,7 +149,7 @@ pub fn handle_state_install_copy(
             let bin_file = format!("{}{}", target.name, state.exe_suffix);
             let src = state.release_dir.join(&bin_file);
             if !src.is_file() {
-                return ErrorBinaryNotFound::new(bin_file).to_chain();
+                return ErrorBinaryNotFound(bin_file).to_chain();
             }
             let dst = state.install_dir.join(&bin_file);
             fs::copy(&src, &dst).map_err(|e| {
@@ -181,7 +184,7 @@ pub fn handle_state_install_copy(
         let root_package = metadata
             .root_package()
             .or_else(|| metadata.workspace_packages().first().copied())
-            .ok_or(ErrorRootPackageNotFound::default())?;
+            .ok_or(ErrorRootPackageNotFound)?;
         return StateInstallEnable {
             install_dir: state.install_dir,
             installed: state.installed,
@@ -207,13 +210,11 @@ pub fn handle_state_install_enable(state: StateInstallEnable) -> Next {
         .args(["pkg-enable", &spec])
         .status()
         .map_err(|e| {
-            ErrorPkgEnableFailed::new(format!("failed to run `mling pkg-enable {spec}`: {e}"))
+            ErrorPkgEnableFailed(format!("failed to run `mling pkg-enable {spec}`: {e}"))
         })?;
     if !status.success() {
-        return ErrorPkgEnableFailed::new(format!(
-            "`mling pkg-enable {spec}` failed with {status}"
-        ))
-        .to_chain();
+        return ErrorPkgEnableFailed(format!("`mling pkg-enable {spec}` failed with {status}"))
+            .to_chain();
     }
 
     ResultInstall {
@@ -236,21 +237,21 @@ pub fn render_result_install(result: ResultInstall) -> RenderResult {
 #[renderer]
 pub fn render_error_build_failed(err: ErrorBuildFailed) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_binary_not_found(err: ErrorBinaryNotFound) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "binary not found: {}", err.info);
+    eprintln_cargo!(r, "binary not found: {}", err.0);
     r
 }
 
 #[renderer]
 pub fn render_error_pkg_enable_failed(err: ErrorPkgEnableFailed) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "{}", err.info);
+    eprintln_cargo!(r, "{}", err.0);
     r
 }
 
diff --git a/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs b/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs
index b4928ce..f0ac88a 100644
--- a/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs
@@ -4,8 +4,8 @@ use std::{
 };
 
 use mingling::{
-    Routable,
-    macros::{buffer, command, pack, r_println, renderer, routeify},
+    Grouped, Routable, Wrap,
+    macros::{buffer, command, r_println, renderer, routeify},
 };
 
 use crate::{
@@ -14,16 +14,18 @@ use crate::{
 };
 
 // Version directory paths of every enabled package.
-pack!(ResultLoadPkgsPaths = Vec<PathBuf>);
+#[derive(Grouped, Wrap)]
+pub struct ResultLoadPkgsPaths(Vec<PathBuf>);
 
 // Completion script paths of every enabled package.
-pack!(ResultLoadPkgsComps = Vec<PathBuf>);
+#[derive(Grouped, Wrap)]
+pub struct ResultLoadPkgsComps(Vec<PathBuf>);
 
 #[command(node = "__loadpkgs_path", routeify)]
 pub fn load_packages_paths(packages_dir: &ResPackagesDir) -> Next {
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
     let paths = enabled_version_dirs(packages_dir).map_err(|e| {
         io::Error::new(
@@ -31,14 +33,14 @@ pub fn load_packages_paths(packages_dir: &ResPackagesDir) -> Next {
             format!("failed to read {}: {e}", packages_dir.display()),
         )
     })?;
-    ResultLoadPkgsPaths::new(paths).to_chain()
+    ResultLoadPkgsPaths(paths).to_chain()
 }
 
 #[command(node = "__loadpkgs_comp_scripts", routeify)]
 pub fn load_packages_comp_scripts(packages_dir: &ResPackagesDir) -> Next {
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
     let scripts = comp_scripts(packages_dir).map_err(|e| {
         io::Error::new(
@@ -46,19 +48,19 @@ pub fn load_packages_comp_scripts(packages_dir: &ResPackagesDir) -> Next {
             format!("failed to read {}: {e}", packages_dir.display()),
         )
     })?;
-    ResultLoadPkgsComps::new(scripts).to_chain()
+    ResultLoadPkgsComps(scripts).to_chain()
 }
 
 #[renderer(buffer)]
 pub fn render_result_load_pkgs_paths(r: ResultLoadPkgsPaths) {
-    for path in r.inner {
+    for path in r.0 {
         r_println!("{}", path.display());
     }
 }
 
 #[renderer(buffer)]
 pub fn render_result_load_pkgs_comps(r: ResultLoadPkgsComps) {
-    for path in r.inner {
+    for path in r.0 {
         r_println!("{}", path.display());
     }
 }
diff --git a/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs b/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs
index 041bb09..b4989eb 100644
--- a/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_pkg_disable.rs
@@ -1,8 +1,8 @@
 use std::{fs, io};
 
 use mingling::{
-    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{arg, chain, command, completion, metadata, pack, pack_err, renderer, routeify},
+    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem, Wrap,
+    macros::{arg, chain, command, completion, metadata, renderer, routeify},
     metadata::Description,
     picker::{EntryPicker, PickerArg},
 };
@@ -18,10 +18,12 @@ use crate::{
 /// Positional argument: package name
 pub static ARG_NAME: PickerArg<String> = arg![String];
 
-pack_err!(ErrorPackageNotEnabled = String);
+#[derive(Grouped, Wrap)]
+pub struct ErrorPackageNotEnabled(String);
 
 // The name of the package to disable
-pack!(StatePkgDisable = String);
+#[derive(Grouped, Wrap)]
+pub struct StatePkgDisable(String);
 
 #[derive(Debug, Default, Grouped)]
 pub struct ResultPkgDisable {
@@ -37,30 +39,30 @@ pub fn desc_pkg_disable() -> Description {
 #[command(node = "pkg-disable", routeify)]
 pub fn package_disable(args: EntryPkgDisable, packages_dir: &ResPackagesDir) -> Next {
     let name = args
-        .pick_or_route(&ARG_NAME, || ErrorPackageNameRequired::default().to_chain())
+        .pick_or_route(&ARG_NAME, || ErrorPackageNameRequired.to_chain())
         .to_result()?;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
     if name.contains('/') || name.contains('\\') || name.contains("..") || name.contains('@') {
-        return ErrorPackageSpecInvalid::new(name).to_chain();
+        return ErrorPackageSpecInvalid(name).to_chain();
     }
 
-    StatePkgDisable::new(name).to_chain()
+    StatePkgDisable(name).to_chain()
 }
 
 #[chain(routeify)]
 pub fn handle_state_pkg_disable(p: StatePkgDisable, packages_dir: &ResPackagesDir) -> Next {
-    let name = p.inner;
+    let name = p.0;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let file = packages_dir.join(&name);
     if !file.is_file() {
-        return ErrorPackageNotEnabled::new(name).to_chain();
+        return ErrorPackageNotEnabled(name).to_chain();
     }
     fs::remove_file(&file).map_err(|e| {
         io::Error::new(
@@ -86,7 +88,7 @@ pub fn render_result_pkg_disable(result: ResultPkgDisable) -> RenderResult {
 #[renderer]
 pub fn render_error_package_not_enabled(err: ErrorPackageNotEnabled) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "package is not enabled: {}", err.info);
+    eprintln_cargo!(r, "package is not enabled: {}", err.0);
     r
 }
 
diff --git a/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs b/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs
index 8f6a234..1235cd3 100644
--- a/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_pkg_enable.rs
@@ -1,8 +1,8 @@
 use std::{fs, io};
 
 use mingling::{
-    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{arg, chain, command, completion, metadata, pack, pack_err, renderer, routeify},
+    Grouped, RenderResult, Routable, ShellContext, Suggest, SuggestItem, Wrap,
+    macros::{arg, chain, command, completion, metadata, renderer, routeify},
     metadata::Description,
     picker::{EntryPicker, PickerArg},
 };
@@ -18,8 +18,11 @@ use crate::{
 /// Positional argument: package spec (`foo`, `foo@0`, `foo@0.1`, `foo@0.1.2`)
 pub static ARG_SPEC: PickerArg<String> = arg![String];
 
-pack_err!(ErrorNoMatchingVersion = String);
-pack!(StatePkgEnable = (String, String));
+#[derive(Grouped, Wrap)]
+pub struct ErrorNoMatchingVersion(String);
+
+#[derive(Grouped, Wrap)]
+pub struct StatePkgEnable((String, String));
 
 #[derive(Debug, Default, Grouped)]
 pub struct ResultPkgEnable {
@@ -35,14 +38,14 @@ pub fn desc_pkg_enable() -> Description {
 #[command(node = "pkg-enable", routeify)]
 pub fn package_enable(args: EntryPkgEnable, packages_dir: &ResPackagesDir) -> Next {
     let spec = args
-        .pick_or_route(&ARG_SPEC, || ErrorPackageNameRequired::default().to_chain())
+        .pick_or_route(&ARG_SPEC, || ErrorPackageNameRequired.to_chain())
         .to_result()?;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
     if spec.contains('/') || spec.contains('\\') || spec.contains("..") {
-        return ErrorPackageSpecInvalid::new(spec).to_chain();
+        return ErrorPackageSpecInvalid(spec).to_chain();
     }
 
     let (name, version_part) = match spec.split_once('@') {
@@ -78,18 +81,18 @@ pub fn package_enable(args: EntryPkgEnable, packages_dir: &ResPackagesDir) -> Ne
     }
 
     let Some((_, version)) = candidates.into_iter().max_by(|a, b| a.1.cmp(&b.1)) else {
-        return ErrorNoMatchingVersion::new(spec).to_chain();
+        return ErrorNoMatchingVersion(spec).to_chain();
     };
 
-    StatePkgEnable::new((name, version.to_string())).to_chain()
+    StatePkgEnable((name, version.to_string())).to_chain()
 }
 
 #[chain(routeify)]
 pub fn handle_state_pkg_enable(p: StatePkgEnable, packages_dir: &ResPackagesDir) -> Next {
-    let (name, version) = p.inner;
+    let (name, version) = p.0;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let file = packages_dir.join(&name);
@@ -110,7 +113,7 @@ pub fn render_result_pkg_enable(result: ResultPkgEnable) -> RenderResult {
 #[renderer]
 pub fn render_error_no_matching_version(err: ErrorNoMatchingVersion) -> RenderResult {
     let mut r = RenderResult::new();
-    eprintln_cargo!(r, "no matching version for: {}", err.info);
+    eprintln_cargo!(r, "no matching version for: {}", err.0);
     r
 }
 
diff --git a/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs b/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs
index 88c79ef..ea26021 100644
--- a/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs
@@ -3,7 +3,7 @@ use std::{collections::BTreeMap, fs, io};
 use colored::Colorize;
 use mingling::{
     Grouped, RenderResult, Routable,
-    macros::{buffer, command, metadata, pack_err, r_println, renderer, routeify},
+    macros::{buffer, command, metadata, r_println, renderer, routeify},
     metadata::Description,
 };
 
@@ -15,8 +15,10 @@ use crate::{
 #[derive(Debug, Default, Clone)]
 pub struct PkgShowEntry {
     pub name: String,
+
     /// Enabled version, from the content of the enable file.
     pub enabled: Option<String>,
+
     /// Installed versions, newest first.
     pub versions: Vec<String>,
 }
@@ -31,13 +33,14 @@ pub fn desc_pkg_show() -> Description {
     "Show locally installed packages".into()
 }
 
-pack_err!(ErrorNoPackagesInstalled);
+#[derive(Grouped, Default)]
+pub struct ErrorNoPackagesInstalled;
 
 #[command(node = "pkg-show", routeify)]
 pub fn package_show(packages_dir: &ResPackagesDir) -> Next {
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let mut entries: BTreeMap<String, PkgShowEntry> = BTreeMap::new();
@@ -84,7 +87,7 @@ pub fn package_show(packages_dir: &ResPackagesDir) -> Next {
     let packages: Vec<PkgShowEntry> = entries.into_values().collect();
 
     if packages.is_empty() {
-        return ErrorNoPackagesInstalled::default().into();
+        return ErrorNoPackagesInstalled.into();
     }
 
     ResultPkgShow { packages }.to_chain()
diff --git a/mingling_cli/src/pkg_mgr/cmd_uninstall.rs b/mingling_cli/src/pkg_mgr/cmd_uninstall.rs
index 2b288d6..0c3886c 100644
--- a/mingling_cli/src/pkg_mgr/cmd_uninstall.rs
+++ b/mingling_cli/src/pkg_mgr/cmd_uninstall.rs
@@ -1,8 +1,8 @@
 use std::{fs, io, path::PathBuf};
 
 use mingling::{
-    LazyRes, RenderResult, Routable, ShellContext, Suggest, SuggestItem,
-    macros::{arg, chain, command, completion, metadata, pack, pack_err, renderer, routeify},
+    Grouped, LazyRes, RenderResult, Routable, ShellContext, Suggest, SuggestItem, Wrap,
+    macros::{arg, chain, command, completion, metadata, renderer, routeify},
     metadata::Description,
     picker::{EntryPicker, PickerArg},
 };
@@ -20,16 +20,20 @@ use crate::{
 pub static ARG_PACKAGE: PickerArg<Option<String>> = arg![Option<String>];
 
 // Directory names to remove, e.g. `["omg@0.1.0", "omg@0.1.1"]`
-pack!(StateUninstallPackages = Vec<String>);
+#[derive(Grouped, Wrap)]
+pub struct StateUninstallPackages(Vec<String>);
 
 // Directories that were successfully removed.
-pack!(ResultPackageUninstalled = Vec<PathBuf>);
+#[derive(Grouped, Wrap)]
+pub struct ResultPackageUninstalled(Vec<PathBuf>);
 
 // Directories that were not installed.
-pack_err!(ErrorPackageNotInstall = Vec<PathBuf>);
+#[derive(Grouped, Wrap)]
+pub struct ErrorPackageNotInstall(Vec<PathBuf>);
 
 // No installed package matched the given spec.
-pack_err!(ErrorNoMatchingPackages);
+#[derive(Grouped, Default)]
+pub struct ErrorNoMatchingPackages;
 
 /// `{data_dir}/mingling/packages`
 #[metadata(EntryUninstall)]
@@ -46,7 +50,7 @@ pub fn uninstall(
     let spec = args.pick(&ARG_PACKAGE).to_result()?;
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let targets = match spec {
@@ -56,13 +60,13 @@ pub fn uninstall(
             let root_package = metadata
                 .root_package()
                 .or_else(|| metadata.workspace_packages().first().copied())
-                .ok_or(ErrorRootPackageNotFound::default())?;
+                .ok_or(ErrorRootPackageNotFound)?;
             vec![format!("{}@{}", root_package.name, root_package.version)]
         }
         // `name` matches every installed version, `name@version` matches exactly
         Some(spec) => {
             if spec.contains('/') || spec.contains('\\') || spec.contains("..") {
-                return ErrorPackageSpecInvalid::new(spec).to_chain();
+                return ErrorPackageSpecInvalid(spec).to_chain();
             }
             if spec.contains('@') {
                 vec![spec]
@@ -87,7 +91,7 @@ pub fn uninstall(
         }
     };
 
-    StateUninstallPackages::new(targets).to_chain()
+    StateUninstallPackages(targets).to_chain()
 }
 
 #[chain(routeify)]
@@ -97,13 +101,13 @@ pub fn handle_state_uninstall_packages(
 ) -> Next {
     let packages_dir = &packages_dir.path;
     if packages_dir.as_os_str().is_empty() {
-        return ErrorNoDataDirectory::default().to_chain();
+        return ErrorNoDataDirectory.to_chain();
     }
 
     let mut removed = Vec::new();
     let mut not_installed = Vec::new();
 
-    for name in p.inner {
+    for name in p.0 {
         let dir = packages_dir.join(&name);
         if !dir.exists() {
             not_installed.push(dir);
@@ -116,18 +120,18 @@ pub fn handle_state_uninstall_packages(
     }
 
     if removed.is_empty() && not_installed.is_empty() {
-        return ErrorNoMatchingPackages::default().to_chain();
+        return ErrorNoMatchingPackages.to_chain();
     }
     if !removed.is_empty() {
-        return ResultPackageUninstalled::new(removed).to_chain();
+        return ResultPackageUninstalled(removed).to_chain();
     }
-    ErrorPackageNotInstall::new(not_installed).to_chain()
+    ErrorPackageNotInstall(not_installed).to_chain()
 }
 
 #[renderer]
 pub fn render_result_package_uninstalled(r: ResultPackageUninstalled) -> RenderResult {
     let mut result = RenderResult::new();
-    for dir in r.inner {
+    for dir in r.0 {
         println_cargo!(result, "Uninstalled: {}", dir.display());
     }
     result
@@ -136,7 +140,7 @@ pub fn render_result_package_uninstalled(r: ResultPackageUninstalled) -> RenderR
 #[renderer]
 pub fn render_error_package_not_install(err: ErrorPackageNotInstall) -> RenderResult {
     let mut result = RenderResult::new();
-    for dir in err.info {
+    for dir in err.0 {
         eprintln_cargo!(result, "not installed: {}", dir.display());
     }
     result