igniter_lang 0.1.0.alpha.1

data/lib/igniter_lang/compiler_result.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "diagnostics"
+
+module IgniterLang
+  module CompilerResult
+    module_function
+
+    def ok(format_version:, semantic_ir:, source_path:, report:, igapp_path:, contracts:, runtime_smoke:)
+      {
+        "kind" => "compiler_result",
+        "format_version" => format_version,
+        "status" => "ok",
+        "program_id" => semantic_ir.fetch("program_id"),
+        "source_path" => source_path.to_s,
+        "source_hash" => report.fetch("source_hash"),
+        "grammar_version" => report.fetch("grammar_version"),
+        "stages" => stages(report, assemble: "ok"),
+        "igapp_path" => igapp_path.to_s,
+        "compilation_report_ref" => report.fetch("program_id"),
+        "semantic_ir_ref" => report.fetch("semantic_ir_ref"),
+        "contracts" => contracts,
+        "diagnostics" => [],
+        "warnings" => Diagnostics.warnings(report.fetch("diagnostics", [])),
+        "runtime_smoke" => runtime_smoke,
+        "report" => report
+      }
+    end
+
+    def refusal(format_version:, status:, report:, source_path:, report_path:)
+      diagnostics = report.fetch("diagnostics", [])
+      {
+        "kind" => "compiler_result",
+        "format_version" => format_version,
+        "status" => status,
+        "program_id" => report.fetch("semantic_ir_ref", nil),
+        "source_path" => source_path.to_s,
+        "source_hash" => report.fetch("source_hash", nil),
+        "grammar_version" => report.fetch("grammar_version", nil),
+        "stages" => stages(report, assemble: "skipped"),
+        "igapp_path" => nil,
+        "contracts" => [],
+        "compilation_report_path" => report_path.to_s,
+        "diagnostics" => Diagnostics.errors(diagnostics),
+        "warnings" => Diagnostics.warnings(diagnostics),
+        "report" => report
+      }
+    end
+
+    def strict_terminal(format_version:, status:, report:, source_path:, diagnostics:)
+      {
+        "kind" => "compiler_result",
+        "format_version" => format_version,
+        "status" => status,
+        "program_id" => report.fetch("semantic_ir_ref", nil),
+        "source_path" => source_path.to_s,
+        "source_hash" => report.fetch("source_hash", nil),
+        "grammar_version" => report.fetch("grammar_version", nil),
+        "stages" => stages(report, assemble: "skipped"),
+        "igapp_path" => nil,
+        "contracts" => [],
+        "compilation_report_path" => nil,
+        "diagnostics" => diagnostics,
+        "warnings" => Diagnostics.warnings(report.fetch("diagnostics", [])),
+        "report" => report
+      }
+    end
+
+    def public_result(result)
+      result.reject { |key, _value| key == "report" }
+    end
+
+    def stages(report, assemble:)
+      report.fetch("stages").merge("assemble" => assemble)
+    end
+  end
+end

data/lib/igniter_lang/diagnostics.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module IgniterLang
+  module Diagnostics
+    CATEGORIES = {
+      parse_error: "parser_error",
+      parse_warning: "parser_warning",
+      classified: "classifier_oof",
+      typechecked: "typechecker_oof",
+      assembler: "assembler_refusal",
+      runtime_smoke: "runtime_smoke_failure"
+    }.freeze
+
+    module_function
+
+    def enrich(entries, category:, contract: nil)
+      Array(entries).map do |entry|
+        normalized = stringify_keys(entry)
+        diagnostic_contract = normalized.key?("contract") ? normalized.fetch("contract") : contract
+        node = normalized.fetch("node", nil)
+        path = normalized.fetch("path", nil) || path_for(diagnostic_contract, node, normalized)
+        span = span_for(normalized)
+
+        normalized.merge(
+          "category" => normalized.fetch("category", category),
+          "rule" => normalized.fetch("rule", "UNKNOWN"),
+          "severity" => normalized.fetch("severity", "error"),
+          "message" => normalized.fetch("message", "compiler diagnostic"),
+          "contract" => diagnostic_contract,
+          "node" => node,
+          "path" => path,
+          "span" => span
+        ).reject { |key, _value| key == "line" || key == "col" }
+      end
+    end
+
+    def from_parse_errors(errors)
+      Array(errors).flat_map do |entry|
+        severity = stringify_keys(entry).fetch("severity", "error")
+        category = severity == "warning" ? CATEGORIES.fetch(:parse_warning) : CATEGORIES.fetch(:parse_error)
+        enrich([entry], category: category)
+      end
+    end
+
+    def from_classified(diagnostics, contract: nil)
+      enrich(diagnostics, category: CATEGORIES.fetch(:classified), contract: contract)
+    end
+
+    def from_typechecked(diagnostics, contract: nil)
+      enrich(diagnostics, category: CATEGORIES.fetch(:typechecked), contract: contract)
+    end
+
+    def from_assembler_refusal(refusal)
+      enrich(
+        [
+          {
+            "rule" => "ASSEMBLER-REFUSAL",
+            "severity" => "error",
+            "message" => refusal.respond_to?(:message) ? refusal.message : refusal.to_s
+          }
+        ],
+        category: CATEGORIES.fetch(:assembler)
+      )
+    end
+
+    def from_runtime_smoke(smoke)
+      return [] if smoke.fetch("trusted", false)
+
+      enrich(
+        [
+          {
+            "rule" => "OOF-RUNTIME-SMOKE",
+            "severity" => "error",
+            "message" => "RuntimeMachine load/evaluate smoke failed",
+            "details" => smoke
+          }
+        ],
+        category: CATEGORIES.fetch(:runtime_smoke)
+      )
+    end
+
+    def warnings(entries)
+      Array(entries).select { |entry| entry.fetch("severity", nil) == "warning" }
+    end
+
+    def errors(entries)
+      Array(entries).reject { |entry| entry.fetch("severity", nil) == "warning" }
+    end
+
+    def stringify_keys(value)
+      case value
+      when Hash
+        value.each_with_object({}) { |(key, entry), out| out[key.to_s] = stringify_keys(entry) }
+      when Array
+        value.map { |entry| stringify_keys(entry) }
+      else
+        value
+      end
+    end
+
+    def path_for(contract, node, entry)
+      return nil unless contract || node
+
+      parts = []
+      parts << "contract:#{contract}" if contract
+      parts << "#{node_kind(entry)}:#{node}" if node
+      parts.join("/")
+    end
+
+    def node_kind(entry)
+      entry.fetch("node_kind", nil) || entry.fetch("kind", nil) || "node"
+    end
+
+    def span_for(entry)
+      span = entry.fetch("span", nil)
+      return span if span.is_a?(Hash)
+
+      line = entry.fetch("line", nil)
+      col = entry.fetch("col", nil) || entry.fetch("column", nil)
+      return nil unless line && col
+
+      { "line" => line, "col" => col }
+    end
+  end
+end

data/lib/igniter_lang/fragment_registry_compatibility_adapter.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# Fragment Registry Compatibility Adapter — internal direct-require-only helper.
+#
+# ISOLATION CONTRACT — this file must not:
+#   - be required from lib/igniter_lang.rb (direct-require-only; no root require)
+#   - be wired into the live classifier (classifier_wiring_authorized: false)
+#   - participate in live classifier dispatch (held_live_dispatch: true)
+#   - return results that become a ClassifiedProgram field, compiler input,
+#     report output, CLI/API output, or artifact metadata
+#   - touch parser, TypeChecker, SemanticIR, assembler, report, .igapp,
+#     runtime, Spark, or production behavior
+#
+# Authorized by: S3-R147-C1-A
+# Track: fragment-registry-compatibility-adapter-helper-implementation-proof-v0
+#
+# Selection rules (R146 proof selection order, pinned exact):
+#   if oof present      → oof
+#   elsif temporal      → temporal
+#   elsif escape        → escape
+#   elsif stream        → escape   (stream maps to escape)
+#   elsif epistemic     → epistemic
+#   else                → core
+#
+# API (exact R146 C1 shape; no field-name or result-structure change without
+# a separate explicit delta review):
+#   IgniterLang::FragmentRegistryCompatibilityAdapter.project(input_hash) -> result_hash
+
+module IgniterLang
+  class FragmentRegistryCompatibilityAdapter
+    FORMAT_VERSION = "0.1.0".freeze
+    KIND_INPUT     = "fragment_registry_compatibility_adapter_helper_input".freeze
+    KIND_RESULT    = "fragment_registry_compatibility_adapter_helper_result".freeze
+
+    # R146 proof selection rules in priority order.
+    # Must match the proof helper_result_shape.json rules_in_order exactly.
+    SELECTION_RULES = [
+      { presence: "oof",       selected: "oof"       },
+      { presence: "temporal",  selected: "temporal"  },
+      { presence: "escape",    selected: "escape"    },
+      { presence: "stream",    selected: "escape"    }, # stream → escape (not a direct fragment)
+      { presence: "epistemic", selected: "epistemic" }
+    ].freeze
+
+    DEFAULT_SELECTED = "core".freeze
+
+    # Project fragment registry compatibility from an internal input hash.
+    #
+    # Input hash shape (kind: fragment_registry_compatibility_adapter_helper_input):
+    #   contracts[]               — array of { contract_ref, declaration_fragment_presence,
+    #                               current_selected_fragment }
+    #   guarded_non_fragments[]   — array of { name, classification_kind, selected_fragment }
+    #   oof_projection_policy     — { primary_semantics, blocked, loadable, capability }
+    #   classifier_wiring_authorized — false (must remain false)
+    #   source_r144               — { matrix_digest, ... }
+    #
+    # @param input_hash [Hash] Internal helper input conforming to R146 C1 shape.
+    # @return [Hash] Internal result conforming to R146 C1 result shape.
+    #   NEVER touches classifier state, reports, public surfaces, or artifacts.
+    def self.project(input_hash)
+      contracts             = Array(input_hash["contracts"])
+      guarded_non_fragments = Array(input_hash["guarded_non_fragments"])
+      oof_projection_policy = input_hash.fetch("oof_projection_policy", {})
+
+      r144_source_digest = input_hash.dig("source_r144", "matrix_digest")
+      r144_source_status = input_hash.dig("source_r144", "source_status") || "PASS"
+
+      rows = contracts.map do |contract|
+        ref      = contract["contract_ref"]
+        presence = Array(contract["declaration_fragment_presence"])
+        current  = contract["current_selected_fragment"]
+        selected = select_fragment(presence)
+        parity   = selected == current ? "PASS" : "MISMATCH"
+
+        {
+          "contract_ref"                  => ref,
+          "declaration_fragment_presence" => presence,
+          "current_selected_fragment"     => current,
+          "selected_fragment"             => selected,
+          "parity"                        => parity
+        }
+      end
+
+      mismatches    = rows.select { |r| r["parity"] == "MISMATCH" }
+      r144_preserved = mismatches.empty?
+
+      {
+        "kind"           => KIND_RESULT,
+        "format_version" => FORMAT_VERSION,
+        "selected_fragment_projection" => {
+          "rows"           => rows,
+          "mismatches"     => mismatches,
+          "rules_in_order" => rules_in_order_description
+        },
+        "guarded_non_fragments"        => guarded_non_fragments,
+        "oof_projection_policy"        => oof_projection_policy,
+        "r144_parity" => {
+          "preserved"     => r144_preserved,
+          "source_digest" => r144_source_digest,
+          "source_status" => r144_source_status
+        },
+        "held_live_dispatch"            => true,
+        "classifier_wiring_authorized"  => false
+      }
+    end
+
+    # -------------------------------------------------------------------------
+    # Private class-level helpers
+    # -------------------------------------------------------------------------
+
+    # Select the fragment name for the given list of declared fragment presences,
+    # applying the R146 proof selection rules in priority order.
+    def self.select_fragment(presence_list)
+      SELECTION_RULES.each do |rule|
+        return rule[:selected] if presence_list.include?(rule[:presence])
+      end
+      DEFAULT_SELECTED
+    end
+    private_class_method :select_fragment
+
+    # Produce the canonical rules_in_order array for inclusion in the result shape.
+    def self.rules_in_order_description
+      SELECTION_RULES.map do |rule|
+        { "if" => "#{rule[:presence]} present", "selected" => rule[:selected] }
+      end + [{ "otherwise" => DEFAULT_SELECTED }]
+    end
+    private_class_method :rules_in_order_description
+  end
+end

data/lib/igniter_lang/internal_profile_assembly.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+# Internal profile assembly boundary.
+#
+# ISOLATION CONTRACT — this file must not:
+#   - be required from lib/igniter_lang.rb
+#   - integrate with parser/classifier/TypeChecker/SemanticIR/assembler/orchestrator
+#   - expose public API or CLI
+#   - read paths, manifests, loader reports, CompatibilityReports, or runtime state
+#   - write .igapp, .ilk, reports, sidecars, goldens, diagnostics, or CompilerResult fields
+#
+# Authorized by: LANG-R132-A
+# Track: internal-profile-assembly-boundary-implementation-v0
+
+require "digest"
+require "json"
+
+module IgniterLang
+  class InternalProfileAssembly
+    KIND = "internal_profile_assembly_result"
+    FORMAT_VERSION = "0.1.0"
+
+    SOURCE_PACKET_KIND = "compiler_profile_oof_registry_source_input"
+    IMPLEMENTATION_CANDIDATE = "implementation_candidate"
+    FINALIZED_INTERNAL = "finalized_internal"
+
+    FINALIZED_INTERNAL_MEANING =
+      "internal assembly state only; not PROP-036 finalization, not compiler_profile_id, " \
+      "and not manifest/profile identity"
+
+    CLOSED_SURFACE_ASSERTIONS = {
+      "root_require" => false,
+      "compiler_pipeline_usage" => false,
+      "public_api_cli" => false,
+      "loader_report" => false,
+      "compatibility_report" => false,
+      "igapp_mutation" => false,
+      "manifest_mutation" => false,
+      "prop036_mutation" => false,
+      "prop038_mutation" => false,
+      "runtime_behavior" => false,
+      "production_behavior" => false,
+      "spark_surface" => false
+    }.freeze
+
+    DIAG_INVALID_SOURCE_PACKET = "internal_profile_assembly.invalid_source_packet"
+    DIAG_INVALID_LIFECYCLE_STATE = "internal_profile_assembly.invalid_lifecycle_state"
+    DIAG_PACKET_MAPPING_FAILED = "internal_profile_assembly.packet_mapping_failed"
+    DIAG_PACKET_VALIDATION_FAILED = "internal_profile_assembly.packet_validation_failed"
+
+    def self.assemble(source_packet:, registry_validator: IgniterLang::OOFFragmentRegistry.new)
+      new(source_packet: source_packet, registry_validator: registry_validator).assemble
+    end
+
+    def initialize(source_packet:, registry_validator:)
+      @source_packet = source_packet
+      @registry_validator = registry_validator
+    end
+
+    def assemble
+      diagnostics = []
+      packet_hash = nil
+      helper_envelopes = nil
+      validation = nil
+      input_lifecycle_state = lifecycle_state_of(@source_packet)
+
+      unless source_packet_compatible?(@source_packet)
+        diagnostics << diag(DIAG_INVALID_SOURCE_PACKET,
+          "source_packet must support lifecycle_state, to_h, to_helper_envelopes, and validate_with")
+        return build_result(false, input_lifecycle_state, diagnostics, packet_hash, helper_envelopes, validation)
+      end
+
+      if input_lifecycle_state != IMPLEMENTATION_CANDIDATE
+        diagnostics << diag(DIAG_INVALID_LIFECYCLE_STATE,
+          "source_packet lifecycle_state must be #{IMPLEMENTATION_CANDIDATE.inspect}, " \
+          "got #{input_lifecycle_state.inspect}")
+      end
+
+      begin
+        packet_hash = @source_packet.to_h
+        helper_envelopes = @source_packet.to_helper_envelopes
+      rescue StandardError => e
+        diagnostics << diag(DIAG_PACKET_MAPPING_FAILED, "#{e.class}: #{e.message}")
+        return build_result(false, input_lifecycle_state, diagnostics, packet_hash, helper_envelopes, validation)
+      end
+
+      unless packet_hash.is_a?(Hash) && packet_hash["kind"] == SOURCE_PACKET_KIND
+        diagnostics << diag(DIAG_INVALID_SOURCE_PACKET,
+          "source_packet.to_h must return kind #{SOURCE_PACKET_KIND.inspect}")
+      end
+
+      begin
+        validation = @source_packet.validate_with(registry_validator: @registry_validator)
+      rescue StandardError => e
+        diagnostics << diag(DIAG_PACKET_VALIDATION_FAILED, "#{e.class}: #{e.message}")
+        return build_result(false, input_lifecycle_state, diagnostics, packet_hash, helper_envelopes, validation)
+      end
+
+      diagnostics.concat(internal_diagnostics_from(validation))
+      valid = diagnostics.empty? && validation.fetch("valid", false)
+
+      build_result(valid, input_lifecycle_state, diagnostics, packet_hash, helper_envelopes, validation)
+    end
+
+    private
+
+    def source_packet_compatible?(packet)
+      %i[
+        lifecycle_state
+        to_h
+        to_helper_envelopes
+        validate_with
+      ].all? { |method_name| packet.respond_to?(method_name) }
+    end
+
+    def lifecycle_state_of(packet)
+      return nil unless packet.respond_to?(:lifecycle_state)
+
+      packet.lifecycle_state
+    end
+
+    def build_result(valid, input_lifecycle_state, diagnostics, packet_hash, helper_envelopes, validation)
+      {
+        "kind" => KIND,
+        "format_version" => FORMAT_VERSION,
+        "valid" => valid,
+        "lifecycle_state" => valid ? FINALIZED_INTERNAL : non_final_lifecycle(input_lifecycle_state),
+        "input_lifecycle_state" => input_lifecycle_state,
+        "packet_kind" => packet_hash.is_a?(Hash) ? packet_hash["kind"] : nil,
+        "packet_digest" => packet_hash ? digest(packet_hash) : nil,
+        "helper_envelopes_digest" => helper_envelopes ? digest(helper_envelopes) : nil,
+        "profile_validation" => validation.is_a?(Hash) ? validation["profile_validation"] : nil,
+        "pack_descriptor_validations" => validation.is_a?(Hash) ? Array(validation["pack_descriptor_validations"]) : [],
+        "diagnostics" => diagnostics,
+        "finalized_internal_meaning" => FINALIZED_INTERNAL_MEANING,
+        "closed_surface_assertions" => deep_copy(CLOSED_SURFACE_ASSERTIONS)
+      }
+    end
+
+    def internal_diagnostics_from(validation)
+      return [diag(DIAG_PACKET_VALIDATION_FAILED, "source_packet.validate_with must return a Hash")] unless validation.is_a?(Hash)
+      return [] if validation.fetch("valid", false)
+
+      diagnostics = []
+      profile_diags = Array(validation.dig("profile_validation", "source_diagnostics"))
+      diagnostics.concat(profile_diags.map { |source_diag| source_validation_diag("profile_validation", source_diag) })
+
+      Array(validation["pack_descriptor_validations"]).each_with_index do |pack_validation, index|
+        Array(pack_validation["source_diagnostics"]).each do |source_diag|
+          diagnostics << source_validation_diag("pack_descriptor_validations[#{index}]", source_diag)
+        end
+      end
+
+      diagnostics << diag(DIAG_PACKET_VALIDATION_FAILED, "source packet validation failed") if diagnostics.empty?
+      diagnostics
+    end
+
+    def non_final_lifecycle(input_lifecycle_state)
+      return IMPLEMENTATION_CANDIDATE if input_lifecycle_state == IMPLEMENTATION_CANDIDATE
+
+      "invalid"
+    end
+
+    def source_validation_diag(path, source_diag)
+      {
+        "code" => DIAG_PACKET_VALIDATION_FAILED,
+        "path" => path,
+        "source_code" => source_diag.fetch("code", nil),
+        "message" => source_diag.fetch("message", "source packet validation failed")
+      }
+    end
+
+    def diag(code, message)
+      {
+        "code" => code,
+        "message" => message
+      }
+    end
+
+    def digest(value)
+      Digest::SHA256.hexdigest(JSON.generate(canonicalize(value)))[0, 24]
+    end
+
+    def canonicalize(value)
+      case value
+      when Hash
+        value.keys.sort.to_h { |key| [key, canonicalize(value[key])] }
+      when Array
+        value.map { |inner| canonicalize(inner) }
+      else
+        value
+      end
+    end
+
+    def deep_copy(value)
+      Marshal.load(Marshal.dump(value))
+    end
+  end
+end