brotli_splice 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c2ff7c74f1280217916777270114a52fefb8a6c7c67899db9a6f2017d978e2c
-  data.tar.gz: 8a4c7335d85ef0364713704e2ee18924596742401f15d63359dba3182a54c5f5
+  metadata.gz: ce9fb6c98f2b365b24bad75eb7f1ae7bfef2f86c025a87f27e04d5bf5f8732ee
+  data.tar.gz: 5b98a2d69c15302930662ea35ce53b1a987a180e388473083d1c2f89dc59f532
 SHA512:
-  metadata.gz: 34fdb4f6643d3924e66214fad37b678806ed3d93333f2e340ec324b5403d1b87b5260909659ab8365e8faaaf4ac5274c28c10a62ea48245a10a768a591d1356e
-  data.tar.gz: ba10b2081093749fac4f52d5c58b4a513181b04a1a99e7ce67d9c50a29b1669b4ed39030dafcb8581caa29a3fff77565a4418e16df26bb86512840b6902c24f9
+  metadata.gz: 122de9b45887622ec860896ea6a7b5ad263f2c0ad5ed78296abc7e53beeaae019b740c86d33c6a88337692fc5bdcacc3673d2ea3b63fdd02e1b98a444daa6a5a
+  data.tar.gz: c5a7e0fc26794e77b74fd412c9c26a2350500d1529f90b93fd3add154b2145d231491864c35bf0a1ae0091b3a09a76ae53ee833736d5583df6d2c4d73245823f

data/README.md

@@ -1,7 +1,7 @@
 # BrotliSplice
 
-A Ruby C extension that produces Brotli-compressed streams with a fixed-length
-**spliceable slot** — a region whose raw bytes can be overwritten without
+A Ruby C extension that produces Brotli-compressed streams with fixed-length
+**spliceable slots** — regions whose raw bytes can be overwritten without
 decompressing or re-encoding the rest of the stream.
 
 ## Use case
@@ -33,6 +33,11 @@ The last 2 bytes of the secret slot are reserved as a fixed **context suffix**
 uses the preceding 2 bytes as literal context when compressing part3. The
 replaceable portion is therefore `secret_length - 2` bytes.
 
+A stream can hold several slots. Each slot repeats the same layout: the encoder
+flushes, writes the slot as an uncompressed meta-block, and continues with a
+fresh encoder at the new stream offset. Every slot has its own context suffix
+and adds its own share of the overhead described below.
+
 Compression overhead vs standard Brotli is small — typically 100–200 bytes
 for realistic HTML documents. Two sources of overhead:
 
@@ -111,9 +116,9 @@ compressed << encoder.slot("live-token\r\n".b)
 compressed << encoder.finish("</head><body>...</body></html>".b)
 ```
 
-`write` flushes and byte-aligns each chunk. `slot` may be called once. Its input must end in the fixed `"\r\n"` context suffix, which is not replaceable. `finish` closes the stream and can include a final chunk. Strings are treated as byte sequences regardless of their Ruby encoding.
+`write` flushes and byte-aligns each chunk. `slot` may be called any number of times. Its input must end in the fixed `"\r\n"` context suffix, which is not replaceable. `finish` closes the stream and can include a final chunk. Strings are treated as byte sequences regardless of their Ruby encoding.
 
-After `slot`, `slot_offset` and `slot_length` identify the raw replaceable bytes in the combined compressed output. `context_suffix` returns `"\r\n"`.
+After `slot`, `slot_offset` and `slot_length` identify the raw replaceable bytes of the most recent slot in the combined compressed output. `slots` lists every slot in stream order as `{ offset:, length: }` hashes. `context_suffix` returns `"\r\n"`.
 
 Call `close` when abandoning an unfinished encoder. It releases native state without producing output and is safe to call more than once or after `finish`. Once an encoder is closed, finished, or fails after consuming input, later encoding operations raise `BrotliSplice::Error`.
 
@@ -137,6 +142,28 @@ Compress `html` with a spliceable slot at the given byte position.
 }
 ```
 
+### `BrotliSplice.encode_slots(html, slots, quality: 11) → Hash`
+
+Compress `html` with a spliceable slot at each given byte range. With one
+range, `data` is identical to the output of `encode`.
+
+**Parameters:**
+- `html` — the full HTML string (binary encoding)
+- `slots` — `[offset, length]` byte ranges in ascending order. Ranges may touch
+  but must not overlap, and each length must be > 2
+- `quality:` — Brotli quality level, 0–11 (default: 11)
+
+**Returns** a Hash:
+```ruby
+{
+  data:           String,  # the Brotli-compressed stream
+  slots:          Array,   # one { offset:, length: } Hash per range, in order:
+                           # the replaceable bytes within the compressed stream
+                           # (length = range length - 2)
+  context_suffix: String,  # the 2 fixed context bytes ("\r\n")
+}
+```
+
 ### `BrotliSplice.replace(compressed_data, new_secret, secret_offset, secret_length) → String`
 
 Replace the secret in a compressed stream. Returns a new string with the
@@ -148,6 +175,15 @@ swapped bytes. This is a pure `memcpy` — no compression or decompression.
 - `secret_offset` — from the `encode` result
 - `secret_length` — from the `encode` result
 
+### `BrotliSplice.replace_slots(compressed_data, replacements) → String`
+
+Replace several slots while copying `compressed_data` only once.
+`replacements` is an Array of `[new_secret, secret_offset, secret_length]`
+entries, with offsets and lengths from `encode_slots` or `Encoder#slots`.
+Entries must be in ascending offset order and must not overlap, as those methods
+return them; they may touch. Every entry is checked before any byte is copied,
+so an invalid entry raises `BrotliSplice::Error` and returns nothing.
+
 ## Example
 
 ```ruby
@@ -185,8 +221,7 @@ longer, or place the suffix where a line break is natural).
 
 ## Limitations
 
-- The replaceable slot must be no larger than 65536 bytes, plus the 2-byte context suffix
+- Each replaceable slot must be no larger than 65536 bytes, plus the 2-byte context suffix
 - The replacement must be **exactly** `secret_length` bytes (no length changes)
-- The last 2 bytes of the original secret region become `\r\n` in the output
-- Only one spliceable slot per stream (encode with multiple slots would require
-  chaining encoders)
+- The last 2 bytes of each original slot region become `\r\n` in the output
+- Slots must not overlap

data/brotli_splice.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.summary = "Create Brotli streams with fixed-length spliceable slots"
   spec.description = <<~DESC
     BrotliSplice is a Ruby C extension that creates Brotli-compressed streams
-    containing a fixed-length uncompressed slot. The slot can be overwritten
+    containing fixed-length uncompressed slots. Each slot can be overwritten
     with a simple byte copy, making it useful for injecting fixed-size secrets
     or tokens into pre-compressed HTML responses.
   DESC

data/ext/brotli_splice/brotli_splice.c

@@ -15,6 +15,8 @@ static VALUE cEncoder;
 static VALUE eBrotliSpliceError;
 
 #define CTX_LEN 2
+/* An uncompressed meta-block header stores MLEN - 1 in 16 bits. */
+#define MAX_SLOT_BODY_LEN 65536
 #define OUTPUT_CHUNK_SIZE 16384
 static const uint8_t CTX_BYTES[CTX_LEN] = { '\r', '\n' };
 
@@ -26,16 +28,21 @@ typedef enum {
     ENCODER_FAILED,
 } encoder_lifecycle_t;
 
+typedef struct {
+    size_t offset;
+    size_t length;
+} slot_position_t;
+
 typedef struct {
     BrotliEncoderState *encoder;
     int quality;
     int lgwin;
     size_t uncompressed_bytes;
     size_t bytes_written;
-    size_t slot_offset;
-    size_t slot_length;
+    slot_position_t *slots;
+    size_t slot_count;
+    size_t slot_capacity;
     size_t native_bytes;
-    int has_slot;
     encoder_lifecycle_t lifecycle;
 } splice_encoder_t;
 
@@ -87,6 +94,7 @@ static void encoder_terminalize(splice_encoder_t *encoder, encoder_lifecycle_t l
 static void encoder_free(void *pointer) {
     splice_encoder_t *encoder = pointer;
     encoder_destroy_native(encoder);
+    xfree(encoder->slots);
     xfree(encoder);
 }
 
@@ -94,8 +102,9 @@ static size_t encoder_memsize(const void *pointer) {
     if (!pointer) return 0;
 
     const splice_encoder_t *encoder = pointer;
-    if (encoder->native_bytes > SIZE_MAX - sizeof(splice_encoder_t)) return SIZE_MAX;
-    return sizeof(splice_encoder_t) + encoder->native_bytes;
+    size_t fixed_size = sizeof(splice_encoder_t) + encoder->slot_capacity * sizeof(slot_position_t);
+    if (encoder->native_bytes > SIZE_MAX - fixed_size) return SIZE_MAX;
+    return fixed_size + encoder->native_bytes;
 }
 
 static const rb_data_type_t encoder_type = {
@@ -319,31 +328,43 @@ static VALUE encoder_slot_operation(VALUE opaque) {
         CTX_LEN);
     rb_str_concat(output, context_output);
 
-    encoder->slot_offset = encoder->bytes_written + flushed_length + sizeof(header);
-    encoder->slot_length = body_length;
-    encoder->has_slot = 1;
+    encoder->slots[encoder->slot_count].offset = encoder->bytes_written + flushed_length + sizeof(header);
+    encoder->slots[encoder->slot_count].length = body_length;
+    encoder->slot_count++;
     encoder->bytes_written += flushed_length + sizeof(header) + body_length + (size_t)RSTRING_LEN(context_output);
     encoder->uncompressed_bytes += body_length + CTX_LEN;
     return output;
 }
 
+/*
+ * Grows the slot list before any stream bytes are produced, so a failed
+ * allocation leaves the encoder usable and the stream unchanged.
+ */
+static void reserve_slot(splice_encoder_t *encoder) {
+    if (encoder->slot_count < encoder->slot_capacity) return;
+
+    size_t capacity = encoder->slot_capacity ? encoder->slot_capacity * 2 : 4;
+    REALLOC_N(encoder->slots, slot_position_t, capacity);
+    encoder->slot_capacity = capacity;
+}
+
 static VALUE encoder_slot(VALUE self, VALUE bytes) {
     splice_encoder_t *encoder;
     TypedData_Get_Struct(self, splice_encoder_t, &encoder_type, encoder);
     ensure_writable(encoder);
     check_string(bytes);
 
-    if (encoder->has_slot) rb_raise(eBrotliSpliceError, "slot may only be written once");
-
     size_t total_length = (size_t)RSTRING_LEN(bytes);
     if (total_length <= CTX_LEN) rb_raise(eBrotliSpliceError, "slot must be longer than 2 bytes");
 
     size_t body_length = total_length - CTX_LEN;
-    if (body_length > 65536) rb_raise(eBrotliSpliceError, "slot body must not exceed 64 KB");
+    if (body_length > MAX_SLOT_BODY_LEN) rb_raise(eBrotliSpliceError, "slot body must not exceed 64 KB");
     if (memcmp(RSTRING_PTR(bytes) + body_length, CTX_BYTES, CTX_LEN) != 0) {
         rb_raise(eBrotliSpliceError, "slot must end with the context suffix \\r\\n");
     }
 
+    reserve_slot(encoder);
+
     encoder_operation_t arguments = {encoder, bytes};
     return run_encoder_operation(encoder, encoder_slot_operation, &arguments);
 }
@@ -386,16 +407,36 @@ static VALUE encoder_close(VALUE self) {
     return Qnil;
 }
 
+static const slot_position_t *last_slot(const splice_encoder_t *encoder) {
+    return encoder->slot_count ? &encoder->slots[encoder->slot_count - 1] : NULL;
+}
+
 static VALUE encoder_slot_offset(VALUE self) {
     splice_encoder_t *encoder;
     TypedData_Get_Struct(self, splice_encoder_t, &encoder_type, encoder);
-    return encoder->has_slot ? SIZET2NUM(encoder->slot_offset) : Qnil;
+    const slot_position_t *slot = last_slot(encoder);
+    return slot ? SIZET2NUM(slot->offset) : Qnil;
 }
 
 static VALUE encoder_slot_length(VALUE self) {
     splice_encoder_t *encoder;
     TypedData_Get_Struct(self, splice_encoder_t, &encoder_type, encoder);
-    return encoder->has_slot ? SIZET2NUM(encoder->slot_length) : Qnil;
+    const slot_position_t *slot = last_slot(encoder);
+    return slot ? SIZET2NUM(slot->length) : Qnil;
+}
+
+static VALUE encoder_slots(VALUE self) {
+    splice_encoder_t *encoder;
+    TypedData_Get_Struct(self, splice_encoder_t, &encoder_type, encoder);
+
+    VALUE slots = rb_ary_new_capa((long)encoder->slot_count);
+    for (size_t index = 0; index < encoder->slot_count; index++) {
+        VALUE slot = rb_hash_new();
+        rb_hash_aset(slot, ID2SYM(rb_intern("offset")), SIZET2NUM(encoder->slots[index].offset));
+        rb_hash_aset(slot, ID2SYM(rb_intern("length")), SIZET2NUM(encoder->slots[index].length));
+        rb_ary_push(slots, slot);
+    }
+    return slots;
 }
 
 static VALUE encoder_context_suffix(VALUE self) {
@@ -404,29 +445,60 @@ static VALUE encoder_context_suffix(VALUE self) {
 
 typedef struct {
     VALUE encoder;
-    VALUE prefix;
-    VALUE slot;
-    VALUE suffix;
+    VALUE pieces;
 } encode_operation_t;
 
+/*
+ * Pieces alternate between compressed chunks and slots, starting and ending
+ * with a compressed chunk: [chunk, slot, chunk, slot, ..., chunk].
+ */
 static VALUE encode_operation(VALUE opaque) {
     encode_operation_t *arguments = (encode_operation_t *)opaque;
-    VALUE data = rb_funcall(arguments->encoder, rb_intern("write"), 1, arguments->prefix);
-    rb_str_concat(data, rb_funcall(arguments->encoder, rb_intern("slot"), 1, arguments->slot));
-    rb_str_concat(data, rb_funcall(arguments->encoder, rb_intern("finish"), 1, arguments->suffix));
-
-    VALUE result = rb_hash_new();
-    rb_hash_aset(result, ID2SYM(rb_intern("data")), data);
-    rb_hash_aset(result, ID2SYM(rb_intern("secret_offset")), rb_funcall(arguments->encoder, rb_intern("slot_offset"), 0));
-    rb_hash_aset(result, ID2SYM(rb_intern("secret_length")), rb_funcall(arguments->encoder, rb_intern("slot_length"), 0));
-    rb_hash_aset(result, ID2SYM(rb_intern("context_suffix")), encoder_context_suffix(arguments->encoder));
-    return result;
+    long last = RARRAY_LEN(arguments->pieces) - 1;
+    VALUE data = binary_string(NULL, 0);
+    for (long index = 0; index < last; index += 2) {
+        rb_str_concat(data, rb_funcall(arguments->encoder, rb_intern("write"), 1, RARRAY_AREF(arguments->pieces, index)));
+        rb_str_concat(data, rb_funcall(arguments->encoder, rb_intern("slot"), 1, RARRAY_AREF(arguments->pieces, index + 1)));
+    }
+    rb_str_concat(data, rb_funcall(arguments->encoder, rb_intern("finish"), 1, RARRAY_AREF(arguments->pieces, last)));
+    return data;
 }
 
 static VALUE close_encoder_ensure(VALUE encoder_value) {
     return encoder_close(encoder_value);
 }
 
+static VALUE new_encoder_with_options(VALUE options) {
+    return rb_class_new_instance_kw(NIL_P(options) ? 0 : 1, NIL_P(options) ? NULL : &options, cEncoder, RB_PASS_KEYWORDS);
+}
+
+static VALUE encode_pieces(VALUE encoder, VALUE pieces) {
+    encode_operation_t arguments = {encoder, pieces};
+    return rb_ensure(encode_operation, (VALUE)&arguments, close_encoder_ensure, encoder);
+}
+
+/*
+ * `bounds` holds validated, ascending, non-overlapping [offset, length] pairs.
+ * Each slot copy ends in the context suffix, which `Encoder#slot` requires.
+ */
+static VALUE slot_pieces(VALUE html, const size_t *bounds, long count) {
+    VALUE pieces = rb_ary_new_capa(count * 2 + 1);
+    size_t position = 0;
+    for (long index = 0; index < count; index++) {
+        size_t offset = bounds[index * 2];
+        size_t length = bounds[index * 2 + 1];
+        rb_ary_push(pieces, binary_string((const uint8_t *)RSTRING_PTR(html) + position, offset - position));
+
+        VALUE slot = binary_string((const uint8_t *)RSTRING_PTR(html) + offset, length);
+        rb_str_modify(slot);
+        memcpy(RSTRING_PTR(slot) + length - CTX_LEN, CTX_BYTES, CTX_LEN);
+        rb_ary_push(pieces, slot);
+        position = offset + length;
+    }
+    rb_ary_push(pieces, binary_string((const uint8_t *)RSTRING_PTR(html) + position, (size_t)RSTRING_LEN(html) - position));
+    return pieces;
+}
+
 static VALUE rb_brotli_splice_encode(int argc, VALUE *argv, VALUE self) {
     VALUE html, secret_offset_value, secret_length_value, options;
     rb_scan_args(argc, argv, "3:", &html, &secret_offset_value, &secret_length_value, &options);
@@ -439,18 +511,66 @@ static VALUE rb_brotli_splice_encode(int argc, VALUE *argv, VALUE self) {
     if (secret_offset > html_length || secret_length > html_length - secret_offset) {
         rb_raise(eBrotliSpliceError, "secret_offset + secret_length exceeds html size");
     }
+    if (secret_length - CTX_LEN > MAX_SLOT_BODY_LEN) rb_raise(eBrotliSpliceError, "slot body must not exceed 64 KB");
 
-    VALUE prefix = binary_string((const uint8_t *)RSTRING_PTR(html), secret_offset);
-    VALUE slot = binary_string((const uint8_t *)RSTRING_PTR(html) + secret_offset, secret_length);
-    VALUE suffix = binary_string(
-        (const uint8_t *)RSTRING_PTR(html) + secret_offset + secret_length,
-        html_length - secret_offset - secret_length);
-    rb_str_modify(slot);
-    memcpy(RSTRING_PTR(slot) + secret_length - CTX_LEN, CTX_BYTES, CTX_LEN);
+    size_t bounds[2] = {secret_offset, secret_length};
+    VALUE pieces = slot_pieces(html, bounds, 1);
+    VALUE encoder = new_encoder_with_options(options);
+    VALUE data = encode_pieces(encoder, pieces);
 
-    VALUE encoder = rb_class_new_instance_kw(NIL_P(options) ? 0 : 1, NIL_P(options) ? NULL : &options, cEncoder, RB_PASS_KEYWORDS);
-    encode_operation_t arguments = {encoder, prefix, slot, suffix};
-    return rb_ensure(encode_operation, (VALUE)&arguments, close_encoder_ensure, encoder);
+    VALUE result = rb_hash_new();
+    rb_hash_aset(result, ID2SYM(rb_intern("data")), data);
+    rb_hash_aset(result, ID2SYM(rb_intern("secret_offset")), encoder_slot_offset(encoder));
+    rb_hash_aset(result, ID2SYM(rb_intern("secret_length")), encoder_slot_length(encoder));
+    rb_hash_aset(result, ID2SYM(rb_intern("context_suffix")), encoder_context_suffix(encoder));
+    return result;
+}
+
+static VALUE rb_brotli_splice_encode_slots(int argc, VALUE *argv, VALUE self) {
+    VALUE html, slots, options;
+    rb_scan_args(argc, argv, "2:", &html, &slots, &options);
+    Check_Type(html, T_STRING);
+    Check_Type(slots, T_ARRAY);
+
+    /*
+     * Coerce every pair before validating any of them: numeric coercion can run
+     * Ruby code that changes `html`.
+     */
+    long count = RARRAY_LEN(slots);
+    VALUE bounds_buffer;
+    size_t *bounds = ALLOCV_N(size_t, bounds_buffer, (size_t)count * 2);
+    for (long index = 0; index < count; index++) {
+        VALUE slot = rb_ary_entry(slots, index);
+        Check_Type(slot, T_ARRAY);
+        if (RARRAY_LEN(slot) != 2) rb_raise(rb_eArgError, "each slot must be an [offset, length] pair");
+        bounds[index * 2] = NUM2SIZET(rb_ary_entry(slot, 0));
+        bounds[index * 2 + 1] = NUM2SIZET(rb_ary_entry(slot, 1));
+    }
+
+    size_t html_length = (size_t)RSTRING_LEN(html);
+    size_t previous_end = 0;
+    for (long index = 0; index < count; index++) {
+        size_t offset = bounds[index * 2];
+        size_t length = bounds[index * 2 + 1];
+        if (length <= CTX_LEN) rb_raise(eBrotliSpliceError, "slot length must be > %d", CTX_LEN);
+        if (length - CTX_LEN > MAX_SLOT_BODY_LEN) rb_raise(eBrotliSpliceError, "slot body must not exceed 64 KB");
+        if (offset > html_length || length > html_length - offset) {
+            rb_raise(eBrotliSpliceError, "slot offset + length exceeds html size");
+        }
+        if (offset < previous_end) rb_raise(eBrotliSpliceError, "slots must be in ascending order and must not overlap");
+        previous_end = offset + length;
+    }
+
+    VALUE pieces = slot_pieces(html, bounds, count);
+    ALLOCV_END(bounds_buffer);
+    VALUE encoder = new_encoder_with_options(options);
+    VALUE data = encode_pieces(encoder, pieces);
+
+    VALUE result = rb_hash_new();
+    rb_hash_aset(result, ID2SYM(rb_intern("data")), data);
+    rb_hash_aset(result, ID2SYM(rb_intern("slots")), encoder_slots(encoder));
+    rb_hash_aset(result, ID2SYM(rb_intern("context_suffix")), encoder_context_suffix(encoder));
+    return result;
 }
 
 static VALUE rb_brotli_splice_replace(VALUE self, VALUE data, VALUE secret,
@@ -473,6 +593,60 @@ static VALUE rb_brotli_splice_replace(VALUE self, VALUE data, VALUE secret,
     return result;
 }
 
+static VALUE rb_brotli_splice_replace_slots(VALUE self, VALUE data, VALUE replacements) {
+    Check_Type(data, T_STRING);
+    Check_Type(replacements, T_ARRAY);
+
+    /*
+     * Coerce every entry before validating any of them: numeric coercion can run
+     * Ruby code that changes `data` or a secret.
+     */
+    long count = RARRAY_LEN(replacements);
+    VALUE secrets = rb_ary_new_capa(count);
+    VALUE bounds_buffer;
+    size_t *bounds = ALLOCV_N(size_t, bounds_buffer, (size_t)count * 2);
+    for (long index = 0; index < count; index++) {
+        VALUE replacement = rb_ary_entry(replacements, index);
+        Check_Type(replacement, T_ARRAY);
+        if (RARRAY_LEN(replacement) != 3) {
+            rb_raise(rb_eArgError, "each replacement must be a [secret, offset, length] triple");
+        }
+        VALUE secret = rb_ary_entry(replacement, 0);
+        Check_Type(secret, T_STRING);
+        rb_ary_push(secrets, secret);
+        bounds[index * 2] = NUM2SIZET(rb_ary_entry(replacement, 1));
+        bounds[index * 2 + 1] = NUM2SIZET(rb_ary_entry(replacement, 2));
+    }
+
+    size_t data_length = (size_t)RSTRING_LEN(data);
+    size_t previous_end = 0;
+    for (long index = 0; index < count; index++) {
+        VALUE secret = RARRAY_AREF(secrets, index);
+        size_t offset = bounds[index * 2];
+        size_t length = bounds[index * 2 + 1];
+        if ((size_t)RSTRING_LEN(secret) != length) {
+            rb_raise(eBrotliSpliceError, "secret length %ld != expected %zu", RSTRING_LEN(secret), length);
+        }
+        if (offset > data_length || length > data_length - offset) {
+            rb_raise(eBrotliSpliceError, "offset+length exceeds data size");
+        }
+        if (offset < previous_end) {
+            rb_raise(eBrotliSpliceError, "replacements must be in ascending order and must not overlap");
+        }
+        previous_end = offset + length;
+    }
+
+    VALUE result = rb_str_dup(data);
+    rb_str_modify(result);
+    for (long index = 0; index < count; index++) {
+        VALUE secret = RARRAY_AREF(secrets, index);
+        memcpy(RSTRING_PTR(result) + bounds[index * 2], RSTRING_PTR(secret), bounds[index * 2 + 1]);
+    }
+    ALLOCV_END(bounds_buffer);
+    RB_GC_GUARD(secrets);
+    return result;
+}
+
 void Init_brotli_splice(void) {
     mBrotliSplice = rb_define_module("BrotliSplice");
     eBrotliSpliceError = rb_define_class_under(mBrotliSplice, "Error", rb_eRuntimeError);
@@ -487,8 +661,11 @@ void Init_brotli_splice(void) {
     rb_define_method(cEncoder, "close", encoder_close, 0);
     rb_define_method(cEncoder, "slot_offset", encoder_slot_offset, 0);
     rb_define_method(cEncoder, "slot_length", encoder_slot_length, 0);
+    rb_define_method(cEncoder, "slots", encoder_slots, 0);
     rb_define_method(cEncoder, "context_suffix", encoder_context_suffix, 0);
 
     rb_define_singleton_method(mBrotliSplice, "encode", rb_brotli_splice_encode, -1);
+    rb_define_singleton_method(mBrotliSplice, "encode_slots", rb_brotli_splice_encode_slots, -1);
     rb_define_singleton_method(mBrotliSplice, "replace", rb_brotli_splice_replace, 4);
+    rb_define_singleton_method(mBrotliSplice, "replace_slots", rb_brotli_splice_replace_slots, 2);
 }

data/lib/brotli_splice/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BrotliSplice
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: brotli_splice
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-11 00:00:00.000000000 Z
+date: 2026-10-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   BrotliSplice is a Ruby C extension that creates Brotli-compressed streams
-  containing a fixed-length uncompressed slot. The slot can be overwritten
+  containing fixed-length uncompressed slots. Each slot can be overwritten
   with a simple byte copy, making it useful for injecting fixed-size secrets
   or tokens into pre-compressed HTML responses.
 email: