build(deps): bump github.com/olekukonko/tablewriter from 1.0.8 to 1.0.9

Bumps [github.com/olekukonko/tablewriter](https://github.com/olekukonko/tablewriter) from 1.0.8 to 1.0.9.
- [Commits](https://github.com/olekukonko/tablewriter/compare/v1.0.8...v1.0.9)

---
updated-dependencies:
- dependency-name: github.com/olekukonko/tablewriter
  dependency-version: 1.0.9
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

vendor/github.com/olekukonko/errors/README.md

@@ -48,6 +48,11 @@ go get github.com/olekukonko/errors@latest
 
 ---
 
+> [!NOTE]  
+> ✓ added support for `errors.Errorf("user %w not found", errors.New("bob"))`  
+> ✓ added support for `sequential chain` execution
+``
+
 ## Using the `errors` Package
 
 ### Basic Error Creation
@@ -74,6 +79,7 @@ func main() {
 
 #### Formatted Error
 ```go
+// main.go
 package main
 
 import (
@@ -83,12 +89,21 @@ import (
 
 func main() {
   // Formatted error without stack trace
-  err := errors.Newf("user %s not found", "bob")
-  fmt.Println(err) // Output: "user bob not found"
+  errNoWrap := errors.Newf("user %s not found", "bob")
+  fmt.Println(errNoWrap) // Output: "user bob not found"
 
-  // Standard formatted error, no fmt.Errorf needed
-  stdErr := errors.Stdf("user %s not found", "bob")
-  fmt.Println(stdErr) // Output: "user bob not found"
+  // Standard formatted error, no fmt.Errorf needed (using own pkg)
+  stdErrNoWrap := errors.Stdf("user %s not found", "bob")
+  fmt.Println(stdErrNoWrap) // Output: "user bob not found"
+
+  // Added support for %w (compatible with fmt.Errorf output)
+  // errors.Errorf is alias of errors.Newf
+  errWrap := errors.Errorf("user %w not found", errors.New("bob"))
+  fmt.Println(errWrap) // Output: "user bob not found"
+
+  // Standard formatted error for comparison
+  stdErrWrap := fmt.Errorf("user %w not found", fmt.Errorf("bob"))
+  fmt.Println(stdErrWrap) // Output: "user bob not found"
 }
 ```
 
@@ -243,7 +258,7 @@ func main() {
 	enhanced := errors.WithStack(err)
 	fmt.Println("Error with stack:")
 	fmt.Println("Message:", enhanced.Error()) // Output: "basic error"
-	fmt.Println("Stack:", enhanced.Stack())   // Output: e.g., ["main.go:15", ...]
+	fmt.Println("Stack:", enhanced.Stack())   // Output: e.g., "main.go:15"
 }
 ```
 
@@ -996,6 +1011,198 @@ func contains(substr string) func(error) bool {
     return strings.Contains(err.Error(), substr)
   }
 }
+```
+
+### Chain Execution
+
+#### Sequential Task Processing
+```go
+package main
+
+import (
+  "fmt"
+  "github.com/olekukonko/errors"
+  "time"
+)
+
+// validateOrder checks order input.
+func validateOrder() error {
+  return nil // Simulate successful validation
+}
+
+// processKYC handles payment processing.
+func processKYC() error {
+  return nil // Simulate successful validation
+}
+
+// processPayment handles payment processing.
+func processPayment() error {
+  return errors.New("payment declined") // Simulate payment failure
+}
+
+// generateInvoice creates an invoice.
+func generateInvoice() error {
+  return errors.New("invoicing unavailable") // Simulate invoicing issue
+}
+
+// sendNotification sends a confirmation.
+func sendNotification() error {
+  return errors.New("notification failed") // Simulate notification failure
+}
+
+// processOrder simulates a multi-step order processing workflow.
+func processOrder() error {
+  c := errors.NewChain()
+
+  // Validate order input
+  c.Step(validateOrder).Tag("validation")
+
+  // KYC  Process
+  c.Step(validateOrder).Tag("validation")
+
+  // Process payment with retries
+  c.Step(processPayment).Tag("billing").Retry(3, 100*time.Millisecond)
+
+  // Generate invoice
+  c.Step(generateInvoice).Tag("invoicing")
+
+  // Send notification (optional)
+  c.Step(sendNotification).Tag("notification").Optional()
+
+  return c.Run()
+}
+
+func main() {
+  if err := processOrder(); err != nil {
+    // Print error to stderr and exit
+    errors.Inspect(err)
+  }
+  fmt.Println("Order processed successfully")
+}
+```
+
+#### Sequential Task Processing 2
+```go
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/olekukonko/errors"
+)
+
+// validate simulates a validation check that fails.
+func validate(name string) error {
+	return errors.Newf("validation for %s failed", name)
+}
+
+// validateOrder checks order input.
+func validateOrder() error {
+	return nil // Simulate successful validation
+}
+
+// verifyKYC handles Know Your Customer verification.
+func verifyKYC(name string) error {
+	return validate(name) // Simulate KYC validation failure
+}
+
+// processPayment handles payment processing.
+func processPayment() error {
+	return nil // Simulate successful payment
+}
+
+// processOrder coordinates the order processing workflow.
+func processOrder() error {
+	chain := errors.NewChain().
+		Step(validateOrder).     // Step 1: Validate order
+		Call(verifyKYC, "john"). // Step 2: Verify customer
+		Step(processPayment)     // Step 3: Process payment
+
+	if err := chain.Run(); err != nil {
+		return errors.Errorf("processing order: %w", err)
+	}
+	return nil
+}
+
+func main() {
+	if err := processOrder(); err != nil {
+		// Print the full error chain to stderr
+		fmt.Fprintf(os.Stderr, "ERROR: %v\n", err)
+		// Output
+		// ERROR: processing order: validation for john failed
+
+		// For debugging, you could print the stack trace:
+		// errors.Inspect(err)
+		os.Exit(1)
+	}
+
+	fmt.Println("order processed successfully")
+}
+
+```
+
+
+#### Retry with Timeout
+```go
+package main
+
+import (
+  "context"
+  "fmt"
+  "github.com/olekukonko/errors"
+  "time"
+)
+
+func main() {
+  c := errors.NewChain(
+    errors.ChainWithTimeout(1*time.Second),
+  ).
+          Step(func() error {
+            time.Sleep(2 * time.Second)
+            return errors.New("fetch failed")
+          }).
+    Tag("api").
+    Retry(3, 200*time.Millisecond)
+
+  err := c.Run()
+  if err != nil {
+    var deadlineErr error
+    if errors.As(err, &deadlineErr) && deadlineErr == context.DeadlineExceeded {
+      fmt.Println("Fetch timed out")
+    } else {
+      fmt.Printf("Fetch failed: %v\n", err)
+    }
+    return
+  }
+  fmt.Println("Fetch succeeded")
+}
+```
+
+#### Collecting All Errors
+```go
+package main
+
+import (
+  "fmt"
+  "github.com/olekukonko/errors"
+)
+
+func main() {
+  c := errors.NewChain(
+    errors.ChainWithMaxErrors(2),
+  ).
+    Step(func() error { return errors.New("task 1 failed") }).Tag("task1").
+    Step(func() error { return nil }).Tag("task2").
+    Step(func() error { return errors.New("task 3 failed") }).Tag("task3")
+
+  err := c.RunAll()
+  if err != nil {
+    errors.Inspect(err)
+    return
+  }
+  fmt.Println("All tasks completed successfully")
+}
 
 ```
 
@@ -1326,7 +1533,7 @@ func main() {
 ## FAQ
 
 - **When to use `Copy()`?**
-  - Use `Copy()` to create a modifiable duplicate of an error without altering the original.
+  - Use ` SOCIALCopy()` to create a modifiable duplicate of an error without altering the original.
 
 - **When to use `Free()`?**
   - Use in performance-critical loops; otherwise, autofree handles it (Go 1.24+).
@@ -1355,4 +1562,4 @@ func main() {
 - Fork, branch, commit, and PR—see [CONTRIBUTING.md](#).
 
 ## License
-MIT License - See [LICENSE](LICENSE).
+MIT License - See [LICENSE](LICENSE).

vendor/github.com/olekukonko/errors/chain.go

@@ -0,0 +1,610 @@
+package errors
+
+import (
+	"context"
+	"fmt"
+	"log/slog" // Standard structured logging package
+	"reflect"
+	"strings"
+	"time"
+)
+
+// Chain executes functions sequentially with enhanced error handling.
+// Logging is optional and configured via a slog.Handler.
+type Chain struct {
+	steps      []chainStep        // List of steps to execute
+	errors     []error            // Accumulated errors during execution
+	config     chainConfig        // Chain-wide configuration
+	lastStep   *chainStep         // Pointer to the last added step for configuration
+	logHandler slog.Handler       // Optional logging handler (nil means no logging)
+	cancel     context.CancelFunc // Function to cancel the context
+}
+
+// chainStep represents a single step in the chain.
+type chainStep struct {
+	execute  func() error // Function to execute for this step
+	optional bool         // If true, errors don't stop the chain
+	config   stepConfig   // Step-specific configuration
+}
+
+// chainConfig holds chain-wide settings.
+type chainConfig struct {
+	timeout   time.Duration // Maximum duration for the entire chain
+	maxErrors int           // Maximum number of errors before stopping (-1 for unlimited)
+	autoWrap  bool          // Whether to automatically wrap errors with additional context
+}
+
+// stepConfig holds configuration for an individual step.
+type stepConfig struct {
+	context      map[string]interface{} // Arbitrary key-value pairs for context
+	category     ErrorCategory          // Category for error classification
+	code         int                    // Numeric error code
+	retry        *Retry                 // Retry policy for the step
+	logOnFail    bool                   // Whether to log errors automatically
+	metricsLabel string                 // Label for metrics (not used in this code)
+	logAttrs     []slog.Attr            // Additional attributes for logging
+}
+
+// ChainOption defines a function that configures a Chain.
+type ChainOption func(*Chain)
+
+// NewChain creates a new Chain with the given options.
+// Logging is disabled by default (logHandler is nil).
+func NewChain(opts ...ChainOption) *Chain {
+	c := &Chain{
+		config: chainConfig{
+			autoWrap:  true, // Enable error wrapping by default
+			maxErrors: -1,   // No limit on errors by default
+		},
+		// logHandler is nil, meaning no logging unless explicitly configured
+	}
+	// Apply each configuration option
+	for _, opt := range opts {
+		opt(c)
+	}
+	return c
+}
+
+// ChainWithLogHandler sets a custom slog.Handler for logging.
+// If handler is nil, logging is effectively disabled.
+func ChainWithLogHandler(handler slog.Handler) ChainOption {
+	return func(c *Chain) {
+		c.logHandler = handler
+	}
+}
+
+// ChainWithTimeout sets a timeout for the entire chain.
+func ChainWithTimeout(d time.Duration) ChainOption {
+	return func(c *Chain) {
+		c.config.timeout = d
+	}
+}
+
+// ChainWithMaxErrors sets the maximum number of errors allowed.
+// A value <= 0 means no limit.
+func ChainWithMaxErrors(max int) ChainOption {
+	return func(c *Chain) {
+		if max <= 0 {
+			c.config.maxErrors = -1 // No limit
+		} else {
+			c.config.maxErrors = max
+		}
+	}
+}
+
+// ChainWithAutoWrap enables or disables automatic error wrapping.
+func ChainWithAutoWrap(auto bool) ChainOption {
+	return func(c *Chain) {
+		c.config.autoWrap = auto
+	}
+}
+
+// Step adds a new step to the chain with the provided function.
+// The function must return an error or nil.
+func (c *Chain) Step(fn func() error) *Chain {
+	if fn == nil {
+		// Panic to enforce valid input
+		panic("Chain.Step: provided function cannot be nil")
+	}
+	// Create a new step with default configuration
+	step := chainStep{execute: fn, config: stepConfig{}}
+	c.steps = append(c.steps, step)
+	// Update lastStep to point to the newly added step
+	c.lastStep = &c.steps[len(c.steps)-1]
+	return c
+}
+
+// Call adds a step by wrapping a function with arguments.
+// It uses reflection to validate and invoke the function.
+func (c *Chain) Call(fn interface{}, args ...interface{}) *Chain {
+	// Wrap the function and arguments into an executable step
+	wrappedFn, err := c.wrapCallable(fn, args...)
+	if err != nil {
+		// Panic on setup errors to catch them early
+		panic(fmt.Sprintf("Chain.Call setup error: %v", err))
+	}
+	// Add the wrapped function as a step
+	step := chainStep{execute: wrappedFn, config: stepConfig{}}
+	c.steps = append(c.steps, step)
+	c.lastStep = &c.steps[len(c.steps)-1]
+	return c
+}
+
+// Optional marks the last step as optional.
+// Optional steps don't stop the chain on error.
+func (c *Chain) Optional() *Chain {
+	if c.lastStep == nil {
+		// Panic if no step exists to mark as optional
+		panic("Chain.Optional: must call Step() or Call() before Optional()")
+	}
+	c.lastStep.optional = true
+	return c
+}
+
+// WithLog adds logging attributes to the last step.
+func (c *Chain) WithLog(attrs ...slog.Attr) *Chain {
+	if c.lastStep == nil {
+		// Panic if no step exists to configure
+		panic("Chain.WithLog: must call Step() or Call() before WithLog()")
+	}
+	// Append attributes to the step's logging configuration
+	c.lastStep.config.logAttrs = append(c.lastStep.config.logAttrs, attrs...)
+	return c
+}
+
+// Timeout sets a timeout for the entire chain.
+func (c *Chain) Timeout(d time.Duration) *Chain {
+	c.config.timeout = d
+	return c
+}
+
+// MaxErrors sets the maximum number of errors allowed.
+func (c *Chain) MaxErrors(max int) *Chain {
+	if max <= 0 {
+		c.config.maxErrors = -1 // No limit
+	} else {
+		c.config.maxErrors = max
+	}
+	return c
+}
+
+// With adds a key-value pair to the last step's context.
+func (c *Chain) With(key string, value interface{}) *Chain {
+	if c.lastStep == nil {
+		// Panic if no step exists to configure
+		panic("Chain.With: must call Step() or Call() before With()")
+	}
+	// Initialize context map if nil
+	if c.lastStep.config.context == nil {
+		c.lastStep.config.context = make(map[string]interface{})
+	}
+	// Add the key-value pair
+	c.lastStep.config.context[key] = value
+	return c
+}
+
+// Tag sets an error category for the last step.
+func (c *Chain) Tag(category ErrorCategory) *Chain {
+	if c.lastStep == nil {
+		// Panic if no step exists to configure
+		panic("Chain.Tag: must call Step() or Call() before Tag()")
+	}
+	c.lastStep.config.category = category
+	return c
+}
+
+// Code sets a numeric error code for the last step.
+func (c *Chain) Code(code int) *Chain {
+	if c.lastStep == nil {
+		// Panic if no step exists to configure
+		panic("Chain.Code: must call Step() or Call() before Code()")
+	}
+	c.lastStep.config.code = code
+	return c
+}
+
+// Retry configures retry behavior for the last step.
+// Retry configures retry behavior for the last step.
+func (c *Chain) Retry(maxAttempts int, delay time.Duration, opts ...RetryOption) *Chain {
+	if c.lastStep == nil {
+		panic("Chain.Retry: must call Step() or Call() before Retry()")
+	}
+	if maxAttempts < 1 {
+		maxAttempts = 1
+	}
+
+	// Define default retry options
+	retryOpts := []RetryOption{
+		WithMaxAttempts(maxAttempts),
+		WithDelay(delay),
+		WithRetryIf(func(err error) bool { return IsRetryable(err) }),
+	}
+
+	// Add logging for retry attempts if a handler is configured
+	if c.logHandler != nil {
+		step := c.lastStep
+		retryOpts = append(retryOpts, WithOnRetry(func(attempt int, err error) {
+			// Prepare logging attributes
+			logAttrs := []slog.Attr{
+				slog.Int("attempt", attempt),
+				slog.Int("max_attempts", maxAttempts),
+			}
+			// Enhance the error with step context
+			enhancedErr := c.enhanceError(err, step)
+			// Log the retry attempt
+			c.logError(enhancedErr, fmt.Sprintf("Retrying step (attempt %d/%d)", attempt, maxAttempts), step.config, logAttrs...)
+		}))
+	}
+
+	// Append any additional retry options
+	retryOpts = append(retryOpts, opts...)
+	// Create and assign the retry configuration
+	c.lastStep.config.retry = NewRetry(retryOpts...)
+	return c
+}
+
+// LogOnFail enables automatic logging of errors for the last step.
+func (c *Chain) LogOnFail() *Chain {
+	if c.lastStep == nil {
+		// Panic if no step exists to configure
+		panic("Chain.LogOnFail: must call Step() or Call() before LogOnFail()")
+	}
+	c.lastStep.config.logOnFail = true
+	return c
+}
+
+// Run executes the chain, stopping on the first non-optional error.
+// It returns the first error encountered or nil if all steps succeed.
+func (c *Chain) Run() error {
+	// Create a context with timeout or cancellation
+	ctx, cancel := c.getContextAndCancel()
+	defer cancel()
+	c.cancel = cancel
+	// Clear any previous errors
+	c.errors = c.errors[:0]
+
+	// Execute each step in sequence
+	for i := range c.steps {
+		step := &c.steps[i]
+		// Check if the context has been canceled
+		select {
+		case <-ctx.Done():
+			err := ctx.Err()
+			// Enhance the error with step context
+			enhancedErr := c.enhanceError(err, step)
+			c.errors = append(c.errors, enhancedErr)
+			// Log the context error
+			c.logError(enhancedErr, "Chain stopped due to context error before step", step.config)
+			return enhancedErr
+		default:
+		}
+
+		// Execute the step
+		err := c.executeStep(ctx, step)
+		if err != nil {
+			// Enhance the error with step context
+			enhancedErr := c.enhanceError(err, step)
+			c.errors = append(c.errors, enhancedErr)
+			// Log the error if required
+			if step.config.logOnFail || !step.optional {
+				logMsg := "Chain stopped due to error in step"
+				if step.optional {
+					logMsg = "Optional step failed"
+				}
+				c.logError(enhancedErr, logMsg, step.config)
+			}
+			// Stop execution if the step is not optional
+			if !step.optional {
+				return enhancedErr
+			}
+		}
+	}
+	// Return nil if all steps completed successfully
+	return nil
+}
+
+// RunAll executes all steps, collecting errors without stopping.
+// It returns a MultiError containing all errors or nil if none occurred.
+func (c *Chain) RunAll() error {
+	ctx, cancel := c.getContextAndCancel()
+	defer cancel()
+	c.cancel = cancel
+	c.errors = c.errors[:0]
+	multi := NewMultiError()
+
+	for i := range c.steps {
+		step := &c.steps[i]
+		select {
+		case <-ctx.Done():
+			err := ctx.Err()
+			enhancedErr := c.enhanceError(err, step)
+			c.errors = append(c.errors, enhancedErr)
+			multi.Add(enhancedErr)
+			c.logError(enhancedErr, "Chain stopped due to context error before step (RunAll)", step.config)
+			goto endRunAll
+		default:
+		}
+
+		err := c.executeStep(ctx, step)
+		if err != nil {
+			enhancedErr := c.enhanceError(err, step)
+			c.errors = append(c.errors, enhancedErr)
+			multi.Add(enhancedErr)
+			if step.config.logOnFail && c.logHandler != nil {
+				c.logError(enhancedErr, "Step failed during RunAll", step.config)
+			}
+			if c.config.maxErrors > 0 && multi.Count() >= c.config.maxErrors {
+				if c.logHandler != nil {
+					// Create a logger to log the max errors condition
+					logger := slog.New(c.logHandler)
+					logger.LogAttrs(
+						context.Background(),
+						slog.LevelError,
+						fmt.Sprintf("Stopping RunAll after reaching max errors (%d)", c.config.maxErrors),
+						slog.Int("max_errors", c.config.maxErrors),
+					)
+				}
+				goto endRunAll
+			}
+		}
+	}
+
+endRunAll:
+	return multi.Single()
+}
+
+// Errors returns a copy of the collected errors.
+func (c *Chain) Errors() []error {
+	if len(c.errors) == 0 {
+		return nil
+	}
+	// Create a copy to prevent external modification
+	errs := make([]error, len(c.errors))
+	copy(errs, c.errors)
+	return errs
+}
+
+// Len returns the number of steps in the chain.
+func (c *Chain) Len() int {
+	return len(c.steps)
+}
+
+// HasErrors checks if any errors were collected.
+func (c *Chain) HasErrors() bool {
+	return len(c.errors) > 0
+}
+
+// LastError returns the most recent error or nil if none exist.
+func (c *Chain) LastError() error {
+	if len(c.errors) > 0 {
+		return c.errors[len(c.errors)-1]
+	}
+	return nil
+}
+
+// Reset clears the chain's steps, errors, and context.
+func (c *Chain) Reset() {
+	if c.cancel != nil {
+		// Cancel any active context
+		c.cancel()
+		c.cancel = nil
+	}
+	// Clear steps and errors
+	c.steps = c.steps[:0]
+	c.errors = c.errors[:0]
+	c.lastStep = nil
+}
+
+// Unwrap returns the collected errors (alias for Errors).
+func (c *Chain) Unwrap() []error {
+	return c.errors
+}
+
+// getContextAndCancel creates a context based on the chain's timeout.
+// It returns a context and its cancellation function.
+func (c *Chain) getContextAndCancel() (context.Context, context.CancelFunc) {
+	parentCtx := context.Background()
+	if c.config.timeout > 0 {
+		// Create a context with a timeout
+		return context.WithTimeout(parentCtx, c.config.timeout)
+	}
+	// Create a cancellable context
+	return context.WithCancel(parentCtx)
+}
+
+// logError logs an error with step-specific context and attributes.
+// It only logs if a handler is configured and the error is non-nil.
+func (c *Chain) logError(err error, msg string, config stepConfig, additionalAttrs ...slog.Attr) {
+	// Skip logging if no handler is set or error is nil
+	if c == nil || c.logHandler == nil || err == nil {
+		return
+	}
+
+	// Create a logger on demand using the configured handler
+	logger := slog.New(c.logHandler)
+
+	// Initialize attributes with error and timestamp
+	allAttrs := make([]slog.Attr, 0, 5+len(config.logAttrs)+len(additionalAttrs))
+	allAttrs = append(allAttrs, slog.Any("error", err))
+	allAttrs = append(allAttrs, slog.Time("timestamp", time.Now()))
+
+	// Add step-specific metadata
+	if config.category != "" {
+		allAttrs = append(allAttrs, slog.String("category", string(config.category)))
+	}
+	if config.code != 0 {
+		allAttrs = append(allAttrs, slog.Int("code", config.code))
+	}
+	for k, v := range config.context {
+		allAttrs = append(allAttrs, slog.Any(k, v))
+	}
+	allAttrs = append(allAttrs, config.logAttrs...)
+	allAttrs = append(allAttrs, additionalAttrs...)
+
+	// Add stack trace and error name if the error is of type *Error
+	if e, ok := err.(*Error); ok {
+		if stack := e.Stack(); len(stack) > 0 {
+			// Format stack trace, truncating if too long
+			stackStr := "\n\t" + strings.Join(stack, "\n\t")
+			if len(stackStr) > 1000 {
+				stackStr = stackStr[:1000] + "..."
+			}
+			allAttrs = append(allAttrs, slog.String("stacktrace", stackStr))
+		}
+		if name := e.Name(); name != "" {
+			allAttrs = append(allAttrs, slog.String("error_name", name))
+		}
+	}
+
+	// Log the error at ERROR level with all attributes
+	// Use a defer to catch any panics during logging
+	defer func() {
+		if r := recover(); r != nil {
+			// Print to stdout to avoid infinite recursion
+			fmt.Printf("ERROR: Recovered from panic during logging: %v\nAttributes: %v\n", r, allAttrs)
+		}
+	}()
+	logger.LogAttrs(context.Background(), slog.LevelError, msg, allAttrs...)
+}
+
+// wrapCallable wraps a function and its arguments into an executable step.
+// It uses reflection to validate the function and arguments.
+func (c *Chain) wrapCallable(fn interface{}, args ...interface{}) (func() error, error) {
+	val := reflect.ValueOf(fn)
+	typ := val.Type()
+
+	// Ensure the provided value is a function
+	if typ.Kind() != reflect.Func {
+		return nil, fmt.Errorf("provided 'fn' is not a function (got %T)", fn)
+	}
+	// Check if the number of arguments matches the function's signature
+	if typ.NumIn() != len(args) {
+		return nil, fmt.Errorf("function expects %d arguments, but %d were provided", typ.NumIn(), len(args))
+	}
+
+	// Prepare argument values
+	argVals := make([]reflect.Value, len(args))
+	errorType := reflect.TypeOf((*error)(nil)).Elem()
+	for i, arg := range args {
+		expectedType := typ.In(i)
+		var providedVal reflect.Value
+		if arg != nil {
+			providedVal = reflect.ValueOf(arg)
+			// Check if the argument type is assignable to the expected type
+			if !providedVal.Type().AssignableTo(expectedType) {
+				// Special case for error interfaces
+				if expectedType.Kind() == reflect.Interface && expectedType.Implements(errorType) && providedVal.Type().Implements(errorType) {
+					// Allow error interface
+				} else {
+					return nil, fmt.Errorf("argument %d type mismatch: expected %s, got %s", i, expectedType, providedVal.Type())
+				}
+			}
+		} else {
+			// Handle nil arguments for nullable types
+			switch expectedType.Kind() {
+			case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
+				providedVal = reflect.Zero(expectedType)
+			default:
+				return nil, fmt.Errorf("argument %d is nil, but expected non-nillable type %s", i, expectedType)
+			}
+		}
+		argVals[i] = providedVal
+	}
+
+	// Validate the function's return type
+	if typ.NumOut() > 1 || (typ.NumOut() == 1 && !typ.Out(0).Implements(errorType)) {
+		return nil, fmt.Errorf("function must return either no values or a single error (got %d return values)", typ.NumOut())
+	}
+
+	// Return a wrapped function that calls the original with the provided arguments
+	return func() error {
+		results := val.Call(argVals)
+		if len(results) == 1 && results[0].Interface() != nil {
+			return results[0].Interface().(error)
+		}
+		return nil
+	}, nil
+}
+
+// executeStep runs a single step, applying retries if configured.
+func (c *Chain) executeStep(ctx context.Context, step *chainStep) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+	if step.config.retry != nil {
+		retry := step.config.retry.Transform(WithContext(ctx))
+		// Wrap step execution to respect context
+		wrappedFn := func() error {
+			type result struct {
+				err error
+			}
+			done := make(chan result, 1)
+			go func() {
+				done <- result{err: step.execute()}
+			}()
+			select {
+			case res := <-done:
+				return res.err
+			case <-ctx.Done():
+				return ctx.Err()
+			}
+		}
+		return retry.Execute(wrappedFn)
+	}
+	// Non-retry case also respects context
+	type result struct {
+		err error
+	}
+	done := make(chan result, 1)
+	go func() {
+		done <- result{err: step.execute()}
+	}()
+	select {
+	case res := <-done:
+		return res.err
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+// enhanceError wraps an error with additional context from the step.
+func (c *Chain) enhanceError(err error, step *chainStep) error {
+	if err == nil || !c.config.autoWrap {
+		// Return the error unchanged if nil or autoWrap is disabled
+		return err
+	}
+
+	// Initialize the base error
+	var baseError *Error
+	if e, ok := err.(*Error); ok {
+		// Copy existing *Error to preserve its properties
+		baseError = e.Copy()
+	} else {
+		// Create a new *Error wrapping the original
+		baseError = New(err.Error()).Wrap(err).WithStack()
+	}
+
+	if step != nil {
+		// Add step-specific context to the error
+		if step.config.category != "" && baseError.Category() == "" {
+			baseError.WithCategory(step.config.category)
+		}
+		if step.config.code != 0 && baseError.Code() == 0 {
+			baseError.WithCode(step.config.code)
+		}
+		for k, v := range step.config.context {
+			baseError.With(k, v)
+		}
+		for _, attr := range step.config.logAttrs {
+			baseError.With(attr.Key, attr.Value.Any())
+		}
+		if step.config.retry != nil && !baseError.HasContextKey(ctxRetry) {
+			// Mark the error as retryable if retries are configured
+			baseError.WithRetryable()
+		}
+	}
+
+	return baseError
+}

vendor/github.com/olekukonko/errors/helper.go

@@ -31,7 +31,7 @@ func Code(err error) int {
 	if e, ok := err.(*Error); ok {
 		return e.Code()
 	}
-	return 500
+	return DefaultCode
 }
 
 // Context extracts the context map from an error, if it is an *Error.
@@ -63,7 +63,12 @@ func Convert(err error) *Error {
 	}
 
 	// Manual unwrapping as fallback
+	visited := make(map[error]bool)
 	for unwrapped := err; unwrapped != nil; {
+		if visited[unwrapped] {
+			break // Cycle detected
+		}
+		visited[unwrapped] = true
 		if e, ok := unwrapped.(*Error); ok {
 			return e
 		}
@@ -229,12 +234,16 @@ func IsRetryable(err error) bool {
 				}
 			}
 		}
-		// Fallback to context map
+		// Check regular context
 		if e.context != nil {
 			if val, ok := e.context[ctxRetry].(bool); ok {
 				return val
 			}
 		}
+		// Check cause recursively
+		if e.cause != nil {
+			return IsRetryable(e.cause)
+		}
 	}
 	lowerMsg := strings.ToLower(err.Error())
 	return IsTimeout(err) || strings.Contains(lowerMsg, "retry")

vendor/github.com/olekukonko/errors/inspect.go

@@ -0,0 +1,225 @@
+// File: inspect.go
+// Updated to support both error and *Error with delegation for cleaner *Error handling
+
+package errors
+
+import (
+	stderrs "errors"
+	"fmt"
+	"strings"
+	"time"
+)
+
+// Inspect provides detailed examination of an error, handling both single errors and MultiError
+func Inspect(err error) {
+	if err == nil {
+		fmt.Println("No error occurred")
+		return
+	}
+
+	fmt.Printf("\n=== Error Inspection ===\n")
+	fmt.Printf("Top-level error: %v\n", err)
+	fmt.Printf("Top-level error type: %T\n", err)
+
+	// Handle *Error directly
+	if e, ok := err.(*Error); ok {
+		InspectError(e)
+		return
+	}
+
+	// Handle MultiError
+	if multi, ok := err.(*MultiError); ok {
+		allErrors := multi.Errors()
+		fmt.Printf("\nContains %d errors:\n", len(allErrors))
+		for i, e := range allErrors {
+			fmt.Printf("\n--- Error %d ---\n", i+1)
+			inspectSingleError(e)
+		}
+	} else {
+		// Inspect single error if not MultiError or *Error
+		fmt.Println("\n--- Details ---")
+		inspectSingleError(err)
+	}
+
+	// Additional diagnostics
+	fmt.Println("\n--- Diagnostics ---")
+	if IsRetryable(err) {
+		fmt.Println("- Error chain contains retryable errors")
+	}
+	if IsTimeout(err) {
+		fmt.Println("- Error chain contains timeout errors")
+	}
+	if code := getErrorCode(err); code != 0 {
+		fmt.Printf("- Highest priority error code: %d\n", code)
+	}
+	fmt.Printf("========================\n\n")
+}
+
+// InspectError provides detailed inspection of a specific *Error instance
+func InspectError(err *Error) {
+	if err == nil {
+		fmt.Println("No error occurred")
+		return
+	}
+
+	fmt.Printf("\n=== Error Inspection (*Error) ===\n")
+	fmt.Printf("Top-level error: %v\n", err)
+	fmt.Printf("Top-level error type: %T\n", err)
+
+	fmt.Println("\n--- Details ---")
+	inspectSingleError(err) // Delegate to handle unwrapping and details
+
+	// Additional diagnostics specific to *Error
+	fmt.Println("\n--- Diagnostics ---")
+	if IsRetryable(err) {
+		fmt.Println("- Error is retryable")
+	}
+	if IsTimeout(err) {
+		fmt.Println("- Error chain contains timeout errors")
+	}
+	if code := err.Code(); code != 0 {
+		fmt.Printf("- Error code: %d\n", code)
+	}
+	fmt.Printf("========================\n\n")
+}
+
+// inspectSingleError handles inspection of a single error (may be part of a chain)
+func inspectSingleError(err error) {
+	if err == nil {
+		fmt.Println("  (nil error)")
+		return
+	}
+
+	fmt.Printf("  Error: %v\n", err)
+	fmt.Printf("  Type: %T\n", err)
+
+	// Handle wrapped errors, including *Error type
+	var currentErr error = err
+	depth := 0
+	for currentErr != nil {
+		prefix := strings.Repeat("  ", depth+1)
+		if depth > 0 {
+			fmt.Printf("%sWrapped Cause (%T): %v\n", prefix, currentErr, currentErr)
+		}
+
+		// Check if it's our specific *Error type
+		if e, ok := currentErr.(*Error); ok {
+			if name := e.Name(); name != "" {
+				fmt.Printf("%sName: %s\n", prefix, name)
+			}
+			if cat := e.Category(); cat != "" {
+				fmt.Printf("%sCategory: %s\n", prefix, cat)
+			}
+			if code := e.Code(); code != 0 {
+				fmt.Printf("%sCode: %d\n", prefix, code)
+			}
+			if ctx := e.Context(); len(ctx) > 0 {
+				fmt.Printf("%sContext:\n", prefix)
+				for k, v := range ctx {
+					fmt.Printf("%s  %s: %v\n", prefix, k, v)
+				}
+			}
+			if stack := e.Stack(); len(stack) > 0 {
+				fmt.Printf("%sStack (Top 3):\n", prefix)
+				limit := 3
+				if len(stack) < limit {
+					limit = len(stack)
+				}
+				for i := 0; i < limit; i++ {
+					fmt.Printf("%s  %s\n", prefix, stack[i])
+				}
+				if len(stack) > limit {
+					fmt.Printf("%s  ... (%d more frames)\n", prefix, len(stack)-limit)
+				}
+			}
+		}
+
+		// Unwrap using standard errors.Unwrap and handle *Error Unwrap
+		var nextErr error
+		// Prioritize *Error's Unwrap if available AND it returns non-nil
+		if e, ok := currentErr.(*Error); ok {
+			unwrapped := e.Unwrap()
+			if unwrapped != nil {
+				nextErr = unwrapped
+			} else {
+				// If *Error.Unwrap returns nil, fall back to standard unwrap
+				// This handles cases where *Error might wrap a non-standard error
+				// or where its internal cause is deliberately nil.
+				nextErr = stderrs.Unwrap(currentErr)
+			}
+		} else {
+			nextErr = stderrs.Unwrap(currentErr) // Fall back to standard unwrap for non-*Error types
+		}
+
+		// Prevent infinite loops if Unwrap returns the same error, or stop if no more unwrapping
+		if nextErr == currentErr || nextErr == nil {
+			break
+		}
+		currentErr = nextErr
+		depth++
+		if depth > 10 { // Safety break for very deep or potentially cyclic chains
+			fmt.Printf("%s... (chain too deep or potential cycle)\n", strings.Repeat("  ", depth+1))
+			break
+		}
+	}
+}
+
+// getErrorCode traverses the error chain to find the highest priority code.
+// It uses errors.As to find the first *Error in the chain.
+func getErrorCode(err error) int {
+	var code int = 0 // Default code
+	var target *Error
+	if As(err, &target) { // Use the package's As helper
+		if target != nil { // Add nil check for safety
+			code = target.Code()
+		}
+	}
+	// If the top-level error is *Error and has a code, it might take precedence.
+	// This depends on desired logic. Let's keep it simple for now: first code found by As.
+	if code == 0 { // Only check top-level if As didn't find one with a code
+		if e, ok := err.(*Error); ok {
+			code = e.Code()
+		}
+	}
+	return code
+}
+
+// handleError demonstrates using Inspect with additional handling logic
+func handleError(err error) {
+	fmt.Println("\n=== Processing Failure ===")
+	Inspect(err) // Use the primary Inspect function
+
+	// Additional handling based on inspection
+	code := getErrorCode(err) // Use the helper
+
+	switch {
+	case IsTimeout(err):
+		fmt.Println("\nAction: Check connectivity or increase timeout")
+	case code == 402: // Check code obtained via helper
+		fmt.Println("\nAction: Payment processing failed - notify billing")
+	default:
+		fmt.Println("\nAction: Generic failure handling")
+	}
+}
+
+// processOrder demonstrates Chain usage with Inspect
+func processOrder() error {
+	validateInput := func() error { return nil }
+	processPayment := func() error { return stderrs.New("credit card declined") }
+	sendNotification := func() error { fmt.Println("Notification sent."); return nil }
+	logOrder := func() error { fmt.Println("Order logged."); return nil }
+
+	chain := NewChain(ChainWithTimeout(2*time.Second)).
+		Step(validateInput).Tag("validation").
+		Step(processPayment).Tag("billing").Code(402).Retry(3, 100*time.Millisecond, WithRetryIf(IsRetryable)).
+		Step(sendNotification).Optional().
+		Step(logOrder)
+
+	err := chain.Run()
+	if err != nil {
+		handleError(err) // Call the unified error handler
+		return err       // Propagate the error if needed
+	}
+	fmt.Println("Order processed successfully!")
+	return nil
+}

vendor/github.com/olekukonko/errors/multi_error.go

@@ -1,11 +1,13 @@
 package errors
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"math/rand"
 	"strings"
 	"sync"
-	"time"
+	"sync/atomic"
 )
 
 // MultiError represents a thread-safe collection of errors with enhanced features.
@@ -45,40 +47,56 @@ func NewMultiError(opts ...MultiErrorOption) *MultiError {
 
 // Add appends an error to the collection with optional sampling, limit checks, and duplicate prevention.
 // Ignores nil errors and duplicates based on string equality; thread-safe.
-func (m *MultiError) Add(err error) {
-	if err == nil {
+func (m *MultiError) Add(errs ...error) {
+	if len(errs) == 0 {
 		return
 	}
 
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	// Check for duplicates by comparing error messages
-	for _, e := range m.errors {
-		if e.Error() == err.Error() {
-			return
+	for _, err := range errs {
+		if err == nil {
+			continue
 		}
-	}
 
-	// Apply sampling if enabled and collection isn’t empty
-	if m.sampling && len(m.errors) > 0 {
-		var r uint32
-		if m.rand != nil {
-			r = uint32(m.rand.Int31n(100))
-		} else {
-			r = fastRand() % 100
+		// Check for duplicates by comparing error messages
+		duplicate := false
+		for _, e := range m.errors {
+			if e.Error() == err.Error() {
+				duplicate = true
+				break
+			}
 		}
-		if r > m.sampleRate { // Accept if random value is within sample rate
-			return
+		if duplicate {
+			continue
 		}
-	}
 
-	// Respect limit if set
-	if m.limit > 0 && len(m.errors) >= m.limit {
-		return
-	}
+		// Apply sampling if enabled and collection isn’t empty
+		if m.sampling && len(m.errors) > 0 {
+			var r uint32
+			if m.rand != nil {
+				r = uint32(m.rand.Int31n(100))
+			} else {
+				r = fastRand() % 100
+			}
+			if r > m.sampleRate { // Accept if random value is within sample rate
+				continue
+			}
+		}
 
-	m.errors = append(m.errors, err)
+		// Respect limit if set
+		if m.limit > 0 && len(m.errors) >= m.limit {
+			continue
+		}
+
+		m.errors = append(m.errors, err)
+	}
+}
+
+// Addf formats and adds a new error to the collection.
+func (m *MultiError) Addf(format string, args ...interface{}) {
+	m.Add(Newf(format, args...))
 }
 
 // Clear removes all errors from the collection.
@@ -300,6 +318,75 @@ func WithRand(r *rand.Rand) MultiErrorOption {
 	}
 }
 
+// MarshalJSON serializes the MultiError to JSON, including all contained errors and configuration metadata.
+// Thread-safe; errors are serialized using their MarshalJSON method if available, otherwise as strings.
+func (m *MultiError) MarshalJSON() ([]byte, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	// Get buffer from pool for efficiency
+	buf := jsonBufferPool.Get().(*bytes.Buffer)
+	defer jsonBufferPool.Put(buf)
+	buf.Reset()
+
+	// Create encoder
+	enc := json.NewEncoder(buf)
+	enc.SetEscapeHTML(false)
+
+	// Define JSON structure
+	type jsonError struct {
+		Error interface{} `json:"error"` // Holds either JSON-marshaled error or string
+	}
+
+	je := struct {
+		Count      int         `json:"count"`                 // Number of errors
+		Limit      int         `json:"limit,omitempty"`       // Maximum error limit (omitted if 0)
+		Sampling   bool        `json:"sampling,omitempty"`    // Whether sampling is enabled
+		SampleRate uint32      `json:"sample_rate,omitempty"` // Sampling rate (1-100, omitted if not sampling)
+		Errors     []jsonError `json:"errors"`                // List of errors
+	}{
+		Count:      len(m.errors),
+		Limit:      m.limit,
+		Sampling:   m.sampling,
+		SampleRate: m.sampleRate,
+	}
+
+	// Serialize each error
+	je.Errors = make([]jsonError, len(m.errors))
+	for i, err := range m.errors {
+		if err == nil {
+			je.Errors[i] = jsonError{Error: nil}
+			continue
+		}
+		// Check if the error implements json.Marshaler
+		if marshaler, ok := err.(json.Marshaler); ok {
+			marshaled, err := marshaler.MarshalJSON()
+			if err != nil {
+				// Fallback to string if marshaling fails
+				je.Errors[i] = jsonError{Error: err.Error()}
+			} else {
+				var raw json.RawMessage = marshaled
+				je.Errors[i] = jsonError{Error: raw}
+			}
+		} else {
+			// Use error string for non-marshaler errors
+			je.Errors[i] = jsonError{Error: err.Error()}
+		}
+	}
+
+	// Encode JSON
+	if err := enc.Encode(je); err != nil {
+		return nil, fmt.Errorf("failed to marshal MultiError: %v", err)
+	}
+
+	// Remove trailing newline
+	result := buf.Bytes()
+	if len(result) > 0 && result[len(result)-1] == '\n' {
+		result = result[:len(result)-1]
+	}
+	return result, nil
+}
+
 // defaultFormat provides the default formatting for multiple errors.
 // Returns a semicolon-separated list prefixed with the error count (e.g., "errors(3): err1; err2; err3").
 func defaultFormat(errs []error) string {
@@ -316,10 +403,21 @@ func defaultFormat(errs []error) string {
 
 // fastRand generates a quick pseudo-random number for sampling.
 // Uses a simple xorshift algorithm based on the current time; not cryptographically secure.
+var fastRandState uint32 = 1 // Must be non-zero
+
 func fastRand() uint32 {
-	r := uint32(time.Now().UnixNano())
-	r ^= r << 13
-	r ^= r >> 17
-	r ^= r << 5
-	return r
+	for {
+		// Atomically load the current state
+		old := atomic.LoadUint32(&fastRandState)
+		// Xorshift computation
+		x := old
+		x ^= x << 13
+		x ^= x >> 17
+		x ^= x << 5
+		// Attempt to store the new state atomically
+		if atomic.CompareAndSwapUint32(&fastRandState, old, x) {
+			return x
+		}
+		// Otherwise retry
+	}
 }

vendor/github.com/olekukonko/errors/retry.go

@@ -103,42 +103,124 @@ func (r *Retry) Execute(fn func() error) error {
 	var lastErr error
 
 	for attempt := 1; attempt <= r.maxAttempts; attempt++ {
+		// Check context before each attempt
+		select {
+		case <-r.ctx.Done():
+			return r.ctx.Err()
+		default:
+		}
+
 		err := fn()
 		if err == nil {
 			return nil
 		}
 
-		// Check if retry is applicable; return immediately if not retryable
+		lastErr = err
+
+		// Check if we should retry
 		if r.retryIf != nil && !r.retryIf(err) {
 			return err
 		}
 
-		lastErr = err
 		if r.onRetry != nil {
 			r.onRetry(attempt, err)
 		}
 
-		// Exit if this was the last attempt
+		// Don't delay after last attempt
 		if attempt == r.maxAttempts {
 			break
 		}
 
-		// Calculate delay with backoff, cap at maxDelay, and apply jitter if enabled
+		// Calculate delay with backoff
+		delay := r.backoff.Backoff(attempt, r.delay)
+		if r.maxDelay > 0 && delay > r.maxDelay {
+			delay = r.maxDelay
+		}
+		if r.jitter {
+			delay = addJitter(delay)
+		}
+
+		// Wait with context
+		select {
+		case <-r.ctx.Done():
+			return r.ctx.Err()
+		case <-time.After(delay):
+		}
+	}
+
+	return lastErr
+}
+
+// ExecuteContext runs the provided function with retry logic, respecting context cancellation.
+// Returns nil on success or the last error if all attempts fail or context is cancelled.
+func (r *Retry) ExecuteContext(ctx context.Context, fn func() error) error {
+	var lastErr error
+
+	// If the retry instance already has a context, use it. Otherwise, use the provided one.
+	// If both are provided, maybe create a derived context? For now, prioritize the one from WithContext.
+	execCtx := r.ctx
+	if execCtx == context.Background() && ctx != nil { // Use provided ctx if retry ctx is default and provided one isn't nil
+		execCtx = ctx
+	} else if ctx == nil { // Ensure we always have a non-nil context
+		execCtx = context.Background()
+	}
+	// Note: This logic might need refinement depending on how contexts should interact.
+	// A safer approach might be: if r.ctx != background, use it. Else use provided ctx.
+
+	for attempt := 1; attempt <= r.maxAttempts; attempt++ {
+		// Check context before executing the function
+		select {
+		case <-execCtx.Done():
+			return execCtx.Err() // Return context error immediately
+		default:
+			// Context is okay, proceed
+		}
+
+		err := fn()
+		if err == nil {
+			return nil // Success
+		}
+
+		// Check if retry is applicable based on the error
+		if r.retryIf != nil && !r.retryIf(err) {
+			return err // Not retryable, return the error
+		}
+
+		lastErr = err // Store the last encountered error
+
+		// Execute the OnRetry callback if configured
+		if r.onRetry != nil {
+			r.onRetry(attempt, err)
+		}
+
+		// Exit loop if this was the last attempt
+		if attempt == r.maxAttempts {
+			break
+		}
+
+		// --- Calculate and apply delay ---
 		currentDelay := r.backoff.Backoff(attempt, r.delay)
-		if currentDelay > r.maxDelay {
+		if r.maxDelay > 0 && currentDelay > r.maxDelay { // Check maxDelay > 0 before capping
 			currentDelay = r.maxDelay
 		}
 		if r.jitter {
 			currentDelay = addJitter(currentDelay)
 		}
-
-		// Wait with respect to context cancellation or timeout
+		if currentDelay < 0 { // Ensure delay isn't negative after jitter
+			currentDelay = 0
+		}
+		// --- Wait for the delay or context cancellation ---
 		select {
-		case <-r.ctx.Done():
-			return r.ctx.Err()
+		case <-execCtx.Done():
+			// If context is cancelled during the wait, return the context error
+			// Often more informative than returning the last application error.
+			return execCtx.Err()
 		case <-time.After(currentDelay):
+			// Wait finished, continue to the next attempt
 		}
 	}
+
+	// All attempts failed, return the last error encountered
 	return lastErr
 }