emf 0.1.2 → 0.2.0

data/lib/emf/conformance/rules/emf_geometry.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+# Drawing geometry rules: point arrays, PolyDraw, GradientFill and region data
+# (MS-EMF 2.3.5, 2.2.7, 2.2.8, 2.2.24-2.2.26, 2.1.15, 2.1.26).
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+module Emf
+  module Conformance
+    module GeometryRules
+      EMF = %i[emf emf_plus].freeze
+      # type => [count field, bytes per point]
+      POINT_ARRAYS = { 2 => [:cptl, 8], 3 => [:cptl, 8], 4 => [:cptl, 8], 5 => [:cptl, 8], 6 => [:cptl, 8],
+                       85 => [:cpts, 4], 86 => [:cpts, 4], 87 => [:cpts, 4], 88 => [:cpts, 4], 89 => [:cpts, 4] }.freeze
+      POLY_POLY = { 7 => [:c_ptl_total, 8], 8 => [:c_ptl_total, 8], 90 => [:c_pts_total, 4], 91 => [:c_pts_total, 4] }.freeze
+      POLY_DRAW = { 56 => [:cptl, 8], 92 => [:cpts, 4] }.freeze
+      POLYLINES = [7, 90].freeze
+      BEZIER = 4
+      POINT_TYPES = [0x02, 0x03, 0x04, 0x05, 0x06].freeze # LINETO, BEZIERTO and MOVETO, optionally with CLOSEFIGURE (not on MOVETO)
+      GRADIENT_FIXED = 36
+      GRADIENT_MODES = [0, 1, 2].freeze
+      GRADIENT_TRIANGLE = 2
+      REGION_RECORDS = { 71 => 32, 72 => 40, 73 => 28, 74 => 28, 75 => 16 }.freeze # fixed part before RgnData
+      BEZIER_COUNT = { 0 => "a multiple of 3", 1 => "one more than a multiple of 3" }.freeze
+      COUNT_WINS = "readers take Count points and ignore the rest of the record"
+      EXTRA_POINTS = "the spec says extra points MUST be ignored, so a reader still draws the curve or polygon"
+
+      module_function
+
+      def field(record, name)
+        wire = record.wire
+        wire.respond_to?(name) ? wire.public_send(name).to_i : nil
+      end
+
+      def at(record, index, message)
+        { message: message, offset: record.offset, record_index: index + 1, record_type: record.type_id.to_i }
+      end
+
+      def each_of(context, types)
+        context.records.each_with_index do |record, index|
+          type = context.record_type(record)
+          yield record, index, type if types.include?(type)
+        end
+      end
+
+      def padded(bytes) = (bytes + 3) & ~3
+
+      def size_finding(context, record, index, type, expected, what)
+        size = context.record_size(record)
+        return if size == expected
+
+        at(record, index, "#{RecordTypes.name(type)} #{what}, so Size MUST be #{expected}, not #{size}")
+      end
+
+      def point_array_size(context)
+        found = []
+        each_of(context, POINT_ARRAYS.keys) do |record, index, type|
+          name, width = POINT_ARRAYS.fetch(type)
+          count = field(record, name)
+          next if count.nil?
+
+          found << size_finding(context, record, index, type, 28 + padded(count * width), "holds #{count} points")
+        end
+        found.compact
+      end
+
+      def bezier_count(context)
+        found = []
+        each_of(context, [2, 85, 5, 88]) do |record, index, type|
+          count = field(record, POINT_ARRAYS.fetch(type).first)
+          next if count.nil?
+
+          expected = [2, 85].include?(type) ? 1 : 0
+          next if (count % 3) == expected
+
+          found << at(record, index, "#{RecordTypes.name(type)} Count #{count} MUST be #{BEZIER_COUNT.fetch(expected)}")
+        end
+        found
+      end
+
+      def poly_poly_totals(record, type)
+        total_name = POLY_POLY.fetch(type).first
+        counts = record.wire.a_poly_counts.to_a.map(&:to_i)
+        [counts, field(record, total_name)]
+      end
+
+      def poly_poly_size(context)
+        found = []
+        each_of(context, POLY_POLY.keys) do |record, index, type|
+          polys = field(record, :n_polys)
+          total = field(record, POLY_POLY.fetch(type).first)
+          next if polys.nil? || total.nil?
+
+          found << size_finding(context, record, index, type, 32 + (4 * polys) + padded(total * POLY_POLY.fetch(type).last),
+                                "holds #{polys} polygons and #{total} points")
+        end
+        found.compact
+      end
+
+      def poly_poly_counts(context)
+        found = []
+        each_of(context, POLY_POLY.keys) do |record, index, type|
+          next unless record.wire.respond_to?(:a_poly_counts)
+
+          counts, total = poly_poly_totals(record, type)
+          sum = counts.sum
+          found << at(record, index, "#{RecordTypes.name(type)} per-figure counts sum to #{sum} but Count says #{total}") if sum != total
+          short = counts.count { |c| c < 2 }
+          if POLYLINES.include?(type) && short.positive?
+            found << at(record, index,
+                        "#{RecordTypes.name(type)} has #{short} polyline(s) with fewer than 2 points, each count MUST be >= 2")
+          end
+        end
+        found
+      end
+
+      def poly_draw_size(context)
+        found = []
+        each_of(context, POLY_DRAW.keys) do |record, index, type|
+          name, width = POLY_DRAW.fetch(type)
+          count = field(record, name)
+          next if count.nil?
+
+          found << size_finding(context, record, index, type, 28 + padded((count * width) + count), "holds #{count} points and types")
+        end
+        found.compact
+      end
+
+      def bezier_runs(types)
+        types.chunk_while { |a, b| (a & ~1) == BEZIER && (b & ~1) == BEZIER }
+             .select { |run| (run.first & ~1) == BEZIER }.map(&:size)
+      end
+
+      def poly_draw_types(context)
+        found = []
+        each_of(context, POLY_DRAW.keys) do |record, index, type|
+          next unless record.wire.respond_to?(:ab_types)
+
+          types = record.wire.ab_types.to_a.map(&:to_i)
+          bad = types.reject { |t| POINT_TYPES.include?(t) }.uniq
+          unless bad.empty?
+            found << at(record, index, "#{RecordTypes.name(type)} point types #{bad.map do |t|
+              format('0x%02X', t)
+            end.join(', ')} are not in the Point enumeration")
+          end
+          odd = bezier_runs(types - bad).reject { |run| (run % 3).zero? }
+          unless odd.empty?
+            found << at(record, index,
+                        "#{RecordTypes.name(type)} has PT_BEZIERTO runs of #{odd.join(', ')} points, they MUST come in sets of three")
+          end
+        end
+        found
+      end
+
+      # GradientFill: header, nVer TriVertex (16 bytes), then nTri index objects (12 bytes each,
+      # a rectangle's 8 bytes plus its mandatory 4 bytes of padding).
+      def gradient_fields(record)
+        %i[n_ver n_tri ul_mode].map { |name| field(record, name) }
+      end
+
+      def gradient_mode(context)
+        found = []
+        each_of(context, [118]) do |record, index, _type|
+          mode = field(record, :ul_mode)
+          next if mode.nil? || GRADIENT_MODES.include?(mode)
+
+          found << at(record, index, "GRADIENTFILL ulMode #{mode} is not GRADIENT_FILL_RECT_H, RECT_V or TRIANGLE")
+        end
+        found
+      end
+
+      def gradient_size(context)
+        found = []
+        each_of(context, [118]) do |record, index, type|
+          n_ver, n_tri, = gradient_fields(record)
+          next if n_ver.nil?
+
+          found << size_finding(context, record, index, type, GRADIENT_FIXED + (16 * n_ver) + (12 * n_tri),
+                                "holds #{n_ver} vertexes and #{n_tri} index objects")
+        end
+        found.compact
+      end
+
+      def gradient_index(context)
+        found = []
+        each_of(context, [118]) do |record, index, _type|
+          n_ver, n_tri, mode = gradient_fields(record)
+          next if n_ver.nil?
+
+          bad = out_of_range_indexes(record.wire.body.to_s.b, n_ver, n_tri, mode)
+          found << at(record, index, "GRADIENTFILL vertex index #{bad.first} is not below nVer (#{n_ver})") if bad.any?
+        end
+        found
+      end
+
+      def out_of_range_indexes(body, n_ver, n_tri, mode)
+        per = mode == GRADIENT_TRIANGLE ? 3 : 2
+        start = 16 * n_ver
+        available = [(body.bytesize - start) / 12, n_tri].min
+        return [] if available <= 0
+
+        (0...available).flat_map { |i| body.byteslice(start + (12 * i), 4 * per).unpack("V#{per}") }.reject { |v| v < n_ver }
+      end
+
+      def region_data(record)
+        wire = record.wire
+        return unless wire.respond_to?(:rgn_data) && field(record, :cb_rgn_data).to_i.positive?
+
+        wire.rgn_data
+      end
+
+      def region_header(context)
+        found = []
+        each_of(context, REGION_RECORDS.keys) do |record, index, type|
+          data = region_data(record)
+          next unless data
+
+          unless data.header_size.to_i == 32
+            found << at(record, index,
+                        "#{RecordTypes.name(type)} RegionDataHeader Size is #{data.header_size.to_i}, MUST be 32")
+          end
+          unless data.region_type.to_i == 1
+            found << at(record, index,
+                        "#{RecordTypes.name(type)} RegionDataHeader Type is #{data.region_type.to_i}, MUST be 1")
+          end
+        end
+        found
+      end
+
+      def region_rects(context)
+        found = []
+        each_of(context, REGION_RECORDS.keys) do |record, index, type|
+          data = region_data(record)
+          next unless data
+
+          count = data.count_rects.to_i
+          size = data.rgn_size.to_i
+          cb = field(record, :cb_rgn_data)
+          if size != count * 16
+            found << at(record, index,
+                        "#{RecordTypes.name(type)} CountRects #{count} needs #{count * 16} bytes but RgnSize is #{size}")
+          end
+          if cb != 32 + size
+            found << at(record, index,
+                        "#{RecordTypes.name(type)} RgnDataSize #{cb} is not the 32-byte header plus RgnSize #{size}")
+          end
+        end
+        found
+      end
+
+      def region_size(context)
+        found = []
+        each_of(context, REGION_RECORDS.keys) do |record, index, type|
+          cb = field(record, :cb_rgn_data)
+          next if cb.nil?
+
+          found << size_finding(context, record, index, type, REGION_RECORDS.fetch(type) + cb, "carries #{cb} bytes of region data")
+        end
+        found.compact
+      end
+    end
+
+    registry = Registry.loading
+    {
+      "emf.geometry.point_array_size" => [:point_array_size, "MS-EMF 2.3.5", :point_array_size, GeometryRules::COUNT_WINS],
+      "emf.geometry.bezier_count" => [:bezier_count, "MS-EMF 2.3.5.16", :bezier_count, GeometryRules::EXTRA_POINTS],
+      "emf.geometry.poly_poly_size" => [:poly_poly_size, "MS-EMF 2.3.5.28", :poly_poly_size, nil],
+      "emf.geometry.poly_poly_counts" => [:poly_poly_counts, "MS-EMF 2.3.5.28", :poly_poly_counts, GeometryRules::EXTRA_POINTS],
+      "emf.geometry.poly_draw_size" => [:poly_draw_size, "MS-EMF 2.3.5.20", :poly_draw_size, nil],
+      "emf.geometry.poly_draw_types" => [:poly_draw_types, "MS-EMF 2.1.26", :poly_draw_types, nil],
+      "emf.geometry.gradient_mode" => [:gradient_mode, "MS-EMF 2.1.15", :gradient_mode, nil],
+      "emf.geometry.gradient_size" => [:gradient_size, "MS-EMF 2.3.5.12", :gradient_size, nil],
+      "emf.geometry.gradient_index" => [:gradient_index, "MS-EMF 2.2.7", :gradient_index, nil],
+      "emf.region.header" => [:region_header, "MS-EMF 2.2.25", :region_header, nil],
+      "emf.region.rects" => [:region_rects, "MS-EMF 2.2.25", :region_rects, nil],
+      "emf.region.size" => [:region_size, "MS-EMF 2.3.5", :region_size, nil]
+    }.each do |id, (method, citation, kind, reason)|
+      registry.register(id: id, formats: GeometryRules::EMF, citation: citation, kind: kind, tolerant_reason: reason) do |context|
+        GeometryRules.public_send(method, context)
+      end
+    end
+  end
+end

data/lib/emf/conformance/rules/emf_header.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# EMR_HEADER / Header object rules (MS-EMF 2.2.9, 2.3.4.2).
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+module Emf
+  module Conformance
+    module HeaderRules
+      EMF = %i[emf emf_plus].freeze
+      SIGNATURE = 0x464D4520
+      FIXED_HEADER_SIZE = 88 # EmfMetafileHeader fixed part (2.3.4.2)
+      CREATE_OBJECT_TYPES = [38, 39, 49, 82, 93, 94, 95, 99, 122].freeze
+      DRIFT = "the numeric header fields are advisory for renderers; every corpus file with a drifted value still renders"
+
+      module_function
+
+      def finding(message) = { message: message, offset: 0, record_index: 0, record_type: RecordTypes::HEADER }
+
+      def signature(context)
+        sig = context.header.signature.to_i
+        return [] if sig == SIGNATURE
+
+        [finding(format("RecordSignature is 0x%08X, MUST be ENHMETA_SIGNATURE 0x464D4520", sig))]
+      end
+
+      def size_bounds(context)
+        size = context.header.n_size.to_i
+        problems = []
+        problems << "header Size #{size} is below the #{FIXED_HEADER_SIZE}-byte fixed part" if size < FIXED_HEADER_SIZE
+        problems << "header Size #{size} is not a multiple of 4" unless (size % 4).zero?
+        problems.map { |message| finding(message) }
+      end
+
+      def bytes_mismatch(context)
+        actual = context.byte_length
+        declared = context.header.n_bytes.to_i
+        return [] if actual.nil? || declared == actual
+
+        [finding("header Bytes is #{declared} but the metafile is #{actual} bytes")]
+      end
+
+      def records_mismatch(context)
+        declared = context.header.n_records.to_i
+        return [] if declared == context.record_count
+
+        [finding("header Records is #{declared} but the metafile holds #{context.record_count} records")]
+      end
+
+      def handle_count(context)
+        handles = context.header.n_handles.to_i
+        context.records.each_with_index.filter_map do |record, index|
+          type = context.record_type(record)
+          next unless CREATE_OBJECT_TYPES.include?(type)
+
+          handle = record.to_binary_s.unpack1("V", offset: 8)
+          next if handle.nil? || handle < handles
+
+          { message: "object handle index #{handle} created at record #{index + 1} is not below header Handles (#{handles})",
+            offset: record.offset, record_index: index + 1, record_type: type }
+        end
+      end
+
+      def description_bounds(context)
+        header = context.header
+        chars = header.n_description.to_i
+        return [] if chars.zero? && header.off_description.to_i.zero?
+
+        offset = header.off_description.to_i
+        problems = []
+        problems << "description offset #{offset} is inside the #{FIXED_HEADER_SIZE}-byte fixed part" if offset < FIXED_HEADER_SIZE
+        if offset + (2 * chars) > header.n_size.to_i
+          problems << "description (#{chars} UTF-16 chars at offset #{offset}) ends past header Size #{header.n_size}"
+        end
+        problems.map { |message| finding(message) }
+      end
+
+      # HeaderExtension1 (and with it the pixel format fields) exists only when
+      # the variable-length data starts at byte 100 or later (MS-EMF 2.3.4.2,
+      # HeaderSize rule); a description at byte 88 means the original 88-byte header.
+      def extension1?(header)
+        return header.n_size.to_i >= 100 if header.n_description.to_i.zero?
+
+        header.off_description.to_i >= 100
+      end
+
+      def pixel_format_bounds(context)
+        header = context.header
+        return [] unless extension1?(header)
+
+        size = header.cb_pixel_format.to_i
+        offset = header.off_pixel_format.to_i
+        return [] if size.zero? && offset.zero?
+        return [] if offset >= FIXED_HEADER_SIZE && offset + size <= header.n_size.to_i
+
+        [finding("pixel format (#{size} bytes at offset #{offset}) lies outside the header record (Size #{header.n_size})")]
+      end
+    end
+
+    registry = Registry.loading
+    {
+      "emf.header.signature" => [:signature, "MS-EMF 2.2.9", :signature, nil],
+      "emf.header.size_bounds" => [:size_bounds, "MS-EMF 2.3.4.2", :header_size, nil],
+      "emf.header.bytes" => [:bytes_mismatch, "MS-EMF 2.2.9", :bytes_mismatch, HeaderRules::DRIFT],
+      "emf.header.records" => [:records_mismatch, "MS-EMF 2.2.9", :records_mismatch, HeaderRules::DRIFT],
+      "emf.header.handles" => [:handle_count, "MS-EMF 2.2.9", :handle_count, HeaderRules::DRIFT],
+      "emf.header.description_bounds" => [:description_bounds, "MS-EMF 2.2.9", :description_bounds, HeaderRules::DRIFT],
+      "emf.header.pixel_format_bounds" => [:pixel_format_bounds, "MS-EMF 2.2.10", :pixel_format_bounds, HeaderRules::DRIFT]
+    }.each do |id, (method, citation, kind, reason)|
+      registry.register(id: id, formats: HeaderRules::EMF, citation: citation, kind: kind, tolerant_reason: reason) do |context|
+        HeaderRules.public_send(method, context)
+      end
+    end
+  end
+end

data/lib/emf/conformance/rules/emf_objects.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+# Object creation and manipulation rules (MS-EMF 2.3.7, 2.3.8, 2.1.31, 2.2.17-2.2.20).
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+module Emf
+  module Conformance
+    module ObjectRules
+      EMF = %i[emf emf_plus].freeze
+      DEFAULT_PALETTE = 0x8000000F
+      STOCK = ((0x80000000..0x80000008).to_a + (0x8000000A..0x80000013).to_a).freeze # MS-EMF 2.1.31
+      # Record types that put a new handle in the object table, and the wire field that holds it.
+      CREATE = { 38 => :ih_pen, 39 => :ih_brush, 49 => :ih_pal, 82 => :ih_object, 93 => :ih_brush,
+                 94 => :ih_brush, 95 => :ih_pen, 99 => :ih_cs, 122 => :ih_cs }.freeze
+      # Records that name an existing handle: type => wire field.
+      SELECT = { 37 => :ih_object, 48 => :ih_pal, 100 => :ih_cs }.freeze
+      DELETE = { 40 => :ih_object, 101 => :ih_cs }.freeze
+      USE = { 50 => :ih_pal, 51 => :ih_pal }.freeze
+      REFERENCES = SELECT.merge(DELETE).merge(USE).freeze
+      FIXED_SIZES = { 38 => 28, 39 => 24, 48 => 12, 100 => 12, 111 => 24 }.freeze
+      PS_GEOMETRIC = 0x10000
+      PS_NULL = 5
+      PS_ALTERNATE = 8
+      BS_SOLID = 0
+      BS_NULL = 1
+      BS_HATCHED = 2
+      MAX_PALETTE = 0x400
+      MIN_FONT_RECORD = 12 + 320 # fixed part plus a LogFontPanose (2.3.7.8)
+      COSMETIC_WIDTH = "GDI writes PS_SOLID pens wider than 1 and renders them at that width; 165 corpus files do this"
+      PEN_BRUSH = "the same section's brush table lists BS_PATTERN and BS_DIBPATTERN as supported for the pen; GDI writes " \
+                  "DIB-pattern geometric pens (5 corpus files)"
+      FONT_SHORT = "the same section says a LogFont MAY be present instead of a LogFontExDv, so a shorter elw is not uniformly invalid"
+      HANDLE_RANGE = "vectory's svg2emf, ps2emf and eps2emf output declares Handles=1 while selecting object indices 1 and 2; " \
+                     "renderers resolve handles from the live table, not the header count, and display the file"
+      UNKNOWN_HANDLE = "readers skip a SELECTOBJECT or DELETEOBJECT whose handle is not in the table and keep drawing"
+
+      module_function
+
+      # nil when the record has no such field, or its body is too short to decode it.
+      def field(record, name)
+        wire = record.wire
+        wire.respond_to?(name) ? wire.public_send(name).to_i : nil
+      rescue ArgumentError
+        nil
+      end
+
+      def at(record, index, message)
+        { message: message, offset: record.offset, record_index: index + 1, record_type: record.type_id.to_i }
+      end
+
+      def each_of(context, types)
+        context.records.each_with_index do |record, index|
+          type = context.record_type(record)
+          yield record, index, type if types.include?(type)
+        end
+      end
+
+      def hex(value) = format("0x%08X", value)
+
+      def fixed_size(context)
+        found = []
+        each_of(context, FIXED_SIZES.keys) do |record, index, type|
+          size = context.record_size(record)
+          next if size == FIXED_SIZES.fetch(type)
+
+          found << at(record, index, "#{RecordTypes.name(type)} Size is #{size}, MUST be #{FIXED_SIZES.fetch(type)}")
+        end
+        found
+      end
+
+      # PenStyle (2.1.25): line style 0-8, cap 0/0x100/0x200, join 0/0x1000/0x2000, type 0/PS_GEOMETRIC.
+      def font_size(context)
+        found = []
+        each_of(context, [82]) do |record, index, _type|
+          size = context.record_size(record)
+          next if size >= MIN_FONT_RECORD
+
+          found << at(record, index, "EXTCREATEFONTINDIRECTW Size #{size} leaves #{size - 12} bytes for elw, " \
+                                     "less than a LogFontPanose (#{MIN_FONT_RECORD - 12})")
+        end
+        found
+      end
+
+      def pen_style_problem(style)
+        return "line style #{style & 0xFF} is outside PS_SOLID..PS_ALTERNATE" if (style & 0xFF) > PS_ALTERNATE
+        return "end cap #{hex(style & 0xF00)} is not round, square or flat" unless [0, 0x100, 0x200].include?(style & 0xF00)
+        return "line join #{hex(style & 0xF000)} is not round, bevel or miter" unless [0, 0x1000, 0x2000].include?(style & 0xF000)
+        return "pen type #{hex(style & 0xF0000)} is not PS_COSMETIC or PS_GEOMETRIC" unless [0, PS_GEOMETRIC].include?(style & 0xF0000)
+        return "bits #{hex(style & 0xFFF00000)} are outside the PenStyle enumeration" unless style.nobits?(0xFFF00000)
+
+        "PS_ALTERNATE is applicable only to PS_COSMETIC pens" if (style & 0xFF) == PS_ALTERNATE && style.anybits?(PS_GEOMETRIC)
+      end
+
+      def pen_style(context)
+        found = []
+        each_of(context, [38, 95]) do |record, index, type|
+          style = field(record, :pen_style)
+          problem = style && pen_style_problem(style)
+          found << at(record, index, "#{RecordTypes.name(type)} PenStyle #{hex(style)}: #{problem}") if problem
+        end
+        found
+      end
+
+      def pen_width(record, type)
+        return record.wire.width.x.to_i if type == 38 && record.wire.respond_to?(:width)
+
+        field(record, :width)
+      end
+
+      def cosmetic_width(context)
+        found = []
+        each_of(context, [38, 95]) do |record, index, type|
+          style = field(record, :pen_style)
+          next if style.nil? || style.anybits?(PS_GEOMETRIC)
+
+          width = pen_width(record, type)
+          next if width.nil? || width == 1
+
+          found << at(record, index, "#{RecordTypes.name(type)} is a PS_COSMETIC pen with width #{width}, MUST be 1")
+        end
+        found
+      end
+
+      def brush_style(context)
+        found = []
+        each_of(context, [39]) do |record, index, _type|
+          style = field(record, :brush_style)
+          next if style.nil? || [BS_SOLID, BS_NULL, BS_HATCHED].include?(style)
+
+          found << at(record, index, "CREATEBRUSHINDIRECT BrushStyle #{style} MUST be BS_SOLID, BS_HATCHED or BS_NULL")
+        end
+        found
+      end
+
+      def extpen_brush_problem(pen_style, brush, hatch)
+        if pen_style.anybits?(PS_GEOMETRIC)
+          "a PS_GEOMETRIC pen MUST use BS_SOLID or BS_HATCHED" unless [BS_SOLID, BS_HATCHED].include?(brush) ||
+                                                                      (brush == BS_NULL && (pen_style & 0xFF) == PS_NULL)
+        elsif brush == BS_HATCHED && ![0x8, 0xA].include?(hatch)
+          "a cosmetic BS_HATCHED pen MUST use HS_SOLIDTEXTCLR or HS_SOLIDBKCLR, not #{hatch}"
+        end
+      end
+
+      def extpen_brush(context)
+        found = []
+        each_of(context, [95]) do |record, index, _type|
+          style = field(record, :pen_style)
+          brush = field(record, :brush_style)
+          next if style.nil? || brush.nil?
+
+          problem = extpen_brush_problem(style, brush, field(record, :brush_hatch))
+          found << at(record, index, "EXTCREATEPEN brush style #{brush}: #{problem}") if problem
+        end
+        found
+      end
+
+      def palette_version(context)
+        found = []
+        each_of(context, [49]) do |record, index, _type|
+          version = field(record, :version)
+          next if version.nil? || version == 0x300
+
+          found << at(record, index, "CREATEPALETTE LogPalette Version is #{format('0x%04X', version)}, MUST be 0x0300")
+        end
+        found
+      end
+
+      def palette_entries(context)
+        found = []
+        each_of(context, [49, 51]) do |record, index, type|
+          count = field(record, :entry_count)
+          next if count.nil?
+          next if count.positive? && (type == 49 || count <= MAX_PALETTE)
+
+          found << at(record, index,
+                      "#{RecordTypes.name(type)} NumberOfEntries is #{count}, MUST be #{type == 49 ? '> 0' : "> 0 and <= #{MAX_PALETTE}"}")
+        end
+        found
+      end
+
+      # Palette records whose entry array is sized by a count: the record Size must match the layout.
+      PALETTE_FIXED = { 49 => 16, 50 => 20 }.freeze
+
+      def palette_size(context)
+        found = []
+        each_of(context, PALETTE_FIXED.keys) do |record, index, type|
+          count = field(record, :entry_count)
+          next if count.nil?
+
+          expected = PALETTE_FIXED.fetch(type) + (4 * count)
+          size = context.record_size(record)
+          next if size == expected
+
+          found << at(record, index, "#{RecordTypes.name(type)} holds #{count} palette entries, so Size MUST be #{expected}, not #{size}")
+        end
+        found
+      end
+
+      def index_zero(context)
+        found = []
+        each_of(context, [37, 40, 48]) do |record, index, type|
+          next unless field(record, REFERENCES.fetch(type))&.zero?
+
+          found << at(record, index, "#{RecordTypes.name(type)} object index 0 is reserved for the metafile itself, MUST NOT be used")
+        end
+        found
+      end
+
+      def delete_stock(context)
+        found = []
+        each_of(context, [40]) do |record, index, _type|
+          handle = field(record, :ih_object)
+          next unless STOCK.include?(handle)
+
+          found << at(record, index, "DELETEOBJECT names the stock object #{hex(handle)}, which cannot be deleted")
+        end
+        found
+      end
+
+      # A stock index is a valid operand of SELECTOBJECT; SELECTPALETTE takes only DEFAULT_PALETTE.
+      def stock_ok?(type, handle)
+        return handle == DEFAULT_PALETTE if type == 48
+
+        type == 37 && STOCK.include?(handle)
+      end
+
+      def handle_range(context)
+        limit = context.header.n_handles.to_i
+        found = []
+        each_of(context, REFERENCES.keys) do |record, index, type|
+          handle = field(record, REFERENCES.fetch(type))
+          next if handle.nil? || handle.zero? || handle < limit || stock_ok?(type, handle)
+          next if type == 40 && STOCK.include?(handle) # emf.object.delete_stock reports it
+
+          found << at(record, index,
+                      "#{RecordTypes.name(type)} names object index #{hex(handle)}, " \
+                      "not below header Handles (#{limit}) and not a stock object")
+        end
+        found
+      end
+
+      # Walks the stream in order, keeping the live handle table.
+      def lifecycle(context)
+        live = {}
+        found = []
+        context.records.each_with_index do |record, index|
+          type = context.record_type(record)
+          name = CREATE[type] || REFERENCES[type]
+          handle = name && field(record, name)
+          next if handle.nil?
+
+          if CREATE.key?(type)
+            live[handle] = index + 1
+          else
+            problem = missing_handle(live, type, handle)
+            found << at(record, index, "#{RecordTypes.name(type)} #{problem}") if problem
+            live.delete(handle) if DELETE.key?(type)
+          end
+        end
+        found
+      end
+
+      def missing_handle(live, _type, handle)
+        return if handle.zero? || handle >= 0x80000000 || live.key?(handle) # zero and stock are other rules' business
+
+        "uses object index #{handle}, which the stream never created or already deleted"
+      end
+    end
+
+    registry = Registry.loading
+    {
+      "emf.object.fixed_size" => [:fixed_size, "MS-EMF 2.3.7", :object_fixed_size, nil],
+      "emf.object.font_size" => [:font_size, "MS-EMF 2.3.7.8", :font_size, ObjectRules::FONT_SHORT],
+      "emf.object.pen_style" => [:pen_style, "MS-EMF 2.1.25", :pen_style, nil],
+      "emf.object.pen_cosmetic_width" => [:cosmetic_width, "MS-EMF 2.2.19", :pen_cosmetic_width, ObjectRules::COSMETIC_WIDTH],
+      "emf.object.brush_style" => [:brush_style, "MS-EMF 2.3.7.1", :brush_style, nil],
+      "emf.object.extpen_brush" => [:extpen_brush, "MS-EMF 2.2.20", :extpen_brush, ObjectRules::PEN_BRUSH],
+      "emf.object.palette_version" => [:palette_version, "MS-EMF 2.3.7.6", :palette_version, nil],
+      "emf.object.palette_entries" => [:palette_entries, "MS-EMF 2.3.8.4", :palette_entries, nil],
+      "emf.object.palette_size" => [:palette_size, "MS-EMF 2.3.7.6", :palette_size, nil],
+      "emf.object.index_zero" => [:index_zero, "MS-EMF 2.3.8.5", :index_zero, nil],
+      "emf.object.delete_stock" => [:delete_stock, "MS-EMF 2.3.8.3", :delete_stock, nil],
+      "emf.object.handle_range" => [:handle_range, "MS-EMF 2.3.8", :handle_range, ObjectRules::HANDLE_RANGE],
+      "emf.object.lifecycle" => [:lifecycle, "MS-EMF 2.3.8", :object_lifecycle, ObjectRules::UNKNOWN_HANDLE]
+    }.each do |id, (method, citation, kind, reason)|
+      registry.register(id: id, formats: ObjectRules::EMF, citation: citation, kind: kind, tolerant_reason: reason) do |context|
+        ObjectRules.public_send(method, context)
+      end
+    end
+  end
+end