udb 0.1.13 → 0.1.14

data/.data/spec/std/isa/isa/globals.isa

@@ -307,6 +307,7 @@ function compatible_mode? {
         (actual_mode == PrivilegeMode::VS) ||
         (actual_mode == PrivilegeMode::VU);
     }
+    return false;
   }
 }
 
@@ -1180,6 +1181,7 @@ function mpv {
       return (MXLEN == 32) ? CSR[mstatush].MPV : CSR[mstatus].MPV;
     } else {
       assert(false, "TODO");
+      unreachable();
     }
   }
 }
@@ -1605,6 +1607,7 @@ function tinst_value_for_guest_page_fault {
           return tinst_transform(encoding, 0); # all guest page faults are aligned
         } else {
           unpredictable("Custom value written into htinst/mtinst");
+          return 0;
         }
       } else if (op == MemoryOperation::Write || op == MemoryOperation::ReadModifyWrite) {
         if (TINST_VALUE_ON_FINAL_STORE_AMO_GUEST_PAGE_FAULT == "always zero") {
@@ -1619,6 +1622,7 @@ function tinst_value_for_guest_page_fault {
           return tinst_transform(encoding, 0); # all guest page faults are aligned
         } else {
           unpredictable("Custom value written into htinst/mtinst");
+          return 0;
         }
       }
     } else {
@@ -1631,6 +1635,7 @@ function tinst_value_for_guest_page_fault {
         }
       }
     }
+    return 0;
   }
 }
 
@@ -1658,9 +1663,11 @@ function tinst_transform {
         return {encoding[31:20], addr_offset, encoding[14:0]};
       } else {
         assert(false, "Bad transform");
+        unreachable();
       }
     } else {
       assert(false, "TODO: compressed instruction");
+      unreachable();
     }
   }
 }
@@ -1675,7 +1682,7 @@ function transformed_standard_instruction_for_tinst {
   }
   body {
     assert(false, "TODO");
-    return 0;
+    unreachable();
   }
 }
 
@@ -1789,6 +1796,7 @@ function tinst_value {
       }
     } else {
       assert(false, "Unhandled exception type");
+      unreachable();
     }
   }
 }
@@ -1974,6 +1982,7 @@ function gstage_page_walk {
               success = atomic_check_then_write_64(pte_paddr, pte, updated_pte);
             } else {
               assert(false, "Unexpected PTESIZE");
+              unreachable();
             }
 
 
@@ -2024,6 +2033,7 @@ function gstage_page_walk {
         ppn = pte[PA_SIZE-3:10] << 12;
       }
     }
+    unreachable();
   }
 }
 
@@ -2298,6 +2308,7 @@ function stage1_page_walk {
               success = atomic_check_then_write_64(pte_phys.paddr, pte, updated_pte);
             } else {
               assert(false, "Unexpected PTESIZE");
+              unreachable();
             }
 
 
@@ -2370,6 +2381,7 @@ function stage1_page_walk {
         ppn = pte[PA_SIZE-3:10];
       }
     }
+    unreachable();
   }
 }
 
@@ -2451,6 +2463,7 @@ function translate {
       result = stage1_page_walk(57, 56, 64, 5, vaddr, op, effective_mode, encoding);
     } else {
       assert(false, "Unexpected SatpMode");
+      unreachable();
     }
 
     maybe_cache_translation(vaddr, op, result);
@@ -2496,6 +2509,7 @@ function canonical_vaddr? {
     } else if ((MXLEN == 64) && satp_mode == SatpMode::Sv57) {
       return eaddr[63:57] == {6{eaddr[56]}};
     }
+    return false;
   }
 }
 
@@ -2522,6 +2536,7 @@ function canonical_gpaddr? {
     } else if ((MXLEN > 32) && (satp_mode == SatpMode::Sv57)) {
       return gpaddr[63:57] == {6{gpaddr[56]}};
     }
+    return false;
   }
 }
 
@@ -2658,8 +2673,10 @@ function read_memory {
         return result;
       } else if (MISALIGNED_SPLIT_STRATEGY == "custom") {
         unpredictable("An implementation is free to break a misaligned access any way, leading to unpredictable behavior when any part of the misaligned access causes an exception");
+        return 0;
       }
     }
+    return 0;
   }
 }
 
@@ -2776,6 +2793,7 @@ function register_reservation_set {
       unpredictable("Implementations may set reservation sets of any size, as long as they cover the reserved accessed");
     } else {
       assert(false, "Unexpected LRSC_RESERVATION_STRATEGY");
+      unreachable();
     }
   }
 }
@@ -2932,12 +2950,14 @@ function amo {
     # PMA Atomicity checks
     if (pma_applies?(PmaAttribute::AmoNone, physical_address, N)) {
       raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
-    } else if (((op == AmoOperation::Add || op == AmoOperation::Max || op == AmoOperation::Maxu || op == AmoOperation::Min || op == AmoOperation::Minu)) &&
-               !pma_applies?(PmaAttribute::AmoArithmetic, physical_address, N)) {
-      raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
-    } else if (((op == AmoOperation::And || op == AmoOperation::Or || op == AmoOperation::Xor)) &&
-                !pma_applies?(PmaAttribute::AmoLogical, physical_address, N)) {
-      raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
+    } else if (((op == AmoOperation::Add || op == AmoOperation::Max || op == AmoOperation::Maxu || op == AmoOperation::Min || op == AmoOperation::Minu))) {
+      if (!pma_applies?(PmaAttribute::AmoArithmetic, physical_address, N)) {
+        raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
+      }
+    } else if (((op == AmoOperation::And || op == AmoOperation::Or || op == AmoOperation::Xor))) {
+      if (!pma_applies?(PmaAttribute::AmoLogical, physical_address, N)) {
+        raise(ExceptionCode::StoreAmoAccessFault, mode(), virtual_address);
+      }
     } else {
       assert(
         pma_applies?(PmaAttribute::AmoSwap, physical_address, N) &&

data/.data/spec/std/isa/isa/interrupts.idl

@@ -259,6 +259,7 @@ function highest_priority_interrupt {
       }
     }
     assert(false, "There is no valid interrupt");
+    unreachable();
   }
 }
 

data/.data/spec/std/isa/param/HSTATEEN_CONTEXT_TYPE.yaml

@@ -19,6 +19,7 @@ schema:
     - rw
     - read-only-0
     - read-only-1
+  default: rw
 requirements:
   idl(): |
     MSTATEEN_CONTEXT_TYPE == "read-only-0" -> HSTATEEN_CONTEXT_TYPE == "read-only-0";

data/.data/spec/std/isa/param/MSTATEEN_CONTEXT_TYPE.yaml

@@ -19,6 +19,7 @@ schema:
     - rw
     - read-only-0
     - read-only-1
+  default: rw
 definedBy:
   extension:
     allOf:

data/.data/spec/std/isa/param/MTVEC_BASE_ALIGNMENT_DIRECT.yaml

@@ -25,6 +25,7 @@ description: |
   the base, the minimum alignment cannot be less than 4.
 schema:
   description: An unsigned power of 2 greater than or equal to 4 that fits in 64 bits
+  default: 4
   enum:
     [
       4,

data/.data/spec/std/isa/param/MTVEC_BASE_ALIGNMENT_VECTORED.yaml

@@ -25,6 +25,7 @@ description: |
   the base, the minimum alignment cannot be less than 4.
 schema:
   description: An unsigned power of 2 greater than or equal to 4 that fits in 64 bits
+  default: 4
   enum:
     [
       4,

data/.data/spec/std/isa/param/NUM_PMP_ENTRIES.yaml

@@ -7,36 +7,25 @@ $schema: param_schema.json#
 kind: parameter
 name: NUM_PMP_ENTRIES
 description: |
-  Number of implemented PMP entries. Can be any value between 0-64, inclusive.
+  Number of implemented PMP entries.
 
   The architecture mandates that the number of implemented PMP registers
-  must appear to be 0, 16, or 64.
-
-  Therefore, pmp registers will behave as follows according to NUN_PMP_ENTRIES:
-
-  [separator="!"]
-  !===
-  ! NUM_PMP_ENTRIES ! pmpaddr<0-15> / pmpcfg<0-3> ! pmpaddr<16-63> / pmpcfg<4-15>
-  ! 0               ! N                           ! N
-  ! 1-16            ! Y                           ! N
-  ! 17-64           ! Y                           ! Y
-  !===
-
-  ** N = Not implemented; access will cause `IllegalInstruction`
-     if TRAP_ON_UNIMPLEMENTED_CSR is true
-  ** Y = Implemented; access will not cause an exception (from M-mode), but register
-     may be read-only-zero if NUM_PMP_ENTRIES is less than the corresponding register
+  must appear to be 0, 16, or 64, so NUM_PMP_ENTRIES must be one of those values.
+  It directly determines which PMP registers exist: `pmpaddr0`-`pmpaddr<N-1>`
+  and their corresponding `pmpNcfg` fields are implemented, and the rest are
+  not. Accessing an unimplemented PMP register causes an `IllegalInstruction`
+  when TRAP_ON_UNIMPLEMENTED_CSR is true.
 
   [NOTE]
-  `pmpcfgN` for an odd N never exists when XLEN == 64
+  `pmpcfgN` for an odd N never exists when XLEN == 64.
 
-  When NUM_PMP_ENTRIES is not exactly 0, 16, or 64, some extant pmp registers,
-  and associated pmpNcfg, will be read-only zero (but will never cause an exception).
+  An implemented entry may still be read-only zero (but will never cause an exception).
+  The number of entries that are actually usable is given by
+  NUM_USABLE_PMP_ENTRIES.
 long_name: TODO
 schema:
   type: integer
-  minimum: 0
-  maximum: 64
+  enum: [0, 16, 64]
 definedBy:
   extension:
     name: Sm

data/.data/spec/std/isa/param/NUM_USABLE_PMP_ENTRIES.yaml

@@ -0,0 +1,35 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# yaml-language-server: $schema=../../../schemas/param_schema.json
+
+$schema: param_schema.json#
+kind: parameter
+name: NUM_USABLE_PMP_ENTRIES
+description: |
+  Number of implemented PMP entries that are actually usable.
+
+  An implementation may implement PMP entries (NUM_PMP_ENTRIES) but hardwire
+  some of them to zero (read-only zero). Such entries exist -- their
+  `pmpaddrN`/`pmpNcfg` registers are accessible and will not cause an exception
+  from M-mode -- but they cannot be configured to guard a region.
+
+  NUM_USABLE_PMP_ENTRIES gives the number of low-numbered entries that are
+  writable/usable. Entries `0` through `NUM_USABLE_PMP_ENTRIES-1` are usable;
+  entries `NUM_USABLE_PMP_ENTRIES` through `NUM_PMP_ENTRIES-1` are read-only
+  zero.
+
+  Must be between 0 and NUM_PMP_ENTRIES, inclusive.
+long_name: TODO
+schema:
+  type: integer
+  minimum: 0
+  maximum: 64
+definedBy:
+  param:
+    name: NUM_PMP_ENTRIES
+    greaterThan: 0
+requirements:
+  idl(): |
+    NUM_PMP_ENTRIES == 16 -> NUM_USABLE_PMP_ENTRIES <= 16;
+  reason: Usable PMP entries cannot exceed the number of implemented PMP entries

data/.data/spec/std/isa/param/PMP_NA4_SUPPORTED.yaml

@@ -0,0 +1,23 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# yaml-language-server: $schema=../../../schemas/param_schema.json
+
+$schema: param_schema.json#
+kind: parameter
+name: PMP_NA4_SUPPORTED
+description: |
+  Whether or not the Naturally Aligned four-byte (NA4) PMP address matching
+  mode is supported.
+
+long_name: PMP NA4 mode supported
+schema:
+  type: boolean
+definedBy:
+  param:
+    name: NUM_PMP_ENTRIES
+    greaterThan: 0
+requirements:
+  idl(): |
+    PMP_NA4_SUPPORTED -> (PMP_GRANULARITY == 2);
+  reason: NA4 is not valid when the PMP granularity is larger than 4 bytes

data/.data/spec/std/isa/param/PMP_NAPOT_SUPPORTED.yaml

@@ -0,0 +1,19 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# yaml-language-server: $schema=../../../schemas/param_schema.json
+
+$schema: param_schema.json#
+kind: parameter
+name: PMP_NAPOT_SUPPORTED
+description: |
+  Whether or not the Naturally Aligned Power-Of-Two (NAPOT) PMP address
+  matching mode is supported.
+
+long_name: PMP NAPOT mode supported
+schema:
+  type: boolean
+definedBy:
+  param:
+    name: NUM_PMP_ENTRIES
+    greaterThan: 0

data/.data/spec/std/isa/param/{MSTATUS_TVM_IMPLEMENTED.yaml → PMP_TOR_SUPPORTED.yaml}

@@ -5,14 +5,14 @@
 
 $schema: param_schema.json#
 kind: parameter
-name: MSTATUS_TVM_IMPLEMENTED
+name: PMP_TOR_SUPPORTED
 description: |
-  Whether or not mstatus.TVM is implemented.
+  Whether or not the Top-of-Range (TOR) PMP address matching mode is supported.
 
-  When not implemented mstatus.TVM will be read-only-zero.
-long_name: TODO
+long_name: PMP TOR mode supported
 schema:
   type: boolean
 definedBy:
-  extension:
-    name: S
+  param:
+    name: NUM_PMP_ENTRIES
+    greaterThan: 0

data/.data/spec/std/isa/param/PRECISE_SYNCHRONOUS_EXCEPTIONS.yaml

@@ -15,3 +15,4 @@ description: |
   will cause execution to enter an unpredictable state.
 schema:
   type: boolean
+  default: true

data/.data/spec/std/isa/param/TRAP_ON_EBREAK.yaml

@@ -15,3 +15,4 @@ description: |
   without raising a trap, in which case the EEI must provide a builtin.
 schema:
   type: boolean
+  default: true

data/.data/spec/std/isa/param/TRAP_ON_ECALL_FROM_M.yaml

@@ -15,3 +15,4 @@ description: |
   without raising a trap, in which case the EEI must provide a builtin.
 schema:
   type: boolean
+  default: true

data/.data/spec/std/isa/param/TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY.yaml

@@ -20,6 +20,7 @@ description: |
 long_name: TODO
 schema:
   type: boolean
+  default: false
 definedBy:
   extension:
     allOf:

data/.data/spec/std/isa/param/ZAWRS_NTO_IS_NOP.yaml

@@ -0,0 +1,19 @@
+# Copyright (c) 2025-26 Harvey Mudd College
+# Author: Ellen Yu (ellyu@hmc.edu)
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# yaml-language-server: $schema=../../../schemas/param_schema.json
+
+$schema: param_schema.json#
+kind: parameter
+name: ZAWRS_NTO_IS_NOP
+description: |
+  When true, WRS.NTO completes immediately, behaving as a no-op, rather than
+  stalling the hart.
+
+long_name: TODO
+schema:
+  type: boolean
+definedBy:
+  extension:
+    name: Zawrs

data/lib/udb/ESPRESSO_VERSION

@@ -1 +1 @@
-espresso-1.0
+espresso-18f59c7

data/lib/udb/config.rb

@@ -417,13 +417,25 @@ module Udb
         else
           @data["implemented_extensions"].map do |e|
             if e.is_a?(Array)
-              { "name" => e[0], "version" => e[1] }
+              { "name" => e[0], "version" => implemented_extension_version(e[1]) }
             elsif e.is_a?(Hash)
-              { "name" => e.fetch("name"), "version" => RequirementSpec.new(e.fetch("version")).version_spec.to_s }
+              { "name" => e.fetch("name"), "version" => implemented_extension_version(e.fetch("version")) }
             end
           end
         end
     end
 
+    private
+
+    sig { params(version: String).returns(String) }
+    def implemented_extension_version(version)
+      version_str = version.strip
+      if version_str.start_with?("=")
+        RequirementSpec.new(version_str).version_spec.to_s
+      else
+        VersionSpec.new(version_str).to_s
+      end
+    end
+
   end
 end

data/lib/udb/doc_link.rb

@@ -33,12 +33,11 @@
 module Udb
   class DocLink
     # @param dst_link [String] The documentation link provided in the YAML
-    # @param db_obj [String] Database object
+    # @param db_obj [Object] Database object
     def initialize(dst_link, db_obj)
-      raise ArgumentError, "Need String but was passed a #{data.class}" unless dst_link.is_a?(String)
+      raise ArgumentError, "Missing documentation link for #{db_obj.name} of kind #{db_obj.kind}" if dst_link.nil?
+      raise ArgumentError, "Need String but was passed a #{dst_link.class}" unless dst_link.is_a?(String)
       @dst_link = dst_link
-
-      raise ArgumentError, "Missing documentation link for #{db_obj.name} of kind #{db_obj.kind}" if @dst_link.nil?
     end
 
     # @return [String] Unique ID of the linked to normative rule

data/lib/udb/obj/instruction.rb

@@ -791,7 +791,7 @@ module Udb
         @left_shift = field_data["left_shift"].nil? ? 0 : field_data["left_shift"]
         @sext = field_data["sign_extend"].nil? ? false : field_data["sign_extend"]
         @alias = field_data["alias"].nil? ? nil : field_data["alias"]
-        @location = field_data["location"]
+        @location = field_data["location"].to_s
         extract_location(field_data["location"])
         @excludes =
           if field_data.key?("not")

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/version.rb

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