multi_compress 0.5.0 → 0.6.1

data/ext/multi_compress/vendor/.vendored

@@ -1,3 +1,3 @@
 zstd=1.5.7
 lz4=1.10.0
-brotli=1.2.0
+brotli=1.2.1

data/ext/multi_compress/vendor/brotli/c/common/version.h

@@ -19,7 +19,7 @@
 
 #define BROTLI_VERSION_MAJOR 1
 #define BROTLI_VERSION_MINOR 2
-#define BROTLI_VERSION_PATCH 0
+#define BROTLI_VERSION_PATCH 1
 
 #define BROTLI_VERSION BROTLI_MAKE_HEX_VERSION(                     \
   BROTLI_VERSION_MAJOR, BROTLI_VERSION_MINOR, BROTLI_VERSION_PATCH)
@@ -33,7 +33,7 @@
  */
 
 #define BROTLI_ABI_CURRENT  3
-#define BROTLI_ABI_REVISION 0
+#define BROTLI_ABI_REVISION 1
 #define BROTLI_ABI_AGE      2
 
 #if BROTLI_VERSION_MAJOR != (BROTLI_ABI_CURRENT - BROTLI_ABI_AGE)

data/ext/multi_compress/vendor/brotli/c/dec/decode.c

@@ -1176,7 +1176,7 @@ static BrotliDecoderErrorCode DecodeContextMap(brotli_reg_t context_map_size,
 
 /* Decodes a command or literal and updates block type ring-buffer.
    Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
+static BROTLI_INLINE BrotliDecoderErrorCode DecodeBlockTypeAndLength(
     int safe, BrotliDecoderState* s, int tree_type) {
   brotli_reg_t max_block_type = s->num_block_types[tree_type];
   const HuffmanCode* type_tree = &s->block_type_trees[
@@ -1187,7 +1187,7 @@ static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
   brotli_reg_t* ringbuffer = &s->block_type_rb[tree_type * 2];
   brotli_reg_t block_type;
   if (max_block_type <= 1) {
-    return BROTLI_FALSE;
+    return BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH;
   }
 
   /* Read 0..15 + 3..39 bits. */
@@ -1197,11 +1197,13 @@ static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
   } else {
     BrotliBitReaderState memento;
     BrotliBitReaderSaveState(br, &memento);
-    if (!SafeReadSymbol(type_tree, br, &block_type)) return BROTLI_FALSE;
+    if (!SafeReadSymbol(type_tree, br, &block_type)) {
+      return BROTLI_DECODER_NEEDS_MORE_INPUT;
+    }
     if (!SafeReadBlockLength(s, &s->block_length[tree_type], len_tree, br)) {
       s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE;
       BrotliBitReaderRestoreState(br, &memento);
-      return BROTLI_FALSE;
+      return BROTLI_DECODER_NEEDS_MORE_INPUT;
     }
   }
 
@@ -1217,7 +1219,7 @@ static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
   }
   ringbuffer[0] = ringbuffer[1];
   ringbuffer[1] = block_type;
-  return BROTLI_TRUE;
+  return BROTLI_DECODER_SUCCESS;
 }
 
 static BROTLI_INLINE void DetectTrivialLiteralBlockTypes(
@@ -1254,62 +1256,68 @@ static BROTLI_INLINE void PrepareLiteralDecoding(BrotliDecoderState* s) {
 
 /* Decodes the block type and updates the state for literal context.
    Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeLiteralBlockSwitchInternal(
+static BROTLI_INLINE BrotliDecoderErrorCode DecodeLiteralBlockSwitchInternal(
     int safe, BrotliDecoderState* s) {
-  if (!DecodeBlockTypeAndLength(safe, s, 0)) {
-    return BROTLI_FALSE;
+  BrotliDecoderErrorCode result = DecodeBlockTypeAndLength(safe, s, 0);
+  if (result != BROTLI_DECODER_SUCCESS) {
+    return result;
   }
   PrepareLiteralDecoding(s);
-  return BROTLI_TRUE;
+  return BROTLI_DECODER_SUCCESS;
 }
 
-static void BROTLI_NOINLINE DecodeLiteralBlockSwitch(BrotliDecoderState* s) {
-  DecodeLiteralBlockSwitchInternal(0, s);
+static BROTLI_NOINLINE BrotliDecoderErrorCode
+DecodeLiteralBlockSwitch(BrotliDecoderState* s) {
+  return DecodeLiteralBlockSwitchInternal(0, s);
 }
 
-static BROTLI_BOOL BROTLI_NOINLINE SafeDecodeLiteralBlockSwitch(
+static BROTLI_NOINLINE BrotliDecoderErrorCode SafeDecodeLiteralBlockSwitch(
     BrotliDecoderState* s) {
   return DecodeLiteralBlockSwitchInternal(1, s);
 }
 
 /* Block switch for insert/copy length.
    Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeCommandBlockSwitchInternal(
+static BROTLI_INLINE BrotliDecoderErrorCode DecodeCommandBlockSwitchInternal(
     int safe, BrotliDecoderState* s) {
-  if (!DecodeBlockTypeAndLength(safe, s, 1)) {
-    return BROTLI_FALSE;
+  BrotliDecoderErrorCode result = DecodeBlockTypeAndLength(safe, s, 1);
+  if (result != BROTLI_DECODER_SUCCESS) {
+    return result;
   }
   s->htree_command = s->insert_copy_hgroup.htrees[s->block_type_rb[3]];
-  return BROTLI_TRUE;
+  return BROTLI_DECODER_SUCCESS;
 }
 
-static void BROTLI_NOINLINE DecodeCommandBlockSwitch(BrotliDecoderState* s) {
-  DecodeCommandBlockSwitchInternal(0, s);
+static BROTLI_NOINLINE BrotliDecoderErrorCode
+DecodeCommandBlockSwitch(BrotliDecoderState* s) {
+  return DecodeCommandBlockSwitchInternal(0, s);
 }
 
-static BROTLI_BOOL BROTLI_NOINLINE SafeDecodeCommandBlockSwitch(
-    BrotliDecoderState* s) {
+static BROTLI_NOINLINE BrotliDecoderErrorCode
+SafeDecodeCommandBlockSwitch(BrotliDecoderState* s) {
   return DecodeCommandBlockSwitchInternal(1, s);
 }
 
 /* Block switch for distance codes.
    Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeDistanceBlockSwitchInternal(
+static BROTLI_INLINE BrotliDecoderErrorCode DecodeDistanceBlockSwitchInternal(
     int safe, BrotliDecoderState* s) {
-  if (!DecodeBlockTypeAndLength(safe, s, 2)) {
-    return BROTLI_FALSE;
+  BrotliDecoderErrorCode result = DecodeBlockTypeAndLength(safe, s, 2);
+  if (result != BROTLI_DECODER_SUCCESS) {
+    return result;
   }
   s->dist_context_map_slice = s->dist_context_map +
       (s->block_type_rb[5] << BROTLI_DISTANCE_CONTEXT_BITS);
   s->dist_htree_index = s->dist_context_map_slice[s->distance_context];
-  return BROTLI_TRUE;
+  return BROTLI_DECODER_SUCCESS;
 }
 
-static void BROTLI_NOINLINE DecodeDistanceBlockSwitch(BrotliDecoderState* s) {
-  DecodeDistanceBlockSwitchInternal(0, s);
+static BROTLI_NOINLINE BrotliDecoderErrorCode
+DecodeDistanceBlockSwitch(BrotliDecoderState* s) {
+  return DecodeDistanceBlockSwitchInternal(0, s);
 }
 
-static BROTLI_BOOL BROTLI_NOINLINE SafeDecodeDistanceBlockSwitch(
+static BROTLI_NOINLINE BrotliDecoderErrorCode SafeDecodeDistanceBlockSwitch(
     BrotliDecoderState* s) {
   return DecodeDistanceBlockSwitchInternal(1, s);
 }
@@ -1940,6 +1948,9 @@ static BROTLI_INLINE BROTLI_BOOL CheckInputAmount(
   return BrotliCheckInputAmount(br);
 }
 
+/* NB: METHOD should return BROTLI_FALSE only in case there is not enough input;
+       in case of "unsafe" execution, when input is guaranteed to be sufficient,
+       result is ignored. */
 #define BROTLI_SAFE(METHOD)                       \
   {                                               \
     if (safe) {                                   \
@@ -1952,6 +1963,22 @@ static BROTLI_INLINE BROTLI_BOOL CheckInputAmount(
     }                                             \
   }
 
+/* NB: METHOD should return BROTLI_DECODER_SUCCESS, BROTLI_DECODER_ERROR_*, or
+   BROTLI_DECODER_NEEDS_MORE_INPUT; the later two break the processing. */
+#define BROTLI_SAFE_WITH_STATUS(METHOD)         \
+  {                                             \
+    BrotliDecoderErrorCode status;              \
+    if (safe) {                                 \
+      status = Safe##METHOD;                    \
+    } else {                                    \
+      status = METHOD;                          \
+    }                                           \
+    if (status != BROTLI_DECODER_SUCCESS) {     \
+      result = status;                          \
+      goto saveStateAndReturn;                  \
+    }                                           \
+  }
+
 static BROTLI_INLINE BrotliDecoderErrorCode ProcessCommandsInternal(
     int safe, BrotliDecoderState* s) {
   int pos = s->pos;
@@ -1991,7 +2018,7 @@ CommandBegin:
     goto saveStateAndReturn;
   }
   if (BROTLI_PREDICT_FALSE(s->block_length[1] == 0)) {
-    BROTLI_SAFE(DecodeCommandBlockSwitch(s));
+    BROTLI_SAFE_WITH_STATUS(DecodeCommandBlockSwitch(s));
     goto CommandBegin;
   }
   /* Read the insert/copy length in the command. */
@@ -2136,7 +2163,7 @@ CommandPostDecodeLiterals:
   } else {
     /* Read distance code in the command, unless it was implicitly zero. */
     if (BROTLI_PREDICT_FALSE(s->block_length[2] == 0)) {
-      BROTLI_SAFE(DecodeDistanceBlockSwitch(s));
+      BROTLI_SAFE_WITH_STATUS(DecodeDistanceBlockSwitch(s));
     }
     BROTLI_SAFE(ReadDistance(s, br));
   }
@@ -2330,7 +2357,7 @@ CommandPostWrapCopy:
   }
 
 NextLiteralBlock:
-  BROTLI_SAFE(DecodeLiteralBlockSwitch(s));
+  BROTLI_SAFE_WITH_STATUS(DecodeLiteralBlockSwitch(s));
   goto CommandInner;
 
 saveStateAndReturn:
@@ -2552,6 +2579,8 @@ BrotliDecoderResult BrotliDecoderDecompressStream(
         if (result != BROTLI_DECODER_SUCCESS) {
           break;
         }
+        BROTLI_DCHECK(s->meta_block_remaining_len <=
+                      (int)BROTLI_BLOCK_SIZE_CAP);
         BROTLI_LOG_UINT(s->is_last_metablock);
         BROTLI_LOG_UINT(s->meta_block_remaining_len);
         BROTLI_LOG_UINT(s->is_metadata);

data/ext/multi_compress/vendor/brotli/c/include/brotli/decode.h

@@ -85,9 +85,7 @@ typedef enum {
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_1, -14) SEPARATOR              \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_2, -15) SEPARATOR              \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, DISTANCE, -16) SEPARATOR               \
-                                                                           \
-  /* -17 code is reserved */                                               \
-                                                                           \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_SWITCH, -17) SEPARATOR           \
   BROTLI_ERROR_CODE(_ERROR_, COMPOUND_DICTIONARY, -18) SEPARATOR           \
   BROTLI_ERROR_CODE(_ERROR_, DICTIONARY_NOT_SET, -19) SEPARATOR            \
   BROTLI_ERROR_CODE(_ERROR_, INVALID_ARGUMENTS, -20) SEPARATOR             \

data/lib/multi_compress/active_record.rb

@@ -12,6 +12,9 @@ end
 module MultiCompress
   module ActiveRecordSupport
     class Type < ActiveModel::Type::Value
+      attr_reader :codec, :mutable
+      private :codec, :mutable
+
       def initialize(mutable: false, **codec_opts)
         @codec   = MultiCompress::Codec.new(**codec_opts)
         @mutable = mutable
@@ -29,32 +32,35 @@ module MultiCompress
 
       # DB -> in-memory (unwrap)
       def deserialize(value)
-        @codec.load(value)
+        codec.load(value)
       end
 
       # in-memory -> DB (compress)
       def serialize(value)
-        @codec.dump(value)
+        codec.dump(value)
       end
 
       def changed_in_place?(raw_old_value, new_value)
-        return false unless @mutable
+        return false unless mutable
 
         deserialize(raw_old_value) != new_value
       end
     end
 
     class Coder
+      attr_reader :codec
+      private :codec
+
       def initialize(**codec_opts)
         @codec = MultiCompress::Codec.new(**codec_opts)
       end
 
       def dump(value)
-        @codec.dump(value)
+        codec.dump(value)
       end
 
       def load(value)
-        @codec.load(value)
+        codec.load(value)
       end
     end
   end

data/lib/multi_compress/codec.rb

@@ -4,51 +4,88 @@ require "multi_compress"
 
 module MultiCompress
   class Codec
-    MAGIC       = "\x89MCDB".b       # reserved 5-byte namespace; 0x89 is an
-                                     # invalid UTF-8 lead byte, so it won't
-                                     # collide with valid text. For BINARY data
-                                     # this prefix is reserved, not collision-free.
+    MAGIC       = "\x89MCDB".b # reserved 5-byte namespace; 0x89 is an
+    # invalid UTF-8 lead byte, so it won't
+    # collide with valid text. For BINARY data
+    # this prefix is reserved, not collision-free.
     VERSION     = 1
     HEADER_SIZE = MAGIC.bytesize + 2 # magic + version byte + algo byte
     B64_PREFIX  = "mc1:"
-    MAX_NATIVE_OUTPUT = (2**(0.size * 8 - 1)) - 1
+    MAX_NATIVE_OUTPUT = (2**((0.size * 8) - 1)) - 1
 
     ALGO_ID  = { zstd: 1, lz4: 2, brotli: 3 }.freeze
     ID_ALGO  = ALGO_ID.invert.freeze
 
-    attr_reader :algo, :level, :max_output_size
+    Options = Struct.new(
+      :algo, :level, :encode, :serializer, :encoding, :max_output_size, :legacy, :dictionary,
+      keyword_init: true
+    )
 
-    def initialize(algo: :zstd, level: nil, encode: nil, serializer: nil,
-                   encoding: Encoding::UTF_8, max_output_size: nil,
-                   legacy: :reject, dictionary: nil)
+    DEFAULT_OPTIONS = {
+      algo: :zstd, level: nil, encode: nil, serializer: nil, encoding: Encoding::UTF_8,
+      max_output_size: nil, legacy: :reject, dictionary: nil
+    }.freeze
+
+    private_constant :DEFAULT_OPTIONS, :Options
+
+    def initialize(**values)
+      resolved_options = DEFAULT_OPTIONS.merge(values)
+      @options = Options.new(**resolved_options)
+      validate_options!
+    end
+
+    def algo
+      @options.algo
+    end
+
+    def level
+      @options.level
+    end
+
+    def max_output_size
+      @options.max_output_size
+    end
+
+    private
+
+    def validate_options!
+      validate_algorithm!
+      validate_encoding!
+      @options.max_output_size = normalized_output_limit
+      @options.legacy = normalize_legacy(@options.legacy)
+    end
+
+    def validate_algorithm!
       raise ArgumentError, "unknown algo #{algo.inspect}" unless ALGO_ID.key?(algo)
-      raise ArgumentError, "encode must be nil or :base64" unless [nil, :base64].include?(encode)
-
-      @algo            = algo
-      @level           = level
-      @encode          = encode
-      @serializer      = serializer
-      @encoding        = encoding
-      limit            = Integer(max_output_size || MultiCompress.config.max_output_size)
+    end
+
+    def validate_encoding!
+      return if [nil, :base64].include?(@options.encode)
+
+      raise ArgumentError, "encode must be nil or :base64"
+    end
+
+    def normalized_output_limit
+      limit = Integer(@options.max_output_size || MultiCompress.config.max_output_size)
       raise ArgumentError, "max_output_size must be greater than 0" unless limit.positive?
       if limit > MAX_NATIVE_OUTPUT
-        raise ArgumentError,
-              "max_output_size must be at most #{MAX_NATIVE_OUTPUT} bytes on this platform"
+        raise ArgumentError, "max_output_size must be at most #{MAX_NATIVE_OUTPUT} bytes on this platform"
       end
 
-      @max_output_size = limit
-      @legacy          = normalize_legacy(legacy)
-      @dictionary      = dictionary
+      limit
     end
 
+    public
+
     def dump(value)
       return nil if value.nil?
 
       payload = serialize_payload(value)
-      body    = MultiCompress.compress(payload, algo: @algo, level: @level, dictionary: @dictionary)
+      body    = MultiCompress.compress(payload, algo: @options.algo, level: @options.level,
+                                                dictionary: @options.dictionary)
       framed  = header + body
 
-      @encode == :base64 ? B64_PREFIX + [framed].pack("m0") : framed
+      @options.encode == :base64 ? B64_PREFIX + [framed].pack("m0") : framed
     end
 
     def load(stored)
@@ -60,105 +97,138 @@ module MultiCompress
       read_legacy(stored)
     end
 
-    private
+    module Envelope
+      private
 
-    def header
-      (MAGIC + [VERSION, ALGO_ID.fetch(@algo)].pack("C2")).b
-    end
+      def header
+        (MAGIC + [VERSION, ALGO_ID.fetch(@options.algo)].pack("C2")).b
+      end
 
-    def decode_transport(stored)
-      if @encode == :base64
-        s = stored.to_s
-        return nil unless s.start_with?(B64_PREFIX)
+      def decode_transport(stored)
+        if @options.encode == :base64
+          s = stored.to_s
+          return nil unless s.start_with?(B64_PREFIX)
 
-        decoded = optional_base64(s.byteslice(B64_PREFIX.bytesize, s.bytesize - B64_PREFIX.bytesize))
-        decoded && decoded.start_with?(MAGIC) ? decoded : nil
-      else
-        b = stored.b
-        b.start_with?(MAGIC) ? b : nil
+          decoded = optional_base64(s.byteslice(B64_PREFIX.bytesize, s.bytesize - B64_PREFIX.bytesize))
+          decoded&.start_with?(MAGIC) ? decoded : nil
+        else
+          b = stored.b
+          b.start_with?(MAGIC) ? b : nil
+        end
       end
-    end
 
-    def unwrap(framed)
-      if framed.bytesize < HEADER_SIZE
-        raise MultiCompress::DataError, "MultiCompress::Codec: truncated envelope"
+      def unwrap(framed)
+        raise MultiCompress::DataError, "MultiCompress::Codec: truncated envelope" if framed.bytesize < HEADER_SIZE
+
+        validate_envelope_version!(framed)
+        algo = envelope_algorithm(framed)
+        body = envelope_body(framed)
+        MultiCompress.decompress(body, algo: algo, dictionary: @options.dictionary,
+                                       max_output_size: @options.max_output_size)
       end
 
-      version = framed.getbyte(MAGIC.bytesize)
-      algo_id = framed.getbyte(MAGIC.bytesize + 1)
-      unless version == VERSION
+      def validate_envelope_version!(framed)
+        version = framed.getbyte(MAGIC.bytesize)
+        return if version == VERSION
+
         raise MultiCompress::DataError, "MultiCompress::Codec: unsupported envelope version #{version}"
       end
-      algo = ID_ALGO[algo_id]
-      raise MultiCompress::DataError, "MultiCompress::Codec: unknown algorithm id #{algo_id}" unless algo
 
-      body = framed.byteslice(HEADER_SIZE, framed.bytesize - HEADER_SIZE) || +"".b
-      MultiCompress.decompress(body, algo: algo, dictionary: @dictionary, max_output_size: @max_output_size)
-    end
+      def envelope_algorithm(framed)
+        algo_id = framed.getbyte(MAGIC.bytesize + 1)
+        ID_ALGO.fetch(algo_id) do
+          raise MultiCompress::DataError, "MultiCompress::Codec: unknown algorithm id #{algo_id}"
+        end
+      end
 
-    def read_legacy(stored)
-      case @legacy[:mode]
-      when :reject
-        raise MultiCompress::DataError,
-              "MultiCompress::Codec: value has no envelope and legacy: :reject is set"
-      when :plain
-        decode_payload(stored.b.dup)
-      when :compressed
+      def envelope_body(framed)
+        framed.byteslice(HEADER_SIZE, framed.bytesize - HEADER_SIZE) || +"".b
+      end
+
+      def read_legacy(stored)
+        case @options.legacy[:mode]
+        when :reject
+          raise MultiCompress::DataError,
+                "MultiCompress::Codec: value has no envelope and legacy: :reject is set"
+        when :plain
+          decode_payload(stored.b.dup)
+        when :compressed
+          decode_legacy_compressed(stored)
+        end
+      end
+
+      def decode_legacy_compressed(stored)
         payload = MultiCompress.decompress(
-          stored.b, algo: @legacy[:algo], dictionary: @dictionary, max_output_size: @max_output_size
+          stored.b,
+          algo: @options.legacy[:algo],
+          dictionary: @options.dictionary,
+          max_output_size: @options.max_output_size
         )
         decode_payload(payload)
       end
-    end
 
-    def normalize_legacy(legacy)
-      case legacy
-      when :reject, :plain
-        { mode: legacy }
-      when Hash
-        algo = legacy[:compressed]
-        raise ArgumentError, "legacy: { compressed: <algo> } required" unless ALGO_ID.key?(algo)
-
-        { mode: :compressed, algo: algo }
-      else
-        raise ArgumentError, "legacy: must be :reject, :plain, or { compressed: :algo }"
+      def normalize_legacy(legacy)
+        case legacy
+        when :reject, :plain
+          { mode: legacy }
+        when Hash
+          algo = legacy[:compressed]
+          raise ArgumentError, "legacy: { compressed: <algo> } required" unless ALGO_ID.key?(algo)
+
+          { mode: :compressed, algo: algo }
+        else
+          raise ArgumentError, "legacy: must be :reject, :plain, or { compressed: :algo }"
+        end
       end
     end
 
-    def serialize_payload(value)
-      if @serializer
-        @serializer.dump(value).b
-      else
+    module Payload
+      private
+
+      def serialize_payload(value)
+        if @options.serializer
+          @options.serializer.dump(value).b
+        else
+          serialize_string(value)
+        end
+      end
+
+      def serialize_string(value)
         unless value.is_a?(String)
           raise TypeError, "MultiCompress::Codec expects a String (or pass serializer:); got #{value.class}"
         end
-
-        unless @encoding == Encoding::BINARY || value.dup.force_encoding(@encoding).valid_encoding?
-          raise ArgumentError, "MultiCompress::Codec: value is not valid #{@encoding} " \
-                               "(use encoding: Encoding::BINARY for arbitrary bytes)"
+        if @options.encoding == Encoding::BINARY || value.dup.force_encoding(@options.encoding).valid_encoding?
+          return value.b
         end
-        value.b
+
+        raise ArgumentError, "MultiCompress::Codec: value is not valid #{@options.encoding} " \
+                             "(use encoding: Encoding::BINARY for arbitrary bytes)"
       end
-    end
 
-    def decode_payload(bytes)
-      return @serializer.load(bytes) if @serializer
+      def decode_payload(bytes)
+        return @options.serializer.load(bytes) if @options.serializer
 
-      finalize_string(bytes)
-    end
+        finalize_string(bytes)
+      end
+
+      def finalize_string(bytes)
+        s = bytes.dup.force_encoding(@options.encoding)
+        unless @options.encoding == Encoding::BINARY || s.valid_encoding?
+          raise MultiCompress::DataError, "MultiCompress::Codec: decoded bytes are not valid #{@options.encoding}"
+        end
 
-    def finalize_string(bytes)
-      s = bytes.dup.force_encoding(@encoding)
-      unless @encoding == Encoding::BINARY || s.valid_encoding?
-        raise MultiCompress::DataError, "MultiCompress::Codec: decoded bytes are not valid #{@encoding}"
+        s
       end
-      s
-    end
 
-    def optional_base64(str)
-      str.unpack1("m0")&.b
-    rescue ArgumentError
-      nil
+      def optional_base64(str)
+        str.unpack1("m0")&.b
+      rescue ArgumentError
+        nil
+      end
     end
+
+    private_constant :Envelope, :Payload
+    include Envelope
+    include Payload
   end
 end

data/lib/multi_compress/database/api.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module Database
+    ENGINE = Engine.new
+    private_constant :ENGINE
+
+    module_function
+
+    def compress(text, dictionary: nil)
+      ENGINE.compress(text, dictionary: dictionary)
+    end
+
+    def compress_v1(text)
+      ENGINE.compress_v1(text)
+    end
+
+    def compress_v2(text, dictionary:)
+      ENGINE.compress_v2(text, dictionary: dictionary)
+    end
+
+    def decompress(blob, dictionary: nil)
+      ENGINE.decompress(blob, dictionary: dictionary)
+    end
+
+    def valid?(blob, dictionary: nil)
+      ENGINE.valid?(blob, dictionary: dictionary)
+    end
+
+    def dictionary_ref(blob)
+      ENGINE.dictionary_ref(blob)
+    end
+
+    def original_size(blob)
+      ENGINE.original_size(blob)
+    end
+
+    def version_string
+      ENGINE.version_string
+    end
+  end
+end