emfsvg 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa10edb2ac2c6602479c03f38b672f394d9c99025093d7a5665346917bab956d
-  data.tar.gz: 1e18ecea04a50531708768fe8b92effe7b0babf52e8b284603855185eaafc6ed
+  metadata.gz: aae7748e35d0b9bdc9d1586c18a8dfe2640efa8cad6f0e67ee6faf77519e92f0
+  data.tar.gz: 8b6866599cf1e938f55d0fe028ba6b5ce5d6626907a5227f82e097c5a1521b92
 SHA512:
-  metadata.gz: 2ad2f6818aa2e6a0dfcc5cc6010de3e12d92065dd5f3b2ca6a8076e2f4c4b96761568e9a8c504e8ad6d14776247942a1a49db54dcf9387443baf0fa1123fa2c7
-  data.tar.gz: 70eb4d34ac8872571de4062150630df64e77e437d88bdfc86d73cf7143cf1efde0f176403cdf1604a6bbb7c49eab1ee7b4ed9bdc38c757976c07c2a1c90ade25
+  metadata.gz: 428e11c19161a8d4a22950ce592e6043c5e580e803ca1869dcf1b4d3d31d231084763fd406465f4d1785abab9dcd25035e483aeac47a9d57a1f5e112c5195d5a
+  data.tar.gz: 2fa1da1604ffc28b495e098aa39bd22b8f0be085b27d40105b67d33c904c880bc352820e4264f131c9709dfe6bed2d00706c98e916e0f3fcaa697e856ff0745e

data/README.adoc

@@ -6,13 +6,18 @@ wrapper around the GPLv2 `libemf2svg` C library.
 
 == Status
 
-* **EMF → SVG**: 208/208 fixtures (100%) semantically match libemf2svg.
-  Verified with the lossy `SvgMatcher` at 0.1px tolerance.
-  79/208 are byte-identical to libemf2svg's output.
-* **SVG → EMF**: functional for shapes, transforms, clips, text, and
-  images. Synthetic SVGs round-trip byte-equal through
-  `SVG → EMF → SVG`. The lossy matcher and golden-master tooling
-  are in place for iterative fidelity improvement.
+Both conversion directions are implemented. Compatibility is enforced by strict
+byte comparisons against the pinned corpus and committed SVG artifacts; the
+lossy matcher is a separate diagnostic tool, not the parity acceptance gate.
+
+Current integration uses a temporary `emf` Git pin. The `image1` round trip now
+matches exactly, and a deliberately pinned C build reproduces all 208 committed
+C goldens byte for byte. The original historical builder remains unknown. Full
+Ruby corpus parity, corrupted-input resource behavior, native backend, and a
+containing released `emf` package remain unqualified. See
+link:docs/compatibility_matrix.adoc[the compatibility matrix] for contracts and
+current evidence, and link:spec/fixtures/README.adoc[fixture setup] before running
+corpus-dependent checks.
 
 == Synopsis
 
@@ -46,7 +51,7 @@ Options (convert):
 [cols="1,4"]
 |===
 | EMF → SVG | `Emf::Model::Metafile` → `Emfsvg::Renderer` → `Emfsvg::Visitors::EmrVisitor` → `Emfsvg::SvgBuilder`
-| SVG → EMF | SVG bytes → Nokogiri → `Emfsvg::Svg::Document` → `Emfsvg::Translation::EmfRenderer` → `Emf::Model::Metafile` → `Emf.serialize`
+| SVG → EMF | SVG bytes → leptris → `Emfsvg::Svg::Document` → `Emfsvg::Translation::EmfRenderer` → `Emf::Model::Metafile` → `Emf.serialize`
 |===
 
 Both directions share:
@@ -104,25 +109,104 @@ Requires Ruby >= 3.1.
   git clone https://github.com/claricle/emfsvg
   cd emfsvg
   bundle install
-  bundle exec rspec
+
+The checkout's `Gemfile` temporarily pins `emf` to
+`5c2c019138bab6f3c67f7602e8b410ba5a67c429` for model integration. This is
+separate from the external fixture corpus revision and does not establish
+compatibility with a released `emf` package.
+
+Follow link:spec/fixtures/README.adoc[the explicit corpus setup] to materialize
+`EMF_FIXTURE_ROOT` at the manifest's exact revision. Missing roots, changed
+inventories, or changed fixture bytes fail setup; there is no sibling-checkout
+or developer-machine fallback.
+
+  bundle exec rspec spec/parity_manifest_spec.rb spec/parity_corpus_spec.rb
+  bundle exec rspec spec/golden_spec.rb spec/round_trip_golden_spec.rb spec/compat_with_libemf2svg_spec.rb --dry-run
   bundle exec rubocop
 
+Dry-run verifies collection, not parity. The strict comparison groups currently
+have known failures; the complete suite is not a passing qualification gate.
+Ordinary compatibility specs use committed artifacts without invoking C.
+
+Live C tools require both `EMF2SVG_REF_PATH` (an executable wrapper) and
+`EMF2SVG_REF_LIB_DIR` (its library directory), resolved only by the spec support
+`Emfsvg::Compat` helper. Neither has a machine-specific default. The live fidelity
+spec is opt-in with `EMFSVG_LIVE_REFERENCE=1`; see the fixture setup for commands
+and the verified current reference build recipe.
+
 === Developer scripts
 
 [cols="1,3"]
 |===
-| `scripts/run_emf_svg_compare.rb [limit] [tolerance]` | EMF→SVG fidelity vs libemf2svg (208 fixtures, 100% pass at 0.1px)
-| `scripts/run_round_trip.rb [limit] [tolerance]` | SVG→EMF→SVG round-trip scan
+| `scripts/run_emf_svg_compare.rb [limit] [tolerance]` | Lossy EMF→SVG diagnostic against the explicitly configured live C reference
+| `scripts/run_round_trip.rb [limit] [tolerance]` | Lossy SVG→EMF→SVG scan of the verified artifact inventory
 | `scripts/diff_fixture.rb <fixture.svg>` | Element-by-element diff between input and round-trip output
 | `scripts/diagnose_round_trip.rb [limit]` | Per-fixture failure reasons for round-trip scan
-| `scripts/regenerate_golden.rb` | Regenerate libemf2svg + emfsvg golden baselines
-| `scripts/run_compat_check.rb` | Legacy compat matrix vs libemf2svg
+| `scripts/regenerate_golden.rb --check` | Stage both baseline sets and report drift without changing committed artifacts
+| `scripts/regenerate_golden.rb --write` | Promote both sets and manifest digests after verified C provenance checks
+| `scripts/run_compat_check.rb` | Diagnostic matrix against the explicitly configured live C reference
 |===
 
+Regeneration requires the verified corpus and explicit C setup. `--write` also
+requires a verified reference status, exact source revision, build recipe, and
+matching executable checksum in the manifest. Review artifact and manifest
+diffs before committing. See link:spec/fixtures/README.adoc[the regeneration
+procedure] for promotion safeguards and limits.
+
+== Resource calibration qualification
+
+The resource-calibration command is gated by production qualification. The
+repository carries a reviewed ledger for 21 corrupted inputs in
+`spec/fixtures/reviewed_corrupt_outcomes.json`. Those independently reviewed
+expectations define the outcome kind, exact ordered warnings, and exception
+details where applicable; an SVG digest is an optional additional constraint.
+A reviewed expectation is not a runtime observation. A ledger entry counted as
+`contracted` means its review requirements are complete, while `matched` means
+an actual observation also passed the contract. The qualification gate runs the
+public conversion for the pinned 9 valid controls and all 21 corrupted inputs
+through Ruby, native, and auto-selected-native backends before resource
+calibration can proceed.
+
+Qualification requires explicit artifact paths through `EMF_RELEASE_PACKAGE`
+(the exact released `emf` `.gem` whose SHA-256 and version match the manifest),
+`EMF_NATIVE_LIBRARY` (the native artifact matching its manifest SHA-256), and
+`EMF_NATIVE_PROVENANCE` (JSON whose `artifact_sha256`, `source_revision`, and
+`abi` exactly match the native-library provenance in the manifest). The gate
+also checks the installed runtime against the release archive, native selection,
+input identities, and evidence for drift. Missing, mismatched, or incomplete
+metadata and artifacts fail closed before samples run.
+
+After the release and native artifacts and the manifest are qualified, run the
+verification mode with explicit host safety caps:
+
+[source,bash]
+----
+EMF_RELEASE_PACKAGE=/absolute/path/emf-version.gem \
+EMF_NATIVE_LIBRARY=/absolute/path/libemf.so \
+EMF_NATIVE_PROVENANCE=/absolute/path/native-provenance.json \
+bundle exec ruby scripts/calibrate_resource_limits.rb check \
+  --manifest spec/fixtures/parity_manifest.yml \
+  --fixture-root "$EMF_FIXTURE_ROOT" \
+  --outer-rss-cap-mib "$EMFSVG_CALIBRATION_RSS_CAP_MIB" \
+  --outer-as-cap-mib "$EMFSVG_CALIBRATION_AS_CAP_MIB" \
+  --timeout-seconds "$EMFSVG_CALIBRATION_TIMEOUT_SECONDS" \
+  --baseline spec/fixtures/resource_limits/emfsvg-v1.yml
+----
+
+This checkout is not qualified: its manifest marks the runtime unqualified,
+identifies development revision `99a8c21256cbe902e243cc0bcac65b282ec52bf4`
+without a released package digest, marks the native artifact unavailable, and
+has not pinned the diagnostics and resources contract revisions. The command
+therefore refuses with the current evidence. A reviewed ledger, passing
+synthetic tests, or a current-source run does not establish released-package,
+native-artifact, whole-corpus parity, or platform qualification. See
+link:docs/compatibility_matrix.adoc[the compatibility matrix] for detailed
+contracts and remaining evidence.
+
 == Dependencies
 
 * `emf` (~> 0.1) — EMF binary parser, domain model, and serializer
-* `nokogiri` (~> 1.16) — SVG parser
+* `leptris` (>= 1.9.365.1) — SVG parser
 * `fontisan` — cmap parsing for glyph-index text
 * `libpng` (~> 1.6) — PNG encode/decode for image round-trip
 * `base64`, `bigdecimal` — stdlib

data/lib/emfsvg/device_context.rb

@@ -52,8 +52,9 @@ module Emfsvg
       @coordinate_state = CoordinateState.new
     end
 
-    attr_accessor :pen, :brush, :font, :text_color, :bk_color, :bk_mode, :poly_fill_mode, :text_align, :stretch_mode, :miter_limit,
-                  :world_transform, :brush_origin, :icm_mode, :layout, :mapper_flags, :arc_direction, :clip_region, :clip_id, :coordinate_state
+    attr_accessor :pen, :brush, :font, :text_color, :bk_color, :bk_mode, :poly_fill_mode, :text_align,
+                  :stretch_mode, :miter_limit, :world_transform, :brush_origin, :icm_mode, :layout,
+                  :mapper_flags, :arc_direction, :clip_region, :clip_id, :coordinate_state
 
     def map_mode
       coordinate_state.map_mode
@@ -113,9 +114,11 @@ module Emfsvg
 
     def dup
       other = DeviceContext.allocate
-      other.pen = pen.dup
-      other.brush = brush.dup
-      other.font = font.dup
+      # Pen, Brush, Font, Matrix and the brush origin are never mutated in
+      # place (handlers replace them), so snapshots share them.
+      other.pen = pen
+      other.brush = brush
+      other.font = font
       other.text_color = text_color
       other.bk_color = bk_color
       other.bk_mode = bk_mode
@@ -124,7 +127,7 @@ module Emfsvg
       other.stretch_mode = stretch_mode
       other.miter_limit = miter_limit
       other.world_transform = world_transform
-      other.brush_origin = brush_origin.dup
+      other.brush_origin = brush_origin
       other.icm_mode = icm_mode
       other.layout = layout
       other.mapper_flags = mapper_flags

data/lib/emfsvg/dib_decoder.rb

@@ -91,6 +91,16 @@ module Emfsvg
         safe_getbyte(bytes, offset) | (bytes.getbyte(offset + 1) << 8)
       end
 
+      def read_palette(bytes, pal_start, pal_entries)
+        (0...pal_entries).map do |i|
+          b = safe_getbyte(bytes, pal_start + (i * 4))
+          g = safe_getbyte(bytes, pal_start + (i * 4) + 1)
+          r = safe_getbyte(bytes, pal_start + (i * 4) + 2)
+          a = safe_getbyte(bytes, pal_start + (i * 4) + 3)
+          [r, g, b, a]
+        end
+      end
+
       def decode_bi_rgb(bytes, header, bits_offset, mono_palette = nil)
         width = header[:width]
         height = header[:height].abs
@@ -102,13 +112,7 @@ module Emfsvg
         # For 1-bpp MONOCHROME brushes libemf2svg overrides the palette with
         # the device context's text/bk colors. Caller can supply that via
         # mono_palette; otherwise read the palette from the BMI.
-        palette = mono_palette || (0...pal_entries).map do |i|
-          b = safe_getbyte(bytes, pal_start + (i * 4))
-          g = safe_getbyte(bytes, pal_start + (i * 4) + 1)
-          r = safe_getbyte(bytes, pal_start + (i * 4) + 2)
-          a = safe_getbyte(bytes, pal_start + (i * 4) + 3)
-          [r, g, b, a]
-        end
+        palette = mono_palette || read_palette(bytes, pal_start, pal_entries)
 
         # When the caller supplies bits_offset (== cb_bmi from the EMF
         # record), use it — the BMI may contain trailing padding between
@@ -173,7 +177,7 @@ module Emfsvg
         return nominal if nominal.zero?
 
         area = header[:width].abs * header[:height].abs
-        nominal > area ? area : nominal
+        [nominal, area].min
       end
 
       def decode_rgb24_row(bytes, row_start, width, pixels, out_start)

data/lib/emfsvg/drawing_hint.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module Emfsvg
+  # Private, per-record spelling provenance for the owned SVG round-trip
+  # contract. Reference C rendering ignores these comments. They never carry
+  # complete SVG, and cannot alter the drawing's geometry or paint.
+  module DrawingHint
+    MAGIC = "emfsvg-draw:1:"
+    MAX_BYTES = 512
+    DRAW_TYPES = %i[BITBLT POLYLINE POLYLINE16 STRETCHDIBITS].map do |name|
+      Emf::Emr::Binary::TypeCodes.const_get(name)
+    end.freeze
+
+    module_function
+
+    def rectangle_values(source)
+      return unless source && source.bytesize <= 256
+
+      number = "-?\\d+(?:\\.\\d+)?"
+      pattern = %r{\A<rect x="(#{number})" y="(#{number})" width="(#{number})" height="(#{number})" \
+fill="(#[0-9A-F]{6})"/>\z}
+      match = source&.match(pattern)
+      match&.captures
+    end
+
+    def for_element(element)
+      if element.is_a?(Svg::Elements::Rect) && element.serialization_hint && !element.clip_path
+        ["rect", element.serialization_hint]
+      elsif element.stroke&.canonical_cosmetic_dash && element.stroke.raw_width == "1.0000"
+        ["stroke", [color_hex(element.stroke.paint.color)]]
+      elsif element.is_a?(Svg::Elements::Image) && element.mime_type == "image/jpeg"
+        ["jpeg", []]
+      end
+    end
+
+    def color_hex(color)
+      format("#%<red>02X%<green>02X%<blue>02X", red: color.red, green: color.green, blue: color.blue)
+    end
+
+    def encode(record, kind, values)
+      MAGIC + JSON.generate("record" => fingerprint(record), "kind" => kind, "values" => values)
+    end
+
+    def fingerprint(record)
+      Digest::SHA256.hexdigest(record.wire.to_binary_s)
+    end
+
+    def decode(wire)
+      length = wire.cb_data.to_i
+      return unless length.between?(MAGIC.bytesize, MAX_BYTES)
+
+      data = wire.data.to_s
+      return unless data.bytesize.between?(length, (length + 3) & ~3)
+      return unless data.byteslice(length..).to_s.bytes.all?(&:zero?)
+      return unless data.start_with?(MAGIC)
+
+      hint = JSON.parse(data.byteslice(MAGIC.bytesize, length - MAGIC.bytesize))
+      return unless hint.is_a?(Hash) && hint.keys.sort == %w[kind record values]
+      return unless hint["record"].is_a?(String) && hint["record"].match?(/\A[0-9a-f]{64}\z/)
+      return unless valid_values?(hint["kind"], hint["values"])
+
+      hint
+    rescue JSON::ParserError
+      nil
+    end
+
+    def valid_values?(kind, values)
+      return false unless values.is_a?(Array)
+
+      case kind
+      when "rect"
+        values.size == 5 && values.first(4).all? do |value|
+          value.is_a?(String) && value.match?(/\A-?\d+(?:\.\d+)?\z/)
+        end &&
+          values.last.is_a?(String) && values.last.match?(/\A#[0-9A-F]{6}\z/)
+      when "stroke"
+        values.size == 1 && values.first.is_a?(String) && values.first.match?(/\A#[0-9A-F]{6}\z/)
+      when "jpeg"
+        values.empty?
+      else
+        false
+      end
+    end
+  end
+end

data/lib/emfsvg/error.rb

@@ -8,4 +8,15 @@ module Emfsvg
   class ParseError < Error; end
 
   class RenderError < Error; end
+
+  class ResourceLimitError < Error
+    attr_reader :resource, :limit, :actual
+
+    def initialize(resource:, limit:, actual:)
+      @resource = resource
+      @limit = limit
+      @actual = actual
+      super("#{resource} limit exceeded (#{actual} > #{limit})")
+    end
+  end
 end

data/lib/emfsvg/format_helpers.rb

@@ -15,16 +15,60 @@ module Emfsvg
   module FormatHelpers
     module_function
 
+    # Digit strings shared by every formatted number. Filled on first use so
+    # a render only pays for the digit groups it actually emits.
+    INTEGER_DIGITS = Hash.new { |cache, key| cache[key] = key.to_s.freeze }
+    FRACTION_DIGITS = Hash.new { |cache, key| cache[key] = format("%04d", key).freeze }
+    INTEGER_CACHE_LIMIT = 10_000
+    private_constant :INTEGER_DIGITS, :FRACTION_DIGITS, :INTEGER_CACHE_LIMIT
+
     # Format a single float as "%.4f" with C printf semantics.
     def fmt(n)
-      bd = BigDecimal("%.20f" % n.to_f)
+      append(+"", n)
+    end
+
+    # Append the "%.4f" text of +n+ to +buffer+ and return the buffer.
+    # Byte-identical to +fmt+; skips the intermediate string per number.
+    def append(buffer, n)
+      f = n.to_f
+      scaled = f.abs * 10_000.0
+      # Fast path: when the scaled value is clearly away from a rounding
+      # tie, double rounding error (< 1e-7 below 1e9) cannot change which
+      # way it rounds, so plain integer rounding matches the exact
+      # half-even result. Ties, zero, NaN and huge values take the exact path.
+      if f != 0.0 && scaled < 1e9
+        floor = scaled.floor
+        frac = scaled - floor
+        if (frac - 0.5).abs > 1e-6
+          units = frac > 0.5 ? floor + 1 : floor
+          whole = units / 10_000
+          buffer << "-" if f.negative?
+          buffer << (whole < INTEGER_CACHE_LIMIT ? INTEGER_DIGITS[whole] : whole.to_s)
+          buffer << "." << FRACTION_DIGITS[units % 10_000]
+          return buffer
+        end
+      end
+
+      buffer << fmt_via_decimal(f)
+    end
+
+    def fmt_via_decimal(value)
+      bd = BigDecimal(format("%.20f", value))
       format("%.4f", bd.round(4, half: :even).to_f)
     end
 
     # Format a coordinate pair as "X,Y " (trailing space, matching
     # libemf2svg's point_draw output).
     def fmt_xy(x, y)
-      "#{fmt(x)},#{fmt(y)} "
+      append_xy(+"", x, y)
+    end
+
+    # Append "X,Y " to +buffer+ and return the buffer.
+    def append_xy(buffer, x, y)
+      append(buffer, x)
+      buffer << ","
+      append(buffer, y)
+      buffer << " "
     end
   end
 end

data/lib/emfsvg/glyph_index_mapper.rb

@@ -40,9 +40,7 @@ module Emfsvg
       codepoints = glyph_ids.map { |gid| reverse_map[gid] || 0 }
       utf8 = codepoints.pack("U*")
 
-      if charset == HEBREW_CHARSET || charset == ARABIC_CHARSET
-        utf8 = utf8.reverse
-      end
+      utf8 = utf8.reverse if [HEBREW_CHARSET, ARABIC_CHARSET].include?(charset)
 
       null_pos = utf8.index("\x00")
       utf8 = utf8[0, null_pos] if null_pos
@@ -67,12 +65,13 @@ module Emfsvg
       end
     end
 
-    def find_font_path(font_family, weight, italic)
+    def find_font_path(font_family, _weight, _italic)
       return nil if font_family.nil? || font_family.empty?
 
       # Build fontconfig pattern matching libemf2svg's get_fontpath.
       pattern = font_family.dup
-      stdout, _ = Open3.capture2("fc-match", "-f", "%{file}\n", pattern)
+      # fc-match's own template syntax; %% keeps the literal percent sign.
+      stdout, = Open3.capture2("fc-match", "-f", format("%%{file}\\n"), pattern)
       path = stdout.strip
       path.empty? ? nil : path
     end
@@ -85,7 +84,7 @@ module Emfsvg
       num_tables = bytes[4, 2].unpack1("n").to_i
       cmap_offset = cmap_length = nil
       (0...num_tables).each do |i|
-        off = 12 + i * 16
+        off = 12 + (i * 16)
         tag = bytes[off, 4]
         next unless tag == "cmap"
 

data/lib/emfsvg/object_table.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Emfsvg
-  # 1-indexed GDI object table (matches EMF's handle numbering).
+  # GDI object table keyed by EMF handles.
   # SELECTOBJECT copies from the table into the current DeviceContext.
   # DELETEOBJECT removes the slot.
   class ObjectTable
@@ -20,32 +20,24 @@ module Emfsvg
     end
 
     def initialize
-      @entries = [] # 0-indexed internally; EMF indices are 1-based
+      @entries = {}
     end
 
     def store(index, type, object)
-      ensure_capacity(index)
-      @entries[index - 1] = Entry.new(type: type, object: object)
+      @entries[index] = Entry.new(type: type, object: object)
     end
 
     def lookup(index)
-      @entries[index - 1]
+      @entries[index]
     end
 
     def delete(index)
-      @entries[index - 1] = nil
+      @entries.delete(index)
+      nil
     end
 
     def size
-      @entries.compact.size
-    end
-
-    private
-
-    def ensure_capacity(index)
-      return if @entries.size >= index
-
-      @entries.fill(nil, @entries.size...index)
+      @entries.size
     end
   end
 end

data/lib/emfsvg/record_access.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  # How the renderer reads one parsed record: its wire class without making
+  # the wire, and its field values without making BinData field objects.
+  #
+  # emf's `WireAdapter#wire_class` and `#values` are used on a record that has
+  # `wire_class` (added with `values` in the same emf); any other record, or an emf without them, gives the wire. Its
+  # accessors have the same names, so every caller reads either one the
+  # same way.
+  module RecordAccess
+    # Wire classes whose handlers read fields only through names and Integer
+    # or Float values that the value view shares with the wire (nested
+    # structs and point arrays included). Handlers of other classes, such as
+    # text, bitmaps and objects with a body, receive the wire.
+    VALUE_CLASSES = %w[
+      SelectObject DeleteObject CreatePen CreateBrushIndirect SetBkColor SetTextColor SetBkMode
+      SetTextAlign SetMapMode SetPolyFillMode SetRop2 SetStretchBltMode SetMiterLimit SetIcmMode
+      SetLayout SaveDc RestoreDc SetWindowOrgEx SetWindowExtEx SetViewportOrgEx SetViewportExtEx
+      SetBrushOrgEx SetWorldTransform ModifyWorldTransform MoveToEx LineTo Rectangle Ellipse SetPixelV
+      IntersectClipRect ExcludeClipRect BeginPath EndPath CloseFigure FillPath StrokePath
+      StrokeAndFillPath Polygon Polyline PolyBezier PolyBezierTo PolylineTo Polygon16 Polyline16
+      PolyBezier16 PolyBezierTo16 PolylineTo16
+    ].to_h { |name| [Emf::Emr::Binary::Records.const_get(name), true] }.compare_by_identity.freeze
+
+    module_function
+
+    # The wire class of the record.
+    def wire_class(record)
+      record.respond_to?(:wire_class) ? record.wire_class : record.wire.class
+    end
+
+    # What the handler of a `klass` record reads its fields from.
+    def fields(record, klass)
+      (record.values if VALUE_CLASSES[klass] && record.respond_to?(:wire_class)) || record.wire
+    end
+  end
+end