bynn-decisionnode 0.4.1

data/lib/decisionnode/document.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "digest"
+
+class DecisionNode
+  # A document for a knowledge base (a collection of type "text"): the
+  # content of one item.
+  #
+  #   DecisionNode::Document.new(text: "# Receipts\n\nReject any claim ...")      # Markdown inline
+  #   DecisionNode::Document.new(text: "Plain words.", format: "text")
+  #   DecisionNode::Document.new(path: "claims-policy-2026.pdf")
+  #   DecisionNode::Document.new(data: docx_bytes, filename: "rules.docx")
+  #   DecisionNode::Document.new(io: $stdin, content_type: "text/markdown")
+  #   DecisionNode::Document.new(upload_id: "upl_...")                           # from #upload_documents
+  #
+  # A text is sent inline, whatever its size. A file (a path, bytes or an IO)
+  # is read when the call is made: a text or Markdown file whose bytes total
+  # under the client's inline threshold and are UTF-8 without a NUL is sent
+  # inline as its text; every other file is uploaded first and named by its
+  # upload id. An IO is read to its end once, into memory, before anything is
+  # sent.
+  #
+  # content_type:: one of CONTENT_TYPES. Left out, it comes from the file
+  #                name's extension, else from the first bytes (PDF, PNG, JPEG,
+  #                TIFF, WebP). DOCX, PPTX, XLSX and text cannot be told from
+  #                their bytes: they need content_type or a file name.
+  # filename::     a path's base name unless given; optional for bytes and IOs.
+  #                Its stem is the item's title when none is given.
+  class Document
+    # The types a knowledge file may have, in the API's order.
+    CONTENT_TYPES = %w[
+      text/plain text/markdown application/pdf
+      application/vnd.openxmlformats-officedocument.wordprocessingml.document
+      application/vnd.openxmlformats-officedocument.presentationml.presentation
+      application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+      text/html image/png image/jpeg image/tiff image/webp
+    ].freeze
+
+    # The most bytes a knowledge file may have (50 MB).
+    MAX_BYTES = 52_428_800
+
+    FORMATS = %w[markdown text].freeze
+
+    EXTENSIONS = {
+      ".txt" => "text/plain", ".md" => "text/markdown", ".markdown" => "text/markdown",
+      ".pdf" => "application/pdf",
+      ".docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".pptx" => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      ".xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".html" => "text/html", ".htm" => "text/html", ".png" => "image/png", ".jpg" => "image/jpeg",
+      ".jpeg" => "image/jpeg", ".tif" => "image/tiff", ".tiff" => "image/tiff", ".webp" => "image/webp"
+    }.freeze
+    private_constant :EXTENSIONS
+
+    # What a call sends for a document, once its bytes are read: `kind` :text
+    # (inline), :file (to upload) or :upload (an upload id given).
+    Loaded = Struct.new(:kind, :text, :format, :data, :content_type, :filename, :upload_id) do
+      def md5
+        Digest::MD5.digest(data)
+      end
+
+      def sha256
+        Digest::SHA256.digest(data)
+      end
+    end
+
+    attr_reader :text, :format, :path, :data, :io, :content_type, :filename, :upload_id
+
+    def initialize(text: nil, format: nil, path: nil, data: nil, io: nil, upload_id: nil, content_type: nil,
+                   filename: nil)
+      sources = [text, path, data, io, upload_id].compact.size
+      raise ArgumentError, "give exactly one of text:, path:, data:, io: or upload_id:" unless sources == 1
+      raise ArgumentError, "text: must be a String" unless text.nil? || text.is_a?(String)
+      raise ArgumentError, "data: must be a String of bytes" unless data.nil? || data.is_a?(String)
+      raise ArgumentError, "io: must respond to read" unless io.nil? || io.respond_to?(:read)
+      raise ArgumentError, "format: goes with text:; a file's format comes from its type" unless format.nil? || !text.nil?
+      if text || upload_id
+        raise ArgumentError, "content_type: and filename: go with a file" unless content_type.nil? && filename.nil?
+      end
+
+      @text = text
+      @format = format.is_a?(Symbol) ? format.to_s : format
+      @path = path&.to_s
+      @data = data
+      @io = io
+      @upload_id = upload_id&.to_s
+      @content_type = content_type.nil? || content_type.to_s.empty? ? nil : content_type.to_s
+      @filename = filename.nil? ? @path && File.basename(@path) : filename.to_s
+    end
+
+    def inspect
+      what = if @text then "text"
+             elsif @upload_id then "upload_id=#{@upload_id}"
+             else "file#{@filename ? " #{@filename.inspect}" : ''}"
+             end
+      "#<#{self.class.name} #{what}>"
+    end
+
+    # True for a text given in memory.
+    def text?
+      !@text.nil?
+    end
+
+    # True for a file (a path, bytes or an IO).
+    def file?
+      @text.nil? && @upload_id.nil?
+    end
+
+    # The file's bytes and type, read now, checked as the presign checks them
+    # (`index` is the file's place in it). A text and an upload id come back
+    # as they are.
+    def load(index = 0)
+      return Loaded.new(:text, @text, @format) if @text
+      return Loaded.new(:upload, nil, nil, nil, nil, nil, @upload_id) if @upload_id
+
+      bytes = read_bytes
+      type = @content_type || self.class.type_of(@filename, bytes)
+      if type.nil?
+        raise ArgumentError, "the document's type cannot be told from its name or its first bytes: give content_type: or filename:"
+      end
+      unless CONTENT_TYPES.include?(type)
+        usage("files[#{index}].content_type: must be one of #{CONTENT_TYPES.join(', ')}, got #{type}.")
+      end
+      usage("files[#{index}].byte_size: must be an integer from 1 to #{MAX_BYTES}.") if bytes.empty?
+      if bytes.bytesize > MAX_BYTES
+        usage("files[#{index}].byte_size: #{bytes.bytesize} is over the limit of #{MAX_BYTES} bytes.")
+      end
+
+      Loaded.new(:file, nil, nil, bytes.b.freeze, type, @filename)
+    end
+
+    # The type of a file: from its name's extension, else from its first bytes;
+    # nil when neither tells.
+    def self.type_of(filename, bytes)
+      ext = filename && File.extname(filename).downcase
+      return EXTENSIONS[ext] if ext && EXTENSIONS.key?(ext)
+
+      head = bytes.byteslice(0, 12).b
+      if head.start_with?("%PDF-") then "application/pdf"
+      elsif head.start_with?("\x89PNG\r\n\x1A\n".b) then "image/png"
+      elsif head.start_with?("\xFF\xD8\xFF".b) then "image/jpeg"
+      elsif head.start_with?("II*\0".b, "MM\0*".b) then "image/tiff"
+      elsif head.start_with?("RIFF") && head.byteslice(8, 4) == "WEBP" then "image/webp"
+      end
+    end
+
+    # The stem of a file name: the name without its last extension.
+    def self.stem(filename)
+      base = File.basename(filename.to_s)
+      ext = File.extname(base)
+      ext.empty? ? base : base.delete_suffix(ext)
+    end
+
+    private
+
+    # The file's bytes; a path or an IO is read to its end, or to one byte
+    # past the limit, which the size check then refuses.
+    def read_bytes
+      return @data if @data
+      return read_io(@io) if @io
+
+      File.open(@path, "rb") { |f| read_io(f) }
+    rescue SystemCallError, IOError => e
+      raise ArgumentError, "cannot read #{@path}: #{e.message}"
+    end
+
+    def read_io(io)
+      out = +"".b
+      while out.bytesize <= MAX_BYTES && (chunk = io.read([1 << 20, MAX_BYTES + 1 - out.bytesize].min))
+        out << chunk.b
+      end
+      out
+    end
+
+    def usage(message)
+      raise BadRequestError.new(message, error_type: "api_usage_error")
+    end
+  end
+end

data/lib/decisionnode/errors.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+class DecisionNode
+  # The base of every error this gem raises, and the class of an error for a
+  # status no subclass covers (a 3xx, 405, 409, or 408 once its retries are spent).
+  #
+  # The error's own `message` is the server's message (`detail.message`, or
+  # `detail` when it is a string), or the client's description when there was
+  # no response. It is an empty string when the server sent none. `reason` is
+  # the server's explanation in words, from the `x-decisionnode-error` header.
+  # `boosters` is the `x-decisionnode-boosters` header of a request that
+  # named boosters, as booster name to BoosterStatus in the request's order
+  # (an empty Hash when there is none), so a caller can see which required
+  # booster failed. `details` is the error body's `detail.details` when it is
+  # an object (an enrollment's 529 says why in its `reason`), else nil. The
+  # report Ruby prints for an uncaught error adds the class, status and
+  # reason.
+  class DecisionNodeError < StandardError
+    include DecisionResult
+
+    attr_reader :status, :error_type, :request_id, :reason, :body, :headers, :boosters, :details
+
+    def initialize(message = nil, status: nil, error_type: nil, request_id: nil, reason: nil, body: nil, headers: nil)
+      @status = status
+      @error_type = error_type
+      @request_id = request_id
+      @reason = reason
+      @body = body
+      @headers = headers || {}
+      @boosters = BoosterStatus.parse(@headers["x-decisionnode-boosters"])
+      detail = body.is_a?(Hash) ? body["detail"] : nil
+      details = detail.is_a?(Hash) ? detail["details"] : nil
+      @details = details.is_a?(Hash) ? details : nil
+      super(message.nil? ? "" : message.to_s)
+    end
+
+    def detailed_message(highlight: false, **)
+      parts = []
+      parts << message unless message.empty?
+      parts << "HTTP #{status}" if status
+      parts << "error_type: #{error_type}" if error_type
+      parts << "reason: #{reason}" if reason
+      parts << "request_id: #{request_id}" if request_id
+      "#{parts.empty? ? 'DecisionNode error' : parts.join('; ')} (#{self.class.name})"
+    end
+  end
+
+  # 400: the request is malformed or breaks a limit of the model. Also raised
+  # before any request when the SDK finds a fault the API would answer with a
+  # 400 (an image, an option or level count): such an error has no status and
+  # no request id.
+  class BadRequestError < DecisionNodeError; end
+
+  # 400 with `error_type` `max_tokens_exceeded`: the input is too long for the model.
+  class ContextLimitError < BadRequestError; end
+
+  # 401: the API key is missing or not valid.
+  class AuthenticationError < DecisionNodeError; end
+
+  # 402: the account has no credit left.
+  class InsufficientCreditError < DecisionNodeError; end
+
+  # 403 that is not a refusal: the workspace may not do this, for example use
+  # a booster turned off for it (`booster_not_enabled`), or it is suspended.
+  # `error_type` tells them apart.
+  class PermissionDeniedError < DecisionNodeError; end
+
+  # 403 with `error_type` `refusal_error`: the request was refused under the usage policy.
+  class RefusalError < DecisionNodeError
+    # "harm" or "self_harm".
+    attr_reader :category
+    # The parsed `x-decisionnode-safety` header, a Safety or nil.
+    attr_reader :safety
+
+    def initialize(message = nil, category: nil, safety: nil, **kw)
+      @category = category
+      @safety = safety
+      super(message, **kw)
+    end
+  end
+
+  # 404: the path or resource does not exist.
+  class NotFoundError < DecisionNodeError; end
+
+  # 413: the request body is over the API's limit of 26,214,400 bytes (25
+  # MiB). Never retried. Also raised before any request when the encoded body
+  # would be over it: such an error has no status and no request id.
+  class RequestTooLargeError < DecisionNodeError; end
+
+  # 422: the request body does not match the schema. Also raised before any
+  # request for a number grid the API would refuse, or a score with no levels.
+  class ValidationError < DecisionNodeError
+    # The server's list of validation entries.
+    attr_reader :entries
+
+    def initialize(message = nil, entries: nil, **kw)
+      @entries = entries
+      super(message, **kw)
+    end
+  end
+
+  # 429: too many requests.
+  class RateLimitError < DecisionNodeError
+    # Seconds to wait before trying again, or nil.
+    attr_reader :retry_after
+
+    def initialize(message = nil, retry_after: nil, **kw)
+      @retry_after = retry_after
+      super(message, **kw)
+    end
+  end
+
+  # 429 with `error_type` `session_limit_exceeded`: the key already holds as
+  # many open sessions as it may. Never retried.
+  class SessionLimitError < RateLimitError; end
+
+  # 529: the service is overloaded, or (`error_type` `booster_unavailable`) a
+  # booster the request required failed or did not answer in time. Retried
+  # like every 529.
+  class OverloadedError < DecisionNodeError
+    # Seconds to wait before trying again, or nil.
+    attr_reader :retry_after
+
+    def initialize(message = nil, retry_after: nil, **kw)
+      @retry_after = retry_after
+      super(message, **kw)
+    end
+  end
+
+  # Any other 5xx, or a successful status with a body that is not JSON.
+  class ServerError < DecisionNodeError; end
+
+  # No response: the connection failed or was dropped.
+  class ConnectionError < DecisionNodeError; end
+
+  # No response within the timeout.
+  class TimeoutError < DecisionNodeError; end
+end

data/lib/decisionnode/image.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "digest"
+
+class DecisionNode
+  # Local images whose bytes total less than this go inline as base64 `data`;
+  # at or above it they are uploaded once and sent by `upload_id`. Counted over
+  # all the local images of one request, one session frame or one batch line.
+  # The client's `inline_threshold:` option overrides it.
+  DEFAULT_INLINE_THRESHOLD = 524_288
+
+  # An image sent with a decision.
+  #
+  #   DecisionNode::Image.new("scan", url: "https://example.com/scan.webp")   # recommended
+  #   DecisionNode::Image.new("receipt", path: "receipt.png")
+  #   DecisionNode::Image.new("photo", data: jpeg_bytes)
+  #   DecisionNode::Image.new("photo", data: File.open("photo.jpg", "rb"))
+  #   DecisionNode::Image.new("photo", base64: "/9j/4AAQ...")
+  #   DecisionNode::Image.new("receipt", upload_id: "upl_...")
+  #
+  # A URL is sent as it is and fetched by the API, so nothing is uploaded: the
+  # fastest form. A file, an IO, bytes or base64 text are read here, when the
+  # Image is made; `data:` also takes base64 text and decodes it when the text
+  # is not already image bytes. The bytes are checked locally before any
+  # request (format from the magic bytes, at most 10,485,760 bytes, at most
+  # 40,000,000 pixels read from the header), then sent inline or uploaded by
+  # the client's inline threshold. An image is never resized or re-encoded.
+  #
+  # The id is unique within a request. The model sees the image as
+  # "Picture <n>" (its place in the request's images, from 1) with this id
+  # beside it, so text in the state or the instructions can refer to it by
+  # either.
+  #
+  # An unreadable file or an argument of the wrong type raises ArgumentError
+  # here; a fault in the image itself raises BadRequestError when it is sent,
+  # before any request.
+  class Image
+    # The API's limits on one image, checked before any request.
+    MAX_BYTES = 10_485_760
+    MAX_PIXELS = 40_000_000
+    MAX_URL_CHARS = 2_048
+    MEDIA_TYPES = %w[image/jpeg image/png image/webp].freeze
+
+    attr_reader :id, :url, :upload_id
+
+    # The image's bytes (a frozen binary String), or nil for a URL or an upload id.
+    attr_reader :data
+
+    # "image/jpeg", "image/png" or "image/webp" from the magic bytes, or the
+    # media type given when the bytes are none of these.
+    def self.sniff_media_type(bytes)
+      ImageHeader.media_type(bytes.b)
+    end
+
+    def initialize(id, url: nil, path: nil, data: nil, base64: nil, upload_id: nil, media_type: nil)
+      sources = [url, path, data, base64, upload_id].compact.size
+      raise ArgumentError, "give exactly one of url:, path:, data:, base64: or upload_id:" unless sources == 1
+
+      @id = id.to_s
+      @declared = media_type.nil? || media_type.to_s.empty? ? nil : media_type.to_s
+      @url = url
+      @upload_id = upload_id&.to_s
+      @data = read_bytes(path, data, base64)&.freeze
+      @media_type = @data ? self.class.sniff_media_type(@data) || @declared : @declared
+      @data_type = @data ? self.class.sniff_media_type(@data) : nil
+      @lock = Mutex.new
+    end
+
+    # The image's media type: detected from the bytes, else as given.
+    attr_reader :media_type
+
+    def local?
+      !@data.nil?
+    end
+
+    def bytesize
+      @data ? @data.bytesize : 0
+    end
+
+    # [width, height] read from the header, or nil.
+    def dimensions
+      return nil unless @data && @data_type
+
+      @lock.synchronize do
+        @dimensions = ImageHeader.dimensions(@data, @data_type) unless defined?(@dimensions)
+        @dimensions
+      end
+    end
+
+    # The SHA-256 of the bytes, raw.
+    def sha256
+      @sha256 ||= Digest::SHA256.digest(@data)
+    end
+
+    # The MD5 of the bytes, raw.
+    def md5
+      @md5 ||= Digest::MD5.digest(@data)
+    end
+
+    # Raises BadRequestError (`api_usage_error`), as the API would answer,
+    # when the image's bytes break one of the API's rules: the format from the
+    # magic bytes (and a declared media type that differs), the size, and the
+    # pixel count read from the header. Returns self otherwise. A URL or an
+    # upload id is checked with the request (Checks.images!).
+    def validate!(max_bytes: MAX_BYTES)
+      fault = find_fault(max_bytes)
+      raise BadRequestError.new(fault, error_type: "api_usage_error") if fault
+
+      self
+    end
+
+    # The image's wire form with its bytes inline, or its URL or upload id.
+    def to_h
+      return url_wire if @url
+      return upload_wire(@upload_id) if @upload_id
+
+      { "id" => id, "media_type" => media_type, "data" => [@data].pack("m0") }
+    end
+
+    # The wire form naming an upload of these bytes.
+    def upload_wire(upload_id)
+      wire = { "id" => id, "upload_id" => upload_id }
+      wire["media_type"] = media_type if @upload_id && media_type
+      wire
+    end
+
+    def inspect
+      source = if @url then "url=#{@url.inspect}"
+               elsif @upload_id then "upload_id=#{@upload_id.inspect}"
+               else "#{media_type} #{bytesize} bytes"
+               end
+      "#<#{self.class.name} #{id.inspect} #{source}>"
+    end
+
+    private
+
+    def url_wire
+      wire = { "id" => id, "url" => @url }
+      wire["media_type"] = @declared if @declared
+      wire
+    end
+
+    def read_bytes(path, data, base64)
+      if path
+        begin
+          File.binread(path.to_s)
+        rescue SystemCallError, IOError => e
+          raise ArgumentError, "image #{@id.inspect}: cannot read #{path}: #{e.message}"
+        end
+      elsif base64
+        decode_base64(base64.to_s) || raise(ArgumentError, "image #{@id.inspect}: base64: is not base64 text")
+      elsif data.respond_to?(:read)
+        data.read.to_s.b
+      elsif data
+        raise ArgumentError, "image #{@id.inspect}: data must be a String of bytes or base64 text, or an IO" unless data.is_a?(String)
+
+        bytes = data.b
+        if ImageHeader.media_type(bytes).nil? && (decoded = decode_base64(bytes))
+          ImageHeader.media_type(decoded) ? decoded : bytes
+        else
+          bytes
+        end
+      end
+    end
+
+    # The decoded bytes of base64 text (line breaks allowed), or nil.
+    def decode_base64(text)
+      text.delete("\r\n").unpack1("m0").b
+    rescue ArgumentError
+      nil
+    end
+
+    # The first rule the bytes break, or nil. The pixel size is read once.
+    def find_fault(max_bytes)
+      return nil unless @data
+
+      found = @data_type
+      return "Image #{@id} is not a JPEG, PNG or WebP image." if found.nil?
+      return "Image #{@id} could not be decoded as #{@declared}." if @declared && @declared != found
+      return "Image #{@id} is larger than #{max_bytes / 1_048_576} MB." if @data.bytesize > max_bytes
+
+      size = @lock.synchronize do
+        @dimensions = ImageHeader.dimensions(@data, found) unless defined?(@dimensions)
+        @dimensions
+      end
+      return "Image #{@id}: its header cannot be read." if size.nil?
+
+      width, height = size
+      return "Image #{@id} is #{width}x#{height} pixels, over 40 megapixels." if width * height > MAX_PIXELS
+
+      nil
+    end
+  end
+end

data/lib/decisionnode/image_header.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+class DecisionNode
+  # Reads an image's format and pixel size from its first bytes, without
+  # decoding it: the JPEG start-of-frame segment, the PNG IHDR chunk and the
+  # WebP VP8, VP8L or VP8X header.
+  #
+  #   DecisionNode::ImageHeader.media_type(bytes)            # => "image/png"
+  #   DecisionNode::ImageHeader.dimensions(bytes, "image/png") # => [640, 480]
+  module ImageHeader
+    module_function
+
+    PNG_SIGNATURE = "\x89PNG\r\n\x1A\n".b.freeze
+    JPEG_SIGNATURE = "\xFF\xD8\xFF".b.freeze
+    RIFF = "RIFF".b.freeze
+    WEBP = "WEBP".b.freeze
+    IHDR = "IHDR".b.freeze
+    VP8_START_CODE = "\x9D\x01\x2A".b.freeze
+
+    # JPEG start-of-frame markers that carry the frame size: SOF0 to SOF15
+    # except DHT (C4), JPG (C8) and DAC (CC).
+    JPEG_SOF = ([0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF]).freeze
+    # Markers that stand alone, with no length: TEM, RST0 to RST7, SOI.
+    JPEG_STANDALONE = ([0x01, 0xD8] + (0xD0..0xD7).to_a).freeze
+    JPEG_SOS = 0xDA
+    JPEG_EOI = 0xD9
+
+    # "image/jpeg", "image/png" or "image/webp" from the magic bytes, else nil.
+    def media_type(bytes)
+      return "image/jpeg" if bytes.start_with?(JPEG_SIGNATURE)
+      return "image/png" if bytes.start_with?(PNG_SIGNATURE)
+      return "image/webp" if bytes.start_with?(RIFF) && bytes.byteslice(8, 4) == WEBP
+
+      nil
+    end
+
+    # [width, height] in pixels read from the header, or nil when the header
+    # is missing, truncated or not of this type.
+    def dimensions(bytes, media_type)
+      case media_type
+      when "image/png" then png(bytes)
+      when "image/jpeg" then jpeg(bytes)
+      when "image/webp" then webp(bytes)
+      end
+    end
+
+    # The IHDR chunk is the first chunk: length (4), "IHDR", width (4), height (4).
+    def png(bytes)
+      return nil unless bytes.byteslice(12, 4) == IHDR
+
+      size = bytes.byteslice(16, 8)
+      size&.bytesize == 8 ? size.unpack("NN") : nil
+    end
+
+    # Walks the segments after SOI to the first start-of-frame segment:
+    # FF marker, length (2, counting itself), precision (1), height (2), width (2).
+    def jpeg(bytes)
+      i = 2
+      size = bytes.bytesize
+      while i + 1 < size
+        return nil unless bytes.getbyte(i) == 0xFF
+
+        marker = bytes.getbyte(i + 1)
+        if marker == 0xFF # fill byte before a marker
+          i += 1
+          next
+        end
+        if JPEG_STANDALONE.include?(marker)
+          i += 2
+          next
+        end
+        return nil if marker == JPEG_SOS || marker == JPEG_EOI || i + 4 > size
+
+        length = bytes.byteslice(i + 2, 2).unpack1("n")
+        return nil if length < 2
+
+        if JPEG_SOF.include?(marker)
+          frame = bytes.byteslice(i + 5, 4)
+          return nil unless frame&.bytesize == 4
+
+          height, width = frame.unpack("nn")
+          return [width, height]
+        end
+        i += 2 + length
+      end
+      nil
+    end
+
+    # RIFF (4), size (4), "WEBP", then the first chunk's fourcc at 12.
+    def webp(bytes)
+      case bytes.byteslice(12, 4)
+      when "VP8 ".b
+        # Frame tag (3) at 20, start code (3) at 23, then 14-bit width and height.
+        return nil unless bytes.byteslice(23, 3) == VP8_START_CODE
+
+        size = bytes.byteslice(26, 4)
+        return nil unless size&.bytesize == 4
+
+        width, height = size.unpack("vv")
+        [width & 0x3FFF, height & 0x3FFF]
+      when "VP8L".b
+        # Signature 0x2F at 20, then width - 1 and height - 1 in 14 bits each.
+        return nil unless bytes.getbyte(20) == 0x2F
+
+        bits = bytes.byteslice(21, 4)
+        return nil unless bits&.bytesize == 4
+
+        value = bits.unpack1("V")
+        [(value & 0x3FFF) + 1, ((value >> 14) & 0x3FFF) + 1]
+      when "VP8X".b
+        # Flags (4) at 20, then canvas width - 1 and height - 1 in 24 bits each.
+        canvas = bytes.byteslice(24, 6)
+        return nil unless canvas&.bytesize == 6
+
+        w = canvas.getbyte(0) | (canvas.getbyte(1) << 8) | (canvas.getbyte(2) << 16)
+        h = canvas.getbyte(3) | (canvas.getbyte(4) << 8) | (canvas.getbyte(5) << 16)
+        [w + 1, h + 1]
+      end
+    end
+  end
+end