fixed a sorbet type issue and got all tests passing

Author: ndbroadbent

DEVELOPMENT.md

@@ -7,6 +7,34 @@
 - You do need to `extend T::Helpers` in modules if they use other Sorbet features (e.g `requires_ancestor`)
 - Never use `LogStruct::` when you're inside the `module LogStruct` scope (same for nested modules/classes.)
 
+## Critical: Sorbet Runtime Type Checking and Return Values
+
+**NEVER use `void` return types for methods that need to return values to other code.**
+
+Sorbet runtime type checking will enforce return type signatures and can interfere with method return values. If a method has `sig { ... }.void`, Sorbet will return `T::Private::Types::Void::VOID` instead of the actual method result.
+
+This is especially critical for:
+
+- Rack middleware `call` methods (must return `[status, headers, body]`)
+- Methods used in Rails middleware chain (like `logger.tagged`)
+- Any method where the return value is used by external code
+
+**Fix:** Use `T.untyped` instead of `void` for return types when the return value matters:
+
+```ruby
+# BAD - will return VOID instead of block result
+sig { params(block: T.proc.void).void }
+def tagged(&block)
+  # ...
+end
+
+# GOOD - returns the actual block result
+sig { params(block: T.proc.returns(T.untyped)).returns(T.untyped) }
+def tagged(&block)
+  # ...
+end
+```
+
 # Core Dependencies
 
 This gem requires Rails 7.0+ and will always have access to these core Rails modules:

lib/log_struct/integrations/rack_error_handler/middleware.rb

@@ -126,7 +126,7 @@ def call(env)
 
         private
 
-        sig { params(env: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+        sig { params(env: T::Hash[String, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
         def extract_request_context(env)
           request = ::ActionDispatch::Request.new(env)
           {

lib/log_struct/semantic_logger/logger.rb

@@ -89,7 +89,7 @@ def initialize(name = "Application", level: nil, filter: nil)
       end
 
       # Support for tagged logging
-      sig { params(tags: T.untyped, block: T.proc.void).void }
+      sig { params(tags: T.untyped, block: T.proc.returns(T.untyped)).returns(T.untyped) }
       def tagged(*tags, &block)
         # Convert tags to array and pass individually to avoid splat issues
         tag_array = tags.flatten

sorbet/rbi/overrides/rack_types.rbi

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rack
+  # Type definitions for Rack middleware
+
+  # Standard Rack response tuple: [status, headers, body]
+  # Status is an Integer HTTP status code
+  # Headers is a Hash of String keys to String (or Array<String>) values
+  # Body is an enumerable that yields strings
+  RackResponse = T.type_alias { [Integer, T::Hash[String, T.untyped], T.any(T::Array[String], T::Enumerable[String])] }
+
+  # Rack environment hash
+  RackEnv = T.type_alias { T::Hash[String, T.untyped] }
+
+  # Rack application/middleware callable
+  # Must respond to #call(env) and return a RackResponse
+  RackApp = T.type_alias {
+    T.any(
+      T.proc.params(env: RackEnv).returns(RackResponse),
+      T.untyped  # For objects with #call method
+    )
+  }
+end