castrum 0.9.2 → 0.9.4

package/rust/http/cookie_parser.rs

@@ -0,0 +1,140 @@
+// rust/http/cookie_parser.rs — Unified zero-alloc cookie parser
+// Eliminated the _vec variant; all callers use the single _into_slice path.
+// Upper-bound pre-allocation for callers that need a Vec.
+
+use crate::util::bytes::cookie_pairs;
+use crate::util::{write_bytes, write_u32_le};
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+
+/// Parse cookies into a caller-provided slice (zero-alloc).
+/// Output format: [u32 count] repeated { [u32 name_len] [name] [u32 value_len] [value] }
+#[inline]
+pub fn cookie_parse_packed_into_slice(input: &[u8], out: &mut [u8]) -> Result<usize> {
+    let mut pos = 0usize;
+    write_u32_le(out, &mut pos, 0)?;
+
+    let mut count = 0u32;
+
+    for (name, value) in cookie_pairs(input) {
+        write_u32_le(out, &mut pos, name.len() as u32)?;
+        write_bytes(out, &mut pos, name)?;
+
+        write_u32_le(out, &mut pos, value.len() as u32)?;
+        write_bytes(out, &mut pos, value)?;
+
+        count += 1;
+    }
+
+    out[0..4].copy_from_slice(&count.to_le_bytes());
+    Ok(pos)
+}
+
+/// Compute the EXACT packed output size for `input` WITHOUT writing — the
+/// "needed-size" pass for the C-ABI convention. Mirrors
+/// [`cookie_parse_packed_into_slice`] (trim + DQUOTE-unwrap, no decode), so the
+/// reported size is byte-exact.
+#[inline]
+pub fn cookie_parse_packed_size(input: &[u8]) -> Result<usize> {
+    let mut size = 4usize; // count prefix
+    for (name, value) in crate::util::bytes::cookie_pairs(input) {
+        size += 4 + name.len();
+        size += 4 + value.len();
+    }
+    Ok(size)
+}
+
+/// Allocate and parse cookies. Uses conservative upper bound to avoid a pre-scan.
+#[inline]
+pub fn cookie_parse_packed_vec(input: &[u8]) -> Result<Vec<u8>> {
+    let upper_bound = input.len().saturating_mul(9).saturating_add(16);
+    let mut out = vec![0u8; upper_bound];
+    let written = cookie_parse_packed_into_slice(input, &mut out)?;
+    out.truncate(written);
+    Ok(out)
+}
+
+#[napi]
+pub fn cookie_parse_packed(input: Uint8Array) -> Result<Buffer> {
+    cookie_parse_packed_vec(input.as_ref()).map(Buffer::from)
+}
+
+#[napi]
+pub fn cookie_parse_packed_into(input: Uint8Array, mut output: Uint8Array) -> Result<u32> {
+    crate::util::run_packed_into(&input, &mut output, cookie_parse_packed_into_slice)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::cookie_parse_packed_vec;
+    use crate::test_support::decode_packed_pairs;
+
+    #[test]
+    fn cookie_parse_basic() {
+        let packed = cookie_parse_packed_vec(b"a=1; b=2").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs.len(), 2);
+        assert_eq!(pairs[0], (b"a".to_vec(), b"1".to_vec()));
+        assert_eq!(pairs[1], (b"b".to_vec(), b"2".to_vec()));
+    }
+
+    #[test]
+    fn cookie_parse_trims_whitespace() {
+        let packed = cookie_parse_packed_vec(b" a = 1 ; b = hello world ").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs.len(), 2);
+        assert_eq!(pairs[0], (b"a".to_vec(), b"1".to_vec()));
+        assert_eq!(pairs[1], (b"b".to_vec(), b"hello world".to_vec()));
+    }
+
+    #[test]
+    fn cookie_parse_skips_empty_name() {
+        let packed = cookie_parse_packed_vec(b"=1; =2; ok=3").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs.len(), 1);
+        assert_eq!(pairs[0], (b"ok".to_vec(), b"3".to_vec()));
+    }
+
+    #[test]
+    fn cookie_parse_empty_value() {
+        let packed = cookie_parse_packed_vec(b"session=").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs.len(), 1);
+        assert_eq!(pairs[0], (b"session".to_vec(), b"".to_vec()));
+    }
+
+    #[test]
+    fn cookie_parse_equals_in_value() {
+        // Only the first `=` separates name from value.
+        let packed = cookie_parse_packed_vec(b"a=b=c").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs.len(), 1);
+        assert_eq!(pairs[0], (b"a".to_vec(), b"b=c".to_vec()));
+    }
+
+    #[test]
+    fn cookie_parse_expires_value_with_commas() {
+        let packed =
+            cookie_parse_packed_vec(b"session=abc; expires=Wed, 21 Oct 2015 07:28:00 GMT").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs.len(), 2);
+        assert_eq!(
+            pairs[1],
+            (
+                b"expires".to_vec(),
+                b"Wed, 21 Oct 2015 07:28:00 GMT".to_vec()
+            )
+        );
+    }
+
+    #[test]
+    fn cookie_parse_quotes_are_not_special() {
+        // Cookies split on `;` unconditionally — quotes are ordinary data, and a
+        // token without `=` becomes a pair with an empty value.
+        let packed = cookie_parse_packed_vec(b"a=\"x;y\"").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs.len(), 2);
+        assert_eq!(pairs[0], (b"a".to_vec(), b"\"x".to_vec()));
+        assert_eq!(pairs[1], (b"y\"".to_vec(), b"".to_vec()));
+    }
+}

package/rust/http/etag.rs

@@ -0,0 +1,289 @@
+// rust/http/etag.rs — HTTP cache semantics (ETag + conditional requests).
+//
+// ETag generation (strong/weak, crc32-based) and the `ConditionalRequest`
+// higher-order instance that turns If-None-Match / If-Modified-Since into a
+// 304 decision. HTTP-date (IMF-fixdate) formatting/parsing lives in the
+// `http_date` submodule; the conditional request reuses
+// `http_date::parse_http_date_secs` for If-Modified-Since.
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+
+use crate::http::http_date::parse_http_date_secs;
+use crate::util::bytes::trim_ascii_whitespace;
+
+// ── ETag ─────────────────────────────────────────────────────────
+
+/// Format a crc32 digest as an 8-char lowercase hex ETag value. Written into a
+/// fixed stack buffer (10 or 12 bytes) — no `format!`/heap allocation.
+pub fn etag_from_crc32(crc: u32, weak: bool) -> String {
+    let mut buf = [0u8; 12];
+    let start = if weak { 2 } else { 0 };
+    if weak {
+        buf[0] = b'W';
+        buf[1] = b'/';
+    }
+    let hex = crate::util::bytes::HEX_LOWER;
+    buf[start] = b'"';
+    buf[start + 1] = hex[((crc >> 28) & 0x0f) as usize];
+    buf[start + 2] = hex[((crc >> 24) & 0x0f) as usize];
+    buf[start + 3] = hex[((crc >> 20) & 0x0f) as usize];
+    buf[start + 4] = hex[((crc >> 16) & 0x0f) as usize];
+    buf[start + 5] = hex[((crc >> 12) & 0x0f) as usize];
+    buf[start + 6] = hex[((crc >> 8) & 0x0f) as usize];
+    buf[start + 7] = hex[((crc >> 4) & 0x0f) as usize];
+    buf[start + 8] = hex[(crc & 0x0f) as usize];
+    buf[start + 9] = b'"';
+    String::from_utf8(buf[..start + 10].to_vec()).expect("etag is ASCII")
+}
+
+/// Format a crc32 digest as an 8-char lowercase hex ETag value directly into
+/// `out` (zero-alloc — no `String`/heap allocation). Returns the number of
+/// bytes written (10 strong, 12 weak). Errors if `out` is too small.
+pub fn etag_from_crc32_into(crc: u32, weak: bool, out: &mut [u8]) -> Result<usize> {
+    let len = if weak { 12 } else { 10 };
+    if out.len() < len {
+        return Err(Error::from_reason("etag: output buffer too small"));
+    }
+    let hex = crate::util::bytes::HEX_LOWER;
+    let mut pos = 0usize;
+    if weak {
+        out[pos] = b'W';
+        out[pos + 1] = b'/';
+        pos += 2;
+    }
+    out[pos] = b'"';
+    pos += 1;
+    out[pos] = hex[((crc >> 28) & 0x0f) as usize];
+    out[pos + 1] = hex[((crc >> 24) & 0x0f) as usize];
+    out[pos + 2] = hex[((crc >> 20) & 0x0f) as usize];
+    out[pos + 3] = hex[((crc >> 16) & 0x0f) as usize];
+    out[pos + 4] = hex[((crc >> 12) & 0x0f) as usize];
+    out[pos + 5] = hex[((crc >> 8) & 0x0f) as usize];
+    out[pos + 6] = hex[((crc >> 4) & 0x0f) as usize];
+    out[pos + 7] = hex[(crc & 0x0f) as usize];
+    out[pos + 8] = b'"';
+    Ok(len)
+}
+
+#[napi]
+pub fn etag(input: Uint8Array, weak: Option<bool>) -> Buffer {
+    let crc = crc32fast::hash(input.as_ref());
+    Buffer::from(etag_from_crc32(crc, weak.unwrap_or(false)).into_bytes())
+}
+
+/// Reusable-output etag: writes the ETag into `output` and returns bytes
+/// written (10 strong / 12 weak). Errors if `output` is too small.
+#[napi]
+pub fn etag_into(input: Uint8Array, mut output: Uint8Array, weak: Option<bool>) -> Result<u32> {
+    let weak = weak.unwrap_or(false);
+    crate::util::run_packed_into(&input, &mut output, move |inp, out| {
+        let crc = crc32fast::hash(inp);
+        etag_from_crc32_into(crc, weak, out)
+    })
+}
+
+/// Packed ETag batch: `[u32 count]{[u32 len][data]}` in →
+/// `[u32 count]{[u32 len][etag]}` out (10 strong / 12 weak bytes each).
+#[napi]
+pub fn etag_batch_packed(input: Uint8Array, weak: Option<bool>) -> Result<Buffer> {
+    let weak = weak.unwrap_or(false);
+    let iter = crate::util::packed::PackedIter::new(input.as_ref())?;
+    let count = iter.len();
+    let per = if weak { 12 } else { 10 };
+    // Direct-write: ETags are fixed-size (10 strong / 12 weak), so no per-item
+    // `String`/`Vec` allocation.
+    let mut out = Vec::with_capacity(4 + count.saturating_mul(4 + per));
+    out.extend_from_slice(&(count as u32).to_le_bytes());
+    for item in iter {
+        let crc = crc32fast::hash(item);
+        out.extend_from_slice(&(per as u32).to_le_bytes());
+        let start = out.len();
+        out.resize(start + per, 0);
+        etag_from_crc32_into(crc, weak, &mut out[start..start + per])?;
+    }
+    Ok(Buffer::from(out))
+}
+
+// ── Conditional requests (If-None-Match / If-Modified-Since) ─────
+
+/// Strip the `W/` weak prefix from an opaque-tag.
+fn strip_weak(tag: &[u8]) -> &[u8] {
+    if tag.starts_with(b"W/") {
+        &tag[2..]
+    } else {
+        tag
+    }
+}
+
+/// Weak equality of two opaque-tags (RFC 7232 §2.3.2).
+fn etag_weak_eq(a: &[u8], b: &[u8]) -> bool {
+    strip_weak(trim_ascii_whitespace(a)) == strip_weak(trim_ascii_whitespace(b))
+}
+
+/// Higher-order instance: per-resource state (etag + last-modified) computed
+/// once, then reused across requests to answer "is this 304?".
+#[napi]
+pub struct ConditionalRequest {
+    etag_value: Vec<u8>,
+    last_modified_secs: i64,
+}
+
+/// Pure core: evaluate is-not-modified against a precompiled etag + last
+/// modified. Shared by the napi method and the C-ABI opaque-handle path, so
+/// both transports answer identically (304 semantics: If-None-Match wins over
+/// If-Modified-Since).
+pub(crate) fn is_not_modified_core(
+    etag_value: &[u8],
+    last_modified_secs: i64,
+    if_none_match: Option<&[u8]>,
+    if_modified_since: Option<&[u8]>,
+) -> bool {
+    if let Some(inm) = if_none_match {
+        let header = trim_ascii_whitespace(inm);
+        if header == b"*" {
+            return true;
+        }
+        return header
+            .split(|&b| b == b',')
+            .any(|candidate| etag_weak_eq(candidate, etag_value));
+    }
+    if let Some(ims) = if_modified_since {
+        if last_modified_secs > 0 {
+            if let Some(secs) = parse_http_date_secs(ims) {
+                return last_modified_secs <= secs;
+            }
+        }
+    }
+    false
+}
+
+#[napi]
+impl ConditionalRequest {
+    #[napi(constructor)]
+    pub fn new(etag_value: Uint8Array, last_modified_secs: Option<f64>) -> Self {
+        Self {
+            etag_value: etag_value.as_ref().to_vec(),
+            last_modified_secs: last_modified_secs.map(|v| v as i64).unwrap_or(0).max(0),
+        }
+    }
+
+    /// Opaque handle to the precompiled state, for the `bun:ffi` C-ABI fast path
+    /// (`castrum_conditional_is_not_modified` in rust/ffi.rs). Only valid while
+    /// THIS instance is alive; the JS wrapper holds the instance for the handle
+    /// lifetime (same contract as `Ingress::ingress_inner_ptr`).
+    #[napi]
+    pub fn inner_ptr(&self) -> u64 {
+        self as *const ConditionalRequest as u64
+    }
+
+    /// true → "304 Not Modified" (If-None-Match wins over If-Modified-Since).
+    #[napi]
+    pub fn is_not_modified(
+        &self,
+        if_none_match: Option<Uint8Array>,
+        if_modified_since: Option<Uint8Array>,
+    ) -> bool {
+        is_not_modified_core(
+            &self.etag_value,
+            self.last_modified_secs,
+            if_none_match.as_deref(),
+            if_modified_since.as_deref(),
+        )
+    }
+}
+
+/// C-ABI support: evaluate is-not-modified against the precompiled state.
+///
+/// # Safety
+/// `p` must be a valid `*const ConditionalRequest` obtained from `inner_ptr`
+/// and must stay alive for the call (the JS wrapper holds the napi instance).
+pub(crate) unsafe fn conditional_is_not_modified(
+    p: *const ConditionalRequest,
+    inm: Option<&[u8]>,
+    ims: Option<&[u8]>,
+) -> bool {
+    let c = &*p;
+    is_not_modified_core(&c.etag_value, c.last_modified_secs, inm, ims)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn etag_formatting() {
+        assert_eq!(etag_from_crc32(0xdead_beef, false), "\"deadbeef\"");
+        assert_eq!(etag_from_crc32(0x0000_0001, true), "W/\"00000001\"");
+    }
+
+    #[test]
+    fn etag_from_crc32_into_matches_allocating() {
+        let crc = crc32fast::hash(b"hello world, this is etag data");
+        let strong = etag_from_crc32(crc, false);
+        let weak = etag_from_crc32(crc, true);
+        let mut out = [0u8; 12];
+        let n = etag_from_crc32_into(crc, false, &mut out).unwrap();
+        assert_eq!(n, strong.len());
+        assert_eq!(&out[..n], strong.as_bytes());
+        let n2 = etag_from_crc32_into(crc, true, &mut out).unwrap();
+        assert_eq!(n2, weak.len());
+        assert_eq!(&out[..n2], weak.as_bytes());
+    }
+
+    #[test]
+    fn etag_from_crc32_into_small_buffer_errors() {
+        let mut out = [0u8; 4];
+        assert!(etag_from_crc32_into(0xdead_beef, false, &mut out).is_err());
+        let mut out2 = [0u8; 10];
+        assert!(etag_from_crc32_into(0xdead_beef, true, &mut out2).is_err());
+    }
+
+    #[test]
+    fn etag_into_reports_length() {
+        let data = b"hello world, this is etag data";
+        let out = Uint8Array::new(vec![0u8; 16]);
+        let n = etag_into(Uint8Array::new(data.to_vec()), out, None).unwrap();
+        assert_eq!(
+            n as usize,
+            etag_from_crc32(crc32fast::hash(data), false).len()
+        );
+        let out2 = Uint8Array::new(vec![0u8; 16]);
+        let n2 = etag_into(Uint8Array::new(data.to_vec()), out2, Some(true)).unwrap();
+        assert_eq!(
+            n2 as usize,
+            etag_from_crc32(crc32fast::hash(data), true).len()
+        );
+    }
+
+    #[test]
+    fn conditional_if_none_match_star() {
+        let c = ConditionalRequest::new(Uint8Array::new(b"\"abc123\"".to_vec()), Some(1_000.0));
+        assert!(c.is_not_modified(Some(Uint8Array::new(b"*".to_vec())), None));
+    }
+
+    #[test]
+    fn conditional_weak_etag_match() {
+        let c = ConditionalRequest::new(Uint8Array::new(b"\"abc123\"".to_vec()), Some(1_000.0));
+        assert!(c.is_not_modified(
+            Some(Uint8Array::new(b"\"xyz\", W/\"abc123\"".to_vec())),
+            None
+        ));
+        assert!(!c.is_not_modified(Some(Uint8Array::new(b"\"xyz\", \"abc124\"".to_vec())), None));
+    }
+
+    #[test]
+    fn conditional_if_modified_since() {
+        // last-modified = 1970-01-01 00:16:40 (secs 1000).
+        let c = ConditionalRequest::new(Uint8Array::new(b"\"abc123\"".to_vec()), Some(1_000.0));
+        // IMS equal to last-modified → not modified → 304.
+        let equal = Uint8Array::new(b"Thu, 01 Jan 1970 00:16:40 GMT".to_vec());
+        assert!(c.is_not_modified(None, Some(equal)));
+        // IMS after last-modified → not modified → 304.
+        let after = Uint8Array::new(b"Thu, 01 Jan 1970 00:16:41 GMT".to_vec());
+        assert!(c.is_not_modified(None, Some(after)));
+        // IMS before last-modified → modified → 200.
+        let before = Uint8Array::new(b"Thu, 01 Jan 1970 00:00:01 GMT".to_vec());
+        assert!(!c.is_not_modified(None, Some(before)));
+    }
+}

package/rust/http/form.rs

@@ -0,0 +1,132 @@
+// rust/http/form.rs — application/x-www-form-urlencoded body parser.
+//
+// Reuses the zero-alloc query-parser core (`query_parse_packed_into_slice`):
+// it already splits on '&', decodes '+'→space and %XX, which is exactly the
+// x-www-form-urlencoded wire format. This module adds the public napi surface:
+// a scalar `form_parse_packed` and the higher-order `FormParser` instance,
+// which owns a reusable output buffer so repeated parses don't reallocate.
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+
+use crate::http::query_parser::query_parse_packed_into_slice;
+
+/// Parse an application/x-www-form-urlencoded body into packed pairs.
+/// Output: `[u32 count] repeated { [u32 name_len] [name] [u32 value_len] [value] }`
+#[inline]
+pub fn form_parse_packed_vec(input: &[u8]) -> Result<Vec<u8>> {
+    // Same conservative upper bound as the query parser (9x + 16).
+    let upper_bound = input.len().saturating_mul(9).saturating_add(16);
+    let mut out = vec![0u8; upper_bound];
+    let written = query_parse_packed_into_slice(input, &mut out)?;
+    out.truncate(written);
+    Ok(out)
+}
+
+#[napi]
+pub fn form_parse_packed(input: Uint8Array) -> Result<Buffer> {
+    form_parse_packed_vec(input.as_ref()).map(Buffer::from)
+}
+
+/// Higher-order instance: owns a reusable output buffer so repeated parses do
+/// not reallocate. Buffer allocation happens once in the constructor (or is
+/// amortized via grow-on-demand in `parse`), and `parse` writes into the
+/// reused buffer — the compiled-once pattern shared by `SchemaValidator` /
+/// `HmacSigner` / `TemplateRenderer`.
+#[napi]
+pub struct FormParser {
+    buf: Vec<u8>,
+}
+
+#[napi]
+impl FormParser {
+    #[napi(constructor)]
+    pub fn new(capacity: Option<u32>) -> Self {
+        // Clamp the initial buffer to a sane cap so a huge capacity can't
+        // force a multi-GiB single allocation; parse() still grows on demand.
+        const MAX_CAPACITY: usize = 16 * 1024 * 1024;
+        let cap = (capacity.unwrap_or(4096).max(256) as usize).min(MAX_CAPACITY);
+        Self {
+            buf: vec![0u8; cap],
+        }
+    }
+
+    /// Parse into the instance's reusable buffer and return the packed pairs.
+    #[napi]
+    pub fn parse(&mut self, input: Uint8Array) -> Result<Buffer> {
+        let need = input.len().saturating_mul(9).saturating_add(16);
+        if self.buf.len() < need {
+            self.buf.resize(need, 0);
+        }
+        let written = query_parse_packed_into_slice(input.as_ref(), &mut self.buf)?;
+        Ok(Buffer::from(self.buf[..written].to_vec()))
+    }
+
+    /// Zero-alloc parse into a caller-provided output buffer.
+    #[napi]
+    pub fn parse_into(&self, input: Uint8Array, mut output: Uint8Array) -> Result<u32> {
+        crate::util::run_packed_into(&input, &mut output, query_parse_packed_into_slice)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_support::decode_packed_pairs;
+
+    #[test]
+    fn form_parse_basic_pairs() {
+        let packed = form_parse_packed_vec(b"name=John%20Doe&age=30&tags=a&tags=b").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs.len(), 4);
+        assert_eq!(pairs[0], (b"name".to_vec(), b"John Doe".to_vec()));
+        assert_eq!(pairs[1], (b"age".to_vec(), b"30".to_vec()));
+        assert_eq!(pairs[2], (b"tags".to_vec(), b"a".to_vec()));
+        assert_eq!(pairs[3], (b"tags".to_vec(), b"b".to_vec()));
+    }
+
+    #[test]
+    fn form_parse_plus_and_percent() {
+        let packed = form_parse_packed_vec(b"a+b=c%2Bd&empty=").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs[0], (b"a b".to_vec(), b"c+d".to_vec()));
+        assert_eq!(pairs[1], (b"empty".to_vec(), b"".to_vec()));
+    }
+
+    #[test]
+    fn form_parse_key_without_equals() {
+        let packed = form_parse_packed_vec(b"flag&x=1").unwrap();
+        let pairs = decode_packed_pairs(&packed);
+        assert_eq!(pairs[0], (b"flag".to_vec(), b"".to_vec()));
+        assert_eq!(pairs[1], (b"x".to_vec(), b"1".to_vec()));
+    }
+
+    #[test]
+    fn form_parse_empty_input() {
+        let packed = form_parse_packed_vec(b"").unwrap();
+        assert!(decode_packed_pairs(&packed).is_empty());
+    }
+
+    #[test]
+    fn form_parse_rejects_malformed_percent() {
+        assert!(form_parse_packed_vec(b"a=%ZZ").is_err());
+    }
+
+    #[test]
+    fn form_parser_reuses_buffer_across_parses() {
+        let mut parser = FormParser::new(Some(64));
+        let a = parser.parse(Uint8Array::new(b"x=1&y=2".to_vec())).unwrap();
+        assert_eq!(
+            decode_packed_pairs(a.as_ref()),
+            vec![
+                (b"x".to_vec(), b"1".to_vec()),
+                (b"y".to_vec(), b"2".to_vec())
+            ]
+        );
+        // A larger input grows the reusable buffer and still parses.
+        let big = format!("k={}", "a".repeat(200));
+        let b = parser.parse(Uint8Array::new(big.into_bytes())).unwrap();
+        let pairs = decode_packed_pairs(b.as_ref());
+        assert_eq!(pairs[0].1, b"a".repeat(200));
+    }
+}