kumi 0.0.29 → 0.0.30

data/golden/roll/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_fbbd9524e89735c5dbaf290442b7ae9b51c1aeedcbe116ad99c5af17605a99ee
+module Kumi::Compiled::KUMI_a1445291f04923fe3d936c1514d8bf48488a469a9328b03080feb08b70093276
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/shift/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_cb5c8bdee5947708dc24300b2c2b672056453e6f137563d7bf848a40bdc4e534
+module Kumi::Compiled::KUMI_d17fb0388f7014e59c7e9a892d540e54a949f21eb86a9e8e8a396bc3488d6f35
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/shift_2d/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_21390de8a42e8b9e82e444c05c8030a3d5285d0077573acab1c303e27d5436fb
+module Kumi::Compiled::KUMI_10a8c4eef85aad586921c958580baafbe11b5bd9ca21b75e678a47f7dd65daab
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/simple_math/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_d729bd10302a56f8a23981643e21bb67803d5850bc61ac80e268c592fdfb37d7
+module Kumi::Compiled::KUMI_b5eff95b28c57576e4613ae2a1fa9784e744318ef6565131ada24c407fec28e7
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/streaming_basics/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_03a2e9a0500bceafc56945b155f90c33cc1a23713c1b16b22908a76f6cc0d8c3
+module Kumi::Compiled::KUMI_d972b45a945bf808f0713ddc12e431b18405a54a9d90bfa262d81a86e42b46ca
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/tuples/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_f7ef5fcd350fe14b8092390d8fc3031fa401de46e5e5a7c5944436336aae60c5
+module Kumi::Compiled::KUMI_2eed3f0a8d77c4064660318dbbae64a67ba86a5d882fba6f60715e64d9677ba2
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/tuples_and_arrays/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_b29542da718e63a254f2e4a844b7515afaafc01da8055fa5e9c661f1ba347beb
+module Kumi::Compiled::KUMI_4d2cbd3183abfbb3252e36a42fbc36925bef07ceb2aaa302e586496362f48566
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/us_tax_2024/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_6b3029186d9b3c61fe69d9ceb9fc1d33177f973d83d0fb228ab8b2088fcb7cf2
+module Kumi::Compiled::KUMI_f570bd1470fbdb4fe98673449f7d2106c6eeb0a11dbd0d656e2d19485860c206
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/with_constants/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_7e3d95df01d361f5adc0bf6b1990b0d5cccfba056716e6870c570d205196a924
+module Kumi::Compiled::KUMI_e200083314e8307addf1cf2056b27031a7256e95b7cde0d0bc3865b4aef4ead2
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/lib/kumi/analyzer.rb

@@ -51,7 +51,7 @@ module Kumi
     def self.analyze!(schema, passes: DEFAULT_PASSES, registry: nil, **opts)
       errors = []
       schema_digest = schema.digest
-      stop_after = Core::Analyzer::Checkpoint.stop_after
+      Core::Analyzer::Checkpoint.stop_after
 
       registry ||= Kumi::RegistryV2.load
       state = Core::Analyzer::AnalysisState.new(opts).with(:registry, registry).with(:schema_digest, schema_digest)
@@ -61,7 +61,7 @@ module Kumi
       state, stopped = run_analysis_passes(schema, HIR_TO_LIR_PASSES, state, errors)
       return create_analysis_result(state) if stopped
 
-      state, stopped = run_analysis_passes(schema, RUBY_TARGET_PASSES, state, errors)
+      state, = run_analysis_passes(schema, RUBY_TARGET_PASSES, state, errors)
 
       handle_analysis_errors(errors) unless errors.empty?
       create_analysis_result(state)
@@ -71,91 +71,51 @@ module Kumi
       # Resume from a saved state if configured
       state = Core::Analyzer::Checkpoint.load_initial_state(state)
 
+      # Prepare options for PassManager
       debug_on = Core::Analyzer::Debug.enabled?
       resume_at  = Core::Analyzer::Checkpoint.resume_at
       stop_after = Core::Analyzer::Checkpoint.stop_after
-      skipping   = !!resume_at
-      stopped    = false
-
-      passes.each_with_index do |pass_class, idx|
-        raise handle_analysis_errors(errors) if !errors.empty? && (ERROR_THRESHOLD_PASS == pass_class)
-
-        pass_name = pass_class.name.split("::").last
 
-        if skipping
-          skipping = false if pass_name == resume_at
-          next if skipping
-        end
-
-        Core::Analyzer::Checkpoint.entering(pass_name:, idx:, state:)
-
-        before = state.to_h if debug_on
-        Core::Analyzer::Debug.reset_log(pass: pass_name) if debug_on
-
-        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        pass_instance = pass_class.new(schema, state)
-        begin
-          state = Dev::Profiler.phase("analyzer.pass", pass: pass_name) do
-            pass_instance.run(errors)
-          end
-        rescue StandardError => e
-          # TODO: - GREATLY improve this, need to capture the context of the error
-          # and the pass that failed and line number if relevant
-          message = "Error in Analysis Pass(#{pass_name}): #{e.message}"
-          errors << Core::ErrorReporter.create_error(message, location: nil, type: :semantic, backtrace: e.backtrace)
-
-          if debug_on
-            logs = Core::Analyzer::Debug.drain_log
-            elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2)
-
-            Core::Analyzer::Debug.emit(
-              pass: pass_name,
-              diff: {},
-              elapsed_ms: elapsed_ms,
-              logs: logs + [{ level: :error, id: :exception, message: e.message, error_class: e.class.name }]
-            )
-          end
-
-          raise
-        end
-        unless state.is_a? Kumi::Core::Analyzer::AnalysisState
-          raise "Pass #{pass_name} returned a '#{state.class}', expected 'AnalysisState'"
-        end
+      # Filter passes based on checkpoint resume point
+      filtered_passes = if resume_at
+                          passes.each_with_index do |pass_class, idx|
+                            pass_name = pass_class.name.split("::").last
+                            if pass_name == resume_at
+                              break passes[idx..]
+                            end
+                          end.flatten.compact
+                        else
+                          passes
+                        end
+
+      # Check for error threshold pass
+      if !errors.empty? && filtered_passes.include?(ERROR_THRESHOLD_PASS)
+        raise handle_analysis_errors(errors)
+      end
 
-        elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2)
-
-        if debug_on
-          after = state.to_h
-
-          # Optional immutability guard
-          if ENV["KUMI_DEBUG_REQUIRE_FROZEN"] == "1"
-            (after || {}).each do |k, v|
-              if v.nil? || v.is_a?(Numeric) || v.is_a?(Symbol) || v.is_a?(TrueClass) || v.is_a?(FalseClass) || (v.is_a?(String) && v.frozen?)
-                next
-              end
-              raise "State[#{k}] not frozen: #{v.class}" unless v.frozen?
-            end
-          end
-
-          diff = Core::Analyzer::Debug.diff_state(before, after)
-          logs = Core::Analyzer::Debug.drain_log
-
-          Core::Analyzer::Debug.emit(
-            pass: pass_name,
-            diff: diff,
-            elapsed_ms: elapsed_ms,
-            logs: logs
+      # Use PassManager for orchestration
+      manager = Core::Analyzer::PassManager.new(filtered_passes)
+      options = {
+        checkpoint_enabled: true,
+        debug_enabled: debug_on,
+        profiling_enabled: true,
+        stop_after: stop_after
+      }
+
+      result = manager.run(schema, state, errors, options)
+
+      # Convert PassFailure errors back to ErrorEntry for consistency
+      if result.failed?
+        result.errors.each do |pass_failure|
+          errors << Core::ErrorReporter.create_error(
+            pass_failure.message,
+            location: pass_failure.location,
+            type: :semantic
           )
         end
-
-        Core::Analyzer::Checkpoint.leaving(pass_name:, idx:, state:)
-
-        if stop_after && pass_name == stop_after
-          stopped = true
-          break
-        end
       end
-      [state, stopped]
+
+      [result.final_state, result.stopped || false]
     end
 
     def self.handle_analysis_errors(errors)

data/lib/kumi/core/analyzer/analysis_state.rb

@@ -19,6 +19,8 @@ module Kumi
           @data.key?(key)
         end
 
+        alias has_key? key?
+
         # Get all keys (same as hash)
         def keys
           @data.keys

data/lib/kumi/core/analyzer/constant_evaluator.rb

@@ -44,8 +44,6 @@ module Kumi
           when NAST::Tuple
             values = node.args.map { |arg| resolve_constant_value(arg) }
             values.all? ? values : nil
-          else
-            nil
           end
         end
       end

data/lib/kumi/core/analyzer/execution_phase.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      class ExecutionPhase
+        attr_reader :pass_class, :index
+
+        def initialize(pass_class:, index:)
+          @pass_class = pass_class
+          @index = index
+        end
+
+        def pass_name
+          @pass_class.name.split("::").last
+        end
+
+        def to_s
+          "Phase #{index}: #{pass_name}"
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/execution_result.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      class ExecutionResult
+        attr_reader :final_state, :errors, :failed_at_phase, :stopped
+
+        def initialize(final_state:, errors: [], failed_at_phase: nil, stopped: false)
+          @final_state = final_state
+          @errors = errors
+          @failed_at_phase = failed_at_phase
+          @stopped = stopped
+        end
+
+        def self.success(final_state:, stopped: false)
+          new(final_state: final_state, errors: [], failed_at_phase: nil, stopped: stopped)
+        end
+
+        def self.failure(final_state:, errors:, failed_at_phase:)
+          new(final_state: final_state, errors: errors, failed_at_phase: failed_at_phase, stopped: false)
+        end
+
+        def succeeded?
+          errors.empty?
+        end
+
+        def failed?
+          !succeeded?
+        end
+
+        def error_count
+          errors.size
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/pass_failure.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      class PassFailure
+        attr_reader :message, :phase, :pass_name, :location
+
+        def initialize(message:, phase:, pass_name:, location:)
+          @message = message
+          @phase = phase
+          @pass_name = pass_name
+          @location = location
+        end
+
+        def to_s
+          if location
+            "#{pass_name} (phase #{phase}) at #{location}: #{message}"
+          else
+            "#{pass_name} (phase #{phase}): #{message}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/pass_manager.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      class PassManager
+        attr_reader :passes, :errors
+
+        def initialize(passes)
+          @passes = passes
+          @errors = []
+        end
+
+        def run(syntax_tree, initial_state = nil, errors = [], options = {})
+          state = initial_state || AnalysisState.new
+
+          passes.each_with_index do |pass_class, phase_index|
+            pass_name = pass_class.name.split("::").last
+
+            # Checkpoint support
+            Checkpoint.entering(pass_name:, idx: phase_index, state:) if options[:checkpoint_enabled]
+
+            # Debug support
+            debug_on = options[:debug_enabled]
+            before = state.to_h if debug_on
+            Debug.reset_log(pass: pass_name) if debug_on
+
+            # Performance profiling support
+            t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC) if options[:profiling_enabled]
+
+            begin
+              pass_instance = pass_class.new(syntax_tree, state)
+
+              if options[:profiling_enabled]
+                state = Dev::Profiler.phase("analyzer.pass", pass: pass_name) do
+                  pass_instance.run(errors)
+                end
+              else
+                state = pass_instance.run(errors)
+              end
+            rescue StandardError => e
+              # Capture exception context
+              message = "Error in Analysis Pass(#{pass_name}): #{e.message}"
+              error_obj = ErrorReporter.create_error(message, location: nil, type: :semantic, backtrace: e.backtrace)
+              errors << error_obj
+
+              if debug_on
+                logs = Debug.drain_log
+                elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2) if options[:profiling_enabled]
+                Debug.emit(
+                  pass: pass_name,
+                  diff: {},
+                  elapsed_ms: elapsed_ms || 0,
+                  logs: logs + [{ level: :error, id: :exception, message: e.message, error_class: e.class.name }]
+                )
+              end
+
+              # Return failure result instead of raising - let caller decide what to do
+              phase = ExecutionPhase.new(pass_class: pass_class, index: phase_index)
+              converted_error = PassFailure.new(
+                message: error_obj.message,
+                phase: phase_index,
+                pass_name: phase.pass_name,
+                location: error_obj.location
+              )
+              return ExecutionResult.failure(
+                final_state: state,
+                errors: [converted_error],
+                failed_at_phase: phase_index
+              )
+            end
+
+            # Type checking (PassManager enforces AnalysisState)
+            unless state.is_a?(AnalysisState)
+              raise "Pass #{pass_name} returned #{state.class}, expected AnalysisState"
+            end
+
+            # Debug logging with state diff
+            if debug_on
+              after = state.to_h
+
+              # Optional immutability guard
+              if ENV["KUMI_DEBUG_REQUIRE_FROZEN"] == "1"
+                (after || {}).each do |k, v|
+                  if v.nil? || v.is_a?(Numeric) || v.is_a?(Symbol) || v.is_a?(TrueClass) || v.is_a?(FalseClass) || (v.is_a?(String) && v.frozen?)
+                    next
+                  end
+                  raise "State[#{k}] not frozen: #{v.class}" unless v.frozen?
+                end
+              end
+
+              diff = Debug.diff_state(before, after)
+              logs = Debug.drain_log
+              elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2) if options[:profiling_enabled]
+
+              Debug.emit(
+                pass: pass_name,
+                diff: diff,
+                elapsed_ms: elapsed_ms || 0,
+                logs: logs
+              )
+            end
+
+            # Checkpoint support
+            Checkpoint.leaving(pass_name:, idx: phase_index, state:) if options[:checkpoint_enabled]
+
+            # Handle errors
+            if !errors.empty?
+              phase = ExecutionPhase.new(pass_class: pass_class, index: phase_index)
+              converted_errors = errors.map do |error|
+                PassFailure.new(
+                  message: error.message,
+                  phase: phase_index,
+                  pass_name: phase.pass_name,
+                  location: error.respond_to?(:location) ? error.location : nil
+                )
+              end
+              return ExecutionResult.failure(
+                final_state: state,
+                errors: converted_errors,
+                failed_at_phase: phase_index
+              )
+            end
+
+            # Check stop_after
+            if options[:stop_after] && pass_name == options[:stop_after]
+              return ExecutionResult.success(final_state: state, stopped: true)
+            end
+          end
+
+          ExecutionResult.success(final_state: state)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/analyzer/passes/codegen/js/declaration_emitter.rb

@@ -73,7 +73,7 @@ module Kumi
                 write "let #{container} = [];"
               end
 
-              def emit_loopend(ins, i)
+              def emit_loopend(_ins, i)
                 start_index = find_loop_start_for_end(i)
                 is_yield_container_loop = @stack.length < @yield_depth && loop_contain_yield?(start_index)
 

data/lib/kumi/core/analyzer/passes/codegen/js_pass.rb

@@ -12,7 +12,7 @@ module Kumi
               schema_digest = get_state(:schema_digest)
               hints = get_state(:hints)
 
-              decls = decls.reject { |n, v| hints[n][:inline] }
+              decls = decls.reject { |n, _v| hints[n][:inline] }
               emitter = Codegen::Js::Emitter.new(manifest["kernels"], manifest["bindings"])
               src = emitter.emit(decls, schema_digest: schema_digest)
 

data/lib/kumi/core/analyzer/passes/codegen/ruby/declaration_emitter.rb

@@ -85,7 +85,7 @@ module Kumi
                 write "#{container} = []"
               end
 
-              def emit_loopend(ins, i)
+              def emit_loopend(_ins, i)
                 is_yield_container_loop = @stack.length < @yield_depth && loop_contain_yield?(find_loop_start_for_end(i))
 
                 if is_yield_container_loop

data/lib/kumi/core/analyzer/passes/codegen/ruby_pass.rb

@@ -18,7 +18,7 @@ module Kumi
               # The codegen pass no longer needs direct access to the registry
               emitter = Codegen::Ruby::Emitter.new(manifest["kernels"], manifest["bindings"])
 
-              decls = decls.reject { |n, v| hints[n][:inline] }
+              decls = decls.reject { |n, _v| hints[n][:inline] }
               src = emitter.emit(decls, schema_digest:)
 
               files = { "codegen.rb" => src }

data/lib/kumi/core/analyzer/passes/constant_folding_pass.rb

@@ -7,7 +7,7 @@ module Kumi
         class ConstantFoldingPass < PassBase
           NAST = Kumi::Core::NAST
 
-          def run(errors)
+          def run(_errors)
             nast_module = get_state(:nast_module, required: true)
             order = get_state(:evaluation_order, required: true)
             @registry = get_state(:registry, required: true)

data/lib/kumi/core/analyzer/passes/formal_constraint_propagator.rb

@@ -25,8 +25,6 @@ module Kumi
               propagate_equality_forward(constraint, operation_spec, operand_map)
             when :range
               propagate_range_forward(constraint, operation_spec, operand_map)
-            else
-              nil
             end
           end
 
@@ -37,8 +35,6 @@ module Kumi
               propagate_equality_reverse(constraint, operation_spec, operand_map)
             when :range
               propagate_range_reverse(constraint, operation_spec, operand_map)
-            else
-              nil
             end
           end
 
@@ -47,7 +43,7 @@ module Kumi
           # FORWARD PROPAGATION: Compute output value from input constraints
           def propagate_equality_forward(constraint, operation_spec, operand_map)
             result_var = operand_map[:result]
-            input_var = constraint[:variable]
+            constraint[:variable]
             input_value = constraint[:value]
 
             case operation_spec.id
@@ -75,8 +71,6 @@ module Kumi
               output_value = input_value - other_operand
               { variable: result_var, op: :==, value: output_value }
 
-            else
-              nil
             end
           end
 
@@ -122,14 +116,12 @@ module Kumi
               output_max = input_max - other
               { variable: result_var, op: :range, min: output_min, max: output_max }
 
-            else
-              nil
             end
           end
 
           # REVERSE PROPAGATION: Derive input equality from output equality
           def propagate_equality_reverse(constraint, operation_spec, operand_map)
-            result_var = constraint[:variable]
+            constraint[:variable]
             result_value = constraint[:value]
             left_var = operand_map[:left_operand]
             right_var = operand_map[:right_operand]
@@ -141,20 +133,18 @@ module Kumi
                 { variable: left_var, op: :==, value: result_value - right_var }
               elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric)
                 { variable: right_var, op: :==, value: result_value - left_var }
-              else
-                nil
               end
 
             when "core.mul"
               # result == V, result = x * C => x == V / C (if C != 0)
               if left_var.is_a?(Symbol) && right_var.is_a?(Numeric) && right_var != 0
                 return nil unless (result_value % right_var).zero?
+
                 { variable: left_var, op: :==, value: result_value / right_var }
               elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric) && left_var != 0
                 return nil unless (result_value % left_var).zero?
+
                 { variable: right_var, op: :==, value: result_value / left_var }
-              else
-                nil
               end
 
             when "core.sub"
@@ -163,12 +153,8 @@ module Kumi
                 { variable: left_var, op: :==, value: result_value + right_var }
               elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric)
                 { variable: right_var, op: :==, value: left_var - result_value }
-              else
-                nil
               end
 
-            else
-              nil
             end
           end
 
@@ -191,17 +177,15 @@ module Kumi
             when "core.mul"
               # result in [min, max], result = x * C => x in [min/C, max/C] (depends on sign)
               if left_var.is_a?(Symbol) && right_var.is_a?(Numeric) && right_var != 0
-                if right_var > 0
-                  return { variable: left_var, op: :range, min: result_min / right_var, max: result_max / right_var }
-                else
-                  return { variable: left_var, op: :range, min: result_max / right_var, max: result_min / right_var }
-                end
+                return { variable: left_var, op: :range, min: result_min / right_var, max: result_max / right_var } if right_var > 0
+
+                return { variable: left_var, op: :range, min: result_max / right_var, max: result_min / right_var }
+
               elsif right_var.is_a?(Symbol) && left_var.is_a?(Numeric) && left_var != 0
-                if left_var > 0
-                  return { variable: right_var, op: :range, min: result_min / left_var, max: result_max / left_var }
-                else
-                  return { variable: right_var, op: :range, min: result_max / left_var, max: result_min / left_var }
-                end
+                return { variable: right_var, op: :range, min: result_min / left_var, max: result_max / left_var } if left_var > 0
+
+                return { variable: right_var, op: :range, min: result_max / left_var, max: result_min / left_var }
+
               end
 
             when "core.sub"
@@ -216,7 +200,7 @@ module Kumi
             nil
           end
 
-          def get_other_operand_value(constraint, operand_map, operation)
+          def get_other_operand_value(constraint, operand_map, _operation)
             input_var = constraint[:variable]
             left_var = operand_map[:left_operand] || operand_map.values[0]
             right_var = operand_map[:right_operand] || operand_map.values[1]
@@ -225,8 +209,6 @@ module Kumi
               right_var
             elsif input_var == right_var && left_var.is_a?(Numeric)
               left_var
-            else
-              nil
             end
           end
         end

data/lib/kumi/core/analyzer/passes/input_access_planner_pass.rb

@@ -5,7 +5,7 @@ module Kumi
     module Analyzer
       module Passes
         class InputAccessPlannerPass < PassBase
-          def run(errors)
+          def run(_errors)
             input_metadata = get_state(:input_metadata)
 
             options = {

data/lib/kumi/core/analyzer/passes/input_collector.rb

@@ -108,7 +108,7 @@ module Kumi
             when Kumi::Core::Types::ArrayType
               :array
             when Kumi::Core::Types::TupleType
-              :array  # Tuples behave like arrays for input access
+              :array # Tuples behave like arrays for input access
             when :array, Kumi::Core::Types::ScalarType
               # Check if it's a hash scalar or :hash symbol
               if t.is_a?(Kumi::Core::Types::ScalarType) && t.kind == :hash