Prove strict decode error surfaces

Author: eldryoth

docs/RELEASE_EVIDENCE.md

@@ -74,6 +74,12 @@ The release gate runs:
   when installed, requiring `wasm-simd128` active encode/decode reporting and
   Standard plus URL-safe deterministic length sweeps, independent scalar
   reference encode checks, malformed-input rejection, and round trips
+- strict decode public-surface evidence through
+  `standard_family_decode_surfaces_cover_tails_and_padding` and
+  `standard_family_decode_error_surfaces_match_scalar`, proving Standard and
+  URL-safe padded/unpadded slice, clear-tail, stack-buffer, vec, and secret
+  helpers match the scalar reference for accepted input and rejected input
+  while clear-tail APIs wipe caller buffers on errors
 - wasm simd128 browser smoke evidence through
   `scripts/check_wasm_browser_dispatch.sh`, which executes the same wasm32
   smoke module in a Chromium-family browser when installed or when

docs/SIMD_ADMISSION.md

@@ -66,6 +66,10 @@ encoded length: `standard_family_decode_surfaces_cover_tails_and_padding`
 checks `decode_slice`, `decode_slice_clear_tail`, stack buffers, and alloc
 helpers against the scalar reference across fixed-block thresholds, short
 inputs, non-block tails, and padded or unpadded input.
+Malformed Standard and URL-safe strict decode inputs are pinned by
+`standard_family_decode_error_surfaces_match_scalar`, which checks the same
+public surfaces against scalar error shapes and verifies clear-tail buffer
+wiping on rejected input.
 
 ## Wasm Posture Decision
 

scripts/validate-simd-admission.sh

@@ -174,4 +174,9 @@ if ! grep -F -q "fn standard_family_decode_surfaces_cover_tails_and_padding()" s
     exit 1
 fi
 
+if ! grep -F -q "fn standard_family_decode_error_surfaces_match_scalar()" src/decode_surface_tests.rs; then
+    echo "simd admission: missing Standard-family malformed decode surface evidence" >&2
+    exit 1
+fi
+
 echo "simd admission: AVX-512 VBMI, AVX2, SSSE3/SSE4.1, NEON, and wasm simd128 encode/decode admission gate ok"

src/decode_surface_tests.rs

@@ -54,6 +54,49 @@ where
     }
 }
 
+fn assert_standard_family_decode_error_surface_matches_scalar<A, const PAD: bool>(input: &[u8])
+where
+    A: Alphabet,
+{
+    let engine = Engine::<A, PAD>::new();
+    let mut slice_output = [0x55; 512];
+    let mut clear_tail_output = [0xaa; 512];
+    let mut scalar_output = [0xcc; 512];
+
+    let scalar_err = scalar::scalar_reference_decode_slice::<A, PAD>(input, &mut scalar_output)
+        .expect_err("malformed fixture must fail through the scalar reference");
+    let slice_err = engine
+        .decode_slice(input, &mut slice_output)
+        .expect_err("malformed fixture must fail through decode_slice");
+    let clear_tail_err = engine
+        .decode_slice_clear_tail(input, &mut clear_tail_output)
+        .expect_err("malformed fixture must fail through decode_slice_clear_tail");
+    let buffer_err = engine
+        .decode_buffer::<512>(input)
+        .expect_err("malformed fixture must fail through decode_buffer");
+
+    assert_eq!(slice_err, scalar_err);
+    assert_eq!(clear_tail_err, scalar_err);
+    assert_eq!(buffer_err, scalar_err);
+    assert!(
+        clear_tail_output.iter().all(|byte| *byte == 0),
+        "decode_slice_clear_tail must wipe the caller buffer on error"
+    );
+
+    #[cfg(feature = "alloc")]
+    {
+        let vec_err = engine
+            .decode_vec(input)
+            .expect_err("malformed fixture must fail through decode_vec");
+        let secret_err = engine
+            .decode_secret(input)
+            .expect_err("malformed fixture must fail through decode_secret");
+
+        assert_eq!(vec_err, scalar_err);
+        assert_eq!(secret_err, scalar_err);
+    }
+}
+
 #[test]
 fn standard_family_decode_surfaces_cover_tails_and_padding() {
     let mut input = [0; 193];
@@ -68,3 +111,29 @@ fn standard_family_decode_surfaces_cover_tails_and_padding() {
         assert_standard_family_decode_surface_matches_scalar::<UrlSafe, false>(input);
     }
 }
+
+#[test]
+fn standard_family_decode_error_surfaces_match_scalar() {
+    for input in [
+        b"!!!!".as_slice(),
+        b"AAAA!",
+        b"AA=A",
+        b"Zh==",
+        b"Zm9v$g==",
+        b"AAAA====",
+    ] {
+        assert_standard_family_decode_error_surface_matches_scalar::<Standard, true>(input);
+    }
+
+    for input in [b"Z".as_slice(), b"Zg=", b"Zg==", b"Zm9v$g", b"Zh"] {
+        assert_standard_family_decode_error_surface_matches_scalar::<Standard, false>(input);
+    }
+
+    for input in [b"AA+A".as_slice(), b"AA/A", b"AA=A", b"Zh==", b"AAAA!"] {
+        assert_standard_family_decode_error_surface_matches_scalar::<UrlSafe, true>(input);
+    }
+
+    for input in [b"Z".as_slice(), b"AA+A", b"AA/A", b"Zg=", b"Zh"] {
+        assert_standard_family_decode_error_surface_matches_scalar::<UrlSafe, false>(input);
+    }
+}