udb 0.1.9 → 0.1.14

data/lib/udb/obj/non_isa_specification.rb

@@ -143,72 +143,19 @@ class NonIsaSpecification
     )
   end
 
-  # Validation methods
-  sig { returns(T::Array[String]) }
-  # Validate all prose statement IDs and conventions for this spec.
-  def validate_prose_ids
-    return [] unless valid?
-
-    issues = []
-    statements = extract_prose_statements
-    statements.each do |stmt|
-      next unless stmt['id']
-      id = stmt['id']
-      source = stmt[:source] || 'unknown'
-
-      # Check ID format according to prose-schema conventions
-      unless valid_id_format?(id)
-        issues << "Invalid ID format '#{id}' in #{source}: must be lowercase with underscores/hyphens only"
-      end
-
-      # Check for non-ISA specification naming convention
-      unless valid_id_naming?(id)
-        issues << "ID '#{id}' in #{source} should start with '#{name.downcase}-' for non-ISA specifications"
-      end
-    end
-
-    # Check for duplicate IDs
-    issues.concat(find_duplicate_ids(statements))
-    issues
-  end
-
-  sig { params(include_sections: T::Boolean).returns(T::Array[T::Hash[T.any(String, Symbol), T.untyped]]) }
-  # Extract all prose statements from description and sections, tagging their source.
-  def extract_prose_statements(include_sections: true)
-    statements = []
-    # Extract from description
-    if spec_description.is_a?(Array)
-      spec_description.each_with_index { |stmt, i| statements << stmt.merge(source: "description[#{i}]") if stmt.is_a?(Hash) }
-    end
-    # Extract from sections
-    if include_sections
-      sections.each_with_index do |section, section_idx|
-        next unless section['content'].is_a?(Array)
-        section['content'].each_with_index do |stmt, stmt_idx|
-          statements << stmt.merge(source: "sections[#{section_idx}].content[#{stmt_idx}]") if stmt.is_a?(Hash)
-        end
-      end
-    end
-    statements
-  end
-
   # Rendering methods
   sig do
     params(
       cfg_arch: T.untyped,
       base_level: Integer,
-      normative: T::Boolean,
-      non_normative: T::Boolean
     ).returns(String)
   end
   # Configuration-aware rendering
-  def render_for_cfg(cfg_arch, base_level: 3, normative: true, non_normative: true)
+  def render_for_cfg(cfg_arch, base_level: 3)
     return "" unless exists_in_cfg?(cfg_arch)
 
     to_asciidoc(
       base_level: base_level,
-      normative: normative,
-      non_normative: non_normative,
       when_callback: create_when_callback(cfg_arch)
     )
   end
@@ -216,24 +163,22 @@ class NonIsaSpecification
   sig do
     params(
       base_level: Integer,
-      normative: T::Boolean,
-      non_normative: T::Boolean,
       when_callback: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
     ).returns(String)
   end
   # Render the full specification as AsciiDoc, including description, sections, and references.
-  def to_asciidoc(base_level: 3, normative: true, non_normative: true, when_callback: nil)
+  def to_asciidoc(base_level: 3, when_callback: nil)
     return create_fallback_content(base_level) unless valid?
 
     content = []
 
     # Add main description prose
-    desc_content = render_structured_prose(spec_description, normative: normative, non_normative: non_normative, when_callback: when_callback)
+    desc_content = render_structured_prose(spec_description, when_callback: when_callback)
     content << desc_content if desc_content && !desc_content.empty?
     content << ""
 
     # Process all sections
-    content.concat(render_sections(base_level, normative, non_normative, when_callback))
+    content.concat(render_sections(base_level, when_callback))
 
     # Add references section if present
     content.concat(render_references(base_level)) unless references.empty?
@@ -243,50 +188,22 @@ class NonIsaSpecification
 
   private
 
-  # Validation helper methods
-  sig { params(id: String).returns(T::Boolean) }
-  # IDs must be lowercase, start with a letter, and use only underscores/hyphens.
-  def valid_id_format?(id)
-    id.match?(/^[a-z][a-z0-9_-]*$/)
-  end
-
-  sig { params(id: String).returns(T::Boolean) }
-  # IDs should start with spec name or allowed prefixes for non-ISA specs.
-  def valid_id_naming?(id)
-    id.start_with?(name.downcase) || id.match?(/^(ext|inst|csr)-/)
-  end
-
-  sig { params(statements: T::Array[T::Hash[T.any(String, Symbol), T.untyped]]).returns(T::Array[String]) }
-  # Find duplicate IDs in the statements array.
-  def find_duplicate_ids(statements)
-    issues = []
-    id_counts = Hash.new(0)
-    statements.each { |stmt| id_counts[stmt['id']] += 1 if stmt['id'] }
-    id_counts.each do |id, count|
-      next if count == 1
-      issues << "Duplicate ID '#{id}' appears #{count} times"
-    end
-    issues
-  end
-
   # Rendering helper methods
   sig do
     params(
       base_level: Integer,
-      normative: T::Boolean,
-      non_normative: T::Boolean,
       when_callback: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
     ).returns(T::Array[String])
   end
   # Render all sections, adjusting heading levels and filtering by callback.
-  def render_sections(base_level, normative, non_normative, when_callback)
+  def render_sections(base_level, when_callback)
     content = []
     sections.each do |section|
       next unless should_include_section?(section, when_callback)
       level = section['level'] || (base_level + 1)
       content << "#{'=' * level} #{section['title']}"
       content << ""
-      section_content = render_structured_prose(section['content'], normative: normative, non_normative: non_normative, when_callback: when_callback)
+      section_content = render_structured_prose(section['content'], when_callback: when_callback)
       content << section_content if section_content && !section_content.empty?
       content << ""
     end
@@ -311,29 +228,34 @@ class NonIsaSpecification
   sig do
     params(
       prose_content: T.untyped,
-      normative: T::Boolean,
-      non_normative: T::Boolean,
       when_callback: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
     ).returns(T.nilable(String))
   end
-  # Render an array of prose statements as AsciiDoc, filtering by normative and conditional status.
-  def render_structured_prose(prose_content, normative: true, non_normative: true, when_callback: nil)
+  # Render an array of prose statements as AsciiDoc.
+  def render_structured_prose(prose_content, when_callback: nil)
     return nil if prose_content.nil?
+
+    # Handle simple string (Asciidoc source)
+    return prose_content if prose_content.is_a?(String)
+
     return "" unless prose_content.is_a?(Array)
 
     rendered_statements = []
     prose_content.each do |statement|
-      next unless statement.is_a?(Hash) && statement['id'] && statement['text']
+      text = nil
+      condition = nil
+
+      next unless statement.is_a?(Hash)
+
+      text = statement['text']
+      condition = statement['when()']
 
-      # Filter by normative status
-      stmt_normative = statement['normative']
-      next if stmt_normative == true && !normative
-      next if stmt_normative == false && !non_normative
+      next unless text
 
       # Filter by when condition
-      next if when_callback && !when_callback.call(statement['when()'], statement)
+      next if when_callback && !when_callback.call(condition, statement)
 
-      rendered_statements << statement['text']
+      rendered_statements << text
     end
     rendered_statements.join("\n\n")
   end

data/lib/udb/obj/portfolio.rb

@@ -23,6 +23,7 @@ module Udb
   class PortfolioExtensionRequirement
     extend T::Sig
     extend Forwardable
+    include Comparable
 
     def_delegators :@ext_req,
       :name,
@@ -41,12 +42,22 @@ module Udb
         presence: T.nilable(Presence)
       ).void
     }
-    def initialize(name, requirements, arch:, note:, req_id:, presence:)
+    def initialize(name, requirements, arch:, note: nil, req_id: nil, presence: nil)
       @ext_req = arch.extension_requirement(name, requirements)
       @note = note
       @req_id = req_id
       @presence = presence
     end
+
+    sig { params(other: T.any(PortfolioExtensionRequirement, ExtensionRequirement)).returns(T.nilable(Integer)) }
+    def <=>(other)
+      case other
+      when PortfolioExtensionRequirement
+        @ext_req <=> other.ext_req
+      when ExtensionRequirement
+        @ext_req <=> other
+      end
+    end
   end
 
 ##################
@@ -440,22 +451,22 @@ module Udb
         end
     end
 
-    sig { returns(T::Hash[String, T.untyped]) }
-    def to_config
-      {
+    sig { params(mandatory: T::Array[PortfolioExtensionRequirement]).returns(T::Hash[String, T.untyped]) }
+    def to_config(mandatory: mandatory_ext_reqs)
+      c = {
         "$schema" => "config_schema.json#",
         "kind" => "architecture configuration",
         "type" => "partially configured",
         "name" => name,
         "description" => description,
-        "params" => all_in_scope_params.map do |p|
+        "params" => all_in_scope_params.sort.map do |p|
           if p.single_value?
             [p.name, p.value]
           else
             nil
           end
         end.compact.to_h,
-        "mandatory_extensions" => mandatory_ext_reqs.map do |ext_req|
+        "mandatory_extensions" => mandatory.sort.map do |ext_req|
           {
             "name" => ext_req.name,
             "version" => \
@@ -466,7 +477,7 @@ module Udb
               end
           }
         end,
-        "non_mandatory_extensions" => optional_ext_reqs.map do |ext_req|
+        "non_mandatory_extensions" => optional_ext_reqs.sort.map do |ext_req|
           {
             "name" => ext_req.name,
             "version" => \
@@ -479,19 +490,41 @@ module Udb
         end,
         "additional_extensions" => true
       }
+      c["requirements"] = requirements_condition.to_h unless requirements_condition.empty?
+      c
     end
 
-    # returns a config arch that treats the Portfolio like a partial config
-    sig { returns(ConfiguredArchitecture) }
-    def to_cfg_arch
-      @cfg_arch_for_mandatory ||= begin
-        Tempfile.create do |f|
-          f.write YAML.dump(to_config)
-          f.fsync
+    # @return portfolio in config form, with requirements of mandatory extensions expanded
+    sig { returns(T::Hash[String, T.untyped]) }
+    def to_strict_config
+      strict_mandatory_ext_reqs = mandatory_ext_reqs
+      mandatory_ext_req_names = strict_mandatory_ext_reqs.map(&:name).to_set
+      cfg_arch_obj = to_cfg_arch
+
+      cfg_arch_obj.extensions.each do |ext|
+        next if mandatory_ext_req_names.include?(ext.name)
+
+        if (-ext.to_ext_req.to_condition & cfg_arch_obj.to_condition).unsatisfiable_by_cfg_arch?(cfg_arch_obj)
+          # what's the minimum?
+          min_ext_ver = ext.versions.find do |ext_ver|
+            compat_with_ext_ver = Condition.new({ "extension" => { "name" => ext.name, "version" => "= #{ext_ver.version_str}" } }, cfg_arch_obj)
+            c = (compat_with_ext_ver & cfg_arch_obj.to_condition)
+            c.satisfiable_by_cfg_arch?(cfg_arch_obj)
+          end
+          raise "condition problem: ext is required but none of the versions are" if min_ext_ver.nil?
 
-          @cfg_arch.config.info.resolver.cfg_arch_for(Pathname.new f.path)
+          strict_mandatory_ext_reqs << PortfolioExtensionRequirement.new(ext.name, "~> #{min_ext_ver.version_str}", arch: cfg_arch_obj)
+          mandatory_ext_req_names.add(ext.name)
         end
       end
+
+      to_config(mandatory: strict_mandatory_ext_reqs)
+    end
+
+    # returns a config arch that treats the Portfolio like a partial config
+    sig { returns(ConfiguredArchitecture) }
+    def to_cfg_arch
+      @cfg_arch_for_mandatory ||= cfg_arch_for_config_data(to_config)
     end
 
     # returns a config arch that treats the *optional* extensions in Portfolio like a partial config
@@ -525,15 +558,38 @@ module Udb
             end,
             "additional_extensions" => true
           }
+        contents["requirements"] = requirements_condition.to_h unless requirements_condition.empty?
+        cfg_arch_for_config_data(contents)
+      end
+    end
+
+    # Build a ConfiguredArchitecture from an in-memory config data hash.
+    # Uses the fast path (no disk round-trip) when the parent has no overlay;
+    # falls back to the full pipeline when the parent's resolved spec differs.
+    sig { params(config_data: T::Hash[String, T.untyped]).returns(ConfiguredArchitecture) }
+    def cfg_arch_for_config_data(config_data)
+      resolver = @cfg_arch.config.info.resolver
+      if @cfg_arch.config.info.overlay_path.nil?
+        resolver.cfg_arch_for_data(config_data)
+      else
         Tempfile.create do |f|
-          f.write YAML.dump(contents)
+          f.write YAML.dump(config_data)
           f.fsync
-
-          @cfg_arch.config.info.resolver.cfg_arch_for(Pathname.new f.path)
+          resolver.cfg_arch_for(Pathname.new f.path)
         end
       end
     end
 
+    sig { returns(AbstractCondition) }
+    def requirements_condition
+      @requirements_condition ||=
+        if @data.key?("requirements")
+          Condition.new(@data.fetch("requirements"), cfg_arch)
+        else
+          AlwaysTrueCondition.new(cfg_arch)
+        end
+    end
+
     # @return [String] Given an instruction +inst_name+, return the presence as a string.
     #                  If the instruction name isn't found in the portfolio, return "-".
     sig { params(inst_name: String).returns(T.nilable(Presence)) }
@@ -739,8 +795,7 @@ module Udb
 
       return @in_scope_csrs unless @in_scope_csrs.nil?
 
-      @in_scope_csrs =
-        in_scope_min_satisfying_extension_versions.map { |ext_ver| ext_ver.in_scope_csrs(design.possible_xlens) }.flatten.uniq
+      @in_scope_csrs = to_cfg_arch.in_scope_csrs()
     end
 
     # @param design [Design] The design

data/lib/udb/obj/profile.rb

@@ -196,10 +196,6 @@ module Udb
       @data["base"]
     end
 
-    def all_in_scope_params
-      [Portfolio::InScopeParameter.new(@cfg_arch.param("MXLEN"), { "const" => @data["base"] }, "")]
-    end
-
     # Too complicated to put in profile ERB template.
     # @param presence_type [String]
     # @param heading_level [Integer]

data/lib/udb/obj/register_file.rb

@@ -49,6 +49,12 @@ class RegisterFile < TopLevelDatabaseObject
     sig { returns(T::Array[String]) }
     def abi_mnemonics = @data.fetch("abi_mnemonics", [])
 
+    sig { returns(T.nilable(String)) }
+    def reset_value = @data["reset_value"]
+
+    sig { returns(RegisterFile) }
+    def register_file = @file
+
     sig { returns(T.any(Integer, String)) }
     def index = @index
 
@@ -97,8 +103,63 @@ class RegisterFile < TopLevelDatabaseObject
     end
   end
 
-  sig { returns(T.any(Integer, String)) }
-  def register_length = @data.fetch("register_length")
+  # Returns the IDL function body string for the register_length() field.
+  # e.g. "return MXLEN;" or "return implemented?(ExtensionName::D) ? 64 : 32;"
+  sig { returns(String) }
+  def register_length = @data.fetch("register_length()")
+
+  # Returns the stripped IDL expression (no 'return' keyword or trailing semicolon).
+  sig { returns(String) }
+  def register_length_expr
+    register_length.strip.sub(/\Areturn\s+/, "").sub(/;\z/, "").strip
+  end
+
+  # Evaluate the register_length() IDL body against the given cfg_arch parameter context.
+  # Returns an Integer if the width is statically determined, or a String param name
+  # if the width depends on a runtime parameter (e.g. "VLEN").
+  sig { params(cfg_arch: ConfiguredArchitecture).returns(T.any(Integer, String)) }
+  def eval_register_length(cfg_arch)
+    expr = register_length_expr
+
+    # Literal integer
+    return Integer(expr) if expr =~ /\A\d+\z/
+
+    # Simple MXLEN reference
+    if expr == "MXLEN"
+      mxlen = cfg_arch.mxlen
+      return mxlen || "MXLEN"  # Return String "MXLEN" for dynamic-XLEN configs
+    end
+
+    # Check for a fixed parameter
+    fixed = cfg_arch.params_with_value.find { |p| p.name == expr }
+    return T.cast(fixed.value, Integer).to_i if fixed
+
+    # Check if it's a free parameter name
+    free = cfg_arch.params_without_value.find { |p| p.name == expr }
+    return expr if free
+
+    # Complex expression — fall back to the architectural maximum.
+    max_register_length
+  end
+
+  # Maximum value register_length() can return across all valid configurations.
+  # Derived by compiling the register_length() expression against the full symtab
+  # and calling max_value — unknown conditions (e.g. implemented?) cause the ternary
+  # to return the max of both branches.
+  sig { returns(Integer) }
+  def max_register_length
+    @max_register_length ||= _compute_max_register_length
+  end
+
+  private def _compute_max_register_length
+    node = cfg_arch.idl_compiler.compile_expression(
+      register_length_expr, cfg_arch.symtab, pass_error: true
+    )
+    max = node.max_value(cfg_arch.symtab)
+    raise "Cannot determine max_register_length for register file '#{name}' " \
+          "(register_length() expression: '#{register_length_expr}')" if max == :unknown
+    Integer(max)
+  end
 
   sig { returns(T.nilable(String)) }
   def summary = @data["summary"]

data/lib/udb/portfolio_design.rb

@@ -4,13 +4,12 @@
 
 # frozen_string_literal: true
 
-# Combines knowledge of the architecture database with one or more portfolios (profile or certificate).
+# Combines knowledge of the architecture database with one or more portfolios (profile).
 #
 # Used in portfolio-based ERB templates to gather information about the "portfolio_design".
 # The "portfolio_design" corresponds to the file being created by the ERB template and facilitates
 # sharing ERB template fragments between different kinds of portfolios (mostly in the appendices).
-# For example, a processor certificate model has one portfolio but a profile release has multiple portfolios
-# but they both have just one PortfolioDesign object.
+# For example, a profile release has multiple portfolios but just one PortfolioDesign object.
 
 require "forwardable"
 
@@ -66,9 +65,7 @@ module Udb
 
     # Class methods
     def self.profile_release_type = "Profile Release"
-    def self.proc_crd_type = "Certification Requirements Document"
-    def self.proc_ctp_type = "Certification Test Plan"
-    def self.portfolio_design_types = [profile_release_type, proc_crd_type, proc_ctp_type]
+    def self.portfolio_design_types = [profile_release_type]
 
     # @param name [#to_s] The name of the portfolio design (i.e., backend filename without a suffix)
     # @param cfg_arch [ConfiguredArchitecture] The database of RISC-V standards for a particular configuration

data/lib/udb/resolver.rb

@@ -15,6 +15,9 @@ require_relative "yaml/yaml_resolver"
 module Udb
   # resolves the specification in the context of a config, and writes to a generation folder
   #
+  # Raised by Resolver#cfg_info when a config name or path cannot be found.
+  class ConfigNotFoundError < StandardError; end
+
   # The primary interface for users will be #cfg_arch_for
   class Resolver
     extend T::Sig
@@ -186,15 +189,20 @@ module Udb
           end
         raise "custom directory '#{overlay_path}' does not exist" if !overlay_path.nil? && !overlay_path.directory?
 
-        if any_newer?(merged_spec_path(config_name) / ".stamp", deps)
-          # Use Ruby YAML resolver instead of Python
-          yaml_resolver = Udb::Yaml::Resolver.new(quiet: @quiet, compile_idl: @compile_idl)
-          yaml_resolver.merge_files(
-            std_path.to_s,
-            overlay_path&.to_s,
-            merged_spec_path(config_name).to_s
-          )
-          FileUtils.touch(merged_spec_path(config_name) / ".stamp")
+        FileUtils.mkdir_p(@gen_path / "spec")
+        merge_lock_name = merged_spec_path(config_name).basename
+        File.open(@gen_path / "spec" / ".#{merge_lock_name}.lock", File::CREAT | File::RDWR) do |f|
+          f.flock(File::LOCK_EX)
+          if any_newer?(merged_spec_path(config_name) / ".stamp", deps)
+            # Use Ruby YAML resolver instead of Python
+            yaml_resolver = Udb::Yaml::Resolver.new(quiet: @quiet, compile_idl: @compile_idl)
+            yaml_resolver.merge_files(
+              std_path.to_s,
+              overlay_path&.to_s,
+              merged_spec_path(config_name).to_s
+            )
+            FileUtils.touch(merged_spec_path(config_name) / ".stamp")
+          end
         end
       end
     end
@@ -205,19 +213,24 @@ module Udb
       @mutex.synchronize do
         config_name = config_yaml["name"]
 
-        deps = Dir[merged_spec_path(config_name) / "**" / "*.yaml"].map { |p| Pathname.new(p) }
-        if any_newer?(resolved_spec_path(config_name) / ".stamp", deps)
-          # Use Ruby YAML resolver instead of Python
-          yaml_resolver = Udb::Yaml::Resolver.new(quiet: @quiet, compile_idl: @compile_idl)
-          yaml_resolver.resolve_files(
-            merged_spec_path(config_name).to_s,
-            resolved_spec_path(config_name).to_s,
-            no_checks: false
-          )
-          FileUtils.touch(resolved_spec_path(config_name) / ".stamp")
-        end
+        FileUtils.mkdir_p(@gen_path / "resolved_spec")
+        resolve_lock_name = resolved_spec_path(config_name).basename
+        File.open(@gen_path / "resolved_spec" / ".#{resolve_lock_name}.lock", File::CREAT | File::RDWR) do |f|
+          f.flock(File::LOCK_EX)
+          deps = Dir[merged_spec_path(config_name) / "**" / "*.yaml"].map { |p| Pathname.new(p) }
+          if any_newer?(resolved_spec_path(config_name) / ".stamp", deps)
+            # Use Ruby YAML resolver instead of Python
+            yaml_resolver = Udb::Yaml::Resolver.new(quiet: @quiet, compile_idl: @compile_idl)
+            yaml_resolver.resolve_files(
+              merged_spec_path(config_name).to_s,
+              resolved_spec_path(config_name).to_s,
+              no_checks: false
+            )
+            FileUtils.touch(resolved_spec_path(config_name) / ".stamp")
+          end
 
-        FileUtils.cp_r(std_path / "isa", resolved_spec_path(config_name))
+          FileUtils.cp_r(std_path / "isa", resolved_spec_path(config_name))
+        end
       end
     end
 
@@ -240,8 +253,7 @@ module Udb
             if (@cfgs_path / "#{config_path_or_name}.yaml").file?
               (@cfgs_path / "#{config_path_or_name}.yaml").realpath
             else
-              Udb.logger.error "Could not find config: #{config_path_or_name}"
-              exit 1
+              raise ConfigNotFoundError, "Could not find config: #{config_path_or_name}"
             end
           else
             T.absurd(config_path_or_name)
@@ -291,6 +303,33 @@ module Udb
       end
     end
 
+    # Resolve a config pointer (name or file path) to a ConfiguredArchitecture.
+    # Resolution order:
+    #   1. If <cfgs_path>/<pointer>.yaml exists on disk, treat as a repo config name
+    #      (handles names that contain '/', e.g. "profile/RVA23U64").
+    #   2. If the pointer ends in .yaml/.yml, is absolute, or starts with ./ or ../,
+    #      treat as a file path resolved relative to +relative_dir+.
+    #   3. Otherwise raise ArgumentError — the pointer is neither a known config name
+    #      nor a recognisable file path.
+    sig { params(pointer: String, relative_dir: Pathname).returns(Udb::ConfiguredArchitecture) }
+    def cfg_arch_for_pointer(pointer, relative_dir:)
+      if (@cfgs_path / "#{pointer}.yaml").file?
+        # Repo config name — may contain '/' for nested configs (e.g. "profile/RVA23U64").
+        cfg_arch_for(pointer)
+      elsif pointer.end_with?(".yaml", ".yml") ||
+            Pathname.new(pointer).absolute? ||
+            pointer.start_with?("./", "../")
+        # Explicit file path — resolve relative to the caller's directory.
+        path = Pathname.new(pointer)
+        cfg_arch_for(path.absolute? ? path : (relative_dir / path).cleanpath)
+      else
+        raise ArgumentError,
+          "Cannot resolve config pointer '#{pointer}': not a known config name " \
+          "under '#{@cfgs_path}' and not a recognisable file path " \
+          "(.yaml/.yml extension, absolute, or starting with ./ or ../)"
+      end
+    end
+
     # resolve the specification for a config, and return a ConfiguredArchitecture
     sig { params(config_path_or_name: T.any(Pathname, String)).returns(Udb::ConfiguredArchitecture) }
     def cfg_arch_for(config_path_or_name)
@@ -312,6 +351,28 @@ module Udb
       end
     end
 
+    # Create a ConfiguredArchitecture directly from an in-memory config data hash,
+    # bypassing resolve_config and resolve_arch entirely. Only valid when the config
+    # has no arch_overlay (i.e., it uses the standard spec at gen/resolved_spec/_).
+    # Callers must ensure this precondition holds before calling this method.
+    sig { params(config_data: T::Hash[String, T.untyped]).returns(Udb::ConfiguredArchitecture) }
+    def cfg_arch_for_data(config_data)
+      info = ConfigInfo.new(
+        name: config_data["name"],
+        path: Pathname.new("portfolio/#{config_data["name"]}"),
+        overlay_path: nil,
+        unresolved_yaml: config_data,
+        spec_path: std_path,
+        merged_spec_path: @gen_path / "spec" / "_",
+        resolved_spec_path: @gen_path / "resolved_spec" / "_",
+        resolver: self
+      )
+      Udb::ConfiguredArchitecture.new(
+        config_data["name"],
+        Udb::AbstractConfig.create_from_data(config_data, info)
+      )
+    end
+
     SCHEMAS_BASE_URL = "https://riscv.github.io/riscv-unified-db/schemas"
 
     # Resolve schema files by rewriting their $id to the full published URL and

data/lib/udb/version.rb

@@ -5,5 +5,5 @@
 # frozen_string_literal: true
 
 module Udb
-  def self.version = "0.1.9"
+  def self.version = "0.1.14"
 end

data/lib/udb/version_spec.rb

@@ -192,6 +192,14 @@ module Udb
     REQUIREMENT_OP_REGEX = /((?:>=)|(?:>)|(?:~>)|(?:<)|(?:<=)|(?:!=)|(?:=))/
     REQUIREMENT_REGEX = /#{REQUIREMENT_OP_REGEX}\s*(#{VersionSpec::VERSION_REGEX})/
 
+    # Intern cache: RequirementSpec.new with the same string returns the same object.
+    @intern_cache = T.let({}, T::Hash[String, RequirementSpec])
+
+    sig { params(requirement: String).returns(RequirementSpec) }
+    def self.new(requirement)
+      @intern_cache[requirement] ||= super
+    end
+
     sig { returns(String) }
     attr_reader :op