diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 295fe3420..73d4fa0ac 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2645,7 +2645,7 @@ typedef size_t (*ZSTD_rust_initCDictResetMatchState_f)(
         int useRowMatchFinder);
 typedef size_t (*ZSTD_rust_initCDictInsertDictionary_f)(
         void* context, const void* params, const void* dict,
-        size_t dictSize, int dictContentType);
+        size_t dictSize, int dictContentType, int dtlm, int tfp);
 typedef struct {
     void* callbackContext;
     void* params;
@@ -6446,14 +6446,15 @@ static size_t ZSTD_rust_initCDict_resetMatchState(
 
 static size_t ZSTD_rust_initCDict_insertDictionary(
         void* context, const void* params, const void* dict,
-        size_t dictSize, int dictContentType)
+        size_t dictSize, int dictContentType, int dtlm, int tfp)
 {
     ZSTD_CDict* const cdict = (ZSTD_CDict*)context;
     return ZSTD_compress_insertDictionary(
             &cdict->cBlockState, &cdict->matchState, NULL, &cdict->workspace,
             (const ZSTD_CCtx_params*)params, dict, dictSize,
-            (ZSTD_dictContentType_e)dictContentType, ZSTD_dtlm_full,
-            ZSTD_tfp_forCDict, cdict->entropyWorkspace);
+            (ZSTD_dictContentType_e)dictContentType,
+            (ZSTD_dictTableLoadMethod_e)dtlm,
+            (ZSTD_tableFillPurpose_e)tfp, cdict->entropyWorkspace);
 }
 
 static size_t ZSTD_rust_compressBegin_resetInternal(
diff --git a/rust/src/zstd_compress_dictionary.rs b/rust/src/zstd_compress_dictionary.rs
index 27a1153f8..e4e1602cd 100644
--- a/rust/src/zstd_compress_dictionary.rs
+++ b/rust/src/zstd_compress_dictionary.rs
@@ -45,6 +45,7 @@ const ZSTD_MAGIC_DICTIONARY: u32 = 0xEC30_A437;
 const ZSTD_DCT_AUTO: c_int = 0;
 const ZSTD_DCT_RAW_CONTENT: c_int = 1;
 const ZSTD_DCT_FULL_DICT: c_int = 2;
+const ZSTD_DTL_FULL: c_int = 1;
 const ZSTD_STATIC_WORKSPACE_ALIGNMENT: usize = 8;
 
 /// C keeps match-state/content insertion private because it depends on the
@@ -1242,15 +1243,22 @@ pub unsafe extern "C" fn ZSTD_rust_compressBeginUsingDict(
 type InitCDictReserveContentFn = unsafe extern "C" fn(*mut c_void, usize) -> *mut c_void;
 type InitCDictReserveEntropyFn = unsafe extern "C" fn(*mut c_void) -> *mut c_void;
 type InitCDictResetMatchStateFn = unsafe extern "C" fn(*mut c_void, *const c_void, c_int) -> usize;
-type InitCDictInsertDictionaryFn =
-    unsafe extern "C" fn(*mut c_void, *const c_void, *const c_void, usize, c_int) -> usize;
+type InitCDictInsertDictionaryFn = unsafe extern "C" fn(
+    *mut c_void,
+    *const c_void,
+    *const c_void,
+    usize,
+    c_int,
+    c_int,
+    c_int,
+) -> usize;
 
 /// Projection for CDict content/state initialization.
 ///
-/// Rust owns the content branch/copy, initialization order, and scalar field
-/// policy. C callbacks retain private workspace allocation, match-state reset,
-/// and dictionary insertion because those operations use private CDict
-/// layouts.
+/// Rust owns the content branch/copy, table-loading policy, initialization
+/// order, and scalar field policy. C callbacks retain private workspace
+/// allocation, match-state reset, and dictionary insertion because those
+/// operations use private CDict layouts.
 #[repr(C)]
 pub struct ZSTD_rust_initCDictState {
     callback_context: *mut c_void,
@@ -1402,6 +1410,8 @@ pub unsafe extern "C" fn ZSTD_rust_initCDict(
             dict_content,
             dict_size,
             dict_content_type,
+            ZSTD_DTL_FULL,
+            ZSTD_TFP_FOR_CDICT as c_int,
         )
     };
     if ERR_isError(dict_id) {
@@ -2614,6 +2624,8 @@ mod tests {
         inserted_dict: *const c_void,
         inserted_size: usize,
         inserted_content_type: c_int,
+        inserted_dtlm: c_int,
+        inserted_tfp: c_int,
         entropy_workspace: *mut c_void,
         reset_match_result: usize,
         insert_result: usize,
@@ -2632,6 +2644,8 @@ mod tests {
                 inserted_dict: ptr::null(),
                 inserted_size: 0,
                 inserted_content_type: 0,
+                inserted_dtlm: 0,
+                inserted_tfp: 0,
                 entropy_workspace: ptr::null_mut(),
                 reset_match_result: 0,
                 insert_result: 0,
@@ -2681,6 +2695,8 @@ mod tests {
         dict: *const c_void,
         dict_size: usize,
         dict_content_type: c_int,
+        dtlm: c_int,
+        tfp: c_int,
     ) -> usize {
         let probe = unsafe { init_cdict_probe(context) };
         probe.events.push("insert");
@@ -2688,6 +2704,8 @@ mod tests {
         probe.inserted_dict = dict;
         probe.inserted_size = dict_size;
         probe.inserted_content_type = dict_content_type;
+        probe.inserted_dtlm = dtlm;
+        probe.inserted_tfp = tfp;
         probe.insert_result
     }
 
@@ -2764,6 +2782,8 @@ mod tests {
         assert_eq!(probe.inserted_dict, dictionary.as_ptr().cast());
         assert_eq!(probe.inserted_size, dictionary.len());
         assert_eq!(probe.inserted_content_type, ZSTD_DCT_RAW_CONTENT);
+        assert_eq!(probe.inserted_dtlm, ZSTD_DTL_FULL);
+        assert_eq!(probe.inserted_tfp, ZSTD_TFP_FOR_CDICT as c_int);
         assert_eq!(match_state_c_params, c_params);
         assert_eq!(dedicated_dict_search, enable_dedicated_dict_search);
         assert_eq!(dict_content_size, dictionary.len());
@@ -2850,6 +2870,8 @@ mod tests {
         assert_eq!(dict_content, probe.content_storage.as_ptr().cast());
         assert_eq!(probe.inserted_dict, dict_content);
         assert_eq!(dict_content_size, dictionary.len());
+        assert_eq!(probe.inserted_dtlm, ZSTD_DTL_FULL);
+        assert_eq!(probe.inserted_tfp, ZSTD_TFP_FOR_CDICT as c_int);
     }
 
     struct CompressBeginProbe {