multi_compress 0.6.0 → 0.6.1

data/lib/multi_compress/database/dictionary.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    # A strict, immutable MCDB2 dictionary. It is intentionally distinct from
+    # MultiCompress::Dictionary: MCDB2 accepts only conformant zstd dictionaries
+    # with a non-zero zstd DictID and an application-level registry id.
+    class Dictionary
+      attr_reader :id, :bytes, :sha256, :zstd_id, :native
+
+      def self.train(samples, id:, size: 32 * 1024)
+        new(id: id, native: MultiCompress::Zstd.train_dictionary(samples, size: size))
+      end
+
+      def self.wrap(native, id:)
+        new(id: id, native: native)
+      end
+
+      def initialize(id:, native: nil, bytes: nil)
+        @id = normalize_id(id)
+        @native = build_native(native, bytes)
+        @bytes = validate_bytes(@native.bytes.b.freeze)
+        @zstd_id = validate_zstd_id(@native.zstd_id)
+        @sha256 = Digest::SHA256.digest(@bytes).freeze
+        freeze
+      end
+
+      def sha256_hex
+        sha256.unpack1("H*")
+      end
+
+      def registry_attributes
+        { id: id, zstd_dict_id: zstd_id, sha256: sha256, bytes: bytes }
+      end
+
+      private
+
+      def build_native(native, bytes)
+        raise ArgumentError, "provide exactly one of native: or bytes:" if (!!native) == (!!bytes)
+
+        value = native || MultiCompress::Dictionary.new(bytes, algo: :zstd)
+        return value if value.is_a?(MultiCompress::Dictionary) && value.algo == :zstd
+
+        raise TypeError, "MCDB2 dictionary must be a MultiCompress::Dictionary with algo: :zstd"
+      end
+
+      def validate_bytes(value)
+        return value unless value.empty? || value.bytesize > MAX_DICTIONARY_BYTES
+
+        raise ArgumentError,
+              "MCDB2 dictionary is #{value.bytesize} bytes; allowed range is 1..#{MAX_DICTIONARY_BYTES}"
+      end
+
+      def validate_zstd_id(value)
+        return value unless value.zero?
+
+        raise ArgumentError, "MCDB2 dictionary must be a conformant zstd dictionary with a non-zero DictID"
+      end
+
+      def normalize_id(value)
+        raise TypeError, "MCDB2 dictionary id must be an Integer" unless value.respond_to?(:to_int)
+
+        integer = value.to_int
+        unless integer.between?(1, MAX_DICTIONARY_REF)
+          raise ArgumentError, "MCDB2 dictionary id must be in 1..#{MAX_DICTIONARY_REF}"
+        end
+
+        integer
+      end
+    end
+  end
+end

data/lib/multi_compress/database/encoding.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    class Engine
+      private
+
+      def input_bytes!(text, format:)
+        validate_input_type!(text)
+
+        bytes = utf8_bytes(text)
+        validate_input_size!(bytes, format)
+        bytes
+      end
+
+      def validate_input_type!(text)
+        return if text.is_a?(String)
+
+        raise TypeError, "MultiCompress::Database.compress expects a String, got #{text.class}"
+      end
+
+      def validate_input_size!(bytes, format)
+        size = bytes.bytesize
+        return unless size > MAX_OUTPUT
+
+        raise ArgumentError,
+              "MultiCompress::Database: input is #{size} bytes, over the #{MAX_OUTPUT}-byte #{format} limit"
+      end
+    end
+  end
+end

data/lib/multi_compress/database/header.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    class Engine
+      private
+
+      def parse_header!(blob)
+        bytes = header_bytes!(blob)
+        version = bytes.getbyte(4)
+        validate_header_size!(bytes, version)
+        header_metadata(bytes, version)
+      end
+
+      def header_bytes!(blob)
+        unless blob.is_a?(String)
+          raise TypeError, "MultiCompress::Database.decompress expects a String, got #{blob.class}"
+        end
+
+        bytes = blob.b
+        err("truncated envelope (#{bytes.bytesize} < #{V1_HEADER_SIZE} bytes)") if bytes.bytesize < V1_HEADER_SIZE
+        err("bad magic") unless bytes.byteslice(0, 4) == MAGIC
+        bytes
+      end
+
+      def validate_header_size!(bytes, version)
+        header_size, max_envelope = envelope_limits(version)
+        if bytes.bytesize < header_size
+          err("truncated #{format_name(version)} envelope (#{bytes.bytesize} < #{header_size} bytes)")
+        end
+        if bytes.bytesize > max_envelope
+          err("stored #{format_name(version)} envelope is #{bytes.bytesize} bytes, over the #{max_envelope}-byte limit")
+        end
+        validate_fixed_header!(bytes)
+      end
+
+      def envelope_limits(version)
+        case version
+        when VERSION_V1 then [V1_HEADER_SIZE, MAX_ENVELOPE_V1]
+        when VERSION_V2 then [V2_HEADER_SIZE, MAX_ENVELOPE_V2]
+        else err("unsupported version #{version}")
+        end
+      end
+
+      def validate_fixed_header!(bytes)
+        err("unsupported codec #{bytes.getbyte(5)}") unless bytes.getbyte(5) == CODEC_ZSTD
+        err("reserved flags must be 0, got #{bytes.getbyte(6)}") unless bytes.getbyte(6) == FLAGS_NONE
+
+        original_size = bytes.byteslice(ORIGINAL_SIZE_OFFSET, 8).unpack1("Q<")
+        err("declared size #{original_size} over the #{MAX_OUTPUT}-byte limit") if original_size > MAX_OUTPUT
+      end
+
+      def header_metadata(bytes, version)
+        header = {
+          version: version,
+          header_size: version == VERSION_V2 ? V2_HEADER_SIZE : V1_HEADER_SIZE,
+          original_size: bytes.byteslice(ORIGINAL_SIZE_OFFSET, 8).unpack1("Q<"),
+          expected_crc: bytes.byteslice(CRC_OFFSET, 4).unpack1("L<")
+        }
+        header[:dictionary_ref] = dictionary_ref_from_header(bytes) if version == VERSION_V2
+        header
+      end
+
+      def dictionary_ref_from_header(bytes)
+        dictionary_ref = bytes.byteslice(DICTIONARY_REF_OFFSET, 8).unpack1("Q<")
+        err("invalid dictionary reference #{dictionary_ref}") unless dictionary_ref.between?(1, MAX_DICTIONARY_REF)
+        dictionary_ref
+      end
+    end
+  end
+end

data/lib/multi_compress/database/operations.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    class Engine
+      # Without a dictionary this emits MCDB1. With Database::Dictionary it emits
+      # MCDB2. Choose one format per database column; mixed use is deliberately
+      # not what the generated dictionary view is optimized for.
+      def compress(text, dictionary: nil)
+        return compress_v1(text) if dictionary.nil?
+
+        compress_v2(text, dictionary: dictionary)
+      end
+
+      def compress_v1(text)
+        bytes = input_bytes!(text, format: "v1")
+        frame = MultiCompress.compress(bytes, algo: :zstd, level: ZSTD_LEVEL)
+        validate_canonical_zstd_frame!(frame, bytes.bytesize, expected_dictionary_id: 0)
+        envelope = header_v1(bytes.bytesize, MultiCompress.crc32(bytes)) << frame
+        check_envelope_size!(envelope, MAX_ENVELOPE_V1, "v1")
+        envelope
+      end
+
+      def compress_v2(text, dictionary:)
+        dictionary = database_dictionary!(dictionary)
+        bytes = input_bytes!(text, format: "v2")
+        frame = MultiCompress.compress(bytes, algo: :zstd, level: ZSTD_LEVEL, dictionary: dictionary.native)
+        validate_canonical_zstd_frame!(frame, bytes.bytesize, expected_dictionary_id: dictionary.zstd_id)
+        envelope = header_v2(bytes.bytesize, MultiCompress.crc32(bytes), dictionary.id) << frame
+        check_envelope_size!(envelope, MAX_ENVELOPE_V2, "v2")
+        envelope
+      end
+
+      def decompress(blob, dictionary: nil)
+        header = parse_header!(blob)
+        case header.fetch(:version)
+        when VERSION_V1
+          raise ArgumentError, "MCDB1 does not accept a dictionary" unless dictionary.nil?
+
+          decode_v1(blob.b, header)
+        when VERSION_V2
+          decode_v2(blob.b, header, dictionary)
+        else
+          err("unsupported version #{header.fetch(:version)}")
+        end
+      end
+
+      def valid?(blob, dictionary: nil)
+        decompress(blob, dictionary: dictionary)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Parses only the envelope header. It is safe for registry/FK consistency
+      # checks and does not decompress the payload.
+      def dictionary_ref(blob)
+        header = parse_header!(blob)
+        return nil if header.fetch(:version) == VERSION_V1
+
+        header.fetch(:dictionary_ref)
+      end
+
+      def original_size(blob)
+        parse_header!(blob).fetch(:original_size)
+      end
+
+      def version_string
+        "MCDB1 + MCDB2 (zstd #{MultiCompress.version(:zstd)})"
+      end
+    end
+  end
+end

data/lib/multi_compress/database/validation.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    class Engine
+      private
+
+      def validate_decoded!(_blob, header, out)
+        validate_decoded_size!(header, out)
+        validate_decoded_crc!(header, out)
+        validate_decoded_text(out)
+      end
+
+      def validate_decoded_size!(header, out)
+        expected_size = header.fetch(:original_size)
+        return if out.bytesize == expected_size
+
+        err("size mismatch: header says #{expected_size}, got #{out.bytesize}")
+      end
+
+      def validate_decoded_crc!(header, out)
+        expected_crc = header.fetch(:expected_crc)
+        actual_crc = MultiCompress.crc32(out)
+        return if actual_crc == expected_crc
+
+        err("crc32 mismatch: header #{expected_crc}, computed #{actual_crc}")
+      end
+
+      def validate_decoded_text(out)
+        text = out.force_encoding(Encoding::UTF_8)
+        err("decompressed bytes are not valid UTF-8") unless text.valid_encoding?
+        err("decompressed text contains a NUL byte") if text.include?("\0")
+        text
+      end
+
+      def utf8_bytes(text)
+        s = text.encoding == Encoding::UTF_8 ? text : text.dup.force_encoding(Encoding::UTF_8)
+        raise ArgumentError, "MultiCompress::Database: input is not valid UTF-8" unless s.valid_encoding?
+        raise ArgumentError, "MultiCompress::Database: input contains a NUL byte" if s.include?("\0")
+
+        s.b
+      end
+
+      def validate_canonical_zstd_frame!(frame, expected_size, expected_dictionary_id:)
+        _frame_size, content_size = MultiCompress.zstd_single_frame_info(frame)
+        if content_size != expected_size
+          err("zstd frame content size #{content_size} does not match header size #{expected_size}")
+        end
+        actual_dictionary_id = MultiCompress.zstd_frame_dictionary_id(frame)
+        if actual_dictionary_id != expected_dictionary_id
+          err("zstd frame dictionary id #{actual_dictionary_id} does not match expected #{expected_dictionary_id}")
+        end
+      rescue MultiCompress::DataError => e
+        err(e.message.sub(/\AMultiCompress::Database: /, ""))
+      end
+
+      def database_dictionary!(value)
+        return value if value.is_a?(Dictionary)
+
+        raise TypeError, "MCDB2 requires MultiCompress::Database::Dictionary, got #{value.class}"
+      end
+
+      def check_envelope_size!(envelope, max, format)
+        return if envelope.bytesize <= max
+
+        raise MultiCompress::DataError,
+              "MultiCompress::Database: stored #{format} envelope is #{envelope.bytesize} bytes, " \
+              "over the #{max}-byte limit"
+      end
+
+      def header_v1(original_size, crc32)
+        encode_header(VERSION_V1, original_size, crc32)
+      end
+
+      def header_v2(original_size, crc32, dictionary_ref)
+        encode_header(VERSION_V2, original_size, crc32, dictionary_ref)
+      end
+
+      def encode_header(version, original_size, crc32, dictionary_ref = nil)
+        header = MAGIC + [version, CODEC_ZSTD, FLAGS_NONE].pack("C3") +
+                 [original_size].pack("Q<") + [crc32].pack("L<")
+        header << [dictionary_ref].pack("Q<") unless dictionary_ref.nil?
+        header.b
+      end
+
+      def format_name(version)
+        version == VERSION_V2 ? "MCDB2" : "MCDB1"
+      end
+
+      def err(message)
+        raise MultiCompress::DataError, "MultiCompress::Database: #{message}"
+      end
+    end
+  end
+end

data/lib/multi_compress/database.rb

@@ -20,293 +20,21 @@ module MultiCompress
     ORIGINAL_SIZE_OFFSET = 7
     CRC_OFFSET           = 15
     DICTIONARY_REF_OFFSET = 19
-    MAX_OUTPUT   = 16 * 1024 * 1024
+    MAX_OUTPUT = 16 * 1024 * 1024
     MAX_DICTIONARY_BYTES = 256 * 1024
     MAX_DICTIONARY_REF = (2**63) - 1
     MAX_ENVELOPE_V1 = 16_842_771
     MAX_ENVELOPE_V2 = 16_842_779
     MAX_ENVELOPE = MAX_ENVELOPE_V2
     ZSTD_LEVEL   = 6
-
-    # A strict, immutable MCDB2 dictionary. It is intentionally distinct from
-    # MultiCompress::Dictionary: MCDB2 accepts only conformant zstd dictionaries
-    # with a non-zero zstd DictID and an application-level registry id.
-    class Dictionary
-      attr_reader :id, :bytes, :sha256, :zstd_id, :native
-
-      def self.train(samples, id:, size: 32 * 1024)
-        new(id: id, native: MultiCompress::Zstd.train_dictionary(samples, size: size))
-      end
-
-      def self.wrap(native, id:)
-        new(id: id, native: native)
-      end
-
-      def initialize(id:, native: nil, bytes: nil)
-        @id = normalize_id(id)
-        raise ArgumentError, "provide exactly one of native: or bytes:" if (!!native) == (!!bytes)
-
-        @native = native || MultiCompress::Dictionary.new(bytes, algo: :zstd)
-        unless @native.is_a?(MultiCompress::Dictionary) && @native.algo == :zstd
-          raise TypeError, "MCDB2 dictionary must be a MultiCompress::Dictionary with algo: :zstd"
-        end
-
-        @bytes = @native.bytes.b.freeze
-        if @bytes.empty? || @bytes.bytesize > MAX_DICTIONARY_BYTES
-          raise ArgumentError,
-                "MCDB2 dictionary is #{@bytes.bytesize} bytes; allowed range is 1..#{MAX_DICTIONARY_BYTES}"
-        end
-
-        @zstd_id = @native.zstd_id
-        raise ArgumentError, "MCDB2 dictionary must be a conformant zstd dictionary with a non-zero DictID" if @zstd_id.zero?
-
-        @sha256 = Digest::SHA256.digest(@bytes).freeze
-        freeze
-      end
-
-      def sha256_hex
-        @sha256.unpack1("H*")
-      end
-
-      def registry_attributes
-        { id: @id, zstd_dict_id: @zstd_id, sha256: @sha256, bytes: @bytes }
-      end
-
-      private
-
-      def normalize_id(value)
-        raise TypeError, "MCDB2 dictionary id must be an Integer" unless value.respond_to?(:to_int)
-
-        integer = value.to_int
-        unless integer.between?(1, MAX_DICTIONARY_REF)
-          raise ArgumentError, "MCDB2 dictionary id must be in 1..#{MAX_DICTIONARY_REF}"
-        end
-        integer
-      end
-    end
-
-    module_function
-
-    # Without a dictionary this emits MCDB1. With Database::Dictionary it emits
-    # MCDB2. Choose one format per database column; mixed use is deliberately
-    # not what the generated dictionary view is optimized for.
-    def compress(text, dictionary: nil)
-      return compress_v1(text) if dictionary.nil?
-
-      compress_v2(text, dictionary: dictionary)
-    end
-
-    def compress_v1(text)
-      bytes = input_bytes!(text, format: "v1")
-      frame = MultiCompress.compress(bytes, algo: :zstd, level: ZSTD_LEVEL)
-      validate_canonical_zstd_frame!(frame, bytes.bytesize, expected_dictionary_id: 0)
-      envelope = header_v1(bytes.bytesize, MultiCompress.crc32(bytes)) << frame
-      check_envelope_size!(envelope, MAX_ENVELOPE_V1, "v1")
-      envelope
-    end
-
-    def compress_v2(text, dictionary:)
-      dictionary = database_dictionary!(dictionary)
-      bytes = input_bytes!(text, format: "v2")
-      frame = MultiCompress.compress(bytes, algo: :zstd, level: ZSTD_LEVEL, dictionary: dictionary.native)
-      validate_canonical_zstd_frame!(frame, bytes.bytesize, expected_dictionary_id: dictionary.zstd_id)
-      envelope = header_v2(bytes.bytesize, MultiCompress.crc32(bytes), dictionary.id) << frame
-      check_envelope_size!(envelope, MAX_ENVELOPE_V2, "v2")
-      envelope
-    end
-
-    def decompress(blob, dictionary: nil)
-      header = parse_header!(blob)
-      case header.fetch(:version)
-      when VERSION_V1
-        raise ArgumentError, "MCDB1 does not accept a dictionary" unless dictionary.nil?
-
-        decode_v1(blob.b, header)
-      when VERSION_V2
-        decode_v2(blob.b, header, dictionary)
-      else
-        err("unsupported version #{header.fetch(:version)}")
-      end
-    end
-
-    def valid?(blob, dictionary: nil)
-      decompress(blob, dictionary: dictionary)
-      true
-    rescue StandardError
-      false
-    end
-
-    # Parses only the envelope header. It is safe for registry/FK consistency
-    # checks and does not decompress the payload.
-    def dictionary_ref(blob)
-      header = parse_header!(blob)
-      return nil if header.fetch(:version) == VERSION_V1
-
-      header.fetch(:dictionary_ref)
-    end
-
-    def original_size(blob)
-      parse_header!(blob).fetch(:original_size)
-    end
-
-    def version_string
-      "MCDB1 + MCDB2 (zstd #{MultiCompress.version(:zstd)})"
-    end
-
-    def input_bytes!(text, format:)
-      raise TypeError, "MultiCompress::Database.compress expects a String, got #{text.class}" unless text.is_a?(String)
-
-      bytes = utf8_bytes(text)
-      n = bytes.bytesize
-      if n > MAX_OUTPUT
-        raise ArgumentError, "MultiCompress::Database: input is #{n} bytes, over the #{MAX_OUTPUT}-byte #{format} limit"
-      end
-      bytes
-    end
-    private_class_method :input_bytes!
-
-    def decode_v1(blob, header)
-      frame = blob.byteslice(V1_HEADER_SIZE, blob.bytesize - V1_HEADER_SIZE) || +"".b
-      validate_canonical_zstd_frame!(frame, header.fetch(:original_size), expected_dictionary_id: 0)
-      out = MultiCompress.decompress(frame, algo: :zstd, max_output_size: MAX_OUTPUT)
-      validate_decoded!(blob, header, out)
-    end
-    private_class_method :decode_v1
-
-    def decode_v2(blob, header, dictionary)
-      err("MCDB2 requires a dictionary") if dictionary.nil?
-      dictionary = database_dictionary!(dictionary)
-      if dictionary.id != header.fetch(:dictionary_ref)
-        err("dictionary reference #{header.fetch(:dictionary_ref)} does not match supplied dictionary #{dictionary.id}")
-      end
-
-      frame = blob.byteslice(V2_HEADER_SIZE, blob.bytesize - V2_HEADER_SIZE) || +"".b
-      validate_canonical_zstd_frame!(frame, header.fetch(:original_size), expected_dictionary_id: dictionary.zstd_id)
-      out = MultiCompress.decompress(
-        frame,
-        algo: :zstd,
-        dictionary: dictionary.native,
-        max_output_size: MAX_OUTPUT
-      )
-      validate_decoded!(blob, header, out)
-    end
-    private_class_method :decode_v2
-
-    def parse_header!(blob)
-      raise TypeError, "MultiCompress::Database.decompress expects a String, got #{blob.class}" unless blob.is_a?(String)
-
-      b = blob.b
-      err("truncated envelope (#{b.bytesize} < #{V1_HEADER_SIZE} bytes)") if b.bytesize < V1_HEADER_SIZE
-      err("bad magic") unless b.byteslice(0, 4) == MAGIC
-
-      version = b.getbyte(4)
-      case version
-      when VERSION_V1
-        header_size = V1_HEADER_SIZE
-        max_envelope = MAX_ENVELOPE_V1
-      when VERSION_V2
-        header_size = V2_HEADER_SIZE
-        max_envelope = MAX_ENVELOPE_V2
-      else
-        err("unsupported version #{version}")
-      end
-
-      err("truncated #{format_name(version)} envelope (#{b.bytesize} < #{header_size} bytes)") if b.bytesize < header_size
-      err("stored #{format_name(version)} envelope is #{b.bytesize} bytes, over the #{max_envelope}-byte limit") if b.bytesize > max_envelope
-      err("unsupported codec #{b.getbyte(5)}") unless b.getbyte(5) == CODEC_ZSTD
-      err("reserved flags must be 0, got #{b.getbyte(6)}") unless b.getbyte(6) == FLAGS_NONE
-
-      original_size = b.byteslice(ORIGINAL_SIZE_OFFSET, 8).unpack1("Q<")
-      err("declared size #{original_size} over the #{MAX_OUTPUT}-byte limit") if original_size > MAX_OUTPUT
-
-      header = {
-        version: version,
-        header_size: header_size,
-        original_size: original_size,
-        expected_crc: b.byteslice(CRC_OFFSET, 4).unpack1("L<")
-      }
-      if version == VERSION_V2
-        dictionary_ref = b.byteslice(DICTIONARY_REF_OFFSET, 8).unpack1("Q<")
-        unless dictionary_ref.between?(1, MAX_DICTIONARY_REF)
-          err("invalid dictionary reference #{dictionary_ref}")
-        end
-        header[:dictionary_ref] = dictionary_ref
-      end
-      header
-    end
-    private_class_method :parse_header!
-
-    def validate_decoded!(blob, header, out)
-      if out.bytesize != header.fetch(:original_size)
-        err("size mismatch: header says #{header.fetch(:original_size)}, got #{out.bytesize}")
-      end
-      actual_crc = MultiCompress.crc32(out)
-      if actual_crc != header.fetch(:expected_crc)
-        err("crc32 mismatch: header #{header.fetch(:expected_crc)}, computed #{actual_crc}")
-      end
-      s = out.force_encoding(Encoding::UTF_8)
-      err("decompressed bytes are not valid UTF-8") unless s.valid_encoding?
-      err("decompressed text contains a NUL byte") if s.include?("\0")
-      s
-    end
-    private_class_method :validate_decoded!
-
-    def utf8_bytes(text)
-      s = text.encoding == Encoding::UTF_8 ? text : text.dup.force_encoding(Encoding::UTF_8)
-      raise ArgumentError, "MultiCompress::Database: input is not valid UTF-8" unless s.valid_encoding?
-      raise ArgumentError, "MultiCompress::Database: input contains a NUL byte" if s.include?("\0")
-
-      s.b
-    end
-    private_class_method :utf8_bytes
-
-    def validate_canonical_zstd_frame!(frame, expected_size, expected_dictionary_id:)
-      _frame_size, content_size = MultiCompress.zstd_single_frame_info(frame)
-      err("zstd frame content size #{content_size} does not match header size #{expected_size}") if content_size != expected_size
-      actual_dictionary_id = MultiCompress.zstd_frame_dictionary_id(frame)
-      if actual_dictionary_id != expected_dictionary_id
-        err("zstd frame dictionary id #{actual_dictionary_id} does not match expected #{expected_dictionary_id}")
-      end
-    rescue MultiCompress::DataError => e
-      err(e.message.sub(/\AMultiCompress::Database: /, ""))
-    end
-    private_class_method :validate_canonical_zstd_frame!
-
-    def database_dictionary!(value)
-      return value if value.is_a?(Dictionary)
-
-      raise TypeError, "MCDB2 requires MultiCompress::Database::Dictionary, got #{value.class}"
-    end
-    private_class_method :database_dictionary!
-
-    def check_envelope_size!(envelope, max, format)
-      return if envelope.bytesize <= max
-
-      raise MultiCompress::DataError,
-            "MultiCompress::Database: stored #{format} envelope is #{envelope.bytesize} bytes, over the #{max}-byte limit"
-    end
-    private_class_method :check_envelope_size!
-
-    def header_v1(original_size, crc32)
-      (MAGIC + [VERSION_V1, CODEC_ZSTD, FLAGS_NONE].pack("C3") +
-        [original_size].pack("Q<") + [crc32].pack("L<")).b
-    end
-    private_class_method :header_v1
-
-    def header_v2(original_size, crc32, dictionary_ref)
-      (MAGIC + [VERSION_V2, CODEC_ZSTD, FLAGS_NONE].pack("C3") +
-        [original_size].pack("Q<") + [crc32].pack("L<") + [dictionary_ref].pack("Q<")).b
-    end
-    private_class_method :header_v2
-
-    def format_name(version)
-      version == VERSION_V2 ? "MCDB2" : "MCDB1"
-    end
-    private_class_method :format_name
-
-    def err(message)
-      raise MultiCompress::DataError, "MultiCompress::Database: #{message}"
-    end
-    private_class_method :err
   end
 end
+
+require "multi_compress/database/dictionary"
+require "multi_compress/database/operations"
+require "multi_compress/database/encoding"
+require "multi_compress/database/decoding"
+require "multi_compress/database/header"
+require "multi_compress/database/validation"
+
+require "multi_compress/database/api"