emf 0.1.2 → 0.2.0

data/lib/emf/wmf/parser.rb

@@ -5,8 +5,153 @@ module Emf
     module Parser
       module_function
 
-      def call(_bytes)
-        raise Error, "WMF parser not yet implemented — see TODO.impl/07-wmf-wire-domain-parser.md"
+      def call(bytes)
+        ResourceLimits.check!(:input_bytes, Binary::MAX_INPUT_BYTES, bytes.bytesize)
+
+        errors = []
+        placeable, start = read_placeable(bytes, errors)
+        header = read_header(bytes, start, placeable)
+        records = read_records(bytes, start + Binary::HEADER_BYTES, bytes.bytesize, errors)
+        Binary.validate_objects(records, header.number_of_objects,
+                                recovered: Evidence.reference_recovery(bytes, errors)) do |record, message|
+          parse_error(record.offset, record.type_id, message)
+        end
+        # The walk is bounded by the real input and ends at the first EOF record, so a header Size or MaxRecord that
+        # disagrees with the records is recovered, like the shapes of Recovery and the object references that
+        # name nothing usable: the model is kept and each departure is recorded in errors.
+        stop = records.last.offset + (records.last.declared_size_words * 2)
+        Model::Metafile.new(format: :wmf, header: header, records: records,
+                            errors: Evidence.ordered(errors + Evidence.drift_errors(bytes)),
+                            trailing: bytes.byteslice(stop..).to_s)
+      end
+
+      def read_placeable(bytes, errors)
+        return [nil, 0] unless bytes.bytesize >= 4 && bytes.unpack1("V") == Binary::PLACEABLE_KEY
+        raise FormatError, "truncated WMF placeable header" if bytes.bytesize < Binary::PLACEABLE_BYTES
+
+        _key, handle, left, top, right, bottom, inch, reserved, checksum = bytes.unpack("Vvs<4vVv")
+        raise FormatError, "WMF placeable reserved field must be zero" unless reserved.zero?
+
+        errors << Evidence.recovered_error(203, bytes, nil) unless checksum == Binary.checksum(bytes.byteslice(0, 20))
+
+        header = Model::Wmf::PlaceableHeader.new(handle: handle, left: left, top: top, right: right, bottom: bottom,
+                                                 inch: inch, checksum: checksum)
+        [header, Binary::PLACEABLE_BYTES]
+      end
+
+      def read_header(bytes, start, placeable)
+        raise FormatError, "truncated WMF standard header" if bytes.bytesize - start < Binary::HEADER_BYTES
+
+        type, header_size, version, size, objects, max_record, members = bytes.byteslice(start, Binary::HEADER_BYTES).unpack("v3VvVv")
+        raise FormatError, "invalid WMF Type" unless [1, 2].include?(type)
+        raise FormatError, "invalid WMF HeaderSize" unless header_size == 9
+        raise FormatError, "invalid WMF Version" unless [0x100, 0x300].include?(version)
+        raise FormatError, "WMF on-disk placeable handle must be zero" if type == 2 && placeable && !placeable.handle.zero?
+
+        Model::Wmf::Header.new(type: type, version: version, size_words: size, number_of_objects: objects,
+                               max_record_words: max_record, number_of_members: members, placeable: placeable)
+      end
+
+      def read_records(bytes, offset, limit, errors)
+        records = []
+        while offset < limit
+          ResourceLimits.check!(:record_count, Binary::MAX_RECORDS, records.length + 1) do
+            Evidence.build(401, bytes, offset)
+          end
+          parse_error(offset, nil, "truncated record header") if limit - offset < 6
+          words, function = bytes.byteslice(offset, 6).unpack("Vv")
+          parse_error(offset, function, "invalid record length #{words}") if words < 3 || words > (limit - offset) / 2
+          raw = bytes.byteslice(offset, words * 2)
+          record, reason = Recovery.record(raw, function, offset)
+          errors << Evidence.recovered_error(reason, bytes, offset, function) if reason
+          record = (record || decode_record(raw, function, offset)).declare_size(words)
+          records << record
+          offset += raw.bytesize
+          return records if record.is_a?(Model::Wmf::Records::Eof)
+        end
+        parse_error(offset, nil, "missing EOF record")
+      end
+
+      def decode_record(raw, function, offset)
+        return Model::Wmf::Records::Eof.new(offset: offset) if function.zero?
+
+        return decode_prefix_record(raw, function, offset) if Binary::PREFIX_FUNCTIONS.include?(function & 0xFF)
+        return decode_object(raw, function, offset) if Binary::OBJECT_RECORDS.key?(function & 0xFF)
+        if Binary::TEXT_FUNCTIONS.include?(function & 0xFF)
+          return TextCodec.decode(raw, function, offset) { |message| parse_error(offset, function, message) }
+        end
+        return decode_point_array(raw, function, offset) if Binary::POINT_ARRAY_RECORDS.key?(function & 0xFF)
+
+        record_class = Binary::FIXED_RECORDS[function & 0xFF]
+        return Model::Wmf::Records::UnknownRecord.new(type_id: function, raw_bytes: raw, offset: offset) unless record_class
+
+        fields = record_class::WIRE_FIELDS
+        parse_error(offset, function, "invalid fixed record length") unless raw.bytesize == 6 + (fields.length * 2)
+        values = raw.byteslice(6..).unpack("s<*")
+        record_class.new(**fields.zip(values).to_h, type_id: function, offset: offset)
+      end
+
+      def decode_prefix_record(raw, function, offset)
+        return decode_font(raw, function, offset) if function & 0xFF == 0xFB
+        return decode_state(raw, function, offset) if Binary::STATE_RECORDS.key?(function & 0xFF)
+
+        codec = [PaletteCodec, RegionCodec, BrushCodec, BitmapCodec, GeometryCodec, DcEscapeCodec]
+                .find { |candidate| candidate::RECORDS.key?(function & 0xFF) }
+        codec.decode(raw, function, offset) { |message| parse_error(offset, function, message) }
+      end
+
+      def decode_state(raw, function, offset)
+        record_class = Binary::STATE_RECORDS.fetch(function & 0xFF)
+        prefix_size = 6 + record_class::PAYLOAD_BYTES
+        parse_error(offset, function, "invalid state record length") if raw.bytesize < prefix_size
+        values = raw.byteslice(6, record_class::PAYLOAD_BYTES).unpack(record_class::WIRE_FORMAT)
+        fields = record_class::WIRE_FIELDS.zip(values).to_h
+        record_class.new(**fields, type_id: function, offset: offset, suffix: raw.byteslice(prefix_size..))
+      end
+
+      def decode_font(raw, function, offset)
+        record_class = Model::Wmf::Records::CreateFontIndirect
+        prefix_size = 6 + record_class::PAYLOAD_BYTES
+        parse_error(offset, function, "invalid font record length") if raw.bytesize < prefix_size
+        values = raw.byteslice(6, record_class::PAYLOAD_BYTES).unpack(record_class::WIRE_FORMAT)
+        fields = record_class::WIRE_FIELDS.zip(values).to_h
+        record_class.new(**fields, type_id: function, offset: offset, suffix: raw.byteslice(prefix_size..))
+      end
+
+      def decode_object(raw, function, offset)
+        record_class = Binary::OBJECT_RECORDS.fetch(function & 0xFF)
+        parse_error(offset, function, "invalid object record length") unless raw.bytesize == 6 + record_class::PAYLOAD_BYTES
+        values = raw.byteslice(6..).unpack(record_class::WIRE_FORMAT)
+        record_class.new(**record_class::WIRE_FIELDS.zip(values).to_h, type_id: function, offset: offset)
+      end
+
+      def decode_point_array(raw, function, offset)
+        parse_error(offset, function, "missing point array count") if raw.bytesize < 8
+        record_class = Binary::POINT_ARRAY_RECORDS.fetch(function & 0xFF)
+        if record_class == Model::Wmf::Records::PolyPolygon
+          polygon_count = raw.byteslice(6, 2).unpack1("v")
+          points_start = 8 + (polygon_count * 2)
+          parse_error(offset, function, "truncated polygon counts") if raw.bytesize < points_start
+          counts = raw.byteslice(8, polygon_count * 2).unpack("v*")
+          point_count = counts.sum
+        else
+          point_count = raw.byteslice(6, 2).unpack1("s<")
+          minimum = record_class == Model::Wmf::Records::Polygon ? 2 : 0
+          parse_error(offset, function, "invalid point count") if point_count < minimum
+          points_start = 8
+        end
+        parse_error(offset, function, "point array length mismatch") unless raw.bytesize == points_start + (point_count * 4)
+
+        points = raw.byteslice(points_start..).unpack("s<*").each_slice(2).map do |x, y|
+          Model::Wmf::Records::PointS.new(x: x, y: y)
+        end
+        fields = { points: points, type_id: function, offset: offset }
+        fields[:points_per_polygon] = counts if counts
+        record_class.new(**fields)
+      end
+
+      def parse_error(offset, function, message)
+        raise ParseError.new(offset: offset, record_code: function, message: "WMF #{message} at offset #{offset}")
       end
     end
   end

data/lib/emf/wmf/recovery.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Emf
+  module Wmf
+    # Record shapes the specification rules out but real producers write and readers (LibreOffice) import. Each is
+    # framed by its own declared RecordSize inside the input, so the record is kept and the departure is recorded in
+    # Metafile#errors instead of raising. Both backends call .record on the same raw record bytes, so the models
+    # are identical. Anything not listed here, and any shape that cannot be framed safely, is left to the strict
+    # decoders, which reject it.
+    #
+    #   406  an EOF record longer than three words: it still ends the stream; the surplus is ignored
+    #   801  an object record (pen, brush, select, delete) with bytes after its payload: the payload is read, the
+    #        surplus is ignored; a shorter record is still rejected
+    #   701  a font record shorter than 32 face-name bytes but holding the 18 fixed bytes: the face name is
+    #        zero-padded; a record without the fixed bytes is still rejected
+    #   1003 a text record with a negative StringLength: no string can be framed, so the record is kept verbatim
+    #        as an UnknownRecord; a truncated text record or rectangle is still rejected first
+    #   903  a META_POLYGON with NumberOfPoints 0 and no point bytes (PowerPoint, seen in Apache POI's
+    #        empty-polygon-close.wmf): kept as a Polygon without points; 1 and negative counts are still rejected
+    #   1203 a META_CREATEREGION whose ObjectCount is two bytes wide (libUEMF, the library Inkscape writes WMF with,
+    #        declares it uint16, so every later field sits two bytes early) and whose RegionSize, read there, is exactly
+    #        the body: the region is kept verbatim as an UnknownRecord (it still takes its object-table slot, from the
+    #        low byte of its function); any other invalid header is still rejected
+    module Recovery
+      EOF_BYTES = 6
+      FONT_FIXED_BYTES = 18
+      # function => [offset of StringLength, shortest record]
+      TEXT_COUNTS = { 0x21 => [6, 12], 0x32 => [10, 14] }.freeze
+      CLIP_OR_OPAQUE = 6
+      RECTANGLE_BYTES = 8
+      POLYGON = 0x24
+      REGION = 0xFF
+      POLYGON_EMPTY_BYTES = 8
+
+      module_function
+
+      # [record, reason] when `raw` (one whole record) is a recoverable shape, otherwise nil.
+      def record(raw, function, offset)
+        low = function & 0xFF
+        return [Model::Wmf::Records::Eof.new(offset: offset), 406] if function.zero? && raw.bytesize > EOF_BYTES
+        return object(raw, function, offset) if Binary::OBJECT_RECORDS.key?(low)
+        return font(raw, function, offset) if low == 0xFB
+        return polygon(raw, function, offset) if low == POLYGON
+        return region(raw, function, offset) if low == REGION
+
+        text(raw, function, offset) if TEXT_COUNTS.key?(low)
+      end
+
+      def object(raw, function, offset)
+        klass = Binary::OBJECT_RECORDS.fetch(function & 0xFF)
+        return unless raw.bytesize > 6 + klass::PAYLOAD_BYTES
+
+        values = raw.byteslice(6, klass::PAYLOAD_BYTES).unpack(klass::WIRE_FORMAT)
+        [klass.new(**klass::WIRE_FIELDS.zip(values).to_h, type_id: function, offset: offset), 801]
+      end
+
+      def font(raw, function, offset)
+        klass = Model::Wmf::Records::CreateFontIndirect
+        return unless raw.bytesize.between?(6 + FONT_FIXED_BYTES, 6 + klass::PAYLOAD_BYTES - 1)
+
+        values = raw.byteslice(6..).ljust(klass::PAYLOAD_BYTES, "\0".b).unpack(klass::WIRE_FORMAT)
+        [klass.new(**klass::WIRE_FIELDS.zip(values).to_h, type_id: function, offset: offset), 701]
+      end
+
+      def polygon(raw, function, offset)
+        return unless raw.bytesize == POLYGON_EMPTY_BYTES && raw.byteslice(6, 2).unpack1("s<").zero?
+
+        [Model::Wmf::Records::Polygon.new(points: [], type_id: function, offset: offset), 903]
+      end
+
+      def region(raw, function, offset)
+        body = raw.byteslice(6..)
+        return unless body.bytesize >= RegionCodec::HEADER_BYTES && RegionCodec.header_invalid?(body)
+
+        kind, size, count = body.unpack("@2v@6s<@8s<")
+        return unless kind == RegionCodec::KIND && size == body.bytesize && !count.negative?
+
+        [Model::Wmf::Records::UnknownRecord.new(type_id: function, raw_bytes: raw, offset: offset), 1203]
+      end
+
+      def text(raw, function, offset)
+        count_at, minimum = TEXT_COUNTS.fetch(function & 0xFF)
+        return if raw.bytesize < minimum
+        return if function & 0xFF == 0x32 && rectangle_truncated?(raw, minimum)
+        return unless raw.byteslice(count_at, 2).unpack1("s<").negative?
+
+        [Model::Wmf::Records::UnknownRecord.new(type_id: function, raw_bytes: raw, offset: offset), 1003]
+      end
+
+      def rectangle_truncated?(raw, minimum)
+        raw.byteslice(12, 2).unpack1("v").anybits?(CLIP_OR_OPAQUE) && raw.bytesize < minimum + RECTANGLE_BYTES
+      end
+    end
+  end
+end

data/lib/emf/wmf/region_codec.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Emf
+  module Wmf
+    module RegionCodec
+      RECORDS = {
+        0xFF => Model::Wmf::Records::CreateRegion,
+        0x28 => Model::Wmf::Records::FillRegion,
+        0x29 => Model::Wmf::Records::FrameRegion,
+        0x2A => Model::Wmf::Records::InvertRegion,
+        0x2B => Model::Wmf::Records::PaintRegion,
+        0x2C => Model::Wmf::Records::SelectClipRegion,
+        0x20 => Model::Wmf::Records::OffsetClipRgn,
+        0x15 => Model::Wmf::Records::ExcludeClipRect,
+        0x16 => Model::Wmf::Records::IntersectClipRect
+      }.freeze
+      FUNCTIONS = RECORDS.invert.freeze
+      HEADER_BYTES = 22
+      KIND = 6
+      BOUNDS_FIELDS = %i[left top right bottom].freeze
+
+      module_function
+
+      def decode(raw, function, offset, &)
+        klass = RECORDS.fetch(function & 0xFF)
+        if klass == Model::Wmf::Records::CreateRegion
+          fields, size = decode_region(raw.byteslice(6..), &)
+        else
+          size = klass::WIRE_FIELDS.length * 2
+          yield "truncated region/clipping prefix" if raw.bytesize < 6 + size
+          fields = klass::WIRE_FIELDS.zip(raw.byteslice(6, size).unpack(klass::WIRE_FORMAT)).to_h
+        end
+        klass.new(**fields, type_id: function, offset: offset, suffix: raw.byteslice((6 + size)..))
+      end
+
+      def decode_region(body, &)
+        yield "truncated region header" if body.bytesize < HEADER_BYTES
+        next_in_chain, _kind, object_count, size, count, max_scan, *bounds = body.unpack("v2Vs<7")
+        yield "invalid region header" if header_invalid?(body)
+        preflight_scans(body, size, count, max_scan, &)
+        cursor = 22
+        scans = Array.new(count) do
+          points, top, bottom = body.byteslice(cursor, 6).unpack("v3")
+          lines = body.byteslice(cursor + 6, points * 2).unpack("v*").each_slice(2).map do |left, right|
+            Model::Wmf::Records::RegionScanLine.new(left: left, right: right)
+          end
+          cursor += 8 + (points * 2)
+          Model::Wmf::Records::RegionScan.new(top: top, bottom: bottom, lines: lines)
+        end
+        [{ next_in_chain: next_in_chain, object_count: object_count,
+           bounds: Model::Wmf::Records::RegionBounds.new(**BOUNDS_FIELDS.zip(bounds).to_h), scans: scans }, size]
+      end
+
+      def header_fields(body)
+        body.unpack("@2v@8s<s<")
+      end
+
+      # The spec's header checks, shared with Wmf::Recovery so a recovered shape is exactly one this rejects.
+      def header_invalid?(body)
+        kind, size, count = header_fields(body)
+        max_scan = body.unpack1("@12s<")
+        kind != KIND || size < HEADER_BYTES || size > body.bytesize || count.negative? || max_scan.negative? ||
+          count > (size - HEADER_BYTES) / 8
+      end
+
+      def preflight_scans(body, size, count, max_scan)
+        cursor = 22
+        observed_max = 0
+        count.times do
+          yield "truncated region scan" if size - cursor < 8
+          points = body.byteslice(cursor, 2).unpack1("v")
+          scan_size = 8 + (points * 2)
+          if points.odd? || scan_size > size - cursor || body.byteslice(cursor + scan_size - 2, 2).unpack1("v") != points
+            yield "invalid region scan"
+          end
+          observed_max = [observed_max, points].max
+          cursor += scan_size
+        end
+        yield "invalid region scan size or maximum" unless cursor == size && observed_max == max_scan
+      end
+
+      def byte_size(record)
+        size = if record.is_a?(Model::Wmf::Records::CreateRegion)
+                 22 + record.scans.sum { |scan| 8 + (scan.lines.length * 4) }
+               else
+                 record.class::WIRE_FIELDS.length * 2
+               end
+        6 + size + record.suffix.bytesize
+      end
+
+      def encode(record)
+        function = Binary.uint16(record.type_id, "RecordFunction")
+        raise SerializeError, "WMF region RecordFunction mismatch" unless function & 0xFF == FUNCTIONS[record.class]
+        unless record.suffix.is_a?(String) && record.suffix.bytesize.even?
+          raise SerializeError, "WMF region suffix must be a String with even length"
+        end
+
+        payload = encode_payload(record) + record.suffix.b
+        [3 + (payload.bytesize / 2), function].pack("Vv") + payload
+      end
+
+      def encode_payload(record)
+        return encode_region(record) if record.is_a?(Model::Wmf::Records::CreateRegion)
+
+        values = record.class::WIRE_FIELDS.zip(record.class::WIRE_TYPES).map do |field, type|
+          Binary.public_send(type, record.public_send(field), field)
+        end
+        values.pack(record.class::WIRE_FORMAT)
+      end
+
+      def encode_region(record)
+        unless record.bounds.is_a?(Model::Wmf::Records::RegionBounds) && record.scans.is_a?(Array)
+          raise SerializeError, "WMF region requires RegionBounds and an array of scans"
+        end
+
+        count = Binary.integer(record.scans.length, 0..0x7FFF, "scan count")
+        size, max_scan = region_layout(record.scans)
+        bounds = BOUNDS_FIELDS.map { |field| Binary.int16(record.bounds.public_send(field), field) }
+        header = [Binary.uint16(record.next_in_chain, "next_in_chain"), 6, Binary.uint32(record.object_count, "object_count"),
+                  size, count, max_scan, *bounds].pack("v2Vs<7")
+        header + record.scans.map { |scan| encode_scan(scan) }.join
+      end
+
+      def region_layout(scans)
+        size = 22
+        max_scan = 0
+        scans.each do |scan|
+          unless scan.is_a?(Model::Wmf::Records::RegionScan) && scan.lines.is_a?(Array)
+            raise SerializeError, "WMF region scan requires RegionScan with an array of lines"
+          end
+
+          points = Binary.integer(scan.lines.length * 2, 0..0x7FFF, "scan point count")
+          size = Binary.integer(size + 8 + (points * 2), 22..0x7FFF, "region size")
+          max_scan = [max_scan, points].max
+        end
+        [size, max_scan]
+      end
+
+      def encode_scan(scan)
+        points = scan.lines.length * 2
+        prefix = [points, Binary.uint16(scan.top, "scan top"), Binary.uint16(scan.bottom, "scan bottom")].pack("v3")
+        lines = scan.lines.map do |line|
+          raise SerializeError, "WMF region line must be a RegionScanLine" unless line.is_a?(Model::Wmf::Records::RegionScanLine)
+
+          [Binary.uint16(line.left, "scan left"), Binary.uint16(line.right, "scan right")].pack("v2")
+        end
+        prefix + lines.join + [points].pack("v")
+      end
+    end
+  end
+end

data/lib/emf/wmf/serializer.rb

@@ -5,8 +5,170 @@ module Emf
     module Serializer
       module_function
 
-      def call(_metafile)
-        raise SerializeError, "WMF serializer not yet implemented — see TODO.impl/07-wmf-wire-domain-parser.md"
+      def call(metafile)
+        raise SerializeError, "expected a WMF metafile" unless metafile.format == :wmf && metafile.header.is_a?(Model::Wmf::Header)
+        raise SerializeError, "WMF record limit exceeded" if metafile.records.length > Binary::MAX_RECORDS
+
+        validate_eof(metafile.records)
+        records = metafile.records.map { |record| serialize_record(record) }
+        capacity = Binary.uint16(metafile.header.number_of_objects, "NumberOfObjects")
+        Binary.validate_objects(metafile.records, capacity) do |_record, message|
+          raise SerializeError, "WMF #{message}"
+        end
+        size = 9 + records.sum { |bytes| bytes.bytesize / 2 }
+        raise SerializeError, "WMF input too large" if (size * 2) + metafile.trailing.bytesize > Binary::MAX_INPUT_BYTES
+
+        header = serialize_header(metafile.header, size, records.map { |bytes| bytes.bytesize / 2 }.max)
+        placeable = serialize_placeable(metafile.header)
+        bytes = placeable + header + records.join + metafile.trailing
+        raise SerializeError, "WMF input too large" if bytes.bytesize > Binary::MAX_INPUT_BYTES
+
+        bytes
+      end
+
+      def validate_eof(records)
+        return if records.last.is_a?(Model::Wmf::Records::Eof) && records.one?(Model::Wmf::Records::Eof)
+
+        raise SerializeError, "WMF requires one final EOF record"
+      end
+
+      def serialize_header(header, size, max_record)
+        raise SerializeError, "invalid WMF Type" unless [1, 2].include?(header.type)
+        raise SerializeError, "invalid WMF Version" unless [0x100, 0x300].include?(header.version)
+
+        [header.type, 9, header.version, size, Binary.uint16(header.number_of_objects, "NumberOfObjects"),
+         max_record, Binary.uint16(header.number_of_members, "NumberOfMembers")].pack("v3VvVv")
+      end
+
+      def serialize_placeable(header)
+        placeable = header.placeable
+        return "".b unless placeable
+        raise SerializeError, "WMF on-disk placeable handle must be zero" if header.type == 2 && !placeable.handle.zero?
+
+        bytes = [Binary::PLACEABLE_KEY, Binary.uint16(placeable.handle, "handle"),
+                 Binary.int16(placeable.left, "left"), Binary.int16(placeable.top, "top"),
+                 Binary.int16(placeable.right, "right"), Binary.int16(placeable.bottom, "bottom"),
+                 Binary.uint16(placeable.inch, "inch"), 0].pack("Vvs<4vV")
+        bytes + [Binary.checksum(bytes)].pack("v")
+      end
+
+      def serialize_record(record)
+        codec = Binary.prefix_codec(record)
+        return codec.encode(record) if codec
+
+        case record
+        when Model::Wmf::Records::Eof then [3, 0].pack("Vv")
+        when Model::Wmf::Records::PointRecord, Model::Wmf::Records::RectangleRecord, Model::Wmf::Records::OffsetRecord
+          serialize_fixed(record)
+        when Model::Wmf::Records::StateRecord then serialize_state(record)
+        when Model::Wmf::Records::CreateFontIndirect then serialize_font(record)
+        when Model::Wmf::Records::ObjectRecord then serialize_object(record)
+        when Model::Wmf::Records::TextOut then TextCodec.encode(record)
+        when Model::Wmf::Records::PointArrayRecord then serialize_point_array(record)
+        when Model::Wmf::Records::UnknownRecord then serialize_unknown(record)
+        else raise SerializeError, "unsupported WMF record #{record.class}"
+        end
+      end
+
+      def serialize_fixed(record)
+        function = Binary.uint16(record.type_id, "RecordFunction")
+        expected = Binary::FIXED_FUNCTIONS[record.class]
+        raise SerializeError, "WMF fixed RecordFunction mismatch" unless function & 0xFF == expected
+
+        values = record.class::WIRE_FIELDS.map { |field| Binary.int16(record.public_send(field), field) }
+        [3 + values.length, function, *values].pack("Vvs<*")
+      end
+
+      def serialize_state(record)
+        function = Binary.uint16(record.type_id, "RecordFunction")
+        expected = Binary::STATE_FUNCTIONS[record.class]
+        raise SerializeError, "WMF state RecordFunction mismatch" unless function & 0xFF == expected
+        unless record.suffix.is_a?(String) && record.suffix.bytesize.even?
+          raise SerializeError, "WMF state suffix must be a String with even length"
+        end
+
+        values = record.class::WIRE_FIELDS.zip(record.class::WIRE_TYPES).map do |field, type|
+          Binary.public_send(type, record.public_send(field), field)
+        end
+        payload = values.pack(record.class::WIRE_FORMAT) + record.suffix.b
+        [3 + (payload.bytesize / 2), function].pack("Vv") + payload
+      end
+
+      def serialize_font(record)
+        function = Binary.uint16(record.type_id, "RecordFunction")
+        raise SerializeError, "WMF font RecordFunction mismatch" unless function & 0xFF == 0xFB
+        unless record.face_name.is_a?(String) && record.face_name.bytesize == 32
+          raise SerializeError, "WMF font face_name must be a String with 32 bytes"
+        end
+        unless record.suffix.is_a?(String) && record.suffix.bytesize.even?
+          raise SerializeError, "WMF font suffix must be a String with even length"
+        end
+
+        values = record.class::SIGNED_FIELDS.map { |field| Binary.int16(record.public_send(field), field) }
+        values += record.class::BYTE_FIELDS.map { |field| Binary.uint8(record.public_send(field), field) }
+        payload = [*values, record.face_name.b].pack(record.class::WIRE_FORMAT) + record.suffix.b
+        [3 + (payload.bytesize / 2), function].pack("Vv") + payload
+      end
+
+      def serialize_object(record)
+        function = Binary.uint16(record.type_id, "RecordFunction")
+        expected = Binary::OBJECT_FUNCTIONS[record.class]
+        raise SerializeError, "WMF object RecordFunction mismatch" unless function & 0xFF == expected
+
+        values = record.class::WIRE_FIELDS.zip(record.class::WIRE_TYPES).map do |field, type|
+          Binary.public_send(type, record.public_send(field), field)
+        end
+        payload = values.pack(record.class::WIRE_FORMAT)
+        [3 + (payload.bytesize / 2), function].pack("Vv") + payload
+      end
+
+      def serialize_point_array(record)
+        function = Binary.uint16(record.type_id, "RecordFunction")
+        expected = Binary::POINT_ARRAY_FUNCTIONS[record.class]
+        raise SerializeError, "WMF point array RecordFunction mismatch" unless function & 0xFF == expected
+        raise SerializeError, "WMF points must be an array" unless record.points.is_a?(Array)
+
+        counts = serialize_point_counts(record)
+        coordinates = record.points.flat_map do |point|
+          raise SerializeError, "WMF point must be a PointS" unless point.is_a?(Model::Wmf::Records::PointS)
+
+          [Binary.int16(point.x, "x"), Binary.int16(point.y, "y")]
+        end
+        payload = counts + coordinates.pack("s<*")
+        [3 + (payload.bytesize / 2), function].pack("Vv") + payload
+      end
+
+      def serialize_point_counts(record)
+        unless record.is_a?(Model::Wmf::Records::PolyPolygon)
+          count = Binary.int16(record.points.length, "NumberOfPoints")
+          raise SerializeError, "WMF Polygon requires at least two points" if record.is_a?(Model::Wmf::Records::Polygon) && count < 2
+
+          return [count].pack("s<")
+        end
+        counts = record.points_per_polygon
+        raise SerializeError, "WMF polygon counts must be an array" unless counts.is_a?(Array)
+
+        polygon_count = Binary.uint16(counts.length, "NumberOfPolygons")
+        counts.each { |count| Binary.uint16(count, "PointsPerPolygon") }
+        raise SerializeError, "WMF polygon point count mismatch" unless counts.sum == record.points.length
+
+        [polygon_count, *counts].pack("v*")
+      end
+
+      # A text record with a negative StringLength, which the parser keeps verbatim (Recovery).
+      def kept_verbatim?(raw, function)
+        Recovery.record(raw, function, nil)&.last == 1003
+      end
+
+      def serialize_unknown(record)
+        raw = record.raw_bytes
+        words, function = raw.unpack("Vv")
+        unless raw.bytesize >= 6 && raw.bytesize.even? && words == raw.bytesize / 2 && function == record.type_id &&
+               !function.zero? && (!Binary::TYPED_FUNCTIONS.include?(function & 0xFF) || kept_verbatim?(raw, function))
+          raise SerializeError, "invalid raw WMF record"
+        end
+
+        raw
       end
     end
   end