emf 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2adf7662f217430cb3a716140567c8c5cfdf53e5da6b49b94a57c7ba6dc8e92
-  data.tar.gz: '01019e1db86ed47be7494287fc164f2aa345ceaa72c8b66ade894d92e49f556c'
+  metadata.gz: f5ee6e6c5a49eabf172b92810e3ec3ab0591122a97ac4960a9f4af32efe6e79f
+  data.tar.gz: 033ccee0b06ca850f57aca486f0d07692cd4e5ac52bfcbb907f1889fd9fd9b5f
 SHA512:
-  metadata.gz: 12935613493f55d59f77bd3a233293df0e14de40fc0f69674c48cdc6c4633a6f0560734de6faced0dd9dab146a48000345695e67a9b8f34141d5e06ac266ccbb
-  data.tar.gz: 261484bdcf95539ca134bb7d2ad5602cdc9bf9140b48f340692292cbb024c14e8448085dfbf3b4a86dd7ceef48d0d0bd56f6a753081d094e6da3fbcada7eefbf
+  metadata.gz: 9746ee5767b814b7da75ee2ee6116a9963dbd260eebf8539cfce50d4ad91631b88339a373c47a7acfd8ee1beaab11bbfd20849db2630d31e7502f1b61e427b99
+  data.tar.gz: caae6ff8f26b3536b55486bca2c95a3bc5d42196cbaff9a4f1e0ea7cd18e03009e1b3447b162139a5f667c2e1755f06b19d32beec1c07b4d75d4722dcb105ff5

data/README.adoc

@@ -1,6 +1,6 @@
-= emf: pure-Ruby parser for WMF, EMF, and EMF+ metafiles
+= emf: parser for WMF, EMF, and EMF+ metafiles
 
-`emf` is a clean-room, pure-Ruby parser for the three Microsoft Windows
+`emf` is a clean-room Ruby parser with an optional Rust native backend for the three Microsoft Windows
 metafile formats:
 
 * **WMF** — Windows Metafile (see MS-WMF, kaitai `wmf.ksy`)
@@ -15,13 +15,17 @@ wrapper around the GPLv2 `libemf2svg` C library.
 
 == Status
 
-* **EMF**: full parse + byte-identical round-trip on every fixture
-  (186/186 in `spec/fixtures/emf/`, 21/21 in `spec/fixtures/emf-ea/`,
-  1/1 in `spec/fixtures/simple/`).
-* **EMF+**: EMF+ payloads are extracted from EMF carrier records as raw
-  bytes (`Metafile#emf_plus`). Structured EMF+ parsing is TODO
-  (see `TODO.impl/12-14`).
-* **WMF**: detected but not yet parsed (`TODO.impl/07`).
+* **EMF**: parsing, mutable wire records and binary serialization are implemented.
+* **EMF+**: raw carrier payloads (`Metafile#emf_plus`) and a typed stream view
+  (`Metafile#emf_plus_stream`) are implemented.
+* **WMF**: standard and placeable headers, records and binary serialization
+  are implemented.
+* **Native backend**: Rust decoding and a Ruby adapter are implemented and match the
+  Ruby backend on the valid and corrupt fixture corpora, every EMF record type and
+  mutated WMF input; installed platform qualification remains open.
+* **Qualification**: implementation does not imply complete format coverage or
+  release readiness. See link:TODO.plan/10-progress.md[delivery progress] and
+  link:TODO.plan/09-format-extension.md[format extension acceptance].
 * **License**: BSD-2-Clause. No GPL obligation.
 
 == Installation
@@ -36,6 +40,45 @@ Or install directly:
 
 Requires Ruby >= 3.1.
 
+== Backend selection
+
+The public `Emf.parse`, `Emf.parse_file` and `Emf.serialize` APIs use
+`EMF_BACKEND` at call time:
+
+[cols="1,3",options="header"]
+|===
+|Value |Behavior
+|`auto` (default) |Use the native backend when available; fall back to Ruby if native setup raises `Emf::Native::Unavailable`.
+|`ruby` |Use Ruby directly, without loading the native library.
+|`native` |Require the native backend; unavailable setup raises `Emf::Native::Unavailable`.
+|===
+
+`Emf.backend` resolves the backend at call time and returns `:ruby` or `:native`.
+It uses the same selection as parsing and serialization, including the `auto`
+availability fallback. It returns a symbol rather than a backend adapter.
+Explicit `native` selection raises `Emf::Native::Unavailable` if unavailable;
+unexpected setup errors propagate. This query may load the native library, and
+its result describes the current settings rather than pinning future operations.
+
+Other values raise `ArgumentError`. A parsing or serialization error after
+backend selection propagates to the caller; it is not retried using Ruby.
+Both backends return the existing Ruby model and use the Ruby binary writers
+for serialization, including mutable wire records.
+
+For example, to explicitly use Ruby:
+
+  EMF_BACKEND=ruby ruby -remf -e 'p Emf.parse_file(ARGV.fetch(0)).format' image.emf
+
+Native loading uses a packaged platform manifest when present. For development
+with an existing compatible library, `EMF_NATIVE_LIBRARY` overrides discovery:
+
+  EMF_BACKEND=native EMF_NATIVE_LIBRARY=/absolute/path/to/libemf_ffi.dylib ruby -remf -e 'p Emf.parse_file(ARGV.fetch(0)).format' image.emf
+
+Use the appropriate shared-library filename for the platform. An empty override
+makes native loading unavailable. Native installation and platform support must
+be qualified using link:TODO.plan/08-platform-delivery.md[the delivery checks];
+the source implementation alone does not establish an available platform gem.
+
 == Synopsis
 
   require "emf"
@@ -50,9 +93,23 @@ Requires Ruby >= 3.1.
   stats = Emf::Visitors::Stats.new.visit_all(metafile)
   puts stats.to_s
 
-  # Serialise back to binary — byte-identical on every fixture
+  # Serialise the model back to binary
   bytes = Emf.serialize(metafile)
 
+=== Reading field values without BinData
+
+`record.values` returns a record's field values as a frozen, plain Ruby object
+(a `Data` with the wire's member names; nested structs as nested `Data`; a counted
+point array as an Array of `Data` points with `x` and `y`) without making
+BinData field objects. It is `nil` for records without a fixed layout or a
+counted point array (for example ExtTextOut, bitmaps, fonts, Comment, Raw); use
+`record.wire` for those. The values are equal on the Ruby and native backends and
+always reflect edits made through `record.wire`.
+
+  record = metafile.records.find { |r| r.type_id == 86 } # POLYGON16
+  record.values.rcl_bounds.left
+  record.values.apts.map { |point| [point.x, point.y] }
+
 == Command-line tool
 
   emf version                  Print version
@@ -62,6 +119,145 @@ Requires Ruby >= 3.1.
   emf validate FILE            Parse + report errors (exit 0 ok, 1 invalid)
   emf round-trip FILE [--out]  Re-serialize after parse, compare or write
 
+== Conformance lens
+
+`Emf::Conformance` checks a metafile against the Microsoft specifications
+(MS-EMF, MS-EMFPLUS and MS-WMF) and reports what it finds. It does not repair
+files and it does not change what the parser returns. The report uses the key
+layout of `svg_conform`, so tools that read one can read the other.
+
+  require "emf"
+
+  report = Emf::Conformance.check("image.emf", profile: :tolerant)
+  report.valid?   # => true when there are no errors (warnings do not count)
+  report.to_h     # => Hash with string keys
+  report.to_yaml
+
+The lens reads only the public model, so the Ruby and the native backend give
+the same report. It adds no runtime dependency: `bindata` is still the only one.
+
+=== Input
+
+`check` accepts four forms:
+
+[cols="1,3",options="header"]
+|===
+|Input |Behavior
+|path `String` |Read with `File.binread`. The path becomes the report's `filename`.
+|`Pathname` |Same as a path `String`.
+|bytes `String` |Parsed once. `filename` is `nil`. A `String` is taken as a path only when it names an existing file, has no NUL byte and is under 4096 bytes long.
+|`Emf::Model::Metafile` |Evaluated without parsing again. `filename` is `nil`.
+|===
+
+A parsed `Metafile` carries no input bytes. Rules that compare a declared
+length with the real input length are skipped for it. One example is
+`emf.header.bytes`. The WMF size check against the input is another. Pass the
+path or the bytes when you want those rules to run.
+
+=== Profiles
+
+`profile:` is `:strict` (the default) or `:tolerant`. Any other value raises
+`ArgumentError`.
+
+* `:strict` reports every spec violation as an error.
+* `:tolerant` accepts what real producers write. A rule that carries a
+  `tolerant_reason` becomes a warning instead of an error. The warning keeps
+  its `requirement_id`, `kind`, citation and offset. The reason appears as
+  `context.waiver`.
+
+A waiver belongs to the rule, not to a file. Every input that triggers that
+rule gets the downgrade. There is no per-file allowlist. A rule without a
+`tolerant_reason` is an error under both profiles.
+
+Two files in `spec/fixtures/emf-corrupted/` cannot be parsed into a model. One
+has a truncated header and one has an unrecognised first word. They report
+`valid: false` under both profiles, with the error `emf.parse.unparseable`.
+The other 19 corrupted fixtures are `valid: true` under `:tolerant`.
+
+=== The report
+
+`Report#to_h` has these keys: `filename`, `profile`, `tool`, `version`,
+`timestamp`, `valid`, `errors` and `warnings`. `errors` and `warnings` each hold
+`total_count`, `by_requirement` and the ordered `issues`. Issues are ordered by
+offset, then requirement id. Each issue has `type`, `requirement_id`,
+`message`, `element`, `attribute`, `value`, `offset`, `severity`, `kind`,
+`category`, `spec_citation`, `remediation_available` and `context`.
+`offset` is the absolute byte offset in the file. `kind` is a stable
+machine-readable name. `category` repeats `kind` and `severity` repeats `type`,
+for `svg_conform` compatibility.
+
+This is the strict report for a repo fixture. It comes from
+`Emf::Conformance.check("spec/fixtures/emf/test-000.emf").to_h(timestamp: false).to_yaml`.
+The `timestamp` line is left out by `timestamp: false`.
+
+  filename: spec/fixtures/emf/test-000.emf
+  profile: strict
+  tool: emf
+  version: 0.1.2
+  valid: false
+  errors:
+    total_count: 1
+    by_requirement:
+      emfplus.property.enum: 1
+    issues:
+    - type: error
+      requirement_id: emfplus.property.enum
+      message: SetCompositingQuality CompositingQuality value 0 is outside 1..5 (EMF+
+        record 0x4024 at offset 0 of EMR_COMMENT_EMFPLUS record 50)
+      element: emf_plus:0x4024
+      attribute:
+      value:
+      offset: 52152
+      severity: error
+      kind: property_enum
+      category: property_enum
+      spec_citation: MS-EMFPLUS 2.3.6
+      remediation_available: false
+      context:
+        spec_citation: MS-EMFPLUS 2.3.6
+        format: emf_plus
+        record_index: 50
+        record_type: 16420
+  warnings:
+    total_count: 0
+    by_requirement: {}
+    issues: []
+
+With `profile: :tolerant` the same file is `valid: true`. The finding moves to
+`warnings`, and `context.waiver` carries the written reason.
+
+=== Comparing backends
+
+The report holds a creation `timestamp`, so two runs never compare equal as they
+are. To compare two reports, drop the timestamp or pin it:
+
+  Emf::Conformance.check(path).to_h(timestamp: false)
+  Emf::Conformance.check(path, now: Time.utc(2026, 1, 1)).to_h   # "timestamp" => "2026-01-01T00:00:00Z"
+
+Run once with `EMF_BACKEND=ruby` and once with `EMF_BACKEND=native` (see
+<<Backend selection>>) and compare the two results. They must be equal. The
+`native` value raises `Emf::Native::Unavailable` when no native library loads.
+
+=== The rule manifest
+
+Every rule the lens implements, and every check it does not yet make, is listed
+in `lib/emf/conformance/manifest/*.yml`. A row has an `id`, a `format`, the
+`record_types` it covers, a `citation`, a `status` and a `reason`. The reason is
+required for every status except `implemented`.
+
+[cols="1,3",options="header"]
+|===
+|Status |Meaning
+|`implemented` |A registered rule with this id exists.
+|`deferred` |The data is readable from the public model today, but no rule is written yet.
+|`blocked:model` |The check needs a public model field that does not exist yet. The reason names the field.
+|`not_checkable` |No input can violate it, or the bytes are ignored on receipt.
+|===
+
+Read the manifest to see what a clean report does not prove. A `deferred` or
+`blocked:model` row is a check the lens does not make. Every record type of the
+three specifications appears in at least one row.
+
 == Architecture
 
 Three layers, kept strictly separate (MECE):
@@ -95,7 +291,7 @@ Three layers, kept strictly separate (MECE):
 * No AI attribution in any commit. All changes go through PRs.
 
 See `docs/architecture.adoc` and `docs/format_notes.adoc` for the deep
-dive, and `TODO.impl/PROGRESS.md` for what's done vs what remains.
+dive, and link:TODO.plan/10-progress.md[delivery progress] for implementation status.
 
 === Reference documentation
 
@@ -110,7 +306,7 @@ revision bumps.
   git clone https://github.com/claricle/emf
   cd emf
   bundle install
-  bundle exec rspec       # ~280 examples across fixtures + units
+  bundle exec rspec       # fixture and unit checks
   bundle exec rubocop     # clean
 
 The round-trip harness in `spec/emf/round_trip_spec.rb` is the strongest
@@ -119,13 +315,22 @@ byte-identical parse -> serialise -> parse.
 
 == Roadmap
 
-Full TODO list lives in `TODO.impl/`. Highlights:
-
-* TODO 09 -- finish remaining ~60 EMR wire types (currently 117 of ~122 done)
-* TODO 10 -- semantic domain records (currently WireAdapter for most types)
-* TODO 11 -- 2-pass path association (BEGINPATH <-> FILLPATH/STROKEPATH)
-* TODO 07 -- WMF parser + fixtures
-* TODO 12-14 -- EMF+ wire + domain + parser
+The execution plan for issue #15 starts at
+link:TODO.plan/00-overview.md[the shared roadmap]. Implementation is in progress; remaining acceptance and
+qualification work is tracked in the linked sections.
+
+* link:TODO.plan/05-ruby-execution.md[Ruby implementation]: existing API dispatch,
+  model compatibility, mutable wire serialization, fallback and CLI behavior.
+* link:TODO.plan/03-rust-core.md[Rust core] and
+  link:TODO.plan/04-c-abi.md[C ABI]: typed decoding, serialization and native ownership.
+* link:TODO.plan/09-format-extension.md[Format extensions]: WMF and structured EMF+.
+* link:TODO.plan/06-resilience.md[Resilience],
+  link:TODO.plan/07-performance.md[performance] and
+  link:TODO.plan/08-platform-delivery.md[platform delivery].
+
+Other roadmap items include semantic domain records beyond `WireAdapter` and
+two-pass path association (`BEGINPATH` with `FILLPATH`/`STROKEPATH`). These remain
+separate from the issue #15 delivery criteria.
 
 == License
 

data/exe/emf

@@ -45,12 +45,24 @@ module Emf
       return unless mf.header
 
       h = mf.header
+      return wmf_info(h) if mf.format == :wmf
+
       puts "Bounds:    left=#{h.bounds.left} top=#{h.bounds.top} right=#{h.bounds.right} bottom=#{h.bounds.bottom}"
       puts "Frame:     left=#{h.frame.left} top=#{h.frame.top} right=#{h.frame.right} bottom=#{h.frame.bottom}"
       puts "Device:    #{h.device_pixels.cx}x#{h.device_pixels.cy} px (#{h.device_mm.cx / 100.0}x#{h.device_mm.cy / 100.0} mm)"
       puts "nRecords:  #{h.n_records}  nHandles: #{h.n_handles}  nBytes: #{h.n_bytes}"
     end
 
+    def wmf_info(header)
+      puts "Type:      #{header.type}  Version: #{header.version}  Size: #{header.size_words} words"
+      puts "Objects:   #{header.number_of_objects}  MaxRecord: #{header.max_record_words} words  Members: #{header.number_of_members}"
+      return unless header.placeable
+
+      placeable = header.placeable
+      puts "Bounds:    left=#{placeable.left} top=#{placeable.top} right=#{placeable.right} bottom=#{placeable.bottom}"
+      puts "Units:     #{placeable.inch} per inch"
+    end
+
     def dump(argv)
       path = parse_path(argv)
       mf = Emf.parse_file(path)

data/lib/emf/backend.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Emf
+  module Backend
+    module Ruby
+      class << self
+        def parse(bytes)
+          deferred = ResourceLimits.preflight(bytes, defer: true)
+          case Detector.call(bytes)
+          when :wmf_apm, :wmf_standard then Wmf::Parser.call(bytes)
+          when :emf then Emr::Parser.call(bytes, deferred_admission: deferred)
+          end
+        rescue FormatError, ParseError => e
+          raise ParseEvidenceBuilder.attach(e, bytes)
+        end
+
+        def serialize(metafile)
+          case metafile.format
+          when :wmf then Wmf::Serializer.call(metafile)
+          when :emf, :emf_plus then Emr::Serializer.call(metafile)
+          else raise SerializeError, "unknown format: #{metafile.format.inspect}"
+          end
+        end
+      end
+    end
+    private_constant :Ruby
+
+    class << self
+      def resolved
+        selected.equal?(Ruby) ? :ruby : :native
+      end
+
+      def parse(bytes)
+        selected.parse(bytes)
+      end
+
+      def serialize(metafile)
+        selected.serialize(metafile)
+      end
+
+      private
+
+      def selected
+        override = ENV.fetch("EMF_BACKEND", "auto")
+        case override
+        when "ruby" then Ruby
+        when "auto" then native_or_ruby
+        when "native" then Native.backend
+        else raise ArgumentError, "invalid EMF_BACKEND: #{override.inspect} (expected auto, ruby, or native)"
+        end
+      end
+
+      def native_or_ruby
+        Native.backend
+      rescue Native::Unavailable
+        Ruby
+      end
+    end
+  end
+end

data/lib/emf/binary/class_field_accessors.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Emf
+  module Binary
+    # BinData defines three singleton accessors per field on every instance,
+    # which dominates allocation when a metafile holds tens of thousands of
+    # records. The accessors depend only on the field's index, so they are
+    # defined once per class on first instantiation and shared afterwards.
+    module ClassFieldAccessors
+      private
+
+      def define_field_accessors
+        klass = self.class
+        return if klass.instance_variable_get(:@field_accessors_defined)
+
+        get_parameter(:fields).each_with_index do |field, index|
+          name = field.name_as_sym
+          define_class_accessors(klass, name, index) if name
+        end
+        klass.instance_variable_set(:@field_accessors_defined, true)
+      end
+
+      def define_setter(klass, name, index)
+        klass.define_method("#{name}=") { |val| assign_field_at(index, val) }
+      end
+
+      # The generic assignment; a class that can take one into the bytes it
+      # is still made from overrides it.
+      def assign_field_at(index, val)
+        instantiate_obj_at(index) if @field_objs.nil? || @field_objs[index].nil?
+        @field_objs[index].assign(val)
+      end
+
+      def define_class_accessors(klass, name, index)
+        klass.define_method(name) do
+          @field_objs&.at(index) || begin
+            instantiate_obj_at(index)
+            @field_objs[index]
+          end
+        end
+        define_setter(klass, name, index)
+        klass.define_method("#{name}?") do
+          instantiate_obj_at(index) if @field_objs.nil? || @field_objs[index].nil?
+          include_obj?(@field_objs[index])
+        end
+      end
+    end
+  end
+end

data/lib/emf/binary/float32_le.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module Binary
+    # Little-endian IEEE 754 single that writes back the exact bits it read.
+    # Ruby widens a float32 to a double on read but `pack("e")` canonicalises
+    # every NaN to 0x7fc00000, so NaN payloads (and signalling NaNs) would
+    # otherwise change on a parse -> serialize round trip. Only NaNs carry
+    # their bits; every other value re-encodes exactly through the Float.
+    # Assigning a value drops the retained bits.
+    class Float32Le < BinData::BasePrimitive
+      def initialize_instance
+        super
+        @nan_bits = nil
+      end
+
+      def assign(val)
+        @nan_bits = nil
+        super
+      end
+
+      def assign_bits(bits)
+        @value = [bits].pack("V").unpack1("e")
+        @nan_bits = @value.nan? ? bits : nil
+        bits
+      end
+
+      def do_num_bytes
+        4
+      end
+
+      private
+
+      def sensible_default
+        0.0
+      end
+
+      def read_and_return_value(io)
+        raw = io.readbytes(4)
+        value = raw.unpack1("e")
+        @nan_bits = value.nan? ? raw.unpack1("V") : nil
+        value
+      end
+
+      def value_to_binary_string(val)
+        return [@nan_bits].pack("V") if @nan_bits
+
+        [val].pack("e")
+      end
+    end
+  end
+end

data/lib/emf/binary/types.rb

@@ -1,9 +1,38 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/binary/class_field_accessors"
+require "emf/binary/float32_le"
 
 module Emf
   module Binary
+    # `Type.new(x: 1, y: 2)` for an all-integer layout copies one instantiated
+    # sample and assigns the given leaves, as BinData's constructor does
+    # field by field; any other call shape, or an unknown key, is BinData's.
+    module KeywordNew
+      def new(*args, **attrs)
+        if args.empty? && !attrs.empty?
+          template, slots = (@keyword_template ||= keyword_template)
+          wire = Emf::Emr::Binary::WireCopy.build(template, slots, attrs)
+          return wire if wire
+        end
+        super
+      end
+
+      private
+
+      def keyword_template
+        sample = allocate_sample
+        [sample, Emf::Emr::Binary::WireCopy.slots(sample)].freeze
+      end
+
+      def allocate_sample
+        sample = method(:new).super_method.call
+        sample.field_names.each { |name| sample.public_send(name) }
+        sample
+      end
+    end
+
     # Bindata primitives shared by all three formats (WMF, EMF, EMF+).
     # Each record type is declared once and used as a `type:` argument in
     # larger records. See TODO.impl/03-binary-primitives.md.
@@ -58,12 +87,12 @@ module Emf
 
       class XForm < BinData::Record
         endian :little
-        float :m11
-        float :m12
-        float :m21
-        float :m22
-        float :dx
-        float :dy
+        float32_le :m11
+        float32_le :m12
+        float32_le :m21
+        float32_le :m22
+        float32_le :dx
+        float32_le :dy
       end
 
       class PaletteEntry < BinData::Record
@@ -86,12 +115,17 @@ module Emf
         uint32 :dw_low_date_time
         uint32 :dw_high_date_time
       end
+
+      constants.each { |name| const_get(name).prepend ClassFieldAccessors }
+
+      [PointL, PointS, SizeL, RectL, RectS, ColorRef].each { |type| type.singleton_class.prepend(Emf::Binary::KeywordNew) }
     end
   end
 end
 
 # Register the primitives so they can be referenced by name (e.g. `rectl :bounds`)
 # inside other BinData records. Bindata resolves types lazily through this registry.
+BinData::RegisteredClasses.register("float32_le", Emf::Binary::Float32Le)
 BinData::RegisteredClasses.register("point_l", Emf::Binary::Types::PointL)
 BinData::RegisteredClasses.register("point_s", Emf::Binary::Types::PointS)
 BinData::RegisteredClasses.register("point_d", Emf::Binary::Types::PointD)

data/lib/emf/conformance/context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Emf
+  module Conformance
+    # What a rule sees: the parsed model plus the input length. `format` is the
+    # Metafile format, or :unparseable when the parser rejected the input
+    # (then `metafile` is nil and `parse_failure` holds the exception).
+    class Context
+      attr_reader :metafile, :bytes, :parse_failure
+
+      def initialize(metafile: nil, bytes: nil, parse_failure: nil)
+        @metafile = metafile
+        @bytes = bytes
+        @parse_failure = parse_failure
+      end
+
+      def format = metafile ? metafile.format : :unparseable
+
+      def header = metafile.header
+
+      def records = metafile.records
+
+      # Input length in bytes, or nil when the metafile was passed in without its bytes.
+      def byte_length = bytes&.bytesize
+
+      # Declared EMR size of a record (its nSize field).
+      # EMF record size in bytes; nil for records without an EMF wire (WMF).
+      def record_size(record) = (record.wire.n_size.to_i if record.respond_to?(:wire))
+
+      def record_type(record) = record.type_id.to_i
+
+      # Total number of EMF records the header counts, header included.
+      def record_count = records.size + 1
+    end
+  end
+end

data/lib/emf/conformance/diagnostic.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Emf
+  module Conformance
+    # One finding. `severity` is already resolved by the profile; `waiver` holds
+    # the written reason when the tolerant profile downgraded an error.
+    Diagnostic = Struct.new(:requirement_id, :spec_citation, :severity, :kind, :format, :offset,
+                            :record_index, :record_type, :message, :waiver, keyword_init: true) do
+      def initialize(**)
+        super
+        freeze
+      end
+
+      def error? = severity == :error
+      def warning? = severity == :warning
+    end
+  end
+end