feat(compress): move advanced begin policy into Rust

Move public ZSTD_compressBegin_advanced parameter validation and init-then-begin
sequencing behind a Rust-owned boundary. Keep C responsible for private
ZSTD_CCtx_params initialization and ZSTD_compressBegin_internal through
explicit callbacks.

Test Plan:
- ulimit -v 41943040; CARGO_BUILD_JOBS=1 cargo test --manifest-path rust/Cargo.toml --release compress_begin_advanced -- --nocapture
- ulimit -v 41943040; CARGO_BUILD_JOBS=1 cargo test --manifest-path rust/Cargo.toml --release
- ulimit -v 41943040; CARGO_BUILD_JOBS=1 cargo clippy --manifest-path rust/Cargo.toml --release --all-targets -- -D warnings
- ulimit -v 41943040; make -B -C programs -j1 zstd
- ulimit -v 41943040; make -C tests -j1 test-zstream ZSTREAM_TESTTIME=-T1s

rust/src/zstd_compress.rs

@@ -1547,6 +1547,66 @@ pub unsafe extern "C" fn ZSTD_rust_compressAdvanced(
     }
 }
 
+type CompressBeginAdvancedInitParamsFn = unsafe extern "C" fn(*mut c_void, *const ZSTD_parameters);
+type CompressBeginAdvancedBeginFn =
+    unsafe extern "C" fn(*mut c_void, *const c_void, usize, *const c_void, u64) -> usize;
+
+/// Explicit projection for the public `ZSTD_compressBegin_advanced` wrapper.
+///
+/// Rust owns public parameter validation and init-then-begin ordering. C
+/// retains private `ZSTD_CCtx_params` initialization and the final begin
+/// operation behind callbacks.
+#[repr(C)]
+pub struct ZSTD_rust_compressBeginAdvancedState {
+    cctx: *mut c_void,
+    cctx_params: *mut c_void,
+    init_params: CompressBeginAdvancedInitParamsFn,
+    begin: CompressBeginAdvancedBeginFn,
+}
+
+const _: () = {
+    assert!(offset_of!(ZSTD_rust_compressBeginAdvancedState, cctx) == 0);
+    assert!(offset_of!(ZSTD_rust_compressBeginAdvancedState, cctx_params) == size_of::<usize>());
+    assert!(
+        offset_of!(ZSTD_rust_compressBeginAdvancedState, init_params) == 2 * size_of::<usize>()
+    );
+    assert!(offset_of!(ZSTD_rust_compressBeginAdvancedState, begin) == 3 * size_of::<usize>());
+    assert!(size_of::<ZSTD_rust_compressBeginAdvancedState>() == size_of::<[usize; 4]>());
+};
+
+/// Validate parameters and begin a frame through the C-owned operation.
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_compressBeginAdvanced(
+    state: *const ZSTD_rust_compressBeginAdvancedState,
+    dict: *const c_void,
+    dict_size: usize,
+    params: *const ZSTD_parameters,
+    pledged_src_size: u64,
+) -> usize {
+    if state.is_null() || params.is_null() {
+        return ERROR(ZstdErrorCode::Generic);
+    }
+    let state = unsafe { &*state };
+    if state.cctx.is_null() || state.cctx_params.is_null() {
+        return ERROR(ZstdErrorCode::Generic);
+    }
+    let params = unsafe { &*params };
+    let check_result = ZSTD_rust_params_checkCParams(params.cParams);
+    if ERR_isError(check_result) {
+        return check_result;
+    }
+    unsafe {
+        (state.init_params)(state.cctx_params, params);
+        (state.begin)(
+            state.cctx,
+            dict,
+            dict_size,
+            state.cctx_params,
+            pledged_src_size,
+        )
+    }
+}
+
 type CompressUsingDictInitParamsFn =
     unsafe extern "C" fn(*mut c_void, *const ZSTD_parameters, c_int);
 
@@ -10657,6 +10717,92 @@ mod tests {
         assert!(context.events.is_empty());
     }
 
+    #[derive(Default)]
+    struct CompressBeginAdvancedTestContext {
+        events: Vec<&'static str>,
+        params: ZSTD_parameters,
+        dict: *const c_void,
+        dict_size: usize,
+        cctx_params: *const c_void,
+        pledged_src_size: u64,
+        result: usize,
+    }
+
+    unsafe extern "C" fn compress_begin_advanced_test_init(
+        context: *mut c_void,
+        params: *const ZSTD_parameters,
+    ) {
+        let context = unsafe { &mut *context.cast::<CompressBeginAdvancedTestContext>() };
+        context.events.push("init");
+        context.params = unsafe { *params };
+    }
+
+    unsafe extern "C" fn compress_begin_advanced_test_begin(
+        context: *mut c_void,
+        dict: *const c_void,
+        dict_size: usize,
+        cctx_params: *const c_void,
+        pledged_src_size: u64,
+    ) -> usize {
+        let context = unsafe { &mut *context.cast::<CompressBeginAdvancedTestContext>() };
+        context.events.push("begin");
+        context.dict = dict;
+        context.dict_size = dict_size;
+        context.cctx_params = cctx_params;
+        context.pledged_src_size = pledged_src_size;
+        context.result
+    }
+
+    fn compress_begin_advanced_test_state(
+        context: &mut CompressBeginAdvancedTestContext,
+    ) -> ZSTD_rust_compressBeginAdvancedState {
+        ZSTD_rust_compressBeginAdvancedState {
+            cctx: (context as *mut CompressBeginAdvancedTestContext).cast(),
+            cctx_params: (context as *mut CompressBeginAdvancedTestContext).cast(),
+            init_params: compress_begin_advanced_test_init,
+            begin: compress_begin_advanced_test_begin,
+        }
+    }
+
+    #[test]
+    fn compress_begin_advanced_validates_and_preserves_init_begin_order() {
+        let mut context = CompressBeginAdvancedTestContext {
+            result: 29,
+            ..CompressBeginAdvancedTestContext::default()
+        };
+        let state = compress_begin_advanced_test_state(&mut context);
+        let params = compress_advanced_test_params();
+        let dict = [1u8, 2, 3];
+
+        let result = unsafe {
+            ZSTD_rust_compressBeginAdvanced(&state, dict.as_ptr().cast(), dict.len(), &params, 123)
+        };
+
+        assert_eq!(result, context.result);
+        assert_eq!(context.events, ["init", "begin"]);
+        assert_eq!(context.params, params);
+        assert_eq!(context.dict, dict.as_ptr().cast());
+        assert_eq!(context.dict_size, dict.len());
+        assert_eq!(
+            context.cctx_params,
+            (&context as *const CompressBeginAdvancedTestContext).cast()
+        );
+        assert_eq!(context.pledged_src_size, 123);
+    }
+
+    #[test]
+    fn compress_begin_advanced_stops_before_callbacks_on_invalid_parameters() {
+        let mut context = CompressBeginAdvancedTestContext::default();
+        let state = compress_begin_advanced_test_state(&mut context);
+        let mut params = compress_advanced_test_params();
+        params.cParams.windowLog = 0;
+
+        let result = unsafe { ZSTD_rust_compressBeginAdvanced(&state, ptr::null(), 0, &params, 0) };
+
+        assert_eq!(result, ERROR(ZstdErrorCode::ParameterOutOfBound));
+        assert!(context.events.is_empty());
+    }
+
     #[derive(Default)]
     struct CompressUsingDictTestContext {
         events: Vec<&'static str>,