// env_validation.go:275-276
if port < 1 || port > 65535 {
	return 0, fmt.Errorf("MCP_GATEWAY_PORT must be between 1 and 65535, got %d", port)
}

// schema_validation.go:240-248
if port < 1 || port > 65535 {
	return &ValidationError{
		Field:      "port",
		Message:    fmt.Sprintf("port must be between 1 and 65535, got %d", port),
		JSONPath:   "gateway.port",
		Suggestion: "Use a valid port number (e.g., 8080)",
	}
}

// validation.go:201-210
if *gateway.Port < 1 || *gateway.Port > 65535 {
	return &ValidationError{
		Field:      "port",
		Message:    fmt.Sprintf("port must be between 1 and 65535, got %d", *gateway.Port),
		JSONPath:   "gateway.port",
		Suggestion: "Use a valid port number (e.g., 8080)",
	}
}

// schema_validation.go:265-272
if stdinCfg.Gateway.StartupTimeout != nil && *stdinCfg.Gateway.StartupTimeout < 1 {
	return &ValidationError{
		Field:      "startupTimeout",
		Message:    fmt.Sprintf("startupTimeout must be at least 1, got %d", *stdinCfg.Gateway.StartupTimeout),
		JSONPath:   "gateway.startupTimeout",
		Suggestion: "Use a positive number of seconds (e.g., 30)",
	}
}

// validation.go:213-220 (identical pattern)

return &ValidationError{
	Field:      "fieldName",
	Message:    fmt.Sprintf("...", value),
	JSONPath:   "path.to.field",
	Suggestion: "...",
}

for i, mount := range server.Mounts {
	if !mountPattern.MatchString(mount) {
		return &ValidationError{
			Field:      "mounts",
			Message:    fmt.Sprintf("mount '%s' does not match required pattern", mount),
			JSONPath:   fmt.Sprintf("%s.mounts[%d]", jsonPath, i),
			Suggestion: "Use format 'source:dest:mode' where mode is 'ro' or 'rw'",
		}
	}
}

func validateMounts(mounts []string, jsonPath string) error {
	for i, mount := range mounts {
		parts := strings.Split(mount, ":")
		if len(parts) != 3 {
			return &ValidationError{
				Field:      "mounts",
				Message:    fmt.Sprintf("invalid mount format '%s' (expected 'source:dest:mode')", mount),
				JSONPath:   fmt.Sprintf("%s.mounts[%d]", jsonPath, i),
				Suggestion: "Use format 'source:dest:mode' where mode is 'ro' (read-only) or 'rw' (read-write)",
			}
		}

		source, dest, mode := parts[0], parts[1], parts[2]

		// Validate source is not empty
		if source == "" {
			return &ValidationError{...}
		}

		// Validate dest is not empty
		if dest == "" {
			return &ValidationError{...}
		}

		// Validate mode
		if mode != "ro" && mode != "rw" {
			return &ValidationError{...}
		}
	}
	return nil
}

// internal/config/rules/rules.go
package rules

// PortRange validates port is in valid range (1-65535)
func PortRange(port int, jsonPath string) *ValidationError {
	if port < 1 || port > 65535 {
		return &ValidationError{
			Field:      "port",
			Message:    fmt.Sprintf("port must be between 1 and 65535, got %d", port),
			JSONPath:   jsonPath,
			Suggestion: "Use a valid port number (e.g., 8080)",
		}
	}
	return nil
}

// TimeoutPositive validates timeout is >= 1
func TimeoutPositive(timeout int, fieldName, jsonPath string) *ValidationError {
	if timeout < 1 {
		return &ValidationError{
			Field:      fieldName,
			Message:    fmt.Sprintf("%s must be at least 1, got %d", fieldName, timeout),
			JSONPath:   jsonPath,
			Suggestion: "Use a positive number of seconds",
		}
	}
	return nil
}

// MountFormat validates mount format and components
func MountFormat(mount, jsonPath string, index int) *ValidationError {
	// Single implementation of mount validation
}

// env_validation.go
func GetGatewayPortFromEnv() (int, error) {
	port, err := strconv.Atoi(portStr)
	if err != nil {
		return 0, err
	}
	
	if err := rules.PortRange(port, "MCP_GATEWAY_PORT"); err != nil {
		return 0, fmt.Errorf("%s", err.Message)
	}
	
	return port, nil
}

// validation.go
func validateGatewayConfig(gateway *StdinGatewayConfig) error {
	if gateway.Port != nil {
		if err := rules.PortRange(*gateway.Port, "gateway.port"); err != nil {
			return err
		}
	}
	
	if gateway.StartupTimeout != nil {
		if err := rules.TimeoutPositive(*gateway.StartupTimeout, "startupTimeout", "gateway.startupTimeout"); err != nil {
			return err
		}
	}
	
	return nil
}

// internal/config/validation_pipeline.go
type Validator interface {
	Validate(cfg *StdinConfig) error
}

type ValidationPipeline struct {
	validators []Validator
}

func (p *ValidationPipeline) Validate(cfg *StdinConfig) error {
	for _, v := range p.validators {
		if err := v.Validate(cfg); err != nil {
			return err
		}
	}
	return nil
}

// Usage:
pipeline := &ValidationPipeline{
	validators: []Validator{
		&SchemaValidator{},
		&SemanticValidator{},
		&EnvironmentValidator{},
	},
}