kumi 0.0.31 → 0.0.33

data/golden/us_tax_2024/expected/schema_javascript.mjs

@@ -1,22 +1,16 @@
 export function _summary(input) {
   let out = [];
   let t974 = input["income"];
-  const t975 = 168600.0;
-  let t976 = [t974, t975];
+  let t976 = [t974, 168600.0];
   let t977 = Math.min(...t976);
-  const t978 = 0.062;
-  let t979 = t977 * t978;
-  const t981 = 0.0145;
-  let t982 = t974 * t981;
+  let t979 = t977 * 0.062;
+  let t982 = t974 * 0.0145;
   let t1032 = input["state_rate"];
   let t1033 = t974 * t1032;
   let t1035 = input["local_rate"];
   let t1036 = t974 * t1035;
   let t181 = input["statuses"];
-  const t824 = 0;
-  const t857 = 1.0;
   let t971 = t979 + t982;
-  const t990 = 0.009;
   let t195 = {
     "marginal": t1032,
     "effective": t1032,
@@ -28,9 +22,7 @@ export function _summary(input) {
     "tax": t1036
   };
   let t204 = input["retirement_contrib"];
-  const t840 = -1;
-  const t842 = 100000000000.0;
-  let t858 = [t974, t857];
+  let t858 = [t974, 1.0];
   let t859 = Math.max(...t858);
   t181.forEach((statuses_el_182, statuses_i_183) => {
     let t184 = statuses_el_182["name"];
@@ -46,31 +38,31 @@ export function _summary(input) {
     let acc1315 = 0.0;
     let t823 = t974 - t822;
     let t986 = t974 - t985;
-    let t825 = [t823, t824];
-    let t988 = [t986, t824];
+    let t825 = [t823, 0];
+    let t988 = [t986, 0];
     let t826 = Math.max(...t825);
     let t989 = Math.max(...t988);
     t803.forEach((t804, t805) => {
       let t829 = t804["lo"];
       let t815 = t826 >= t829;
       let t847 = t804["hi"];
-      let t841 = t847 == t840;
-      let t844 = t841 ? t842 : t847;
+      let t841 = t847 == -1;
+      let t844 = t841 ? 100000000000.0 : t847;
       let t818 = t826 < t844;
       let t819 = t815 && t818;
       let t853 = t804["rate"];
-      let t809 = t819 ? t853 : t824;
+      let t809 = t819 ? t853 : 0;
       acc802 += t809;
     });
-    let t991 = t989 * t990;
+    let t991 = t989 * 0.009;
     t803.forEach((t865, t866) => {
       let t890 = t865["lo"];
       let t875 = t826 - t890;
       let t901 = t865["hi"];
-      let t895 = t901 == t840;
-      let t898 = t895 ? t842 : t901;
+      let t895 = t901 == -1;
+      let t898 = t895 ? 100000000000.0 : t901;
       let t879 = t898 - t890;
-      let t880 = Math.min(Math.max(t875, t824), t879);
+      let t880 = Math.min(Math.max(t875, 0), t879);
       let t910 = t865["rate"];
       let t869 = t880 * t910;
       acc863 += t869;

data/golden/us_tax_2024/expected/schema_ruby.rb

@@ -1,49 +1,18 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_f570bd1470fbdb4fe98673449f7d2106c6eeb0a11dbd0d656e2d19485860c206
-  def self.from(input_data = nil)
-    instance = Object.new
-    instance.extend(self)
-    instance.instance_variable_set(:@input, input_data)
-    instance
-  end
-
-  def self.__kumi_executable__
-    instance = Object.new
-    instance.extend(self)
-    instance
-  end
-
-  def update(input_data)
-    @input = @input.merge(input_data)
-    self
-  end
-
-  def [](name)
-    case name
-    when :summary then _summary
-    else raise KeyError, "Unknown declaration"
-    end
-  end
-
-  def _summary(input = @input)
+module Kumi::Compiled::KUMI_f93cd7180a38afa538b4e27322ce1f862595fccb54611929cd3b3d32b7a0a7f0
+  def self._summary(input)
     out = []
     t974 = input["income"] || input[:income]
-    t975 = 168600.0
-    t976 = [t974, t975]
+    t976 = [t974, 168600.0]
     t977 = t976.min
-    t978 = 0.062
-    t979 = t977 * t978
-    t981 = 0.0145
-    t982 = t974 * t981
+    t979 = t977 * 0.062
+    t982 = t974 * 0.0145
     t1032 = input["state_rate"] || input[:state_rate]
     t1033 = t974 * t1032
     t1035 = input["local_rate"] || input[:local_rate]
     t1036 = t974 * t1035
     t181 = input["statuses"] || input[:statuses]
-    t824 = 0
-    t857 = 1.0
     t971 = t979 + t982
-    t990 = 0.009
     t195 = {
       "marginal" => t1032,
       "effective" => t1032,
@@ -55,9 +24,7 @@ module Kumi::Compiled::KUMI_f570bd1470fbdb4fe98673449f7d2106c6eeb0a11dbd0d656e2d
       "tax" => t1036
     }
     t204 = input["retirement_contrib"] || input[:retirement_contrib]
-    t840 = -1
-    t842 = 100000000000.0
-    t858 = [t974, t857]
+    t858 = [t974, 1.0]
     t859 = t858.max
     t181.each_with_index do |statuses_el_182, statuses_i_183|
       t184 = statuses_el_182["name"] || statuses_el_182[:name]
@@ -73,32 +40,32 @@ module Kumi::Compiled::KUMI_f570bd1470fbdb4fe98673449f7d2106c6eeb0a11dbd0d656e2d
       acc1315 = 0.0
       t823 = t974 - t822
       t986 = t974 - t985
-      t825 = [t823, t824]
-      t988 = [t986, t824]
+      t825 = [t823, 0]
+      t988 = [t986, 0]
       t826 = t825.max
       t989 = t988.max
       t803.each_with_index do |t804, t805|
         t829 = t804["lo"] || t804[:lo]
         t815 = t826 >= t829
         t847 = t804["hi"] || t804[:hi]
-        t841 = t847 == t840
-        t844 = t841 ? t842 : t847
+        t841 = t847 == -1
+        t844 = t841 ? 100000000000.0 : t847
         t818 = t826 < t844
         t819 = t815 && t818
         t853 = t804["rate"] || t804[:rate]
-        t809 = t819 ? t853 : t824
+        t809 = t819 ? t853 : 0
         acc802 += t809
       end
-      t991 = t989 * t990
+      t991 = t989 * 0.009
       t810 = acc802
       t803.each_with_index do |t865, t866|
         t890 = t865["lo"] || t865[:lo]
         t875 = t826 - t890
         t901 = t865["hi"] || t865[:hi]
-        t895 = t901 == t840
-        t898 = t895 ? t842 : t901
+        t895 = t901 == -1
+        t898 = t895 ? 100000000000.0 : t901
         t879 = t898 - t890
-        t880 = [[ t875, t824 ].max, t879 ].min
+        t880 = t875.clamp(0, t879)
         t910 = t865["rate"] || t865[:rate]
         t869 = t880 * t910
         acc863 += t869

data/golden/with_constants/expected/lir_06_const_prop.txt

@@ -1,17 +1,12 @@
 (LIR
   (Declaration scores
-    %t1 = const 100 :: integer
-    %t2 = const 85 :: integer
-    %t3 = const 92 :: integer
-    %t4 = make_tuple(%t1, %t2, %t3) :: tuple<integer, integer, integer>
+    %t4 = make_tuple(%__immediate_placeholder__, %__immediate_placeholder__, %__immediate_placeholder__) :: tuple<integer, integer, integer>
     yield %t4
   )
   (Declaration first_score
-    %t5 = const 100 :: integer
-    yield %t5
+    yield %__immediate_placeholder__
   )
   (Declaration second_score
-    %t6 = const 85 :: integer
-    yield %t6
+    yield %__immediate_placeholder__
   )
 )

data/golden/with_constants/expected/schema_javascript.mjs

@@ -1,18 +1,13 @@
 export function _scores(input) {
-  const t1 = 100;
-  const t2 = 85;
-  const t3 = 92;
-  let t4 = [t1, t2, t3];
+  let t4 = [100, 85, 92];
   return t4;
 }
 
 export function _first_score(input) {
-  const t5 = 100;
-  return t5;
+  return 100;
 }
 
 export function _second_score(input) {
-  const t6 = 85;
-  return t6;
+  return 85;
 }
 

data/golden/with_constants/expected/schema_ruby.rb

@@ -1,44 +1,14 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_e200083314e8307addf1cf2056b27031a7256e95b7cde0d0bc3865b4aef4ead2
-  def self.from(input_data = nil)
-    instance = Object.new
-    instance.extend(self)
-    instance.instance_variable_set(:@input, input_data)
-    instance
+module Kumi::Compiled::KUMI_5108af24d012f937e1c0316f75655a9577ee8e16e0b0867506c94ceb7237ae46
+  def self._scores(input)
+    [100, 85, 92]
   end
 
-  def self.__kumi_executable__
-    instance = Object.new
-    instance.extend(self)
-    instance
-  end
-
-  def update(input_data)
-    @input = @input.merge(input_data)
-    self
-  end
-
-  def [](name)
-    case name
-    when :scores then _scores
-    when :first_score then _first_score
-    when :second_score then _second_score
-    else raise KeyError, "Unknown declaration"
-    end
-  end
-
-  def _scores(input = @input)
-    t1 = 100
-    t2 = 85
-    t3 = 92
-    [t1, t2, t3]
-  end
-
-  def _first_score(input = @input)
+  def self._first_score(input)
     100
   end
 
-  def _second_score(input = @input)
+  def self._second_score(input)
     85
   end
 end

data/lib/kumi/analyzer.rb

@@ -8,13 +8,14 @@ module Kumi
 
     DEFAULT_PASSES = [
       Passes::NameIndexer,                     # 1. Finds all names and checks for duplicates.
-      Passes::InputCollector,                  # 2. Collects field metadata from input declarations.
-      Passes::InputFormSchemaPass,             # 3. Builds minimal form schema from input metadata.
-      Passes::DeclarationValidator,            # 4. Checks the basic structure of each rule.
-      Passes::SemanticConstraintValidator,     # 5. Validates DSL semantic constraints at AST level.
-      Passes::DependencyResolver,              # 6. Builds the dependency graph with conditional dependencies.
-      Passes::Toposorter,                      # 7. Creates the final evaluation order, allowing safe cycles.
-      Passes::InputAccessPlannerPass           # 8. Plans access strategies for input fields.
+      Passes::ImportAnalysisPass,              # 2. Loads source schemas for imports (NEW).
+      Passes::InputCollector,                  # 3. Collects field metadata from input declarations.
+      Passes::InputFormSchemaPass,             # 4. Builds minimal form schema from input metadata.
+      Passes::DeclarationValidator,            # 5. Checks the basic structure of each rule.
+      Passes::SemanticConstraintValidator,     # 6. Validates DSL semantic constraints at AST level.
+      Passes::DependencyResolver,              # 7. Builds the dependency graph with conditional dependencies.
+      Passes::Toposorter,                      # 8. Creates the final evaluation order, allowing safe cycles.
+      Passes::InputAccessPlannerPass           # 9. Plans access strategies for input fields.
     ].freeze
 
     # Pipeline passes for the determinisitic NAST->LIR approach

data/lib/kumi/configuration.rb

@@ -53,14 +53,15 @@ module Kumi
     # refresh" experience, and AOT for production to ensure fast boots
     # and catch precompilation errors in CI.
     def default_compilation_mode
-      # RACK_ENV is a common standard, but Rails.env is more specific.
-      env = defined?(Rails) ? Rails.env.to_s : ENV.fetch("RACK_ENV", nil)
+      override = ENV.fetch("KUMI_COMPILATION_MODE", nil)
+      if override && !override.strip.empty?
+        normalized = override.strip.downcase.to_sym
+        return normalized if %i[jit aot].include?(normalized)
 
-      if env == "development"
-        :jit
-      else
-        :aot
+        warn "[kumi] Ignoring invalid KUMI_COMPILATION_MODE=#{override.inspect}; falling back to environment-based default"
       end
+
+      :jit
     end
   end
 end

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

@@ -46,7 +46,7 @@ module Kumi
                 walk.call(x.on_false)
               when NAST::Reduce, NAST::Fold
                 walk.call(x.arg)
-              when NAST::Call, NAST::Tuple
+              when NAST::Call, NAST::Tuple, NAST::ImportCall
                 x.args.each { walk.call(_1) }
               when NAST::Hash
                 x.pairs.each { walk.call(_1) }

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

@@ -29,7 +29,7 @@ module Kumi
               annotate!(node.body, by_fqn)
             when NAST::InputRef
               annotate_input_ref!(node, by_fqn)
-            when NAST::Tuple, NAST::Call
+            when NAST::Tuple, NAST::Call, NAST::ImportCall
               node.args.each { |a| annotate!(a, by_fqn) }
             when NAST::Hash
               node.pairs.each { |p| annotate!(p.value, by_fqn) }

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

@@ -123,6 +123,26 @@ module Kumi
                 end
               end
 
+              def emit_importschemacall(ins, _i)
+                # Generate code to call an imported schema function
+                source_module = ins.attributes[:source_module]
+                fn_name = ins.attributes[:fn_name]
+                input_keys = ins.attributes[:input_mapping_keys]
+                args = operands_for(ins)
+
+                js_module = ruby_module_to_js(source_module)
+                input_obj = input_keys.zip(args).map { |k, v| "'#{k}': #{v}" }.join(", ")
+
+                write "let #{vreg(ins)} = #{js_module}.from({#{input_obj}})._#{fn_name};"
+              end
+
+              private
+
+              def ruby_module_to_js(ruby_module_path)
+                # Convert Ruby module path (GoldenSchemas::Tax) to JavaScript path (GoldenSchemas.Tax)
+                ruby_module_path.to_s.gsub('::', '.')
+              end
+
               def emit_fold(ins, _i)
                 kernel = kernel_for(ins.result_register)
                 args = operands_for(ins)

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

@@ -27,7 +27,7 @@ module Kumi
                 # Pre-calculate the depth of the single Yield instruction.
                 @yield_depth = find_yield_depth(ops)
 
-                write "def _#{name}(input = @input)"
+                write "def self._#{name}(input)"
                 indent!
 
                 # Setup the top-level 'out' container if the result is an array.
@@ -129,18 +129,27 @@ module Kumi
 
                 if (template = kernel[:attrs]["inline"])
                   inlined_code = _inline_kernel(template, args)
-                  if template.start_with?("=") || template.include?("$0")
-                    write "#{vreg(ins)} #{inlined_code}"
-                  else
-                    # For +=, -= etc.
-                    write "#{vreg(ins)} #{inlined_code}".lstrip
-                  end
+                  write "#{vreg(ins)} #{inlined_code}"
                 else
                   fn_name = kernel_method_name(kernel[:fn_id])
                   write "#{vreg(ins)} = #{fn_name}(#{args.join(', ')})"
                 end
               end
 
+              def emit_importschemacall(ins, _i)
+                # Generate code to call an imported schema function
+                source_module = ins.attributes[:source_module]
+                fn_name = ins.attributes[:fn_name]
+                input_keys = ins.attributes[:input_mapping_keys]
+                args = operands_for(ins)
+
+                # Create a hash of input parameters
+                input_hash = input_keys.zip(args).map { |k, v| "#{k.inspect} => #{v}" }.join(", ")
+
+                # Generate: imported_module._fn_name({input_mapping})
+                write "#{vreg(ins)} = #{source_module}._#{fn_name}({#{input_hash}})"
+              end
+
               def emit_fold(ins, _i)
                 kernel = kernel_for(ins.result_register)
                 args = operands_for(ins)

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

@@ -35,41 +35,9 @@ module Kumi
                 write "end"
               end
 
-              def emit_class_methods(decl_names)
-                write "def self.from(input_data = nil)"
-                indented do
-                  write "instance = Object.new"
-                  write "instance.extend(self)"
-                  write "instance.instance_variable_set(:@input, input_data)"
-                  write "instance"
-                end
-                write "end\n"
-
-                write "def self.__kumi_executable__"
-                indented do
-                  write "instance = Object.new"
-                  write "instance.extend(self)"
-                  write "instance"
-                end
-                write "end\n"
-
-                write "def update(input_data)"
-                indented do
-                  write "@input = @input.merge(input_data)"
-                  write "self"
-                end
-                write "end\n"
-
-                return unless decl_names.size >= 1
-
-                write "def [](name)"
-                indented do
-                  write "case name"
-                  decl_names.each { |name| write "when :#{name} then _#{name}" }
-                  write "else raise KeyError, \"Unknown declaration\""
-                  write "end"
-                end
-                write "end\n"
+              def emit_class_methods(_decl_names)
+                # No boilerplate needed anymore - all declarations are pure module functions
+                # This method remains for backward compatibility with the emit pipeline
               end
 
               def section(name)

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

@@ -68,6 +68,12 @@ module Kumi
               # adds the root input declaration as a dependency
               root_input_declr_name = node.path.first
               add_dependency_edge(graph, reverse_deps, decl.name, root_input_declr_name, :key, context[:via])
+            when ImportCall
+              # Check that imported name exists
+              imported_schemas = get_state(:imported_schemas) || {}
+              report_error(errors, "undefined import reference `#{node.fn_name}`", location: node.loc) unless imported_schemas.key?(node.fn_name)
+
+              add_dependency_edge(graph, reverse_deps, decl.name, node.fn_name, :import_call, node.fn_name)
             when Literal
               leaves[decl.name] << node
             end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Analyzer
+      module Passes
+        class ImportAnalysisPass < PassBase
+          def run(errors)
+            imported_decls = get_state(:imported_declarations)
+            imported_schemas = {}
+
+            imported_decls.each do |name, meta|
+              source_module_ref = meta[:from_module]
+
+              begin
+                source_module = resolve_source_module(source_module_ref)
+              rescue NameError => e
+                report_error(
+                  errors,
+                  "cannot import `#{name}`: module #{source_module_ref.inspect} not found (#{e.message})",
+                  location: meta[:loc]
+                )
+                next
+              end
+
+              begin
+                syntax_tree = source_module.__kumi_syntax_tree__
+              rescue NoMethodError
+                report_error(
+                  errors,
+                  "cannot import `#{name}` from #{qualified_ref(source_module_ref, source_module)}: not a Kumi schema (missing __kumi_syntax_tree__)",
+                  location: meta[:loc]
+                )
+                next
+              end
+
+              source_decl = syntax_tree.values.find { |v| v.name == name } ||
+                            syntax_tree.traits.find { |t| t.name == name }
+
+              unless source_decl
+                available = (syntax_tree.values.map(&:name) + syntax_tree.traits.map(&:name)).sort
+                msg = "imported declaration `#{name}` not found in #{qualified_ref(source_module_ref, source_module)}"
+                msg += "\navailable declarations: #{available.join(', ')}" if available.any?
+                report_error(errors, msg, location: meta[:loc])
+                next
+              end
+
+              begin
+                analyzed_state = Kumi::Analyzer.analyze!(syntax_tree).state
+              rescue => e
+                report_error(
+                  errors,
+                  "failed to analyze imported schema from #{qualified_ref(source_module_ref, source_module)}: #{e.class}: #{e.message}",
+                  location: meta[:loc]
+                )
+                next
+              end
+
+              imported_schemas[name] = {
+                decl: source_decl,
+                source_module: source_module,
+                source_root: syntax_tree,
+                analyzed_state: analyzed_state,
+                input_metadata: analyzed_state[:input_metadata] || {}
+              }
+            end
+
+            state.with(:imported_schemas, imported_schemas.freeze)
+          end
+
+          private
+
+          def resolve_source_module(source_module_ref)
+            if source_module_ref.is_a?(String)
+              Object.const_get(source_module_ref)
+            else
+              source_module_ref
+            end
+          end
+
+          def qualified_ref(ref, mod = nil)
+            return mod if mod
+            return ref if ref
+            "(unknown)"
+          end
+        end
+      end
+    end
+  end
+end