feat(rust): port block entropy statistics

Continue the incremental zstd_compress.c migration with its sequence
statistics and seqStore entropy-compression layer.  The following now
live in rust/src/zstd_compress_stats.rs:

- ZSTD_seqToCodes(), exported under its original name because the C
  dictionary builder (zdict.c) and decodecorpus link against it,
- ZSTD_buildSequencesStatistics() and its dummy variant, whose result
  struct no longer crosses the language boundary,
- ZSTD_entropyCompressSeqStore_internal(), _wExtLitBuffer(), and
  ZSTD_entropyCompressSeqStore(),
- ZSTD_buildBlockEntropyStats() with its literals/sequences helpers,
- ZSTD_copyBlockSequences() and the ZSTD_updateRep() rules it shares
  with the superblock writer.

Boundary: ZSTD_CCtx and ZSTD_CCtx_params stay private to C.  These
paths read exactly two parameter fields, so the C shims keep the
original static/exported function names and forward the strategy and
ZSTD_literalsCompressionIsDisabled() as int scalars alongside the
seqStore and entropy-table leaves.  The leaf layouts (SeqDef,
SeqStore_t, ZSTD_hufCTables_t, ZSTD_fseCTables_t, entropy metadata,
SeqCollector, ZSTD_Sequence) are pinned by compile-time asserts in
zstd_compress.c and by both-pointer-width layout tests in Rust.
ZSTD_buildSeqStore, block dispatch/splitting, and the block-size
estimation helpers remain C for a later slice.

The superblock module previously round-tripped through the C export of
ZSTD_buildBlockEntropyStats and mirrored the entropy leaf structs
privately.  It now calls the crate-internal builder directly, and the
shared struct definitions moved to zstd_compress_stats; consequently
ZSTD_rust_compressSuperBlock() takes the two parameter scalars instead
of an opaque ZSTD_CCtx_params pointer, extracted by its C shim.  Its
layout and repcode tests moved with the definitions.

One C helper family gets no shim: the static
ZSTD_entropyCompressSeqStore_wExtLitBuffer() had a single caller and
was folded into the Rust implementation.

Byte-identity was verified against the pre-change compressor: COPYING,
datagen -g5000000 -s7, and datagen -g300000 -s21 -P90, each at levels
1/3/9/19 and --fast=5, plus a superblock-heavy pass at level 19 with
--target-compressed-block-size=1024; all 18 frames are byte-identical,
covering the repeat-mode state machine, longOffsets, RLE/raw fallback,
and dstSize_tooSmall paths through the block splitter and superblock.

Test plan:
- cd rust && cargo fmt --check && cargo clippy --all-targets -- -D
  warnings && cargo test --all-targets (131 tests: new reference
  vectors for seqToCodes, RLE table headers, empty-seqStore repeat
  copies, literal-stats type selection, and repcode resolution in
  copyBlockSequences)
- cargo build --release --no-default-features --features compression
  and --features decompression
- make -C tests fuzzer && ./tests/fuzzer -i1 --no-big-tests (covers
  ZSTD_generateSequences and ZDICT training over the Rust seqToCodes)
- make -C tests test-rust-lib-smoke
- ./tests/zstreamtest -i1 and ./tests/zstreamtest --newapi -t1 -i1
- ./tests/decodecorpus -t -T1s (decodecorpus links Rust seqToCodes)
- /tmp/ref vs /tmp/got frame diff as described above: byte-identical

lib/compress/zstd_compress.c

@@ -38,6 +38,123 @@ size_t ZSTD_rust_writeFrameHeader(void* dst, size_t dstCapacity,
                                   U32 windowLog, U64 pledgedSrcSize,
                                   U32 dictID);
 
+/* Context-free compression-parameter selection and sizing leaves live in
+ * Rust (rust/src/zstd_compress_params.rs).  This file retains
+ * configuration-sensitive policy: the excluded-block-compressor strategy
+ * cascade, private ZSTD_CCtx_params handling, and sanitizer workspace
+ * policy, which it feeds to the leaves as explicit scalar inputs.  The
+ * ZSTD_CParamMode_e and ZSTD_ParamSwitch_e enums are passed as int; the
+ * Rust side mirrors their values. */
+int ZSTD_rust_params_maxCLevel(void);
+int ZSTD_rust_params_minCLevel(void);
+int ZSTD_rust_params_defaultCLevel(void);
+ZSTD_bounds ZSTD_rust_params_getBounds(int param);
+size_t ZSTD_rust_params_checkCParams(ZSTD_compressionParameters cParams);
+ZSTD_compressionParameters
+ZSTD_rust_params_clampCParams(ZSTD_compressionParameters cParams);
+U32 ZSTD_rust_params_cycleLog(U32 hashLog, int strategy);
+ZSTD_compressionParameters
+ZSTD_rust_params_selectCParams(int compressionLevel, U64 srcSizeHint,
+                               size_t dictSize, int mode);
+ZSTD_compressionParameters
+ZSTD_rust_params_adjustCParams(ZSTD_compressionParameters cParams, U64 srcSize,
+                               size_t dictSize, int mode,
+                               int useRowMatchFinder);
+ZSTD_parameters ZSTD_rust_params_makeParams(ZSTD_compressionParameters cParams);
+size_t ZSTD_rust_params_maxNbSeq(size_t blockSize, U32 minMatch,
+                                 int useSequenceProducer);
+size_t ZSTD_rust_params_resolveMaxBlockSize(size_t maxBlockSize);
+
+typedef struct {
+    U32 hashLog3Max;
+    size_t matchTSize;
+    size_t optimalTSize;
+    size_t asanRedzoneSize;
+} ZSTD_rustMatchStateSizing;
+size_t ZSTD_rust_params_estimateMatchStateSize(
+        ZSTD_compressionParameters cParams, int useRowMatchFinder,
+        int enableDedicatedDictSearch, U32 forCCtx,
+        const ZSTD_rustMatchStateSizing* sizing);
+
+typedef struct {
+    size_t cdictSize;
+    size_t hufWorkspaceSize;
+    U32 hashLog3Max;
+    size_t matchTSize;
+    size_t optimalTSize;
+    size_t asanRedzoneSize;
+} ZSTD_rustCDictSizing;
+size_t ZSTD_rust_params_estimateCDictSizeFromCParams(
+        size_t dictSize, ZSTD_compressionParameters cParams,
+        int dictLoadMethod, const ZSTD_rustCDictSizing* sizing);
+
+/* Sequence statistics and seqStore entropy compression live in Rust
+ * (rust/src/zstd_compress_stats.rs), which also exports ZSTD_seqToCodes()
+ * under its original name.  The shims below extract the sequence store, the
+ * entropy-table leaves, and the only two ZSTD_CCtx_params fields these paths
+ * read (the strategy and the literals-compression switch), so the private
+ * parameter structure layout never crosses the language boundary.  The
+ * shared leaf layouts are pinned by the compile-time asserts that follow. */
+size_t ZSTD_rust_entropyCompressSeqStore_internal(
+        void* dst, size_t dstCapacity,
+        const void* literals, size_t litSize,
+        const SeqStore_t* seqStorePtr,
+        const ZSTD_entropyCTables_t* prevEntropy,
+        ZSTD_entropyCTables_t* nextEntropy,
+        int strategy, int disableLiteralCompression,
+        void* entropyWorkspace, size_t entropyWkspSize,
+        int bmi2);
+size_t ZSTD_rust_entropyCompressSeqStore(
+        const SeqStore_t* seqStorePtr,
+        const ZSTD_entropyCTables_t* prevEntropy,
+        ZSTD_entropyCTables_t* nextEntropy,
+        int strategy, int disableLiteralCompression,
+        void* dst, size_t dstCapacity,
+        size_t srcSize,
+        void* entropyWorkspace, size_t entropyWkspSize,
+        int bmi2);
+size_t ZSTD_rust_buildBlockEntropyStats(
+        const SeqStore_t* seqStorePtr,
+        const ZSTD_entropyCTables_t* prevEntropy,
+        ZSTD_entropyCTables_t* nextEntropy,
+        int strategy, int disableLiteralCompression,
+        ZSTD_entropyCTablesMetadata_t* entropyMetadata,
+        void* workspace, size_t wkspSize);
+size_t ZSTD_rust_copyBlockSequences(
+        SeqCollector* seqCollector, const SeqStore_t* seqStore,
+        const U32 prevRepcodes[ZSTD_REP_NUM]);
+
+typedef char ZSTD_rust_stats_seqdef_layout[(sizeof(SeqDef) == 8) ? 1 : -1];
+typedef char ZSTD_rust_stats_seqstore_long_length_pos[
+        (offsetof(SeqStore_t, longLengthPos) == 9 * sizeof(size_t) + 4) ? 1 : -1];
+typedef char ZSTD_rust_stats_seqstore_layout[
+        (sizeof(SeqStore_t) == 9 * sizeof(size_t) + 8) ? 1 : -1];
+typedef char ZSTD_rust_stats_huf_layout[
+        (sizeof(ZSTD_hufCTables_t) == 258 * sizeof(size_t)) ? 1 : -1];
+typedef char ZSTD_rust_stats_fse_layout[(sizeof(ZSTD_fseCTables_t) == 3552) ? 1 : -1];
+typedef char ZSTD_rust_stats_entropy_fse_offset[
+        (offsetof(ZSTD_entropyCTables_t, fse) == sizeof(ZSTD_hufCTables_t)) ? 1 : -1];
+typedef char ZSTD_rust_stats_huf_metadata_buffer[
+        (offsetof(ZSTD_hufCTablesMetadata_t, hufDesBuffer) == 4
+         && ZSTD_MAX_HUF_HEADER_SIZE == 128) ? 1 : -1];
+typedef char ZSTD_rust_stats_fse_metadata_buffer[
+        (offsetof(ZSTD_fseCTablesMetadata_t, fseTablesBuffer) == 12
+         && ZSTD_MAX_FSE_HEADERS_SIZE == 133) ? 1 : -1];
+typedef char ZSTD_rust_stats_entropy_metadata_layout[
+        (offsetof(ZSTD_entropyCTablesMetadata_t, fseMetadata)
+                == sizeof(ZSTD_hufCTablesMetadata_t)) ? 1 : -1];
+typedef char ZSTD_rust_stats_sequence_layout[(sizeof(ZSTD_Sequence) == 16) ? 1 : -1];
+typedef char ZSTD_rust_stats_seqcollector_layout[
+        (offsetof(SeqCollector, seqStart) == sizeof(size_t)
+         && offsetof(SeqCollector, seqIndex) == 2 * sizeof(size_t)
+         && sizeof(SeqCollector) == 4 * sizeof(size_t)) ? 1 : -1];
+
+#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
+#  define ZSTD_RUST_ASAN_REDZONE_SIZE ((size_t)ZSTD_CWKSP_ASAN_REDZONE_SIZE)
+#else
+#  define ZSTD_RUST_ASAN_REDZONE_SIZE ((size_t)0)
+#endif
+
 /* ***************************************************************
 *  Tuning parameters
 *****************************************************************/
@@ -276,11 +393,7 @@ static int ZSTD_resolveExternalSequenceValidation(int mode) {
 
 /* Resolves maxBlockSize to the default if no value is present. */
 static size_t ZSTD_resolveMaxBlockSize(size_t maxBlockSize) {
-    if (maxBlockSize == 0) {
-        return ZSTD_BLOCKSIZE_MAX;
-    } else {
-        return maxBlockSize;
-    }
+    return ZSTD_rust_params_resolveMaxBlockSize(maxBlockSize);
 }
 
 static ZSTD_ParamSwitch_e ZSTD_resolveExternalRepcodeSearch(ZSTD_ParamSwitch_e value, int cLevel) {
@@ -420,45 +533,17 @@ ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
 
     switch(param)
     {
+    /* The compression level and the seven core compression parameters are
+     * bounded by the Rust leaf. */
     case ZSTD_c_compressionLevel:
-        bounds.lowerBound = ZSTD_minCLevel();
-        bounds.upperBound = ZSTD_maxCLevel();
-        return bounds;
-
     case ZSTD_c_windowLog:
-        bounds.lowerBound = ZSTD_WINDOWLOG_MIN;
-        bounds.upperBound = ZSTD_WINDOWLOG_MAX;
-        return bounds;
-
     case ZSTD_c_hashLog:
-        bounds.lowerBound = ZSTD_HASHLOG_MIN;
-        bounds.upperBound = ZSTD_HASHLOG_MAX;
-        return bounds;
-
     case ZSTD_c_chainLog:
-        bounds.lowerBound = ZSTD_CHAINLOG_MIN;
-        bounds.upperBound = ZSTD_CHAINLOG_MAX;
-        return bounds;
-
     case ZSTD_c_searchLog:
-        bounds.lowerBound = ZSTD_SEARCHLOG_MIN;
-        bounds.upperBound = ZSTD_SEARCHLOG_MAX;
-        return bounds;
-
     case ZSTD_c_minMatch:
-        bounds.lowerBound = ZSTD_MINMATCH_MIN;
-        bounds.upperBound = ZSTD_MINMATCH_MAX;
-        return bounds;
-
     case ZSTD_c_targetLength:
-        bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;
-        bounds.upperBound = ZSTD_TARGETLENGTH_MAX;
-        return bounds;
-
     case ZSTD_c_strategy:
-        bounds.lowerBound = ZSTD_STRATEGY_MIN;
-        bounds.upperBound = ZSTD_STRATEGY_MAX;
-        return bounds;
+        return ZSTD_rust_params_getBounds((int)param);
 
     case ZSTD_c_contentSizeFlag:
         bounds.lowerBound = 0;
@@ -1385,14 +1470,7 @@ size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)
     @return : 0, or an error code if one value is beyond authorized range */
 size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
 {
-    BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
-    BOUNDCHECK(ZSTD_c_chainLog,  (int)cParams.chainLog);
-    BOUNDCHECK(ZSTD_c_hashLog,   (int)cParams.hashLog);
-    BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
-    BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);
-    BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
-    BOUNDCHECK(ZSTD_c_strategy,  (int)cParams.strategy);
-    return 0;
+    return ZSTD_rust_params_checkCParams(cParams);
 }
 
 /** ZSTD_clampCParams() :
@@ -1401,63 +1479,14 @@ size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
 static ZSTD_compressionParameters
 ZSTD_clampCParams(ZSTD_compressionParameters cParams)
 {
-#   define CLAMP_TYPE(cParam, val, type)                                      \
-        do {                                                                  \
-            ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);         \
-            if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound;      \
-            else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
-        } while (0)
-#   define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)
-    CLAMP(ZSTD_c_windowLog, cParams.windowLog);
-    CLAMP(ZSTD_c_chainLog,  cParams.chainLog);
-    CLAMP(ZSTD_c_hashLog,   cParams.hashLog);
-    CLAMP(ZSTD_c_searchLog, cParams.searchLog);
-    CLAMP(ZSTD_c_minMatch,  cParams.minMatch);
-    CLAMP(ZSTD_c_targetLength,cParams.targetLength);
-    CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
-    return cParams;
+    return ZSTD_rust_params_clampCParams(cParams);
 }
 
 /** ZSTD_cycleLog() :
  *  condition for correct operation : hashLog > 1 */
 U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
 {
-    U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);
-    return hashLog - btScale;
-}
-
-/** ZSTD_dictAndWindowLog() :
- * Returns an adjusted window log that is large enough to fit the source and the dictionary.
- * The zstd format says that the entire dictionary is valid if one byte of the dictionary
- * is within the window. So the hashLog and chainLog should be large enough to reference both
- * the dictionary and the window. So we must use this adjusted dictAndWindowLog when downsizing
- * the hashLog and windowLog.
- * NOTE: srcSize must not be ZSTD_CONTENTSIZE_UNKNOWN.
- */
-static U32 ZSTD_dictAndWindowLog(U32 windowLog, U64 srcSize, U64 dictSize)
-{
-    const U64 maxWindowSize = 1ULL << ZSTD_WINDOWLOG_MAX;
-    /* No dictionary ==> No change */
-    if (dictSize == 0) {
-        return windowLog;
-    }
-    assert(windowLog <= ZSTD_WINDOWLOG_MAX);
-    assert(srcSize != ZSTD_CONTENTSIZE_UNKNOWN); /* Handled in ZSTD_adjustCParams_internal() */
-    {
-        U64 const windowSize = 1ULL << windowLog;
-        U64 const dictAndWindowSize = dictSize + windowSize;
-        /* If the window size is already large enough to fit both the source and the dictionary
-         * then just use the window size. Otherwise adjust so that it fits the dictionary and
-         * the window.
-         */
-        if (windowSize >= dictSize + srcSize) {
-            return windowLog; /* Window size large enough already */
-        } else if (dictAndWindowSize >= maxWindowSize) {
-            return ZSTD_WINDOWLOG_MAX; /* Larger than max window log */
-        } else  {
-            return ZSTD_highbit32((U32)dictAndWindowSize - 1) + 1;
-        }
-    }
+    return ZSTD_rust_params_cycleLog(hashLog, (int)strat);
 }
 
 /** ZSTD_adjustCParams_internal() :
@@ -1474,8 +1503,6 @@ ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
                             ZSTD_CParamMode_e mode,
                             ZSTD_ParamSwitch_e useRowMatchFinder)
 {
-    const U64 minSrcSize = 513; /* (1<<9) + 1 */
-    const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);
     assert(ZSTD_checkCParams(cPar)==0);
 
     /* Cascade the selected strategy down to the next-highest one built into
@@ -1520,90 +1547,13 @@ ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
     }
 #endif
 
-    switch (mode) {
-    case ZSTD_cpm_unknown:
-    case ZSTD_cpm_noAttachDict:
-        /* If we don't know the source size, don't make any
-         * assumptions about it. We will already have selected
-         * smaller parameters if a dictionary is in use.
-         */
-        break;
-    case ZSTD_cpm_createCDict:
-        /* Assume a small source size when creating a dictionary
-         * with an unknown source size.
-         */
-        if (dictSize && srcSize == ZSTD_CONTENTSIZE_UNKNOWN)
-            srcSize = minSrcSize;
-        break;
-    case ZSTD_cpm_attachDict:
-        /* Dictionary has its own dedicated parameters which have
-         * already been selected. We are selecting parameters
-         * for only the source.
-         */
-        dictSize = 0;
-        break;
-    default:
-        assert(0);
-        break;
-    }
-
-    /* resize windowLog if input is small enough, to use less memory */
-    if ( (srcSize <= maxWindowResize)
-      && (dictSize <= maxWindowResize) )  {
-        U32 const tSize = (U32)(srcSize + dictSize);
-        static U32 const hashSizeMin = 1 << ZSTD_HASHLOG_MIN;
-        U32 const srcLog = (tSize < hashSizeMin) ? ZSTD_HASHLOG_MIN :
-                            ZSTD_highbit32(tSize-1) + 1;
-        if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;
-    }
-    if (srcSize != ZSTD_CONTENTSIZE_UNKNOWN) {
-        U32 const dictAndWindowLog = ZSTD_dictAndWindowLog(cPar.windowLog, (U64)srcSize, (U64)dictSize);
-        U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
-        if (cPar.hashLog > dictAndWindowLog+1) cPar.hashLog = dictAndWindowLog+1;
-        if (cycleLog > dictAndWindowLog)
-            cPar.chainLog -= (cycleLog - dictAndWindowLog);
-    }
-
-    if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
-        cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */
-
-    /* We can't use more than 32 bits of hash in total, so that means that we require:
-     * (hashLog + 8) <= 32 && (chainLog + 8) <= 32
-     */
-    if (mode == ZSTD_cpm_createCDict && ZSTD_CDictIndicesAreTagged(&cPar)) {
-        U32 const maxShortCacheHashLog = 32 - ZSTD_SHORT_CACHE_TAG_BITS;
-        if (cPar.hashLog > maxShortCacheHashLog) {
-            cPar.hashLog = maxShortCacheHashLog;
-        }
-        if (cPar.chainLog > maxShortCacheHashLog) {
-            cPar.chainLog = maxShortCacheHashLog;
-        }
-    }
-
-
-    /* At this point, we aren't 100% sure if we are using the row match finder.
-     * Unless it is explicitly disabled, conservatively assume that it is enabled.
-     * In this case it will only be disabled for small sources, so shrinking the
-     * hash log a little bit shouldn't result in any ratio loss.
-     */
-    if (useRowMatchFinder == ZSTD_ps_auto)
-        useRowMatchFinder = ZSTD_ps_enable;
-
-    /* We can't hash more than 32-bits in total. So that means that we require:
-     * (hashLog - rowLog + 8) <= 32
-     */
-    if (ZSTD_rowMatchFinderUsed(cPar.strategy, useRowMatchFinder)) {
-        /* Switch to 32-entry rows if searchLog is 5 (or more) */
-        U32 const rowLog = BOUNDED(4, cPar.searchLog, 6);
-        U32 const maxRowHashLog = 32 - ZSTD_ROW_HASH_TAG_BITS;
-        U32 const maxHashLog = maxRowHashLog + rowLog;
-        assert(cPar.hashLog >= rowLog);
-        if (cPar.hashLog > maxHashLog) {
-            cPar.hashLog = maxHashLog;
-        }
-    }
-
-    return cPar;
+    /* The remaining adjustment logic is context-free and lives in Rust.  The
+     * short-cache and row-hash tag widths the leaf assumes are fixed
+     * private-header constants; keep them checked here. */
+    ZSTD_STATIC_ASSERT(ZSTD_SHORT_CACHE_TAG_BITS == 8);
+    ZSTD_STATIC_ASSERT(ZSTD_ROW_HASH_TAG_BITS == 8);
+    return ZSTD_rust_params_adjustCParams(cPar, (U64)srcSize, dictSize,
+                                          (int)mode, (int)useRowMatchFinder);
 }
 
 ZSTD_compressionParameters
@@ -1654,47 +1604,31 @@ ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
                        const int enableDedicatedDictSearch,
                        const U32 forCCtx)
 {
-    /* chain table size should be 0 for fast or row-hash strategies */
-    size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder, enableDedicatedDictSearch && !forCCtx)
-                                ? ((size_t)1 << cParams->chainLog)
-                                : 0;
-    size_t const hSize = ((size_t)1) << cParams->hashLog;
-    U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
-    size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;
-    /* We don't use ZSTD_cwksp_alloc_size() here because the tables aren't
-     * surrounded by redzones in ASAN. */
-    size_t const tableSpace = chainSize * sizeof(U32)
-                            + hSize * sizeof(U32)
-                            + h3Size * sizeof(U32);
-    size_t const optPotentialSpace =
-        ZSTD_cwksp_aligned64_alloc_size((MaxML+1) * sizeof(U32))
-      + ZSTD_cwksp_aligned64_alloc_size((MaxLL+1) * sizeof(U32))
-      + ZSTD_cwksp_aligned64_alloc_size((MaxOff+1) * sizeof(U32))
-      + ZSTD_cwksp_aligned64_alloc_size((1<<Litbits) * sizeof(U32))
-      + ZSTD_cwksp_aligned64_alloc_size(ZSTD_OPT_SIZE * sizeof(ZSTD_match_t))
-      + ZSTD_cwksp_aligned64_alloc_size(ZSTD_OPT_SIZE * sizeof(ZSTD_optimal_t));
-    size_t const lazyAdditionalSpace = ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)
-                                            ? ZSTD_cwksp_aligned64_alloc_size(hSize)
-                                            : 0;
-    size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
-                                ? optPotentialSpace
-                                : 0;
-    size_t const slackSpace = ZSTD_cwksp_slack_space_required();
+    ZSTD_rustMatchStateSizing sizing;
+    sizing.hashLog3Max = ZSTD_HASHLOG3_MAX;
+    sizing.matchTSize = sizeof(ZSTD_match_t);
+    sizing.optimalTSize = sizeof(ZSTD_optimal_t);
+    sizing.asanRedzoneSize = ZSTD_RUST_ASAN_REDZONE_SIZE;
 
+    /* The Rust leaf hardcodes the frozen format bounds and workspace rules;
+     * keep them checked against the private headers here. */
+    ZSTD_STATIC_ASSERT(MaxML == 52 && MaxLL == 35 && MaxOff == 31);
+    ZSTD_STATIC_ASSERT(Litbits == 8 && ZSTD_OPT_SIZE == 4099);
+    ZSTD_STATIC_ASSERT(ZSTD_CWKSP_ALIGNMENT_BYTES == 64);
     /* tables are guaranteed to be sized in multiples of 64 bytes (or 16 uint32_t) */
     ZSTD_STATIC_ASSERT(ZSTD_HASHLOG_MIN >= 4 && ZSTD_WINDOWLOG_MIN >= 4 && ZSTD_CHAINLOG_MIN >= 4);
     assert(useRowMatchFinder != ZSTD_ps_auto);
 
-    DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u",
-                (U32)chainSize, (U32)hSize, (U32)h3Size);
-    return tableSpace + optSpace + slackSpace + lazyAdditionalSpace;
+    return ZSTD_rust_params_estimateMatchStateSize(*cParams,
+                                                   (int)useRowMatchFinder,
+                                                   enableDedicatedDictSearch,
+                                                   forCCtx, &sizing);
 }
 
 /* Helper function for calculating memory requirements.
  * Gives a tighter bound than ZSTD_sequenceBound() by taking minMatch into account. */
 static size_t ZSTD_maxNbSeq(size_t blockSize, unsigned minMatch, int useSequenceProducer) {
-    U32 const divider = (minMatch==3 || useSequenceProducer) ? 3 : 4;
-    return blockSize / divider;
+    return ZSTD_rust_params_maxNbSeq(blockSize, minMatch, useSequenceProducer);
 }
 
 static size_t ZSTD_estimateCCtxSize_usingCCtxParams_internal(
@@ -2688,33 +2622,7 @@ static void ZSTD_reduceIndex (ZSTD_MatchState_t* ms, ZSTD_CCtx_params const* par
 
 /* See doc/zstd_compression_format.md for detailed format description */
 
-int ZSTD_seqToCodes(const SeqStore_t* seqStorePtr)
-{
-    const SeqDef* const sequences = seqStorePtr->sequencesStart;
-    BYTE* const llCodeTable = seqStorePtr->llCode;
-    BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    U32 u;
-    int longOffsets = 0;
-    assert(nbSeq <= seqStorePtr->maxNbSeq);
-    for (u=0; u<nbSeq; u++) {
-        U32 const llv = sequences[u].litLength;
-        U32 const ofCode = ZSTD_highbit32(sequences[u].offBase);
-        U32 const mlv = sequences[u].mlBase;
-        llCodeTable[u] = (BYTE)ZSTD_LLcode(llv);
-        ofCodeTable[u] = (BYTE)ofCode;
-        mlCodeTable[u] = (BYTE)ZSTD_MLcode(mlv);
-        assert(!(MEM_64bits() && ofCode >= STREAM_ACCUMULATOR_MIN));
-        if (MEM_32bits() && ofCode >= STREAM_ACCUMULATOR_MIN)
-            longOffsets = 1;
-    }
-    if (seqStorePtr->longLengthType==ZSTD_llt_literalLength)
-        llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
-    if (seqStorePtr->longLengthType==ZSTD_llt_matchLength)
-        mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
-    return longOffsets;
-}
+/* ZSTD_seqToCodes() lives in rust/src/zstd_compress_stats.rs. */
 
 /* ZSTD_useTargetCBlockSize():
  * Returns if target compressed block size param is being used.
@@ -2738,150 +2646,11 @@ static int ZSTD_blockSplitterEnabled(ZSTD_CCtx_params* cctxParams)
     return (cctxParams->postBlockSplitter == ZSTD_ps_enable);
 }
 
-/* Type returned by ZSTD_buildSequencesStatistics containing finalized symbol encoding types
- * and size of the sequences statistics
- */
-typedef struct {
-    U32 LLtype;
-    U32 Offtype;
-    U32 MLtype;
-    size_t size;
-    size_t lastCountSize; /* Accounts for bug in 1.3.4. More detail in ZSTD_entropyCompressSeqStore_internal() */
-    int longOffsets;
-} ZSTD_symbolEncodingTypeStats_t;
+/* ZSTD_buildSequencesStatistics() and the ZSTD_entropyCompressSeqStore*()
+ * implementations live in rust/src/zstd_compress_stats.rs.  The wrappers
+ * below keep the original signatures and extract the only two
+ * ZSTD_CCtx_params fields those paths read. */
 
-/* ZSTD_buildSequencesStatistics():
- * Returns a ZSTD_symbolEncodingTypeStats_t, or a zstd error code in the `size` field.
- * Modifies `nextEntropy` to have the appropriate values as a side effect.
- * nbSeq must be greater than 0.
- *
- * entropyWkspSize must be of size at least ENTROPY_WORKSPACE_SIZE - (MaxSeq + 1)*sizeof(U32)
- */
-static ZSTD_symbolEncodingTypeStats_t
-ZSTD_buildSequencesStatistics(
-                const SeqStore_t* seqStorePtr, size_t nbSeq,
-                const ZSTD_fseCTables_t* prevEntropy, ZSTD_fseCTables_t* nextEntropy,
-                      BYTE* dst, const BYTE* const dstEnd,
-                      ZSTD_strategy strategy, unsigned* countWorkspace,
-                      void* entropyWorkspace, size_t entropyWkspSize)
-{
-    BYTE* const ostart = dst;
-    const BYTE* const oend = dstEnd;
-    BYTE* op = ostart;
-    FSE_CTable* CTable_LitLength = nextEntropy->litlengthCTable;
-    FSE_CTable* CTable_OffsetBits = nextEntropy->offcodeCTable;
-    FSE_CTable* CTable_MatchLength = nextEntropy->matchlengthCTable;
-    const BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    const BYTE* const llCodeTable = seqStorePtr->llCode;
-    const BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    ZSTD_symbolEncodingTypeStats_t stats;
-
-    stats.lastCountSize = 0;
-    /* convert length/distances into codes */
-    stats.longOffsets = ZSTD_seqToCodes(seqStorePtr);
-    assert(op <= oend);
-    assert(nbSeq != 0); /* ZSTD_selectEncodingType() divides by nbSeq */
-    /* build CTable for Literal Lengths */
-    {   unsigned max = MaxLL;
-        size_t const mostFrequent = HIST_countFast_wksp(countWorkspace, &max, llCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);   /* can't fail */
-        DEBUGLOG(5, "Building LL table");
-        nextEntropy->litlength_repeatMode = prevEntropy->litlength_repeatMode;
-        stats.LLtype = ZSTD_selectEncodingType(&nextEntropy->litlength_repeatMode,
-                                        countWorkspace, max, mostFrequent, nbSeq,
-                                        LLFSELog, prevEntropy->litlengthCTable,
-                                        LL_defaultNorm, LL_defaultNormLog,
-                                        ZSTD_defaultAllowed, strategy);
-        assert(set_basic < set_compressed && set_rle < set_compressed);
-        assert(!(stats.LLtype < set_compressed && nextEntropy->litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-        {   size_t const countSize = ZSTD_buildCTable(
-                op, (size_t)(oend - op),
-                CTable_LitLength, LLFSELog, (SymbolEncodingType_e)stats.LLtype,
-                countWorkspace, max, llCodeTable, nbSeq,
-                LL_defaultNorm, LL_defaultNormLog, MaxLL,
-                prevEntropy->litlengthCTable,
-                sizeof(prevEntropy->litlengthCTable),
-                entropyWorkspace, entropyWkspSize);
-            if (ZSTD_isError(countSize)) {
-                DEBUGLOG(3, "ZSTD_buildCTable for LitLens failed");
-                stats.size = countSize;
-                return stats;
-            }
-            if (stats.LLtype == set_compressed)
-                stats.lastCountSize = countSize;
-            op += countSize;
-            assert(op <= oend);
-    }   }
-    /* build CTable for Offsets */
-    {   unsigned max = MaxOff;
-        size_t const mostFrequent = HIST_countFast_wksp(
-            countWorkspace, &max, ofCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);  /* can't fail */
-        /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
-        ZSTD_DefaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
-        DEBUGLOG(5, "Building OF table");
-        nextEntropy->offcode_repeatMode = prevEntropy->offcode_repeatMode;
-        stats.Offtype = ZSTD_selectEncodingType(&nextEntropy->offcode_repeatMode,
-                                        countWorkspace, max, mostFrequent, nbSeq,
-                                        OffFSELog, prevEntropy->offcodeCTable,
-                                        OF_defaultNorm, OF_defaultNormLog,
-                                        defaultPolicy, strategy);
-        assert(!(stats.Offtype < set_compressed && nextEntropy->offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-        {   size_t const countSize = ZSTD_buildCTable(
-                op, (size_t)(oend - op),
-                CTable_OffsetBits, OffFSELog, (SymbolEncodingType_e)stats.Offtype,
-                countWorkspace, max, ofCodeTable, nbSeq,
-                OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
-                prevEntropy->offcodeCTable,
-                sizeof(prevEntropy->offcodeCTable),
-                entropyWorkspace, entropyWkspSize);
-            if (ZSTD_isError(countSize)) {
-                DEBUGLOG(3, "ZSTD_buildCTable for Offsets failed");
-                stats.size = countSize;
-                return stats;
-            }
-            if (stats.Offtype == set_compressed)
-                stats.lastCountSize = countSize;
-            op += countSize;
-            assert(op <= oend);
-    }   }
-    /* build CTable for MatchLengths */
-    {   unsigned max = MaxML;
-        size_t const mostFrequent = HIST_countFast_wksp(
-            countWorkspace, &max, mlCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);   /* can't fail */
-        DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
-        nextEntropy->matchlength_repeatMode = prevEntropy->matchlength_repeatMode;
-        stats.MLtype = ZSTD_selectEncodingType(&nextEntropy->matchlength_repeatMode,
-                                        countWorkspace, max, mostFrequent, nbSeq,
-                                        MLFSELog, prevEntropy->matchlengthCTable,
-                                        ML_defaultNorm, ML_defaultNormLog,
-                                        ZSTD_defaultAllowed, strategy);
-        assert(!(stats.MLtype < set_compressed && nextEntropy->matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-        {   size_t const countSize = ZSTD_buildCTable(
-                op, (size_t)(oend - op),
-                CTable_MatchLength, MLFSELog, (SymbolEncodingType_e)stats.MLtype,
-                countWorkspace, max, mlCodeTable, nbSeq,
-                ML_defaultNorm, ML_defaultNormLog, MaxML,
-                prevEntropy->matchlengthCTable,
-                sizeof(prevEntropy->matchlengthCTable),
-                entropyWorkspace, entropyWkspSize);
-            if (ZSTD_isError(countSize)) {
-                DEBUGLOG(3, "ZSTD_buildCTable for MatchLengths failed");
-                stats.size = countSize;
-                return stats;
-            }
-            if (stats.MLtype == set_compressed)
-                stats.lastCountSize = countSize;
-            op += countSize;
-            assert(op <= oend);
-    }   }
-    stats.size = (size_t)(op-ostart);
-    return stats;
-}
-
-/* ZSTD_entropyCompressSeqStore_internal():
- * compresses both literals and sequences
- * Returns compressed size of block, or a zstd error.
- */
-#define SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO 20
 MEM_STATIC size_t
 ZSTD_entropyCompressSeqStore_internal(
                               void* dst, size_t dstCapacity,
@@ -2893,150 +2662,13 @@ ZSTD_entropyCompressSeqStore_internal(
                               void* entropyWorkspace, size_t entropyWkspSize,
                         const int bmi2)
 {
-    ZSTD_strategy const strategy = cctxParams->cParams.strategy;
-    unsigned* count = (unsigned*)entropyWorkspace;
-    FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable;
-    FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable;
-    FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable;
-    const SeqDef* const sequences = seqStorePtr->sequencesStart;
-    const size_t nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    const BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    const BYTE* const llCodeTable = seqStorePtr->llCode;
-    const BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstCapacity;
-    BYTE* op = ostart;
-    size_t lastCountSize;
-    int longOffsets = 0;
-
-    entropyWorkspace = count + (MaxSeq + 1);
-    entropyWkspSize -= (MaxSeq + 1) * sizeof(*count);
-
-    DEBUGLOG(5, "ZSTD_entropyCompressSeqStore_internal (nbSeq=%zu, dstCapacity=%zu)", nbSeq, dstCapacity);
-    ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
-    assert(entropyWkspSize >= HUF_WORKSPACE_SIZE);
-
-    /* Compress literals */
-    {   size_t const numSequences = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-        /* Base suspicion of uncompressibility on ratio of literals to sequences */
-        int const suspectUncompressible = (numSequences == 0) || (litSize / numSequences >= SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO);
-
-        size_t const cSize = ZSTD_compressLiterals(
-                                    op, dstCapacity,
-                                    literals, litSize,
-                                    entropyWorkspace, entropyWkspSize,
-                                    &prevEntropy->huf, &nextEntropy->huf,
-                                    cctxParams->cParams.strategy,
-                                    ZSTD_literalsCompressionIsDisabled(cctxParams),
-                                    suspectUncompressible, bmi2);
-        FORWARD_IF_ERROR(cSize, "ZSTD_compressLiterals failed");
-        assert(cSize <= dstCapacity);
-        op += cSize;
-    }
-
-    /* Sequences Header */
-    RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
-                    dstSize_tooSmall, "Can't fit seq hdr in output buf!");
-    if (nbSeq < 128) {
-        *op++ = (BYTE)nbSeq;
-    } else if (nbSeq < LONGNBSEQ) {
-        op[0] = (BYTE)((nbSeq>>8) + 0x80);
-        op[1] = (BYTE)nbSeq;
-        op+=2;
-    } else {
-        op[0]=0xFF;
-        MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ));
-        op+=3;
-    }
-    assert(op <= oend);
-    if (nbSeq==0) {
-        /* Copy the old tables over as if we repeated them */
-        ZSTD_memcpy(&nextEntropy->fse, &prevEntropy->fse, sizeof(prevEntropy->fse));
-        return (size_t)(op - ostart);
-    }
-    {   BYTE* const seqHead = op++;
-        /* build stats for sequences */
-        const ZSTD_symbolEncodingTypeStats_t stats =
-                ZSTD_buildSequencesStatistics(seqStorePtr, nbSeq,
-                                             &prevEntropy->fse, &nextEntropy->fse,
-                                              op, oend,
-                                              strategy, count,
-                                              entropyWorkspace, entropyWkspSize);
-        FORWARD_IF_ERROR(stats.size, "ZSTD_buildSequencesStatistics failed!");
-        *seqHead = (BYTE)((stats.LLtype<<6) + (stats.Offtype<<4) + (stats.MLtype<<2));
-        lastCountSize = stats.lastCountSize;
-        op += stats.size;
-        longOffsets = stats.longOffsets;
-    }
-
-    {   size_t const bitstreamSize = ZSTD_encodeSequences(
-                                        op, (size_t)(oend - op),
-                                        CTable_MatchLength, mlCodeTable,
-                                        CTable_OffsetBits, ofCodeTable,
-                                        CTable_LitLength, llCodeTable,
-                                        sequences, nbSeq,
-                                        longOffsets, bmi2);
-        FORWARD_IF_ERROR(bitstreamSize, "ZSTD_encodeSequences failed");
-        op += bitstreamSize;
-        assert(op <= oend);
-        /* zstd versions <= 1.3.4 mistakenly report corruption when
-         * FSE_readNCount() receives a buffer < 4 bytes.
-         * Fixed by https://github.com/facebook/zstd/pull/1146.
-         * This can happen when the last set_compressed table present is 2
-         * bytes and the bitstream is only one byte.
-         * In this exceedingly rare case, we will simply emit an uncompressed
-         * block, since it isn't worth optimizing.
-         */
-        if (lastCountSize && (lastCountSize + bitstreamSize) < 4) {
-            /* lastCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
-            assert(lastCountSize + bitstreamSize == 3);
-            DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
-                        "emitting an uncompressed block.");
-            return 0;
-        }
-    }
-
-    DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart));
-    return (size_t)(op - ostart);
-}
-
-static size_t
-ZSTD_entropyCompressSeqStore_wExtLitBuffer(
-                          void* dst, size_t dstCapacity,
-                    const void* literals, size_t litSize,
-                          size_t blockSize,
-                    const SeqStore_t* seqStorePtr,
-                    const ZSTD_entropyCTables_t* prevEntropy,
-                          ZSTD_entropyCTables_t* nextEntropy,
-                    const ZSTD_CCtx_params* cctxParams,
-                          void* entropyWorkspace, size_t entropyWkspSize,
-                          int bmi2)
-{
-    size_t const cSize = ZSTD_entropyCompressSeqStore_internal(
-                            dst, dstCapacity,
-                            literals, litSize,
-                            seqStorePtr, prevEntropy, nextEntropy, cctxParams,
-                            entropyWorkspace, entropyWkspSize, bmi2);
-    if (cSize == 0) return 0;
-    /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
-     * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
-     */
-    if ((cSize == ERROR(dstSize_tooSmall)) & (blockSize <= dstCapacity)) {
-        DEBUGLOG(4, "not enough dstCapacity (%zu) for ZSTD_entropyCompressSeqStore_internal()=> do not compress block", dstCapacity);
-        return 0;  /* block not compressed */
-    }
-    FORWARD_IF_ERROR(cSize, "ZSTD_entropyCompressSeqStore_internal failed");
-
-    /* Check compressibility */
-    {   size_t const maxCSize = blockSize - ZSTD_minGain(blockSize, cctxParams->cParams.strategy);
-        if (cSize >= maxCSize) return 0;  /* block not compressed */
-    }
-    DEBUGLOG(5, "ZSTD_entropyCompressSeqStore() cSize: %zu", cSize);
-    /* libzstd decoder before  > v1.5.4 is not compatible with compressed blocks of size ZSTD_BLOCKSIZE_MAX exactly.
-     * This restriction is indirectly already fulfilled by respecting ZSTD_minGain() condition above.
-     */
-    assert(cSize < ZSTD_BLOCKSIZE_MAX);
-    return cSize;
+    return ZSTD_rust_entropyCompressSeqStore_internal(
+                dst, dstCapacity,
+                literals, litSize,
+                seqStorePtr, prevEntropy, nextEntropy,
+                (int)cctxParams->cParams.strategy,
+                ZSTD_literalsCompressionIsDisabled(cctxParams),
+                entropyWorkspace, entropyWkspSize, bmi2);
 }
 
 static size_t
@@ -3050,13 +2682,12 @@ ZSTD_entropyCompressSeqStore(
                           void* entropyWorkspace, size_t entropyWkspSize,
                           int bmi2)
 {
-    return ZSTD_entropyCompressSeqStore_wExtLitBuffer(
+    return ZSTD_rust_entropyCompressSeqStore(
+                seqStorePtr, prevEntropy, nextEntropy,
+                (int)cctxParams->cParams.strategy,
+                ZSTD_literalsCompressionIsDisabled(cctxParams),
                 dst, dstCapacity,
-                seqStorePtr->litStart, (size_t)(seqStorePtr->lit - seqStorePtr->litStart),
                 srcSize,
-                seqStorePtr,
-                prevEntropy, nextEntropy,
-                cctxParams,
                 entropyWorkspace, entropyWkspSize,
                 bmi2);
 }
@@ -3426,87 +3057,8 @@ static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
 
 static size_t ZSTD_copyBlockSequences(SeqCollector* seqCollector, const SeqStore_t* seqStore, const U32 prevRepcodes[ZSTD_REP_NUM])
 {
-    const SeqDef* inSeqs = seqStore->sequencesStart;
-    const size_t nbInSequences = (size_t)(seqStore->sequences - inSeqs);
-    const size_t nbInLiterals = (size_t)(seqStore->lit - seqStore->litStart);
-
-    ZSTD_Sequence* outSeqs = seqCollector->seqIndex == 0 ? seqCollector->seqStart : seqCollector->seqStart + seqCollector->seqIndex;
-    const size_t nbOutSequences = nbInSequences + 1;
-    size_t nbOutLiterals = 0;
-    Repcodes_t repcodes;
-    size_t i;
-
-    /* Bounds check that we have enough space for every input sequence
-     * and the block delimiter
-     */
-    assert(seqCollector->seqIndex <= seqCollector->maxSequences);
-    RETURN_ERROR_IF(
-        nbOutSequences > (size_t)(seqCollector->maxSequences - seqCollector->seqIndex),
-        dstSize_tooSmall,
-        "Not enough space to copy sequences");
-
-    ZSTD_memcpy(&repcodes, prevRepcodes, sizeof(repcodes));
-    for (i = 0; i < nbInSequences; ++i) {
-        U32 rawOffset;
-        outSeqs[i].litLength = inSeqs[i].litLength;
-        outSeqs[i].matchLength = inSeqs[i].mlBase + MINMATCH;
-        outSeqs[i].rep = 0;
-
-        /* Handle the possible single length >= 64K
-         * There can only be one because we add MINMATCH to every match length,
-         * and blocks are at most 128K.
-         */
-        if (i == seqStore->longLengthPos) {
-            if (seqStore->longLengthType == ZSTD_llt_literalLength) {
-                outSeqs[i].litLength += 0x10000;
-            } else if (seqStore->longLengthType == ZSTD_llt_matchLength) {
-                outSeqs[i].matchLength += 0x10000;
-            }
-        }
-
-        /* Determine the raw offset given the offBase, which may be a repcode. */
-        if (OFFBASE_IS_REPCODE(inSeqs[i].offBase)) {
-            const U32 repcode = OFFBASE_TO_REPCODE(inSeqs[i].offBase);
-            assert(repcode > 0);
-            outSeqs[i].rep = repcode;
-            if (outSeqs[i].litLength != 0) {
-                rawOffset = repcodes.rep[repcode - 1];
-            } else {
-                if (repcode == 3) {
-                    assert(repcodes.rep[0] > 1);
-                    rawOffset = repcodes.rep[0] - 1;
-                } else {
-                    rawOffset = repcodes.rep[repcode];
-                }
-            }
-        } else {
-            rawOffset = OFFBASE_TO_OFFSET(inSeqs[i].offBase);
-        }
-        outSeqs[i].offset = rawOffset;
-
-        /* Update repcode history for the sequence */
-        ZSTD_updateRep(repcodes.rep,
-                       inSeqs[i].offBase,
-                       inSeqs[i].litLength == 0);
-
-        nbOutLiterals += outSeqs[i].litLength;
-    }
-    /* Insert last literals (if any exist) in the block as a sequence with ml == off == 0.
-     * If there are no last literals, then we'll emit (of: 0, ml: 0, ll: 0), which is a marker
-     * for the block boundary, according to the API.
-     */
-    assert(nbInLiterals >= nbOutLiterals);
-    {
-        const size_t lastLLSize = nbInLiterals - nbOutLiterals;
-        outSeqs[nbInSequences].litLength = (U32)lastLLSize;
-        outSeqs[nbInSequences].matchLength = 0;
-        outSeqs[nbInSequences].offset = 0;
-        assert(nbOutSequences == nbInSequences + 1);
-    }
-    seqCollector->seqIndex += nbOutSequences;
-    assert(seqCollector->seqIndex <= seqCollector->maxSequences);
-
-    return 0;
+    /* The implementation lives in rust/src/zstd_compress_stats.rs. */
+    return ZSTD_rust_copyBlockSequences(seqCollector, seqStore, prevRepcodes);
 }
 
 /* ZSTD_sequenceBound() lives in rust/src/zstd_compress_api.rs. */
@@ -3602,178 +3154,14 @@ writeBlockHeader(void* op, size_t cSize, size_t blockSize, U32 lastBlock)
     DEBUGLOG(5, "writeBlockHeader: cSize: %zu blockSize: %zu lastBlock: %u", cSize, blockSize, lastBlock);
 }
 
-/** ZSTD_buildBlockEntropyStats_literals() :
- *  Builds entropy for the literals.
- *  Stores literals block type (raw, rle, compressed, repeat) and
- *  huffman description table to hufMetadata.
- *  Requires ENTROPY_WORKSPACE_SIZE workspace
- * @return : size of huffman description table, or an error code
- */
-static size_t
-ZSTD_buildBlockEntropyStats_literals(void* const src, size_t srcSize,
-                               const ZSTD_hufCTables_t* prevHuf,
-                                     ZSTD_hufCTables_t* nextHuf,
-                                     ZSTD_hufCTablesMetadata_t* hufMetadata,
-                               const int literalsCompressionIsDisabled,
-                                     void* workspace, size_t wkspSize,
-                                     int hufFlags)
-{
-    BYTE* const wkspStart = (BYTE*)workspace;
-    BYTE* const wkspEnd = wkspStart + wkspSize;
-    BYTE* const countWkspStart = wkspStart;
-    unsigned* const countWksp = (unsigned*)workspace;
-    const size_t countWkspSize = (HUF_SYMBOLVALUE_MAX + 1) * sizeof(unsigned);
-    BYTE* const nodeWksp = countWkspStart + countWkspSize;
-    const size_t nodeWkspSize = (size_t)(wkspEnd - nodeWksp);
-    unsigned maxSymbolValue = HUF_SYMBOLVALUE_MAX;
-    unsigned huffLog = LitHufLog;
-    HUF_repeat repeat = prevHuf->repeatMode;
-    DEBUGLOG(5, "ZSTD_buildBlockEntropyStats_literals (srcSize=%zu)", srcSize);
-
-    /* Prepare nextEntropy assuming reusing the existing table */
-    ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-
-    if (literalsCompressionIsDisabled) {
-        DEBUGLOG(5, "set_basic - disabled");
-        hufMetadata->hType = set_basic;
-        return 0;
-    }
-
-    /* small ? don't even attempt compression (speed opt) */
-#ifndef COMPRESS_LITERALS_SIZE_MIN
-# define COMPRESS_LITERALS_SIZE_MIN 63  /* heuristic */
-#endif
-    {   size_t const minLitSize = (prevHuf->repeatMode == HUF_repeat_valid) ? 6 : COMPRESS_LITERALS_SIZE_MIN;
-        if (srcSize <= minLitSize) {
-            DEBUGLOG(5, "set_basic - too small");
-            hufMetadata->hType = set_basic;
-            return 0;
-    }   }
-
-    /* Scan input and build symbol stats */
-    {   size_t const largest =
-            HIST_count_wksp (countWksp, &maxSymbolValue,
-                            (const BYTE*)src, srcSize,
-                            workspace, wkspSize);
-        FORWARD_IF_ERROR(largest, "HIST_count_wksp failed");
-        if (largest == srcSize) {
-            /* only one literal symbol */
-            DEBUGLOG(5, "set_rle");
-            hufMetadata->hType = set_rle;
-            return 0;
-        }
-        if (largest <= (srcSize >> 7)+4) {
-            /* heuristic: likely not compressible */
-            DEBUGLOG(5, "set_basic - no gain");
-            hufMetadata->hType = set_basic;
-            return 0;
-    }   }
-
-    /* Validate the previous Huffman table */
-    if (repeat == HUF_repeat_check
-      && !HUF_validateCTable((HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue)) {
-        repeat = HUF_repeat_none;
-    }
-
-    /* Build Huffman Tree */
-    ZSTD_memset(nextHuf->CTable, 0, sizeof(nextHuf->CTable));
-    huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue, nodeWksp, nodeWkspSize, nextHuf->CTable, countWksp, hufFlags);
-    assert(huffLog <= LitHufLog);
-    {   size_t const maxBits = HUF_buildCTable_wksp((HUF_CElt*)nextHuf->CTable, countWksp,
-                                                    maxSymbolValue, huffLog,
-                                                    nodeWksp, nodeWkspSize);
-        FORWARD_IF_ERROR(maxBits, "HUF_buildCTable_wksp");
-        huffLog = (U32)maxBits;
-    }
-    {   /* Build and write the CTable */
-        size_t const newCSize = HUF_estimateCompressedSize(
-                (HUF_CElt*)nextHuf->CTable, countWksp, maxSymbolValue);
-        size_t const hSize = HUF_writeCTable_wksp(
-                hufMetadata->hufDesBuffer, sizeof(hufMetadata->hufDesBuffer),
-                (HUF_CElt*)nextHuf->CTable, maxSymbolValue, huffLog,
-                nodeWksp, nodeWkspSize);
-        /* Check against repeating the previous CTable */
-        if (repeat != HUF_repeat_none) {
-            size_t const oldCSize = HUF_estimateCompressedSize(
-                    (HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue);
-            if (oldCSize < srcSize && (oldCSize <= hSize + newCSize || hSize + 12 >= srcSize)) {
-                DEBUGLOG(5, "set_repeat - smaller");
-                ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-                hufMetadata->hType = set_repeat;
-                return 0;
-        }   }
-        if (newCSize + hSize >= srcSize) {
-            DEBUGLOG(5, "set_basic - no gains");
-            ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-            hufMetadata->hType = set_basic;
-            return 0;
-        }
-        DEBUGLOG(5, "set_compressed (hSize=%u)", (U32)hSize);
-        hufMetadata->hType = set_compressed;
-        nextHuf->repeatMode = HUF_repeat_check;
-        return hSize;
-    }
-}
-
-
-/* ZSTD_buildDummySequencesStatistics():
- * Returns a ZSTD_symbolEncodingTypeStats_t with all encoding types as set_basic,
- * and updates nextEntropy to the appropriate repeatMode.
- */
-static ZSTD_symbolEncodingTypeStats_t
-ZSTD_buildDummySequencesStatistics(ZSTD_fseCTables_t* nextEntropy)
-{
-    ZSTD_symbolEncodingTypeStats_t stats = {set_basic, set_basic, set_basic, 0, 0, 0};
-    nextEntropy->litlength_repeatMode = FSE_repeat_none;
-    nextEntropy->offcode_repeatMode = FSE_repeat_none;
-    nextEntropy->matchlength_repeatMode = FSE_repeat_none;
-    return stats;
-}
-
-/** ZSTD_buildBlockEntropyStats_sequences() :
- *  Builds entropy for the sequences.
- *  Stores symbol compression modes and fse table to fseMetadata.
- *  Requires ENTROPY_WORKSPACE_SIZE wksp.
- * @return : size of fse tables or error code */
-static size_t
-ZSTD_buildBlockEntropyStats_sequences(
-                const SeqStore_t* seqStorePtr,
-                const ZSTD_fseCTables_t* prevEntropy,
-                      ZSTD_fseCTables_t* nextEntropy,
-                const ZSTD_CCtx_params* cctxParams,
-                      ZSTD_fseCTablesMetadata_t* fseMetadata,
-                      void* workspace, size_t wkspSize)
-{
-    ZSTD_strategy const strategy = cctxParams->cParams.strategy;
-    size_t const nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    BYTE* const ostart = fseMetadata->fseTablesBuffer;
-    BYTE* const oend = ostart + sizeof(fseMetadata->fseTablesBuffer);
-    BYTE* op = ostart;
-    unsigned* countWorkspace = (unsigned*)workspace;
-    unsigned* entropyWorkspace = countWorkspace + (MaxSeq + 1);
-    size_t entropyWorkspaceSize = wkspSize - (MaxSeq + 1) * sizeof(*countWorkspace);
-    ZSTD_symbolEncodingTypeStats_t stats;
-
-    DEBUGLOG(5, "ZSTD_buildBlockEntropyStats_sequences (nbSeq=%zu)", nbSeq);
-    stats = nbSeq != 0 ? ZSTD_buildSequencesStatistics(seqStorePtr, nbSeq,
-                                          prevEntropy, nextEntropy, op, oend,
-                                          strategy, countWorkspace,
-                                          entropyWorkspace, entropyWorkspaceSize)
-                       : ZSTD_buildDummySequencesStatistics(nextEntropy);
-    FORWARD_IF_ERROR(stats.size, "ZSTD_buildSequencesStatistics failed!");
-    fseMetadata->llType = (SymbolEncodingType_e) stats.LLtype;
-    fseMetadata->ofType = (SymbolEncodingType_e) stats.Offtype;
-    fseMetadata->mlType = (SymbolEncodingType_e) stats.MLtype;
-    fseMetadata->lastCountSize = stats.lastCountSize;
-    return stats.size;
-}
-
-
 /** ZSTD_buildBlockEntropyStats() :
  *  Builds entropy for the block.
  *  Requires workspace size ENTROPY_WORKSPACE_SIZE
  * @return : 0 on success, or an error code
  *  Note : also employed in superblock
+ *
+ *  The implementation, together with its literals/sequences/dummy helpers,
+ *  lives in rust/src/zstd_compress_stats.rs.
  */
 size_t ZSTD_buildBlockEntropyStats(
             const SeqStore_t* seqStorePtr,
@@ -3783,26 +3171,12 @@ size_t ZSTD_buildBlockEntropyStats(
                   ZSTD_entropyCTablesMetadata_t* entropyMetadata,
                   void* workspace, size_t wkspSize)
 {
-    size_t const litSize = (size_t)(seqStorePtr->lit - seqStorePtr->litStart);
-    int const huf_useOptDepth = (cctxParams->cParams.strategy >= HUF_OPTIMAL_DEPTH_THRESHOLD);
-    int const hufFlags = huf_useOptDepth ? HUF_flags_optimalDepth : 0;
-
-    entropyMetadata->hufMetadata.hufDesSize =
-        ZSTD_buildBlockEntropyStats_literals(seqStorePtr->litStart, litSize,
-                                            &prevEntropy->huf, &nextEntropy->huf,
-                                            &entropyMetadata->hufMetadata,
-                                            ZSTD_literalsCompressionIsDisabled(cctxParams),
-                                            workspace, wkspSize, hufFlags);
-
-    FORWARD_IF_ERROR(entropyMetadata->hufMetadata.hufDesSize, "ZSTD_buildBlockEntropyStats_literals failed");
-    entropyMetadata->fseMetadata.fseTablesSize =
-        ZSTD_buildBlockEntropyStats_sequences(seqStorePtr,
-                                              &prevEntropy->fse, &nextEntropy->fse,
-                                              cctxParams,
-                                              &entropyMetadata->fseMetadata,
-                                              workspace, wkspSize);
-    FORWARD_IF_ERROR(entropyMetadata->fseMetadata.fseTablesSize, "ZSTD_buildBlockEntropyStats_sequences failed");
-    return 0;
+    return ZSTD_rust_buildBlockEntropyStats(
+                seqStorePtr, prevEntropy, nextEntropy,
+                (int)cctxParams->cParams.strategy,
+                ZSTD_literalsCompressionIsDisabled(cctxParams),
+                entropyMetadata,
+                workspace, wkspSize);
 }
 
 /* Returns the size estimate for the literals section (header + content) of a block */
@@ -5430,15 +4804,15 @@ size_t ZSTD_estimateCDictSize_advanced(
         size_t dictSize, ZSTD_compressionParameters cParams,
         ZSTD_dictLoadMethod_e dictLoadMethod)
 {
-    DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict));
-    return ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))
-         + ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)
-         /* enableDedicatedDictSearch == 1 ensures that CDict estimation will not be too small
-          * in case we are using DDS with row-hash. */
-         + ZSTD_sizeof_matchState(&cParams, ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams),
-                                  /* enableDedicatedDictSearch */ 1, /* forCCtx */ 0)
-         + (dictLoadMethod == ZSTD_dlm_byRef ? 0
-            : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void *))));
+    ZSTD_rustCDictSizing sizing;
+    sizing.cdictSize = sizeof(ZSTD_CDict);
+    sizing.hufWorkspaceSize = HUF_WORKSPACE_SIZE;
+    sizing.hashLog3Max = ZSTD_HASHLOG3_MAX;
+    sizing.matchTSize = sizeof(ZSTD_match_t);
+    sizing.optimalTSize = sizeof(ZSTD_optimal_t);
+    sizing.asanRedzoneSize = ZSTD_RUST_ASAN_REDZONE_SIZE;
+    return ZSTD_rust_params_estimateCDictSizeFromCParams(
+            dictSize, cParams, (int)dictLoadMethod, &sizing);
 }
 
 size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)
@@ -7576,11 +6950,12 @@ size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
 
 
 /*-=====  Pre-defined compression levels  =====-*/
-#include "clevels.h"
+/* The compression-level tables (formerly included from clevels.h) live in
+ * rust/src/zstd_compress_params.rs. */
 
-int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
-int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }
-int ZSTD_defaultCLevel(void) { return ZSTD_CLEVEL_DEFAULT; }
+int ZSTD_maxCLevel(void) { return ZSTD_rust_params_maxCLevel(); }
+int ZSTD_minCLevel(void) { return ZSTD_rust_params_minCLevel(); }
+int ZSTD_defaultCLevel(void) { return ZSTD_rust_params_defaultCLevel(); }
 
 static ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(int const compressionLevel, size_t const dictSize)
 {
@@ -7639,26 +7014,6 @@ static void ZSTD_dedicatedDictSearch_revertCParams(
     }
 }
 
-static U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)
-{
-    switch (mode) {
-    case ZSTD_cpm_unknown:
-    case ZSTD_cpm_noAttachDict:
-    case ZSTD_cpm_createCDict:
-        break;
-    case ZSTD_cpm_attachDict:
-        dictSize = 0;
-        break;
-    default:
-        assert(0);
-        break;
-    }
-    {   int const unknown = srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN;
-        size_t const addedSize = unknown && dictSize > 0 ? 500 : 0;
-        return unknown && dictSize == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : srcSizeHint+dictSize+addedSize;
-    }
-}
-
 /*! ZSTD_getCParams_internal() :
  * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
  *  Note: srcSizeHint 0 means 0, use ZSTD_CONTENTSIZE_UNKNOWN for unknown.
@@ -7666,27 +7021,12 @@ static U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_CParamMo
  *  Note: `mode` controls how we treat the `dictSize`. See docs for `ZSTD_CParamMode_e`. */
 static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)
 {
-    U64 const rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode);
-    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
-    int row;
-    DEBUGLOG(5, "ZSTD_getCParams_internal (cLevel=%i)", compressionLevel);
-
-    /* row */
-    if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT;   /* 0 == default */
-    else if (compressionLevel < 0) row = 0;   /* entry 0 is baseline for fast mode */
-    else if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL;
-    else row = compressionLevel;
-
-    {   ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row];
-        DEBUGLOG(5, "ZSTD_getCParams_internal selected tableID: %u row: %u strat: %u", tableID, row, (U32)cp.strategy);
-        /* acceleration factor */
-        if (compressionLevel < 0) {
-            int const clampedCompressionLevel = MAX(ZSTD_minCLevel(), compressionLevel);
-            cp.targetLength = (unsigned)(-clampedCompressionLevel);
-        }
-        /* refine parameters based on srcSize & dictSize */
-        return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode, ZSTD_ps_auto);
-    }
+    /* Table selection is context-free and lives in Rust; the adjustment step
+     * stays behind ZSTD_adjustCParams_internal() so this build's strategy
+     * cascade applies. */
+    ZSTD_compressionParameters const cp = ZSTD_rust_params_selectCParams(
+            compressionLevel, srcSizeHint, dictSize, (int)mode);
+    return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode, ZSTD_ps_auto);
 }
 
 /*! ZSTD_getCParams() :
@@ -7705,13 +7045,9 @@ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long l
 static ZSTD_parameters
 ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)
 {
-    ZSTD_parameters params;
     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, mode);
     DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel);
-    ZSTD_memset(&params, 0, sizeof(params));
-    params.cParams = cParams;
-    params.fParams.contentSizeFlag = 1;
-    return params;
+    return ZSTD_rust_params_makeParams(cParams);
 }
 
 /*! ZSTD_getParams() :

lib/compress/zstd_compress_superblock.c

@@ -29,7 +29,7 @@ size_t ZSTD_rust_compressSuperBlock(
         const SeqStore_t* seqStore,
         const ZSTD_compressedBlockState_t* prevCBlock,
         ZSTD_compressedBlockState_t* nextCBlock,
-        const ZSTD_CCtx_params* cctxParams,
+        int strategy, int disableLiteralCompression,
         void* workspace, size_t wkspSize,
         int bmi2, U32 windowLog, size_t targetCBlockSize,
         void* dst, size_t dstCapacity,
@@ -45,7 +45,8 @@ size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
             &zc->seqStore,
             zc->blockState.prevCBlock,
             zc->blockState.nextCBlock,
-            &zc->appliedParams,
+            (int)zc->appliedParams.cParams.strategy,
+            ZSTD_literalsCompressionIsDisabled(&zc->appliedParams),
             zc->tmpWorkspace, zc->tmpWkspSize,
             zc->bmi2, zc->appliedParams.cParams.windowLog,
             zc->appliedParams.targetCBlockSize,

rust/README.md

@@ -31,9 +31,22 @@ zstd ABI:
   - `zstd_presplit` chooses split points for full compression blocks.
   - `zstd_compress_literals` emits raw, RLE, and Huffman literal sections
     while preserving the compressor's Huffman-table repeat state.
+  - `zstd_compress_stats` converts stored sequences into symbol codes,
+    selects each block's symbol encoding types, compresses a seqStore's
+    literals and sequences into a compressed-block body, builds the block
+    entropy statistics shared with the superblock writer and the block
+    splitter, and exports collected sequences in the public `ZSTD_Sequence`
+    format.  Its C shims extract the sequence store, the entropy-table
+    leaves, and the two `ZSTD_CCtx_params` scalars these paths read.
   - `zstd_compress_frame` serializes frame headers, skippable frames, and the
     last empty block; it takes scalar frame parameters so the C-owned
     `ZSTD_CCtx_params` layout never crosses the language boundary.
+  - `zstd_compress_params` owns the compression-level tables (formerly
+    `clevels.h`), parameter bounds, clamping, validation, table selection,
+    source/dictionary adjustment, and match-state/CDict size estimation.
+    The C integration layer keeps the public `ZSTD_*` symbols and feeds the
+    leaves configuration-owned scalars: the excluded-block-compressor
+    strategy cascade, struct sizes, and sanitizer redzone policy.
   - `zstd_fast` and `zstd_double_fast` implement the single- and two-table
     fast block match finders, including attached and external dictionary paths.
   - `zstd_lazy` implements greedy, lazy, lazy2, and binary-tree matching,

rust/src/lib.rs

@@ -28,8 +28,12 @@ pub mod zstd_compress_frame;
 #[cfg(feature = "compression")]
 pub mod zstd_compress_literals;
 #[cfg(feature = "compression")]
+pub mod zstd_compress_params;
+#[cfg(feature = "compression")]
 pub mod zstd_compress_sequences;
 #[cfg(feature = "compression")]
+pub mod zstd_compress_stats;
+#[cfg(feature = "compression")]
 pub mod zstd_compress_superblock;
 #[cfg(feature = "decompression")]
 pub mod zstd_ddict;

rust/src/zstd_compress_literals.rs

@@ -65,7 +65,7 @@ unsafe fn copy_bytes(dst: *mut u8, src: *const u8, size: usize) {
 }
 
 #[inline]
-unsafe fn copy_huf_tables(dst: *mut ZSTD_hufCTables_t, src: *const ZSTD_hufCTables_t) {
+pub(crate) unsafe fn copy_huf_tables(dst: *mut ZSTD_hufCTables_t, src: *const ZSTD_hufCTables_t) {
     // Copy as bytes, not as a Rust struct: C's memcpy preserves the four tail
     // padding bytes that this layout has on 64-bit targets.  Some C callers
     // copy or compare the complete entropy state, so leaving those bytes from
@@ -192,8 +192,10 @@ fn min_literals_to_compress(strategy: c_int, huf_repeat: c_int) -> usize {
     }
 }
 
+/// C's `ZSTD_minGain()`: minimum compression gain required to emit a
+/// compressed block or compressed literals section.
 #[inline]
-fn min_gain(src_size: usize, strategy: c_int) -> usize {
+pub(crate) fn min_gain(src_size: usize, strategy: c_int) -> usize {
     let min_log = if strategy >= ZSTD_BTULTRA {
         strategy.saturating_sub(1) as u32
     } else {

rust/src/zstd_compress_params.rs

@@ -0,0 +1,1048 @@
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(clippy::missing_safety_doc)]
+#![allow(clippy::too_many_arguments)]
+
+//! Context-free compression-parameter selection and sizing leaves.
+//!
+//! This module deliberately does **not** own the public `ZSTD_*` symbols yet.
+//! `zstd_compress.c` still owns configuration-sensitive policy: excluded block
+//! compressors, private `ZSTD_CCtx_params` layouts, LDM workspace sizing, and
+//! ASAN workspace policy.  The C integration layer can select a raw table
+//! entry here, apply its configured strategy cascade, then use the adjustment
+//! and sizing leaves below.  That keeps the Rust implementation independent of
+//! C preprocessor state while retaining byte-for-byte C policy for reduced
+//! builds.
+
+use crate::errors::{ZstdErrorCode, ERROR};
+use std::mem::size_of;
+use std::os::raw::c_int;
+
+pub const ZSTD_CONTENTSIZE_UNKNOWN: u64 = u64::MAX;
+
+const ZSTD_CLEVEL_DEFAULT: c_int = 3;
+const ZSTD_MAX_CLEVEL: c_int = 22;
+const ZSTD_TARGETLENGTH_MAX: c_int = 1 << 17;
+const ZSTD_BLOCKSIZE_MAX: usize = 1 << 17;
+
+const ZSTD_WINDOWLOG_MIN: c_int = 10;
+#[cfg(target_pointer_width = "32")]
+const ZSTD_WINDOWLOG_MAX: c_int = 30;
+#[cfg(not(target_pointer_width = "32"))]
+const ZSTD_WINDOWLOG_MAX: c_int = 31;
+const ZSTD_HASHLOG_MIN: c_int = 6;
+const ZSTD_HASHLOG_MAX: c_int = 30;
+const ZSTD_CHAINLOG_MIN: c_int = ZSTD_HASHLOG_MIN;
+#[cfg(target_pointer_width = "32")]
+const ZSTD_CHAINLOG_MAX: c_int = 29;
+#[cfg(not(target_pointer_width = "32"))]
+const ZSTD_CHAINLOG_MAX: c_int = 30;
+const ZSTD_SEARCHLOG_MIN: c_int = 1;
+const ZSTD_SEARCHLOG_MAX: c_int = ZSTD_WINDOWLOG_MAX - 1;
+const ZSTD_MINMATCH_MIN: c_int = 3;
+const ZSTD_MINMATCH_MAX: c_int = 7;
+const ZSTD_TARGETLENGTH_MIN: c_int = 0;
+
+const ZSTD_FAST: c_int = 1;
+const ZSTD_DFAST: c_int = 2;
+const ZSTD_GREEDY: c_int = 3;
+const ZSTD_LAZY: c_int = 4;
+const ZSTD_LAZY2: c_int = 5;
+const ZSTD_BTLAZY2: c_int = 6;
+const ZSTD_BTOPT: c_int = 7;
+const ZSTD_BTULTRA: c_int = 8;
+const ZSTD_BTULTRA2: c_int = 9;
+
+const ZSTD_C_COMPRESSION_LEVEL: c_int = 100;
+const ZSTD_C_WINDOW_LOG: c_int = 101;
+const ZSTD_C_HASH_LOG: c_int = 102;
+const ZSTD_C_CHAIN_LOG: c_int = 103;
+const ZSTD_C_SEARCH_LOG: c_int = 104;
+const ZSTD_C_MIN_MATCH: c_int = 105;
+const ZSTD_C_TARGET_LENGTH: c_int = 106;
+const ZSTD_C_STRATEGY: c_int = 107;
+
+/// Private compression-parameter modes from `zstd_compress_internal.h`.
+///
+/// They are ABI-compatible with `ZSTD_CParamMode_e` and intentionally kept as
+/// integer constants because that enum remains private C API for now.
+pub const ZSTD_RUST_CPM_NO_ATTACH_DICT: c_int = 0;
+pub const ZSTD_RUST_CPM_ATTACH_DICT: c_int = 1;
+pub const ZSTD_RUST_CPM_CREATE_CDICT: c_int = 2;
+pub const ZSTD_RUST_CPM_UNKNOWN: c_int = 3;
+
+/// `ZSTD_ParamSwitch_e` values used by the adjustment and sizing leaves.
+pub const ZSTD_RUST_PS_AUTO: c_int = 0;
+pub const ZSTD_RUST_PS_ENABLE: c_int = 1;
+pub const ZSTD_RUST_PS_DISABLE: c_int = 2;
+
+/// ABI-compatible `ZSTD_compressionParameters` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ZSTD_compressionParameters {
+    pub windowLog: u32,
+    pub chainLog: u32,
+    pub hashLog: u32,
+    pub searchLog: u32,
+    pub minMatch: u32,
+    pub targetLength: u32,
+    pub strategy: c_int,
+}
+
+/// ABI-compatible `ZSTD_frameParameters` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ZSTD_frameParameters {
+    pub contentSizeFlag: c_int,
+    pub checksumFlag: c_int,
+    pub noDictIDFlag: c_int,
+}
+
+/// ABI-compatible `ZSTD_parameters` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ZSTD_parameters {
+    pub cParams: ZSTD_compressionParameters,
+    pub fParams: ZSTD_frameParameters,
+}
+
+/// ABI-compatible `ZSTD_bounds` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ZSTD_bounds {
+    pub error: usize,
+    pub lowerBound: c_int,
+    pub upperBound: c_int,
+}
+
+/* `clevels.h`, represented as raw fields so the table stays compact and easy
+ * to compare mechanically against its C source.  Field order is W, C, H, S,
+ * L, TL, strategy. */
+const DEFAULT_CPARAMS: [[[u32; 7]; 23]; 4] = [
+    [
+        [19, 12, 13, 1, 6, 1, ZSTD_FAST as u32],
+        [19, 13, 14, 1, 7, 0, ZSTD_FAST as u32],
+        [20, 15, 16, 1, 6, 0, ZSTD_FAST as u32],
+        [21, 16, 17, 1, 5, 0, ZSTD_DFAST as u32],
+        [21, 18, 18, 1, 5, 0, ZSTD_DFAST as u32],
+        [21, 18, 19, 3, 5, 2, ZSTD_GREEDY as u32],
+        [21, 18, 19, 3, 5, 4, ZSTD_LAZY as u32],
+        [21, 19, 20, 4, 5, 8, ZSTD_LAZY as u32],
+        [21, 19, 20, 4, 5, 16, ZSTD_LAZY2 as u32],
+        [22, 20, 21, 4, 5, 16, ZSTD_LAZY2 as u32],
+        [22, 21, 22, 5, 5, 16, ZSTD_LAZY2 as u32],
+        [22, 21, 22, 6, 5, 16, ZSTD_LAZY2 as u32],
+        [22, 22, 23, 6, 5, 32, ZSTD_LAZY2 as u32],
+        [22, 22, 22, 4, 5, 32, ZSTD_BTLAZY2 as u32],
+        [22, 22, 23, 5, 5, 32, ZSTD_BTLAZY2 as u32],
+        [22, 23, 23, 6, 5, 32, ZSTD_BTLAZY2 as u32],
+        [22, 22, 22, 5, 5, 48, ZSTD_BTOPT as u32],
+        [23, 23, 22, 5, 4, 64, ZSTD_BTOPT as u32],
+        [23, 23, 22, 6, 3, 64, ZSTD_BTULTRA as u32],
+        [23, 24, 22, 7, 3, 256, ZSTD_BTULTRA2 as u32],
+        [25, 25, 23, 7, 3, 256, ZSTD_BTULTRA2 as u32],
+        [26, 26, 24, 7, 3, 512, ZSTD_BTULTRA2 as u32],
+        [27, 27, 25, 9, 3, 999, ZSTD_BTULTRA2 as u32],
+    ],
+    [
+        [18, 12, 13, 1, 5, 1, ZSTD_FAST as u32],
+        [18, 13, 14, 1, 6, 0, ZSTD_FAST as u32],
+        [18, 14, 14, 1, 5, 0, ZSTD_DFAST as u32],
+        [18, 16, 16, 1, 4, 0, ZSTD_DFAST as u32],
+        [18, 16, 17, 3, 5, 2, ZSTD_GREEDY as u32],
+        [18, 17, 18, 5, 5, 2, ZSTD_GREEDY as u32],
+        [18, 18, 19, 3, 5, 4, ZSTD_LAZY as u32],
+        [18, 18, 19, 4, 4, 4, ZSTD_LAZY as u32],
+        [18, 18, 19, 4, 4, 8, ZSTD_LAZY2 as u32],
+        [18, 18, 19, 5, 4, 8, ZSTD_LAZY2 as u32],
+        [18, 18, 19, 6, 4, 8, ZSTD_LAZY2 as u32],
+        [18, 18, 19, 5, 4, 12, ZSTD_BTLAZY2 as u32],
+        [18, 19, 19, 7, 4, 12, ZSTD_BTLAZY2 as u32],
+        [18, 18, 19, 4, 4, 16, ZSTD_BTOPT as u32],
+        [18, 18, 19, 4, 3, 32, ZSTD_BTOPT as u32],
+        [18, 18, 19, 6, 3, 128, ZSTD_BTOPT as u32],
+        [18, 19, 19, 6, 3, 128, ZSTD_BTULTRA as u32],
+        [18, 19, 19, 8, 3, 256, ZSTD_BTULTRA as u32],
+        [18, 19, 19, 6, 3, 128, ZSTD_BTULTRA2 as u32],
+        [18, 19, 19, 8, 3, 256, ZSTD_BTULTRA2 as u32],
+        [18, 19, 19, 10, 3, 512, ZSTD_BTULTRA2 as u32],
+        [18, 19, 19, 12, 3, 512, ZSTD_BTULTRA2 as u32],
+        [18, 19, 19, 13, 3, 999, ZSTD_BTULTRA2 as u32],
+    ],
+    [
+        [17, 12, 12, 1, 5, 1, ZSTD_FAST as u32],
+        [17, 12, 13, 1, 6, 0, ZSTD_FAST as u32],
+        [17, 13, 15, 1, 5, 0, ZSTD_FAST as u32],
+        [17, 15, 16, 2, 5, 0, ZSTD_DFAST as u32],
+        [17, 17, 17, 2, 4, 0, ZSTD_DFAST as u32],
+        [17, 16, 17, 3, 4, 2, ZSTD_GREEDY as u32],
+        [17, 16, 17, 3, 4, 4, ZSTD_LAZY as u32],
+        [17, 16, 17, 3, 4, 8, ZSTD_LAZY2 as u32],
+        [17, 16, 17, 4, 4, 8, ZSTD_LAZY2 as u32],
+        [17, 16, 17, 5, 4, 8, ZSTD_LAZY2 as u32],
+        [17, 16, 17, 6, 4, 8, ZSTD_LAZY2 as u32],
+        [17, 17, 17, 5, 4, 8, ZSTD_BTLAZY2 as u32],
+        [17, 18, 17, 7, 4, 12, ZSTD_BTLAZY2 as u32],
+        [17, 18, 17, 3, 4, 12, ZSTD_BTOPT as u32],
+        [17, 18, 17, 4, 3, 32, ZSTD_BTOPT as u32],
+        [17, 18, 17, 6, 3, 256, ZSTD_BTOPT as u32],
+        [17, 18, 17, 6, 3, 128, ZSTD_BTULTRA as u32],
+        [17, 18, 17, 8, 3, 256, ZSTD_BTULTRA as u32],
+        [17, 18, 17, 10, 3, 512, ZSTD_BTULTRA as u32],
+        [17, 18, 17, 5, 3, 256, ZSTD_BTULTRA2 as u32],
+        [17, 18, 17, 7, 3, 512, ZSTD_BTULTRA2 as u32],
+        [17, 18, 17, 9, 3, 512, ZSTD_BTULTRA2 as u32],
+        [17, 18, 17, 11, 3, 999, ZSTD_BTULTRA2 as u32],
+    ],
+    [
+        [14, 12, 13, 1, 5, 1, ZSTD_FAST as u32],
+        [14, 14, 15, 1, 5, 0, ZSTD_FAST as u32],
+        [14, 14, 15, 1, 4, 0, ZSTD_FAST as u32],
+        [14, 14, 15, 2, 4, 0, ZSTD_DFAST as u32],
+        [14, 14, 14, 4, 4, 2, ZSTD_GREEDY as u32],
+        [14, 14, 14, 3, 4, 4, ZSTD_LAZY as u32],
+        [14, 14, 14, 4, 4, 8, ZSTD_LAZY2 as u32],
+        [14, 14, 14, 6, 4, 8, ZSTD_LAZY2 as u32],
+        [14, 14, 14, 8, 4, 8, ZSTD_LAZY2 as u32],
+        [14, 15, 14, 5, 4, 8, ZSTD_BTLAZY2 as u32],
+        [14, 15, 14, 9, 4, 8, ZSTD_BTLAZY2 as u32],
+        [14, 15, 14, 3, 4, 12, ZSTD_BTOPT as u32],
+        [14, 15, 14, 4, 3, 24, ZSTD_BTOPT as u32],
+        [14, 15, 14, 5, 3, 32, ZSTD_BTULTRA as u32],
+        [14, 15, 15, 6, 3, 64, ZSTD_BTULTRA as u32],
+        [14, 15, 15, 7, 3, 256, ZSTD_BTULTRA as u32],
+        [14, 15, 15, 5, 3, 48, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 6, 3, 128, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 7, 3, 256, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 8, 3, 256, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 8, 3, 512, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 9, 3, 512, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 10, 3, 999, ZSTD_BTULTRA2 as u32],
+    ],
+];
+
+#[inline]
+fn cparams_from_row(row: [u32; 7]) -> ZSTD_compressionParameters {
+    ZSTD_compressionParameters {
+        windowLog: row[0],
+        chainLog: row[1],
+        hashLog: row[2],
+        searchLog: row[3],
+        minMatch: row[4],
+        targetLength: row[5],
+        strategy: row[6] as c_int,
+    }
+}
+
+#[inline]
+fn bounds(param: c_int) -> ZSTD_bounds {
+    let (lowerBound, upperBound) = match param {
+        ZSTD_C_COMPRESSION_LEVEL => (ZSTD_rust_params_minCLevel(), ZSTD_rust_params_maxCLevel()),
+        ZSTD_C_WINDOW_LOG => (ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX),
+        ZSTD_C_HASH_LOG => (ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX),
+        ZSTD_C_CHAIN_LOG => (ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX),
+        ZSTD_C_SEARCH_LOG => (ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX),
+        ZSTD_C_MIN_MATCH => (ZSTD_MINMATCH_MIN, ZSTD_MINMATCH_MAX),
+        ZSTD_C_TARGET_LENGTH => (ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX),
+        ZSTD_C_STRATEGY => (ZSTD_FAST, ZSTD_BTULTRA2),
+        _ => {
+            return ZSTD_bounds {
+                error: ERROR(ZstdErrorCode::ParameterUnsupported),
+                lowerBound: 0,
+                upperBound: 0,
+            }
+        }
+    };
+    ZSTD_bounds {
+        error: 0,
+        lowerBound,
+        upperBound,
+    }
+}
+
+#[inline]
+fn within_bounds(param: c_int, value: c_int) -> bool {
+    let bounds = bounds(param);
+    bounds.error == 0 && value >= bounds.lowerBound && value <= bounds.upperBound
+}
+
+#[inline]
+fn clamp_unsigned(value: u32, param: c_int) -> u32 {
+    let bounds = bounds(param);
+    debug_assert_eq!(bounds.error, 0);
+    let signed = value as c_int;
+    if signed < bounds.lowerBound {
+        bounds.lowerBound as u32
+    } else if signed > bounds.upperBound {
+        bounds.upperBound as u32
+    } else {
+        value
+    }
+}
+
+#[inline]
+fn clamp_cparams(mut cparams: ZSTD_compressionParameters) -> ZSTD_compressionParameters {
+    cparams.windowLog = clamp_unsigned(cparams.windowLog, ZSTD_C_WINDOW_LOG);
+    cparams.chainLog = clamp_unsigned(cparams.chainLog, ZSTD_C_CHAIN_LOG);
+    cparams.hashLog = clamp_unsigned(cparams.hashLog, ZSTD_C_HASH_LOG);
+    cparams.searchLog = clamp_unsigned(cparams.searchLog, ZSTD_C_SEARCH_LOG);
+    cparams.minMatch = clamp_unsigned(cparams.minMatch, ZSTD_C_MIN_MATCH);
+    cparams.targetLength = clamp_unsigned(cparams.targetLength, ZSTD_C_TARGET_LENGTH);
+    let strategy_bounds = bounds(ZSTD_C_STRATEGY);
+    if cparams.strategy < strategy_bounds.lowerBound {
+        cparams.strategy = strategy_bounds.lowerBound;
+    } else if cparams.strategy > strategy_bounds.upperBound {
+        cparams.strategy = strategy_bounds.upperBound;
+    }
+    cparams
+}
+
+#[inline]
+fn highbit32(value: u32) -> u32 {
+    debug_assert_ne!(value, 0);
+    u32::BITS - 1 - value.leading_zeros()
+}
+
+#[inline]
+fn cycle_log(hash_log: u32, strategy: c_int) -> u32 {
+    hash_log.wrapping_sub((strategy >= ZSTD_BTLAZY2) as u32)
+}
+
+#[inline]
+fn strategy_supports_row_match_finder(strategy: c_int) -> bool {
+    (ZSTD_GREEDY..=ZSTD_LAZY2).contains(&strategy)
+}
+
+#[inline]
+fn row_match_finder_used(strategy: c_int, mode: c_int) -> bool {
+    debug_assert_ne!(mode, ZSTD_RUST_PS_AUTO);
+    strategy_supports_row_match_finder(strategy) && mode == ZSTD_RUST_PS_ENABLE
+}
+
+#[inline]
+fn resolve_row_match_finder(mode: c_int, cparams: ZSTD_compressionParameters) -> c_int {
+    if mode != ZSTD_RUST_PS_AUTO {
+        return mode;
+    }
+    if strategy_supports_row_match_finder(cparams.strategy) && cparams.windowLog > 14 {
+        ZSTD_RUST_PS_ENABLE
+    } else {
+        ZSTD_RUST_PS_DISABLE
+    }
+}
+
+#[inline]
+fn dict_and_window_log(window_log: u32, src_size: u64, dict_size: u64) -> u32 {
+    /* 1ULL << ZSTD_WINDOWLOG_MAX, which is smaller for 32-bit builds. */
+    const MAX_WINDOW_SIZE: u64 = 1u64 << ZSTD_WINDOWLOG_MAX;
+    if dict_size == 0 {
+        return window_log;
+    }
+    debug_assert!(window_log <= ZSTD_WINDOWLOG_MAX as u32);
+    debug_assert_ne!(src_size, ZSTD_CONTENTSIZE_UNKNOWN);
+    let window_size = 1u64 << window_log;
+    if window_size >= dict_size.wrapping_add(src_size) {
+        window_log
+    } else {
+        let dict_and_window_size = dict_size.wrapping_add(window_size);
+        if dict_and_window_size >= MAX_WINDOW_SIZE {
+            ZSTD_WINDOWLOG_MAX as u32
+        } else {
+            highbit32((dict_and_window_size as u32).wrapping_sub(1)) + 1
+        }
+    }
+}
+
+/// Adjusts a *validated, configuration-resolved* parameter set.
+///
+/// This is the direct Rust leaf for `ZSTD_adjustCParams_internal()` after the
+/// C wrapper has applied its `ZSTD_EXCLUDE_*_BLOCK_COMPRESSOR` cascade.  In
+/// particular, it does not select a fallback strategy itself. `srcSize == 0`
+/// means a known empty input here, just as it does in the C internal helper;
+/// the public C wrapper must translate zero to `ZSTD_CONTENTSIZE_UNKNOWN`.
+fn adjust_cparams(
+    mut cparams: ZSTD_compressionParameters,
+    mut src_size: u64,
+    mut dict_size: usize,
+    mode: c_int,
+    mut use_row_match_finder: c_int,
+) -> ZSTD_compressionParameters {
+    debug_assert_eq!(check_cparams(cparams), 0);
+
+    const MIN_SRC_SIZE: u64 = 513;
+    /* 1ULL << (ZSTD_WINDOWLOG_MAX - 1), which is smaller for 32-bit builds. */
+    const MAX_WINDOW_RESIZE: u64 = 1u64 << (ZSTD_WINDOWLOG_MAX - 1);
+
+    match mode {
+        ZSTD_RUST_CPM_UNKNOWN | ZSTD_RUST_CPM_NO_ATTACH_DICT => {}
+        ZSTD_RUST_CPM_CREATE_CDICT => {
+            if dict_size != 0 && src_size == ZSTD_CONTENTSIZE_UNKNOWN {
+                src_size = MIN_SRC_SIZE;
+            }
+        }
+        ZSTD_RUST_CPM_ATTACH_DICT => dict_size = 0,
+        _ => debug_assert!(false, "invalid ZSTD_CParamMode_e"),
+    }
+
+    if src_size <= MAX_WINDOW_RESIZE && (dict_size as u64) <= MAX_WINDOW_RESIZE {
+        let total_size = src_size.wrapping_add(dict_size as u64) as u32;
+        let hash_size_min = 1u32 << ZSTD_HASHLOG_MIN;
+        let src_log = if total_size < hash_size_min {
+            ZSTD_HASHLOG_MIN as u32
+        } else {
+            highbit32(total_size.wrapping_sub(1)) + 1
+        };
+        cparams.windowLog = cparams.windowLog.min(src_log);
+    }
+
+    if src_size != ZSTD_CONTENTSIZE_UNKNOWN {
+        let dict_and_window_log =
+            dict_and_window_log(cparams.windowLog, src_size, dict_size as u64);
+        let cycle_log = cycle_log(cparams.chainLog, cparams.strategy);
+        cparams.hashLog = cparams.hashLog.min(dict_and_window_log + 1);
+        if cycle_log > dict_and_window_log {
+            cparams.chainLog = cparams
+                .chainLog
+                .wrapping_sub(cycle_log - dict_and_window_log);
+        }
+    }
+
+    cparams.windowLog = cparams.windowLog.max(ZSTD_WINDOWLOG_MIN as u32);
+
+    /* The short-cache tags used for fast and dfast CDicts consume eight bits
+     * of each 32-bit index.  This is a fixed private-header constant today;
+     * if it becomes configurable, the C shim must pass it as an explicit
+     * adjustment input rather than silently changing this leaf. */
+    if mode == ZSTD_RUST_CPM_CREATE_CDICT
+        && (cparams.strategy == ZSTD_FAST || cparams.strategy == ZSTD_DFAST)
+    {
+        const SHORT_CACHE_TAG_BITS: u32 = 8;
+        let max_short_cache_hash_log = 32 - SHORT_CACHE_TAG_BITS;
+        cparams.hashLog = cparams.hashLog.min(max_short_cache_hash_log);
+        cparams.chainLog = cparams.chainLog.min(max_short_cache_hash_log);
+    }
+
+    if use_row_match_finder == ZSTD_RUST_PS_AUTO {
+        use_row_match_finder = ZSTD_RUST_PS_ENABLE;
+    }
+    if row_match_finder_used(cparams.strategy, use_row_match_finder) {
+        const ROW_HASH_TAG_BITS: u32 = 8;
+        let row_log = cparams.searchLog.clamp(4, 6);
+        let max_hash_log = (32 - ROW_HASH_TAG_BITS) + row_log;
+        debug_assert!(cparams.hashLog >= row_log);
+        cparams.hashLog = cparams.hashLog.min(max_hash_log);
+    }
+
+    cparams
+}
+
+#[inline]
+fn get_cparam_row_size(src_size_hint: u64, dict_size: usize, mode: c_int) -> u64 {
+    let mut dict_size = dict_size as u64;
+    match mode {
+        ZSTD_RUST_CPM_UNKNOWN | ZSTD_RUST_CPM_NO_ATTACH_DICT | ZSTD_RUST_CPM_CREATE_CDICT => {}
+        ZSTD_RUST_CPM_ATTACH_DICT => dict_size = 0,
+        _ => debug_assert!(false, "invalid ZSTD_CParamMode_e"),
+    }
+    let unknown = src_size_hint == ZSTD_CONTENTSIZE_UNKNOWN;
+    let added_size = if unknown && dict_size > 0 { 500 } else { 0 };
+    if unknown && dict_size == 0 {
+        ZSTD_CONTENTSIZE_UNKNOWN
+    } else {
+        src_size_hint
+            .wrapping_add(dict_size)
+            .wrapping_add(added_size)
+    }
+}
+
+/// Selects a raw compression-level-table entry, without strategy cascading or
+/// source/dictionary adjustment.
+///
+/// A C wrapper must apply its active excluded-compressor cascade to the
+/// returned strategy before calling [`ZSTD_rust_params_adjustCParams`].
+fn select_cparams(
+    compression_level: c_int,
+    src_size_hint: u64,
+    dict_size: usize,
+    mode: c_int,
+) -> ZSTD_compressionParameters {
+    let row_size = get_cparam_row_size(src_size_hint, dict_size, mode);
+    let table_id = usize::from(row_size <= 256 * 1024)
+        + usize::from(row_size <= 128 * 1024)
+        + usize::from(row_size <= 16 * 1024);
+    let row = if compression_level == 0 {
+        ZSTD_CLEVEL_DEFAULT
+    } else if compression_level < 0 {
+        0
+    } else {
+        compression_level.min(ZSTD_MAX_CLEVEL)
+    } as usize;
+
+    let mut cparams = cparams_from_row(DEFAULT_CPARAMS[table_id][row]);
+    if compression_level < 0 {
+        let clamped = compression_level.max(ZSTD_rust_params_minCLevel());
+        cparams.targetLength = (-clamped) as u32;
+    }
+    cparams
+}
+
+#[inline]
+fn make_params(cparams: ZSTD_compressionParameters) -> ZSTD_parameters {
+    ZSTD_parameters {
+        cParams: cparams,
+        fParams: ZSTD_frameParameters {
+            contentSizeFlag: 1,
+            checksumFlag: 0,
+            noDictIDFlag: 0,
+        },
+    }
+}
+
+#[inline]
+fn check_cparams(cparams: ZSTD_compressionParameters) -> usize {
+    if !within_bounds(ZSTD_C_WINDOW_LOG, cparams.windowLog as c_int)
+        || !within_bounds(ZSTD_C_CHAIN_LOG, cparams.chainLog as c_int)
+        || !within_bounds(ZSTD_C_HASH_LOG, cparams.hashLog as c_int)
+        || !within_bounds(ZSTD_C_SEARCH_LOG, cparams.searchLog as c_int)
+        || !within_bounds(ZSTD_C_MIN_MATCH, cparams.minMatch as c_int)
+        || !within_bounds(ZSTD_C_TARGET_LENGTH, cparams.targetLength as c_int)
+        || !within_bounds(ZSTD_C_STRATEGY, cparams.strategy)
+    {
+        ERROR(ZstdErrorCode::ParameterOutOfBound)
+    } else {
+        0
+    }
+}
+
+/// Returns the highest table-backed compression level (`ZSTD_MAX_CLEVEL`).
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_maxCLevel() -> c_int {
+    ZSTD_MAX_CLEVEL
+}
+
+/// Returns the lowest public fast level (`-ZSTD_TARGETLENGTH_MAX`).
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_minCLevel() -> c_int {
+    -ZSTD_TARGETLENGTH_MAX
+}
+
+/// Returns the default compression level from `zstd.h`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_defaultCLevel() -> c_int {
+    ZSTD_CLEVEL_DEFAULT
+}
+
+/// Returns bounds for the seven core compression parameters and compression
+/// level.  Other `ZSTD_cParameter` cases remain C-owned.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_getBounds(param: c_int) -> ZSTD_bounds {
+    bounds(param)
+}
+
+/// Checks the seven fields of `ZSTD_compressionParameters`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_checkCParams(cparams: ZSTD_compressionParameters) -> usize {
+    check_cparams(cparams)
+}
+
+/// Clamps the seven fields of `ZSTD_compressionParameters` to public bounds.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_clampCParams(
+    cparams: ZSTD_compressionParameters,
+) -> ZSTD_compressionParameters {
+    clamp_cparams(cparams)
+}
+
+/// C ABI for `ZSTD_cycleLog()`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_cycleLog(hashLog: u32, strategy: c_int) -> u32 {
+    cycle_log(hashLog, strategy)
+}
+
+/// C ABI for private `ZSTD_getCParamRowSize()`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_getCParamRowSize(
+    srcSizeHint: u64,
+    dictSize: usize,
+    mode: c_int,
+) -> u64 {
+    get_cparam_row_size(srcSizeHint, dictSize, mode)
+}
+
+/// Returns the unadjusted compression-level-table entry.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_selectCParams(
+    compressionLevel: c_int,
+    srcSizeHint: u64,
+    dictSize: usize,
+    mode: c_int,
+) -> ZSTD_compressionParameters {
+    select_cparams(compressionLevel, srcSizeHint, dictSize, mode)
+}
+
+/// Adjusts a validated, strategy-resolved C parameter set.
+///
+/// See [`adjust_cparams`] for the required C-side policy step.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_adjustCParams(
+    cparams: ZSTD_compressionParameters,
+    srcSize: u64,
+    dictSize: usize,
+    mode: c_int,
+    useRowMatchFinder: c_int,
+) -> ZSTD_compressionParameters {
+    adjust_cparams(cparams, srcSize, dictSize, mode, useRowMatchFinder)
+}
+
+/// Builds `ZSTD_parameters` with the public default frame parameters.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_makeParams(
+    cparams: ZSTD_compressionParameters,
+) -> ZSTD_parameters {
+    make_params(cparams)
+}
+
+/// Runtime sizes needed to reproduce `ZSTD_sizeof_matchState()` without
+/// exposing private C structures to Rust.
+///
+/// `asanRedzoneSize` is `ZSTD_CWKSP_ASAN_REDZONE_SIZE` when workspace
+/// poisoning is enabled and zero otherwise. `matchTSize` and `optimalTSize`
+/// must be `sizeof(ZSTD_match_t)` and `sizeof(ZSTD_optimal_t)` respectively.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct ZSTD_rustMatchStateSizing {
+    pub hashLog3Max: u32,
+    pub matchTSize: usize,
+    pub optimalTSize: usize,
+    pub asanRedzoneSize: usize,
+}
+
+/// C-only layout inputs for `ZSTD_estimateCDictSize_advanced()`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct ZSTD_rustCDictSizing {
+    pub cdictSize: usize,
+    pub hufWorkspaceSize: usize,
+    pub hashLog3Max: u32,
+    pub matchTSize: usize,
+    pub optimalTSize: usize,
+    pub asanRedzoneSize: usize,
+}
+
+#[inline]
+fn cwksp_alloc_size(size: usize, asan_redzone_size: usize) -> usize {
+    if size == 0 {
+        0
+    } else {
+        size.wrapping_add(asan_redzone_size.wrapping_mul(2))
+    }
+}
+
+#[inline]
+fn cwksp_align(size: usize, alignment: usize) -> usize {
+    debug_assert!(alignment.is_power_of_two());
+    size.wrapping_add(alignment - 1) & !(alignment - 1)
+}
+
+#[inline]
+fn cwksp_aligned64_alloc_size(size: usize, asan_redzone_size: usize) -> usize {
+    cwksp_alloc_size(cwksp_align(size, 64), asan_redzone_size)
+}
+
+#[inline]
+fn shift_size(log: u32) -> usize {
+    debug_assert!(log < usize::BITS);
+    1usize << log
+}
+
+#[inline]
+fn allocate_chain_table(strategy: c_int, use_row_match_finder: c_int, for_dds_dict: bool) -> bool {
+    for_dds_dict
+        || (strategy != ZSTD_FAST && !row_match_finder_used(strategy, use_row_match_finder))
+}
+
+fn estimate_match_state_size(
+    cparams: ZSTD_compressionParameters,
+    use_row_match_finder: c_int,
+    enable_dedicated_dict_search: bool,
+    for_cctx: bool,
+    sizing: ZSTD_rustMatchStateSizing,
+) -> usize {
+    if check_cparams(cparams) != 0 || use_row_match_finder == ZSTD_RUST_PS_AUTO {
+        return 0;
+    }
+
+    let chain_size = if allocate_chain_table(
+        cparams.strategy,
+        use_row_match_finder,
+        enable_dedicated_dict_search && !for_cctx,
+    ) {
+        shift_size(cparams.chainLog)
+    } else {
+        0
+    };
+    let hash_size = shift_size(cparams.hashLog);
+    let hash_log_3 = if for_cctx && cparams.minMatch == 3 {
+        cparams.windowLog.min(sizing.hashLog3Max)
+    } else {
+        0
+    };
+    let hash3_size = if hash_log_3 == 0 {
+        0
+    } else {
+        shift_size(hash_log_3)
+    };
+    let table_space = chain_size
+        .wrapping_mul(size_of::<u32>())
+        .wrapping_add(hash_size.wrapping_mul(size_of::<u32>()))
+        .wrapping_add(hash3_size.wrapping_mul(size_of::<u32>()));
+
+    let redzone = sizing.asanRedzoneSize;
+    let opt_potential_space = cwksp_aligned64_alloc_size((52 + 1) * size_of::<u32>(), redzone)
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            (35 + 1) * size_of::<u32>(),
+            redzone,
+        ))
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            (31 + 1) * size_of::<u32>(),
+            redzone,
+        ))
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            (1 << 8) * size_of::<u32>(),
+            redzone,
+        ))
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            4099usize.wrapping_mul(sizing.matchTSize),
+            redzone,
+        ))
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            4099usize.wrapping_mul(sizing.optimalTSize),
+            redzone,
+        ));
+    let lazy_additional_space = if row_match_finder_used(cparams.strategy, use_row_match_finder) {
+        cwksp_aligned64_alloc_size(hash_size, redzone)
+    } else {
+        0
+    };
+    let opt_space = if for_cctx && cparams.strategy >= ZSTD_BTOPT {
+        opt_potential_space
+    } else {
+        0
+    };
+    let slack_space = 2 * 64;
+
+    table_space
+        .wrapping_add(opt_space)
+        .wrapping_add(slack_space)
+        .wrapping_add(lazy_additional_space)
+}
+
+/// Pure leaf for private `ZSTD_sizeof_matchState()`.
+///
+/// `useRowMatchFinder` must already be resolved to enable or disable.  A NULL
+/// `sizing` pointer or invalid C parameters returns zero; C never supplies
+/// either in a valid estimator call.
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_params_estimateMatchStateSize(
+    cparams: ZSTD_compressionParameters,
+    useRowMatchFinder: c_int,
+    enableDedicatedDictSearch: c_int,
+    forCCtx: u32,
+    sizing: *const ZSTD_rustMatchStateSizing,
+) -> usize {
+    if sizing.is_null() {
+        return 0;
+    }
+    let sizing = unsafe { *sizing };
+    estimate_match_state_size(
+        cparams,
+        useRowMatchFinder,
+        enableDedicatedDictSearch != 0,
+        forCCtx != 0,
+        sizing,
+    )
+}
+
+#[inline]
+fn max_nb_seq(block_size: usize, min_match: u32, use_sequence_producer: bool) -> usize {
+    let divider = if min_match == 3 || use_sequence_producer {
+        3
+    } else {
+        4
+    };
+    block_size / divider
+}
+
+/// Pure leaf for private `ZSTD_maxNbSeq()`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_maxNbSeq(
+    blockSize: usize,
+    minMatch: u32,
+    useSequenceProducer: c_int,
+) -> usize {
+    max_nb_seq(blockSize, minMatch, useSequenceProducer != 0)
+}
+
+/// Pure leaf for private `ZSTD_resolveMaxBlockSize()`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_resolveMaxBlockSize(maxBlockSize: usize) -> usize {
+    if maxBlockSize == 0 {
+        ZSTD_BLOCKSIZE_MAX
+    } else {
+        maxBlockSize
+    }
+}
+
+fn estimate_cdict_size_from_cparams(
+    dict_size: usize,
+    cparams: ZSTD_compressionParameters,
+    dict_load_method: c_int,
+    sizing: ZSTD_rustCDictSizing,
+) -> usize {
+    if check_cparams(cparams) != 0 {
+        return 0;
+    }
+    let match_state_sizing = ZSTD_rustMatchStateSizing {
+        hashLog3Max: sizing.hashLog3Max,
+        matchTSize: sizing.matchTSize,
+        optimalTSize: sizing.optimalTSize,
+        asanRedzoneSize: sizing.asanRedzoneSize,
+    };
+    let row_match_finder = resolve_row_match_finder(ZSTD_RUST_PS_AUTO, cparams);
+    let copied_dict_space = if dict_load_method == 1 {
+        0
+    } else {
+        cwksp_alloc_size(
+            cwksp_align(dict_size, size_of::<usize>()),
+            sizing.asanRedzoneSize,
+        )
+    };
+    cwksp_alloc_size(sizing.cdictSize, sizing.asanRedzoneSize)
+        .wrapping_add(cwksp_alloc_size(
+            sizing.hufWorkspaceSize,
+            sizing.asanRedzoneSize,
+        ))
+        .wrapping_add(estimate_match_state_size(
+            cparams,
+            row_match_finder,
+            true,
+            false,
+            match_state_sizing,
+        ))
+        .wrapping_add(copied_dict_space)
+}
+
+/// Parameter-only leaf for `ZSTD_estimateCDictSize_advanced()`.
+///
+/// C retains ownership of `sizeof(ZSTD_CDict)`, HUF workspace configuration,
+/// and sanitizer workspace policy, then passes them in `sizing`. A NULL sizing
+/// pointer returns zero.
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_params_estimateCDictSizeFromCParams(
+    dictSize: usize,
+    cparams: ZSTD_compressionParameters,
+    dictLoadMethod: c_int,
+    sizing: *const ZSTD_rustCDictSizing,
+) -> usize {
+    if sizing.is_null() {
+        return 0;
+    }
+    estimate_cdict_size_from_cparams(dictSize, cparams, dictLoadMethod, unsafe { *sizing })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::errors::ERR_isError;
+    use std::mem::{align_of, size_of};
+
+    fn adjust_public(
+        cparams: ZSTD_compressionParameters,
+        src_size: u64,
+        dict_size: usize,
+    ) -> ZSTD_compressionParameters {
+        let src_size = if src_size == 0 {
+            ZSTD_CONTENTSIZE_UNKNOWN
+        } else {
+            src_size
+        };
+        adjust_cparams(
+            clamp_cparams(cparams),
+            src_size,
+            dict_size,
+            ZSTD_RUST_CPM_UNKNOWN,
+            ZSTD_RUST_PS_AUTO,
+        )
+    }
+
+    #[test]
+    fn abi_parameter_layouts_match_zstd_h() {
+        assert_eq!(
+            size_of::<ZSTD_compressionParameters>(),
+            7 * size_of::<u32>()
+        );
+        assert_eq!(align_of::<ZSTD_compressionParameters>(), align_of::<u32>());
+        assert_eq!(size_of::<ZSTD_frameParameters>(), 3 * size_of::<c_int>());
+        assert_eq!(size_of::<ZSTD_parameters>(), 10 * size_of::<u32>());
+        assert_eq!(
+            size_of::<ZSTD_bounds>(),
+            size_of::<usize>() + 2 * size_of::<c_int>()
+        );
+    }
+
+    #[test]
+    fn level_tables_match_representative_clevels_entries() {
+        let large = select_cparams(3, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
+        assert_eq!(
+            large,
+            ZSTD_compressionParameters {
+                windowLog: 21,
+                chainLog: 16,
+                hashLog: 17,
+                searchLog: 1,
+                minMatch: 5,
+                targetLength: 0,
+                strategy: ZSTD_DFAST,
+            }
+        );
+
+        let small = select_cparams(3, 16 * 1024, 0, ZSTD_RUST_CPM_UNKNOWN);
+        assert_eq!(
+            small,
+            ZSTD_compressionParameters {
+                windowLog: 14,
+                chainLog: 14,
+                hashLog: 15,
+                searchLog: 2,
+                minMatch: 4,
+                targetLength: 0,
+                strategy: ZSTD_DFAST,
+            }
+        );
+
+        let fast = select_cparams(-5, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
+        assert_eq!(fast.strategy, ZSTD_FAST);
+        assert_eq!(fast.targetLength, 5);
+        assert_eq!(
+            select_cparams(999, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN),
+            select_cparams(22, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN)
+        );
+    }
+
+    #[test]
+    fn adjustment_clamps_and_downsizes_like_the_c_leaf() {
+        let input = ZSTD_compressionParameters {
+            windowLog: 31,
+            chainLog: 30,
+            hashLog: 30,
+            searchLog: 1,
+            minMatch: 3,
+            targetLength: 0,
+            strategy: ZSTD_BTOPT,
+        };
+        let adjusted = adjust_public(input, 1, 0);
+        assert_eq!(adjusted.windowLog, 10);
+        /* C applies WINDOWLOG_ABSOLUTEMIN only after it has used the smaller
+         * temporary window to downsize the hash and chain logs. */
+        assert_eq!(adjusted.hashLog, 7);
+        assert_eq!(adjusted.chainLog, 7);
+        assert_eq!(ZSTD_rust_params_checkCParams(adjusted), 0);
+
+        let clamped = ZSTD_rust_params_clampCParams(ZSTD_compressionParameters {
+            windowLog: u32::MAX,
+            chainLog: 0,
+            hashLog: 0,
+            searchLog: 0,
+            minMatch: 0,
+            targetLength: u32::MAX,
+            strategy: 99,
+        });
+        assert_eq!(clamped.windowLog, ZSTD_WINDOWLOG_MIN as u32);
+        assert_eq!(clamped.chainLog, ZSTD_CHAINLOG_MIN as u32);
+        assert_eq!(clamped.hashLog, ZSTD_HASHLOG_MIN as u32);
+        assert_eq!(clamped.searchLog, ZSTD_SEARCHLOG_MIN as u32);
+        assert_eq!(clamped.minMatch, ZSTD_MINMATCH_MIN as u32);
+        assert_eq!(clamped.targetLength, ZSTD_TARGETLENGTH_MIN as u32);
+        assert_eq!(clamped.strategy, ZSTD_BTULTRA2);
+    }
+
+    #[test]
+    fn checking_and_bounds_preserve_the_public_error_contract() {
+        let valid = select_cparams(1, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
+        assert_eq!(check_cparams(valid), 0);
+        let mut invalid = valid;
+        invalid.minMatch = 2;
+        assert!(ERR_isError(check_cparams(invalid)));
+        let bounds = ZSTD_rust_params_getBounds(ZSTD_C_HASH_LOG);
+        assert_eq!(bounds.error, 0);
+        assert_eq!(bounds.lowerBound, 6);
+        assert_eq!(bounds.upperBound, 30);
+        assert!(ERR_isError(ZSTD_rust_params_getBounds(-1).error));
+    }
+
+    #[test]
+    fn params_default_frame_flags_match_c() {
+        let cparams = select_cparams(5, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
+        let params = ZSTD_rust_params_makeParams(cparams);
+        assert_eq!(params.cParams, cparams);
+        assert_eq!(params.fParams.contentSizeFlag, 1);
+        assert_eq!(params.fParams.checksumFlag, 0);
+        assert_eq!(params.fParams.noDictIDFlag, 0);
+    }
+
+    #[test]
+    fn row_size_preserves_unknown_dictionary_overflow_semantics() {
+        assert_eq!(
+            get_cparam_row_size(ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN),
+            ZSTD_CONTENTSIZE_UNKNOWN
+        );
+        assert_eq!(
+            get_cparam_row_size(ZSTD_CONTENTSIZE_UNKNOWN, 1, ZSTD_RUST_CPM_UNKNOWN),
+            500
+        );
+        assert_eq!(
+            get_cparam_row_size(128 * 1024, 1, ZSTD_RUST_CPM_ATTACH_DICT),
+            128 * 1024
+        );
+    }
+
+    #[test]
+    fn match_state_sizing_reproduces_table_and_row_rules() {
+        let sizing = ZSTD_rustMatchStateSizing {
+            hashLog3Max: 17,
+            matchTSize: 16,
+            optimalTSize: 32,
+            asanRedzoneSize: 0,
+        };
+        let fast = ZSTD_compressionParameters {
+            windowLog: 10,
+            chainLog: 10,
+            hashLog: 10,
+            searchLog: 1,
+            minMatch: 4,
+            targetLength: 0,
+            strategy: ZSTD_FAST,
+        };
+        assert_eq!(
+            estimate_match_state_size(fast, ZSTD_RUST_PS_DISABLE, false, true, sizing),
+            4096 + 128
+        );
+
+        let row = ZSTD_compressionParameters {
+            windowLog: 15,
+            chainLog: 10,
+            hashLog: 10,
+            searchLog: 4,
+            minMatch: 4,
+            targetLength: 0,
+            strategy: ZSTD_GREEDY,
+        };
+        assert_eq!(
+            estimate_match_state_size(row, ZSTD_RUST_PS_ENABLE, false, true, sizing),
+            4096 + 1024 + 128
+        );
+        assert_eq!(ZSTD_rust_params_maxNbSeq(100, 3, 0), 33);
+        assert_eq!(ZSTD_rust_params_maxNbSeq(100, 4, 0), 25);
+        assert_eq!(ZSTD_rust_params_resolveMaxBlockSize(0), 128 * 1024);
+    }
+}

rust/src/zstd_compress_stats.rs

@@ -0,0 +1,1549 @@
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+//! Sequence statistics and seqStore entropy compression.
+//!
+//! This module translates the block entropy-statistics layer of
+//! `zstd_compress.c`: `ZSTD_seqToCodes()`, `ZSTD_buildSequencesStatistics()`,
+//! `ZSTD_entropyCompressSeqStore*()`, `ZSTD_buildBlockEntropyStats*()`, and
+//! `ZSTD_copyBlockSequences()`.  The `ZSTD_CCtx` and `ZSTD_CCtx_params`
+//! layouts stay private to C: the C shims extract the sequence store, the
+//! entropy-table leaves, and the two parameter scalars these paths read
+//! (the compression strategy and the literals-compression switch).  Block
+//! dispatch, block splitting, and the block-size estimation heuristics also
+//! remain in C for a later slice.
+
+use crate::bits::ZSTD_highbit32;
+use crate::common::{
+    DEFAULT_MAX_OFF, LL_DEFAULT_NORM, LL_DEFAULT_NORM_LOG, LL_FSE_LOG, LONGNBSEQ, MAX_LL, MAX_ML,
+    MAX_OFF, MAX_SEQ, MINMATCH, ML_DEFAULT_NORM, ML_DEFAULT_NORM_LOG, ML_FSE_LOG, OFF_FSE_LOG,
+    OF_DEFAULT_NORM, OF_DEFAULT_NORM_LOG, ZSTD_MAX_FSE_HEADERS_SIZE, ZSTD_MAX_HUF_HEADER_SIZE,
+    ZSTD_REP_NUM,
+};
+use crate::errors::{ERR_isError, ZstdErrorCode, ERROR};
+use crate::hist::{HIST_countFast_wksp, HIST_count_wksp};
+use crate::huf_compress::{
+    HUF_buildCTable_wksp, HUF_estimateCompressedSize, HUF_optimalTableLog, HUF_validateCTable,
+    HUF_writeCTable_wksp,
+};
+use crate::mem::{MEM_32bits, MEM_writeLE16};
+use crate::zstd_compress_literals::{
+    copy_huf_tables, min_gain, ZSTD_compressLiterals, ZSTD_hufCTables_t,
+};
+use crate::zstd_compress_sequences::{
+    SeqDef, ZSTD_buildCTable, ZSTD_encodeSequences, ZSTD_selectEncodingType,
+};
+use std::ffi::c_void;
+use std::mem::{size_of, size_of_val};
+use std::os::raw::{c_int, c_uint};
+use std::ptr;
+
+const SET_BASIC: c_int = 0;
+const SET_RLE: c_int = 1;
+const SET_COMPRESSED: c_int = 2;
+const SET_REPEAT: c_int = 3;
+
+const FSE_REPEAT_NONE: c_int = 0;
+
+const HUF_REPEAT_NONE: c_int = 0;
+const HUF_REPEAT_CHECK: c_int = 1;
+const HUF_REPEAT_VALID: c_int = 2;
+
+const HUF_FLAGS_OPTIMAL_DEPTH: c_int = 1 << 1;
+const HUF_OPTIMAL_DEPTH_THRESHOLD: c_int = 8; /* ZSTD_btultra */
+
+const ZSTD_DEFAULT_DISALLOWED: c_int = 0;
+const ZSTD_DEFAULT_ALLOWED: c_int = 1;
+
+const HUF_SYMBOLVALUE_MAX: c_uint = 255;
+const LIT_HUF_LOG: c_uint = 11;
+const COMPRESS_LITERALS_SIZE_MIN: usize = 63;
+const SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO: usize = 20;
+
+const STREAM_ACCUMULATOR_MIN_32: u32 = 25;
+const STREAM_ACCUMULATOR_MIN_64: u32 = 57;
+
+const LL_DELTA_CODE: u32 = 19;
+const ML_DELTA_CODE: u32 = 36;
+
+pub(crate) const ZSTD_LLT_LITERAL_LENGTH: c_int = 1;
+pub(crate) const ZSTD_LLT_MATCH_LENGTH: c_int = 2;
+
+/// `FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)` from the C headers.
+pub const OFF_CTABLE_SIZE: usize = 1 + (1 << (OFF_FSE_LOG - 1)) + ((MAX_OFF + 1) * 2);
+/// `FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)` from the C headers.
+pub const ML_CTABLE_SIZE: usize = 1 + (1 << (ML_FSE_LOG - 1)) + ((MAX_ML + 1) * 2);
+/// `FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)` from the C headers.
+pub const LL_CTABLE_SIZE: usize = 1 + (1 << (LL_FSE_LOG - 1)) + ((MAX_LL + 1) * 2);
+
+/// ABI-compatible `SeqStore_t` leaf layout from `zstd_compress_internal.h`.
+///
+/// The C context itself remains opaque; its shims pass the `seqStore` member
+/// directly, so this small, stable hot-path structure is the only sequence
+/// storage representation crossing into Rust.
+#[repr(C)]
+pub struct SeqStore_t {
+    pub sequencesStart: *mut SeqDef,
+    pub sequences: *mut SeqDef,
+    pub litStart: *mut u8,
+    pub lit: *mut u8,
+    pub llCode: *mut u8,
+    pub mlCode: *mut u8,
+    pub ofCode: *mut u8,
+    pub maxNbSeq: usize,
+    pub maxNbLit: usize,
+    pub longLengthType: c_int,
+    pub longLengthPos: u32,
+}
+
+/// C's `ZSTD_fseCTables_t`.  The table element type is `FSE_CTable`, an
+/// `unsigned`, and the table lengths are the header macros expanded above.
+#[repr(C)]
+pub struct ZSTD_fseCTables_t {
+    pub offcodeCTable: [u32; OFF_CTABLE_SIZE],
+    pub matchlengthCTable: [u32; ML_CTABLE_SIZE],
+    pub litlengthCTable: [u32; LL_CTABLE_SIZE],
+    pub offcode_repeatMode: c_int,
+    pub matchlength_repeatMode: c_int,
+    pub litlength_repeatMode: c_int,
+}
+
+/// C's `ZSTD_entropyCTables_t`.
+#[repr(C)]
+pub struct ZSTD_entropyCTables_t {
+    pub huf: ZSTD_hufCTables_t,
+    pub fse: ZSTD_fseCTables_t,
+}
+
+/// C's `ZSTD_compressedBlockState_t`.
+#[repr(C)]
+pub struct ZSTD_compressedBlockState_t {
+    pub entropy: ZSTD_entropyCTables_t,
+    pub rep: [u32; ZSTD_REP_NUM],
+}
+
+/// C's `ZSTD_hufCTablesMetadata_t`.
+#[repr(C)]
+pub struct ZSTD_hufCTablesMetadata_t {
+    pub hType: c_int,
+    pub hufDesBuffer: [u8; ZSTD_MAX_HUF_HEADER_SIZE],
+    pub hufDesSize: usize,
+}
+
+/// C's `ZSTD_fseCTablesMetadata_t`.
+#[repr(C)]
+pub struct ZSTD_fseCTablesMetadata_t {
+    pub llType: c_int,
+    pub ofType: c_int,
+    pub mlType: c_int,
+    pub fseTablesBuffer: [u8; ZSTD_MAX_FSE_HEADERS_SIZE],
+    pub fseTablesSize: usize,
+    pub lastCountSize: usize,
+}
+
+/// C's `ZSTD_entropyCTablesMetadata_t`.
+#[repr(C)]
+pub struct ZSTD_entropyCTablesMetadata_t {
+    pub hufMetadata: ZSTD_hufCTablesMetadata_t,
+    pub fseMetadata: ZSTD_fseCTablesMetadata_t,
+}
+
+/// Public `ZSTD_Sequence` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ZSTD_Sequence {
+    pub offset: u32,
+    pub litLength: u32,
+    pub matchLength: u32,
+    pub rep: u32,
+}
+
+/// C's `SeqCollector` leaf from `zstd_compress_internal.h`.
+#[repr(C)]
+pub struct SeqCollector {
+    pub collectSequences: c_int,
+    pub seqStart: *mut ZSTD_Sequence,
+    pub seqIndex: usize,
+    pub maxSequences: usize,
+}
+
+/// Result of `build_sequences_statistics()`; mirrors C's
+/// `ZSTD_symbolEncodingTypeStats_t`, which no longer crosses the boundary.
+pub(crate) struct SymbolEncodingTypeStats {
+    pub ll_type: u32,
+    pub off_type: u32,
+    pub ml_type: u32,
+    pub size: usize,
+    /// Accounts for a bug in zstd 1.3.4; see
+    /// `entropy_compress_seq_store_internal()`.
+    pub last_count_size: usize,
+    pub long_offsets: c_int,
+}
+
+/// C's `ZSTD_updateRep()` repeat-offset history update.
+#[inline]
+pub(crate) fn update_rep(reps: &mut [u32; 3], off_base: u32, literal_length_is_zero: bool) {
+    if off_base > 3 {
+        reps[2] = reps[1];
+        reps[1] = reps[0];
+        reps[0] = off_base - 3;
+        return;
+    }
+    let rep_code = off_base - 1 + u32::from(literal_length_is_zero);
+    if rep_code == 0 {
+        return;
+    }
+    let current_offset = if rep_code == 3 {
+        reps[0].wrapping_sub(1)
+    } else {
+        reps[rep_code as usize]
+    };
+    reps[2] = if rep_code >= 2 { reps[1] } else { reps[2] };
+    reps[1] = reps[0];
+    reps[0] = current_offset;
+}
+
+#[inline]
+fn ll_code(lit_length: u32) -> u32 {
+    const LL_CODE: [u8; 64] = [
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20,
+        20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+        24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    ];
+    if lit_length > 63 {
+        ZSTD_highbit32(lit_length) + LL_DELTA_CODE
+    } else {
+        LL_CODE[lit_length as usize] as u32
+    }
+}
+
+#[inline]
+fn ml_code(ml_base: u32) -> u32 {
+    const ML_CODE: [u8; 128] = [
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+        25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
+        38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40,
+        40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+        42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+    ];
+    if ml_base > 127 {
+        ZSTD_highbit32(ml_base) + ML_DELTA_CODE
+    } else {
+        ML_CODE[ml_base as usize] as u32
+    }
+}
+
+#[inline]
+unsafe fn copy_fse_tables(dst: *mut ZSTD_fseCTables_t, src: *const ZSTD_fseCTables_t) {
+    unsafe {
+        ptr::copy_nonoverlapping(
+            src.cast::<u8>(),
+            dst.cast::<u8>(),
+            size_of::<ZSTD_fseCTables_t>(),
+        )
+    };
+}
+
+/// Converts the stored lengths and distances into symbol codes.
+///
+/// Retains its original exported name: the C dictionary builder and the
+/// decodecorpus test tool link against it directly.
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_seqToCodes(seq_store: *const SeqStore_t) -> c_int {
+    let store = unsafe { &*seq_store };
+    let sequences = store.sequencesStart;
+    let nb_seq = unsafe { store.sequences.offset_from(sequences) } as usize;
+    let mut long_offsets = 0;
+    debug_assert!(nb_seq <= store.maxNbSeq);
+
+    for index in 0..nb_seq {
+        let sequence = unsafe { sequences.add(index).read() };
+        let of_code = ZSTD_highbit32(sequence.offBase);
+        unsafe {
+            *store.llCode.add(index) = ll_code(sequence.litLength as u32) as u8;
+            *store.ofCode.add(index) = of_code as u8;
+            *store.mlCode.add(index) = ml_code(sequence.mlBase as u32) as u8;
+        }
+        debug_assert!(MEM_32bits() || of_code < STREAM_ACCUMULATOR_MIN_64);
+        if MEM_32bits() && of_code >= STREAM_ACCUMULATOR_MIN_32 {
+            long_offsets = 1;
+        }
+    }
+    if store.longLengthType == ZSTD_LLT_LITERAL_LENGTH {
+        unsafe { *store.llCode.add(store.longLengthPos as usize) = MAX_LL as u8 };
+    }
+    if store.longLengthType == ZSTD_LLT_MATCH_LENGTH {
+        unsafe { *store.mlCode.add(store.longLengthPos as usize) = MAX_ML as u8 };
+    }
+    long_offsets
+}
+
+/// C's `ZSTD_buildSequencesStatistics()`.
+///
+/// Returns the statistics with a zstd error code in the `size` field on
+/// failure, and updates `next_entropy` as a side effect.  `nb_seq` must be
+/// greater than zero, and the entropy workspace must hold at least
+/// `ENTROPY_WORKSPACE_SIZE - (MaxSeq + 1) * sizeof(U32)` bytes.
+#[allow(clippy::too_many_arguments)]
+pub(crate) unsafe fn build_sequences_statistics(
+    seq_store: *const SeqStore_t,
+    nb_seq: usize,
+    prev_entropy: *const ZSTD_fseCTables_t,
+    next_entropy: *mut ZSTD_fseCTables_t,
+    dst: *mut u8,
+    dst_capacity: usize,
+    strategy: c_int,
+    count_workspace: *mut c_uint,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+) -> SymbolEncodingTypeStats {
+    let store = unsafe { &*seq_store };
+    let mut stats = SymbolEncodingTypeStats {
+        ll_type: 0,
+        off_type: 0,
+        ml_type: 0,
+        size: 0,
+        last_count_size: 0,
+        long_offsets: 0,
+    };
+    let mut written = 0usize;
+
+    /* convert length/distances into codes */
+    stats.long_offsets = unsafe { ZSTD_seqToCodes(seq_store) };
+    debug_assert!(nb_seq != 0); /* ZSTD_selectEncodingType() divides by nb_seq */
+
+    /* build CTable for Literal Lengths */
+    {
+        let mut max = MAX_LL as c_uint;
+        let most_frequent = unsafe {
+            HIST_countFast_wksp(
+                count_workspace,
+                &mut max,
+                store.llCode.cast::<c_void>(),
+                nb_seq,
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        }; /* can't fail */
+        unsafe { (*next_entropy).litlength_repeatMode = (*prev_entropy).litlength_repeatMode };
+        stats.ll_type = unsafe {
+            ZSTD_selectEncodingType(
+                ptr::addr_of_mut!((*next_entropy).litlength_repeatMode),
+                count_workspace,
+                max,
+                most_frequent,
+                nb_seq,
+                LL_FSE_LOG as c_uint,
+                ptr::addr_of!((*prev_entropy).litlengthCTable).cast::<u32>(),
+                LL_DEFAULT_NORM.as_ptr(),
+                LL_DEFAULT_NORM_LOG,
+                ZSTD_DEFAULT_ALLOWED,
+                strategy,
+            )
+        } as u32;
+        let count_size = unsafe {
+            ZSTD_buildCTable(
+                dst.add(written).cast::<c_void>(),
+                dst_capacity - written,
+                ptr::addr_of_mut!((*next_entropy).litlengthCTable).cast::<u32>(),
+                LL_FSE_LOG as u32,
+                stats.ll_type as c_int,
+                count_workspace,
+                max,
+                store.llCode,
+                nb_seq,
+                LL_DEFAULT_NORM.as_ptr(),
+                LL_DEFAULT_NORM_LOG,
+                MAX_LL as u32,
+                ptr::addr_of!((*prev_entropy).litlengthCTable).cast::<u32>(),
+                size_of::<[u32; LL_CTABLE_SIZE]>(),
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        };
+        if ERR_isError(count_size) {
+            stats.size = count_size;
+            return stats;
+        }
+        if stats.ll_type == SET_COMPRESSED as u32 {
+            stats.last_count_size = count_size;
+        }
+        written += count_size;
+    }
+    /* build CTable for Offsets */
+    {
+        let mut max = MAX_OFF as c_uint;
+        let most_frequent = unsafe {
+            HIST_countFast_wksp(
+                count_workspace,
+                &mut max,
+                store.ofCode.cast::<c_void>(),
+                nb_seq,
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        }; /* can't fail */
+        /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
+        let default_policy = if max <= DEFAULT_MAX_OFF as c_uint {
+            ZSTD_DEFAULT_ALLOWED
+        } else {
+            ZSTD_DEFAULT_DISALLOWED
+        };
+        unsafe { (*next_entropy).offcode_repeatMode = (*prev_entropy).offcode_repeatMode };
+        stats.off_type = unsafe {
+            ZSTD_selectEncodingType(
+                ptr::addr_of_mut!((*next_entropy).offcode_repeatMode),
+                count_workspace,
+                max,
+                most_frequent,
+                nb_seq,
+                OFF_FSE_LOG as c_uint,
+                ptr::addr_of!((*prev_entropy).offcodeCTable).cast::<u32>(),
+                OF_DEFAULT_NORM.as_ptr(),
+                OF_DEFAULT_NORM_LOG,
+                default_policy,
+                strategy,
+            )
+        } as u32;
+        let count_size = unsafe {
+            ZSTD_buildCTable(
+                dst.add(written).cast::<c_void>(),
+                dst_capacity - written,
+                ptr::addr_of_mut!((*next_entropy).offcodeCTable).cast::<u32>(),
+                OFF_FSE_LOG as u32,
+                stats.off_type as c_int,
+                count_workspace,
+                max,
+                store.ofCode,
+                nb_seq,
+                OF_DEFAULT_NORM.as_ptr(),
+                OF_DEFAULT_NORM_LOG,
+                DEFAULT_MAX_OFF as u32,
+                ptr::addr_of!((*prev_entropy).offcodeCTable).cast::<u32>(),
+                size_of::<[u32; OFF_CTABLE_SIZE]>(),
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        };
+        if ERR_isError(count_size) {
+            stats.size = count_size;
+            return stats;
+        }
+        if stats.off_type == SET_COMPRESSED as u32 {
+            stats.last_count_size = count_size;
+        }
+        written += count_size;
+    }
+    /* build CTable for MatchLengths */
+    {
+        let mut max = MAX_ML as c_uint;
+        let most_frequent = unsafe {
+            HIST_countFast_wksp(
+                count_workspace,
+                &mut max,
+                store.mlCode.cast::<c_void>(),
+                nb_seq,
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        }; /* can't fail */
+        unsafe { (*next_entropy).matchlength_repeatMode = (*prev_entropy).matchlength_repeatMode };
+        stats.ml_type = unsafe {
+            ZSTD_selectEncodingType(
+                ptr::addr_of_mut!((*next_entropy).matchlength_repeatMode),
+                count_workspace,
+                max,
+                most_frequent,
+                nb_seq,
+                ML_FSE_LOG as c_uint,
+                ptr::addr_of!((*prev_entropy).matchlengthCTable).cast::<u32>(),
+                ML_DEFAULT_NORM.as_ptr(),
+                ML_DEFAULT_NORM_LOG,
+                ZSTD_DEFAULT_ALLOWED,
+                strategy,
+            )
+        } as u32;
+        let count_size = unsafe {
+            ZSTD_buildCTable(
+                dst.add(written).cast::<c_void>(),
+                dst_capacity - written,
+                ptr::addr_of_mut!((*next_entropy).matchlengthCTable).cast::<u32>(),
+                ML_FSE_LOG as u32,
+                stats.ml_type as c_int,
+                count_workspace,
+                max,
+                store.mlCode,
+                nb_seq,
+                ML_DEFAULT_NORM.as_ptr(),
+                ML_DEFAULT_NORM_LOG,
+                MAX_ML as u32,
+                ptr::addr_of!((*prev_entropy).matchlengthCTable).cast::<u32>(),
+                size_of::<[u32; ML_CTABLE_SIZE]>(),
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        };
+        if ERR_isError(count_size) {
+            stats.size = count_size;
+            return stats;
+        }
+        if stats.ml_type == SET_COMPRESSED as u32 {
+            stats.last_count_size = count_size;
+        }
+        written += count_size;
+    }
+    stats.size = written;
+    stats
+}
+
+/// C's `ZSTD_entropyCompressSeqStore_internal()`: compresses literals and
+/// sequences into one compressed-block body.
+#[allow(clippy::too_many_arguments)]
+unsafe fn entropy_compress_seq_store_internal(
+    dst: *mut c_void,
+    dst_capacity: usize,
+    literals: *const c_void,
+    lit_size: usize,
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+    bmi2: c_int,
+) -> usize {
+    let count = entropy_workspace.cast::<c_uint>();
+    let entropy_workspace = unsafe { count.add(MAX_SEQ + 1) }.cast::<c_void>();
+    let entropy_wksp_size = entropy_wksp_size.wrapping_sub((MAX_SEQ + 1) * size_of::<c_uint>());
+    let store = unsafe { &*seq_store };
+    let sequences = store.sequencesStart;
+    let nb_seq = unsafe { store.sequences.offset_from(sequences) } as usize;
+    let ostart = dst.cast::<u8>();
+    let mut written = 0usize;
+    let last_count_size;
+    let long_offsets;
+
+    /* Compress literals */
+    {
+        /* Base suspicion of uncompressibility on ratio of literals to sequences */
+        let suspect_uncompressible =
+            c_int::from(nb_seq == 0 || lit_size / nb_seq >= SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO);
+        let c_size = unsafe {
+            ZSTD_compressLiterals(
+                dst,
+                dst_capacity,
+                literals,
+                lit_size,
+                entropy_workspace,
+                entropy_wksp_size,
+                ptr::addr_of!((*prev_entropy).huf),
+                ptr::addr_of_mut!((*next_entropy).huf),
+                strategy,
+                disable_literal_compression,
+                suspect_uncompressible,
+                bmi2,
+            )
+        };
+        if ERR_isError(c_size) {
+            return c_size;
+        }
+        debug_assert!(c_size <= dst_capacity);
+        written += c_size;
+    }
+
+    /* Sequences Header */
+    if (dst_capacity as isize).wrapping_sub(written as isize) < 3 /* max nbSeq Size */ + 1
+    /* seqHead */
+    {
+        return ERROR(ZstdErrorCode::DstSizeTooSmall);
+    }
+    unsafe {
+        if nb_seq < 128 {
+            *ostart.add(written) = nb_seq as u8;
+            written += 1;
+        } else if nb_seq < LONGNBSEQ as usize {
+            *ostart.add(written) = ((nb_seq >> 8) + 0x80) as u8;
+            *ostart.add(written + 1) = nb_seq as u8;
+            written += 2;
+        } else {
+            *ostart.add(written) = 0xFF;
+            MEM_writeLE16(
+                ostart.add(written + 1).cast::<c_void>(),
+                (nb_seq - LONGNBSEQ as usize) as u16,
+            );
+            written += 3;
+        }
+    }
+    if nb_seq == 0 {
+        /* Copy the old tables over as if we repeated them */
+        unsafe {
+            copy_fse_tables(
+                ptr::addr_of_mut!((*next_entropy).fse),
+                ptr::addr_of!((*prev_entropy).fse),
+            )
+        };
+        return written;
+    }
+    {
+        let seq_head = written;
+        written += 1;
+        /* build stats for sequences */
+        let stats = unsafe {
+            build_sequences_statistics(
+                seq_store,
+                nb_seq,
+                ptr::addr_of!((*prev_entropy).fse),
+                ptr::addr_of_mut!((*next_entropy).fse),
+                ostart.add(written),
+                dst_capacity - written,
+                strategy,
+                count,
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        };
+        if ERR_isError(stats.size) {
+            return stats.size;
+        }
+        unsafe {
+            *ostart.add(seq_head) =
+                ((stats.ll_type << 6) + (stats.off_type << 4) + (stats.ml_type << 2)) as u8;
+        }
+        last_count_size = stats.last_count_size;
+        written += stats.size;
+        long_offsets = stats.long_offsets;
+    }
+
+    {
+        let bitstream_size = unsafe {
+            ZSTD_encodeSequences(
+                ostart.add(written).cast::<c_void>(),
+                dst_capacity - written,
+                ptr::addr_of!((*next_entropy).fse.matchlengthCTable).cast::<u32>(),
+                store.mlCode,
+                ptr::addr_of!((*next_entropy).fse.offcodeCTable).cast::<u32>(),
+                store.ofCode,
+                ptr::addr_of!((*next_entropy).fse.litlengthCTable).cast::<u32>(),
+                store.llCode,
+                sequences,
+                nb_seq,
+                long_offsets,
+                bmi2,
+            )
+        };
+        if ERR_isError(bitstream_size) {
+            return bitstream_size;
+        }
+        written += bitstream_size;
+        /* zstd versions <= 1.3.4 mistakenly report corruption when
+         * FSE_readNCount() receives a buffer < 4 bytes.
+         * Fixed by https://github.com/facebook/zstd/pull/1146.
+         * This can happen when the last set_compressed table present is 2
+         * bytes and the bitstream is only one byte.
+         * In this exceedingly rare case, we will simply emit an uncompressed
+         * block, since it isn't worth optimizing.
+         */
+        if last_count_size != 0 && last_count_size + bitstream_size < 4 {
+            /* last_count_size >= 2 && bitstream_size > 0 ==> last_count_size == 3 */
+            debug_assert!(last_count_size + bitstream_size == 3);
+            return 0;
+        }
+    }
+
+    written
+}
+
+/// C's `ZSTD_entropyCompressSeqStore_wExtLitBuffer()`: adds the
+/// incompressibility fallbacks around the internal entropy pass.
+#[allow(clippy::too_many_arguments)]
+unsafe fn entropy_compress_seq_store_w_ext_lit_buffer(
+    dst: *mut c_void,
+    dst_capacity: usize,
+    literals: *const c_void,
+    lit_size: usize,
+    block_size: usize,
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+    bmi2: c_int,
+) -> usize {
+    let c_size = unsafe {
+        entropy_compress_seq_store_internal(
+            dst,
+            dst_capacity,
+            literals,
+            lit_size,
+            seq_store,
+            prev_entropy,
+            next_entropy,
+            strategy,
+            disable_literal_compression,
+            entropy_workspace,
+            entropy_wksp_size,
+            bmi2,
+        )
+    };
+    if c_size == 0 {
+        return 0;
+    }
+    /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
+     * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
+     */
+    if c_size == ERROR(ZstdErrorCode::DstSizeTooSmall) && block_size <= dst_capacity {
+        return 0; /* block not compressed */
+    }
+    if ERR_isError(c_size) {
+        return c_size;
+    }
+
+    /* Check compressibility */
+    let max_c_size = block_size.wrapping_sub(min_gain(block_size, strategy));
+    if c_size >= max_c_size {
+        return 0; /* block not compressed */
+    }
+    c_size
+}
+
+/// C ABI wrapper for the external-literal-buffer entropy pass; the C shim
+/// keeps the `ZSTD_entropyCompressSeqStore_internal()` name and extracts the
+/// two `ZSTD_CCtx_params` scalars.
+#[allow(clippy::too_many_arguments)]
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_entropyCompressSeqStore_internal(
+    dst: *mut c_void,
+    dst_capacity: usize,
+    literals: *const c_void,
+    lit_size: usize,
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+    bmi2: c_int,
+) -> usize {
+    unsafe {
+        entropy_compress_seq_store_internal(
+            dst,
+            dst_capacity,
+            literals,
+            lit_size,
+            seq_store,
+            prev_entropy,
+            next_entropy,
+            strategy,
+            disable_literal_compression,
+            entropy_workspace,
+            entropy_wksp_size,
+            bmi2,
+        )
+    }
+}
+
+/// C ABI implementation behind the `ZSTD_entropyCompressSeqStore()` shim.
+#[allow(clippy::too_many_arguments)]
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_entropyCompressSeqStore(
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    dst: *mut c_void,
+    dst_capacity: usize,
+    src_size: usize,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+    bmi2: c_int,
+) -> usize {
+    let store = unsafe { &*seq_store };
+    let lit_size = unsafe { store.lit.offset_from(store.litStart) } as usize;
+    unsafe {
+        entropy_compress_seq_store_w_ext_lit_buffer(
+            dst,
+            dst_capacity,
+            store.litStart.cast::<c_void>(),
+            lit_size,
+            src_size,
+            seq_store,
+            prev_entropy,
+            next_entropy,
+            strategy,
+            disable_literal_compression,
+            entropy_workspace,
+            entropy_wksp_size,
+            bmi2,
+        )
+    }
+}
+
+/// C's `ZSTD_buildBlockEntropyStats_literals()`.
+///
+/// Stores the literals block type and Huffman description table into
+/// `huf_metadata` and returns the description size, or an error code.
+#[allow(clippy::too_many_arguments)]
+unsafe fn build_block_entropy_stats_literals(
+    src: *const c_void,
+    src_size: usize,
+    prev_huf: *const ZSTD_hufCTables_t,
+    next_huf: *mut ZSTD_hufCTables_t,
+    huf_metadata: *mut ZSTD_hufCTablesMetadata_t,
+    literals_compression_is_disabled: c_int,
+    workspace: *mut c_void,
+    wksp_size: usize,
+    huf_flags: c_int,
+) -> usize {
+    let count_wksp = workspace.cast::<c_uint>();
+    let count_wksp_size = (HUF_SYMBOLVALUE_MAX as usize + 1) * size_of::<c_uint>();
+    let node_wksp = unsafe { workspace.cast::<u8>().add(count_wksp_size) }.cast::<c_void>();
+    let node_wksp_size = wksp_size.wrapping_sub(count_wksp_size);
+    let mut max_symbol_value = HUF_SYMBOLVALUE_MAX;
+    let mut huff_log = LIT_HUF_LOG;
+    let mut repeat = unsafe { (*prev_huf).repeatMode };
+
+    /* Prepare nextEntropy assuming reusing the existing table */
+    unsafe { copy_huf_tables(next_huf, prev_huf) };
+
+    if literals_compression_is_disabled != 0 {
+        unsafe { (*huf_metadata).hType = SET_BASIC };
+        return 0;
+    }
+
+    /* small ? don't even attempt compression (speed opt) */
+    {
+        let min_lit_size = if repeat == HUF_REPEAT_VALID {
+            6
+        } else {
+            COMPRESS_LITERALS_SIZE_MIN
+        };
+        if src_size <= min_lit_size {
+            unsafe { (*huf_metadata).hType = SET_BASIC };
+            return 0;
+        }
+    }
+
+    /* Scan input and build symbol stats */
+    {
+        let largest = unsafe {
+            HIST_count_wksp(
+                count_wksp,
+                &mut max_symbol_value,
+                src,
+                src_size,
+                workspace,
+                wksp_size,
+            )
+        };
+        if ERR_isError(largest) {
+            return largest;
+        }
+        if largest == src_size {
+            /* only one literal symbol */
+            unsafe { (*huf_metadata).hType = SET_RLE };
+            return 0;
+        }
+        if largest <= (src_size >> 7) + 4 {
+            /* heuristic: likely not compressible */
+            unsafe { (*huf_metadata).hType = SET_BASIC };
+            return 0;
+        }
+    }
+
+    /* Validate the previous Huffman table */
+    if repeat == HUF_REPEAT_CHECK
+        && unsafe {
+            HUF_validateCTable(
+                ptr::addr_of!((*prev_huf).CTable).cast::<usize>(),
+                count_wksp,
+                max_symbol_value,
+            )
+        } == 0
+    {
+        repeat = HUF_REPEAT_NONE;
+    }
+
+    /* Build Huffman Tree */
+    unsafe {
+        ptr::write_bytes(
+            ptr::addr_of_mut!((*next_huf).CTable).cast::<u8>(),
+            0,
+            size_of_val(&(*next_huf).CTable),
+        );
+    }
+    huff_log = unsafe {
+        HUF_optimalTableLog(
+            huff_log,
+            src_size,
+            max_symbol_value,
+            node_wksp,
+            node_wksp_size,
+            ptr::addr_of_mut!((*next_huf).CTable).cast::<usize>(),
+            count_wksp,
+            huf_flags,
+        )
+    };
+    debug_assert!(huff_log <= LIT_HUF_LOG);
+    {
+        let max_bits = unsafe {
+            HUF_buildCTable_wksp(
+                ptr::addr_of_mut!((*next_huf).CTable).cast::<usize>(),
+                count_wksp,
+                max_symbol_value,
+                huff_log,
+                node_wksp,
+                node_wksp_size,
+            )
+        };
+        if ERR_isError(max_bits) {
+            return max_bits;
+        }
+        huff_log = max_bits as c_uint;
+    }
+    {
+        /* Build and write the CTable */
+        let new_c_size = unsafe {
+            HUF_estimateCompressedSize(
+                ptr::addr_of!((*next_huf).CTable).cast::<usize>(),
+                count_wksp,
+                max_symbol_value,
+            )
+        };
+        let h_size = unsafe {
+            HUF_writeCTable_wksp(
+                ptr::addr_of_mut!((*huf_metadata).hufDesBuffer).cast::<c_void>(),
+                size_of::<[u8; ZSTD_MAX_HUF_HEADER_SIZE]>(),
+                ptr::addr_of!((*next_huf).CTable).cast::<usize>(),
+                max_symbol_value,
+                huff_log,
+                node_wksp,
+                node_wksp_size,
+            )
+        };
+        /* Check against repeating the previous CTable */
+        if repeat != HUF_REPEAT_NONE {
+            let old_c_size = unsafe {
+                HUF_estimateCompressedSize(
+                    ptr::addr_of!((*prev_huf).CTable).cast::<usize>(),
+                    count_wksp,
+                    max_symbol_value,
+                )
+            };
+            if old_c_size < src_size
+                && (old_c_size <= h_size.wrapping_add(new_c_size)
+                    || h_size.wrapping_add(12) >= src_size)
+            {
+                unsafe {
+                    copy_huf_tables(next_huf, prev_huf);
+                    (*huf_metadata).hType = SET_REPEAT;
+                }
+                return 0;
+            }
+        }
+        if new_c_size.wrapping_add(h_size) >= src_size {
+            unsafe {
+                copy_huf_tables(next_huf, prev_huf);
+                (*huf_metadata).hType = SET_BASIC;
+            }
+            return 0;
+        }
+        unsafe {
+            (*huf_metadata).hType = SET_COMPRESSED;
+            (*next_huf).repeatMode = HUF_REPEAT_CHECK;
+        }
+        h_size
+    }
+}
+
+/// C's `ZSTD_buildDummySequencesStatistics()`: marks every encoding type as
+/// basic and resets the FSE repeat modes.
+unsafe fn build_dummy_sequences_statistics(
+    next_entropy: *mut ZSTD_fseCTables_t,
+) -> SymbolEncodingTypeStats {
+    unsafe {
+        (*next_entropy).litlength_repeatMode = FSE_REPEAT_NONE;
+        (*next_entropy).offcode_repeatMode = FSE_REPEAT_NONE;
+        (*next_entropy).matchlength_repeatMode = FSE_REPEAT_NONE;
+    }
+    SymbolEncodingTypeStats {
+        ll_type: SET_BASIC as u32,
+        off_type: SET_BASIC as u32,
+        ml_type: SET_BASIC as u32,
+        size: 0,
+        last_count_size: 0,
+        long_offsets: 0,
+    }
+}
+
+/// C's `ZSTD_buildBlockEntropyStats_sequences()`.
+#[allow(clippy::too_many_arguments)]
+unsafe fn build_block_entropy_stats_sequences(
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_fseCTables_t,
+    next_entropy: *mut ZSTD_fseCTables_t,
+    strategy: c_int,
+    fse_metadata: *mut ZSTD_fseCTablesMetadata_t,
+    workspace: *mut c_void,
+    wksp_size: usize,
+) -> usize {
+    let store = unsafe { &*seq_store };
+    let nb_seq = unsafe { store.sequences.offset_from(store.sequencesStart) } as usize;
+    let count_workspace = workspace.cast::<c_uint>();
+    let entropy_workspace = unsafe { count_workspace.add(MAX_SEQ + 1) }.cast::<c_void>();
+    let entropy_workspace_size = wksp_size.wrapping_sub((MAX_SEQ + 1) * size_of::<c_uint>());
+
+    let stats = if nb_seq != 0 {
+        unsafe {
+            build_sequences_statistics(
+                seq_store,
+                nb_seq,
+                prev_entropy,
+                next_entropy,
+                ptr::addr_of_mut!((*fse_metadata).fseTablesBuffer).cast::<u8>(),
+                ZSTD_MAX_FSE_HEADERS_SIZE,
+                strategy,
+                count_workspace,
+                entropy_workspace,
+                entropy_workspace_size,
+            )
+        }
+    } else {
+        unsafe { build_dummy_sequences_statistics(next_entropy) }
+    };
+    if ERR_isError(stats.size) {
+        return stats.size;
+    }
+    unsafe {
+        (*fse_metadata).llType = stats.ll_type as c_int;
+        (*fse_metadata).ofType = stats.off_type as c_int;
+        (*fse_metadata).mlType = stats.ml_type as c_int;
+        (*fse_metadata).lastCountSize = stats.last_count_size;
+    }
+    stats.size
+}
+
+/// C's `ZSTD_buildBlockEntropyStats()`: builds entropy statistics for one
+/// block.  Requires an `ENTROPY_WORKSPACE_SIZE` workspace.
+#[allow(clippy::too_many_arguments)]
+pub(crate) unsafe fn build_block_entropy_stats(
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_metadata: *mut ZSTD_entropyCTablesMetadata_t,
+    workspace: *mut c_void,
+    wksp_size: usize,
+) -> usize {
+    let store = unsafe { &*seq_store };
+    let lit_size = unsafe { store.lit.offset_from(store.litStart) } as usize;
+    let huf_flags = if strategy >= HUF_OPTIMAL_DEPTH_THRESHOLD {
+        HUF_FLAGS_OPTIMAL_DEPTH
+    } else {
+        0
+    };
+
+    let huf_des_size = unsafe {
+        build_block_entropy_stats_literals(
+            store.litStart.cast::<c_void>(),
+            lit_size,
+            ptr::addr_of!((*prev_entropy).huf),
+            ptr::addr_of_mut!((*next_entropy).huf),
+            ptr::addr_of_mut!((*entropy_metadata).hufMetadata),
+            disable_literal_compression,
+            workspace,
+            wksp_size,
+            huf_flags,
+        )
+    };
+    unsafe { (*entropy_metadata).hufMetadata.hufDesSize = huf_des_size };
+    if ERR_isError(huf_des_size) {
+        return huf_des_size;
+    }
+
+    let fse_tables_size = unsafe {
+        build_block_entropy_stats_sequences(
+            seq_store,
+            ptr::addr_of!((*prev_entropy).fse),
+            ptr::addr_of_mut!((*next_entropy).fse),
+            strategy,
+            ptr::addr_of_mut!((*entropy_metadata).fseMetadata),
+            workspace,
+            wksp_size,
+        )
+    };
+    unsafe { (*entropy_metadata).fseMetadata.fseTablesSize = fse_tables_size };
+    if ERR_isError(fse_tables_size) {
+        return fse_tables_size;
+    }
+    0
+}
+
+/// C ABI wrapper behind the `ZSTD_buildBlockEntropyStats()` shim, which is
+/// still exported from C for the block splitter's size estimation.
+#[allow(clippy::too_many_arguments)]
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_buildBlockEntropyStats(
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_metadata: *mut ZSTD_entropyCTablesMetadata_t,
+    workspace: *mut c_void,
+    wksp_size: usize,
+) -> usize {
+    unsafe {
+        build_block_entropy_stats(
+            seq_store,
+            prev_entropy,
+            next_entropy,
+            strategy,
+            disable_literal_compression,
+            entropy_metadata,
+            workspace,
+            wksp_size,
+        )
+    }
+}
+
+/// C's `ZSTD_copyBlockSequences()`: exports a block's sequences in the public
+/// `ZSTD_Sequence` format, appending the last-literals block delimiter.
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_copyBlockSequences(
+    seq_collector: *mut SeqCollector,
+    seq_store: *const SeqStore_t,
+    prev_repcodes: *const u32,
+) -> usize {
+    let collector = unsafe { &mut *seq_collector };
+    let store = unsafe { &*seq_store };
+    let in_seqs = store.sequencesStart;
+    let nb_in_sequences = unsafe { store.sequences.offset_from(in_seqs) } as usize;
+    let nb_in_literals = unsafe { store.lit.offset_from(store.litStart) } as usize;
+    let out_seqs = if collector.seqIndex == 0 {
+        collector.seqStart
+    } else {
+        unsafe { collector.seqStart.add(collector.seqIndex) }
+    };
+    let nb_out_sequences = nb_in_sequences + 1;
+    let mut nb_out_literals = 0usize;
+
+    /* Bounds check that we have enough space for every input sequence
+     * and the block delimiter
+     */
+    debug_assert!(collector.seqIndex <= collector.maxSequences);
+    if nb_out_sequences > collector.maxSequences.wrapping_sub(collector.seqIndex) {
+        return ERROR(ZstdErrorCode::DstSizeTooSmall);
+    }
+
+    let mut repcodes = [0u32; ZSTD_REP_NUM];
+    unsafe { ptr::copy_nonoverlapping(prev_repcodes, repcodes.as_mut_ptr(), ZSTD_REP_NUM) };
+    for index in 0..nb_in_sequences {
+        let in_seq = unsafe { in_seqs.add(index).read() };
+        let out = unsafe { out_seqs.add(index) };
+        let mut lit_length = in_seq.litLength as u32;
+        let mut match_length = in_seq.mlBase as u32 + MINMATCH as u32;
+        let mut rep = 0u32;
+
+        /* Handle the possible single length >= 64K
+         * There can only be one because we add MINMATCH to every match length,
+         * and blocks are at most 128K.
+         */
+        if index == store.longLengthPos as usize {
+            if store.longLengthType == ZSTD_LLT_LITERAL_LENGTH {
+                lit_length += 0x10000;
+            } else if store.longLengthType == ZSTD_LLT_MATCH_LENGTH {
+                match_length += 0x10000;
+            }
+        }
+
+        /* Determine the raw offset given the offBase, which may be a repcode. */
+        let raw_offset = if (1..=ZSTD_REP_NUM as u32).contains(&in_seq.offBase) {
+            let repcode = in_seq.offBase;
+            debug_assert!(repcode > 0);
+            rep = repcode;
+            if lit_length != 0 {
+                repcodes[repcode as usize - 1]
+            } else if repcode == 3 {
+                debug_assert!(repcodes[0] > 1);
+                repcodes[0].wrapping_sub(1)
+            } else {
+                repcodes[repcode as usize]
+            }
+        } else {
+            in_seq.offBase.wrapping_sub(ZSTD_REP_NUM as u32)
+        };
+        unsafe {
+            (*out).litLength = lit_length;
+            (*out).matchLength = match_length;
+            (*out).offset = raw_offset;
+            (*out).rep = rep;
+        }
+
+        /* Update repcode history for the sequence */
+        update_rep(&mut repcodes, in_seq.offBase, in_seq.litLength == 0);
+
+        nb_out_literals += lit_length as usize;
+    }
+    /* Insert last literals (if any exist) in the block as a sequence with ml == off == 0.
+     * If there are no last literals, then we'll emit (of: 0, ml: 0, ll: 0), which is a marker
+     * for the block boundary, according to the API.
+     */
+    debug_assert!(nb_in_literals >= nb_out_literals);
+    {
+        let last_ll_size = nb_in_literals.wrapping_sub(nb_out_literals);
+        unsafe {
+            let last = out_seqs.add(nb_in_sequences);
+            (*last).litLength = last_ll_size as u32;
+            (*last).matchLength = 0;
+            (*last).offset = 0;
+        }
+    }
+    collector.seqIndex += nb_out_sequences;
+    debug_assert!(collector.seqIndex <= collector.maxSequences);
+
+    0
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::mem::{align_of, offset_of};
+
+    const HUF_CTABLE_SIZE_ST: usize = HUF_SYMBOLVALUE_MAX as usize + 2;
+    const ENTROPY_WORKSPACE_SIZE: usize = (8 << 10) + 512 + (MAX_SEQ + 2) * size_of::<u32>();
+
+    fn empty_huf_tables(repeat: c_int) -> ZSTD_hufCTables_t {
+        ZSTD_hufCTables_t {
+            CTable: [0; HUF_CTABLE_SIZE_ST],
+            repeatMode: repeat,
+        }
+    }
+
+    fn empty_fse_tables(repeat: c_int) -> ZSTD_fseCTables_t {
+        ZSTD_fseCTables_t {
+            offcodeCTable: [0; OFF_CTABLE_SIZE],
+            matchlengthCTable: [0; ML_CTABLE_SIZE],
+            litlengthCTable: [0; LL_CTABLE_SIZE],
+            offcode_repeatMode: repeat,
+            matchlength_repeatMode: repeat,
+            litlength_repeatMode: repeat,
+        }
+    }
+
+    struct TestSeqStore {
+        sequences: Vec<SeqDef>,
+        literals: Vec<u8>,
+        ll_codes: Vec<u8>,
+        ml_codes: Vec<u8>,
+        of_codes: Vec<u8>,
+    }
+
+    impl TestSeqStore {
+        fn new(sequences: Vec<SeqDef>, literals: Vec<u8>) -> Self {
+            let nb_seq = sequences.len();
+            TestSeqStore {
+                sequences,
+                literals,
+                ll_codes: vec![0; nb_seq],
+                ml_codes: vec![0; nb_seq],
+                of_codes: vec![0; nb_seq],
+            }
+        }
+
+        fn seq_store(&mut self) -> SeqStore_t {
+            let nb_seq = self.sequences.len();
+            let nb_lit = self.literals.len();
+            SeqStore_t {
+                sequencesStart: self.sequences.as_mut_ptr(),
+                sequences: unsafe { self.sequences.as_mut_ptr().add(nb_seq) },
+                litStart: self.literals.as_mut_ptr(),
+                lit: unsafe { self.literals.as_mut_ptr().add(nb_lit) },
+                llCode: self.ll_codes.as_mut_ptr(),
+                mlCode: self.ml_codes.as_mut_ptr(),
+                ofCode: self.of_codes.as_mut_ptr(),
+                maxNbSeq: nb_seq,
+                maxNbLit: nb_lit,
+                longLengthType: 0,
+                longLengthPos: 0,
+            }
+        }
+    }
+
+    #[test]
+    fn c_leaf_layouts_match_supported_abis() {
+        assert_eq!(size_of::<SeqDef>(), 8);
+        assert_eq!(align_of::<SeqDef>(), align_of::<u32>());
+        assert_eq!(offset_of!(SeqStore_t, sequencesStart), 0);
+        assert_eq!(
+            offset_of!(SeqStore_t, longLengthPos),
+            9 * size_of::<usize>() + 4
+        );
+        assert_eq!(size_of::<SeqStore_t>(), 9 * size_of::<usize>() + 8);
+        assert_eq!(size_of::<ZSTD_fseCTables_t>(), 3552);
+        assert_eq!(offset_of!(ZSTD_compressedBlockState_t, entropy), 0);
+        assert_eq!(
+            offset_of!(ZSTD_compressedBlockState_t, rep),
+            size_of::<ZSTD_entropyCTables_t>()
+        );
+        assert_eq!(size_of::<ZSTD_Sequence>(), 16);
+        assert_eq!(offset_of!(SeqCollector, seqStart), size_of::<usize>());
+        assert_eq!(offset_of!(SeqCollector, seqIndex), 2 * size_of::<usize>());
+        assert_eq!(size_of::<SeqCollector>(), 4 * size_of::<usize>());
+        if size_of::<usize>() == 8 {
+            assert_eq!(size_of::<ZSTD_hufCTablesMetadata_t>(), 144);
+            assert_eq!(size_of::<ZSTD_fseCTablesMetadata_t>(), 168);
+            assert_eq!(size_of::<ZSTD_entropyCTablesMetadata_t>(), 312);
+            assert_eq!(size_of::<ZSTD_entropyCTables_t>(), 5616);
+            assert_eq!(size_of::<ZSTD_compressedBlockState_t>(), 5632);
+        } else {
+            assert_eq!(size_of::<ZSTD_hufCTablesMetadata_t>(), 136);
+            assert_eq!(size_of::<ZSTD_fseCTablesMetadata_t>(), 156);
+            assert_eq!(size_of::<ZSTD_entropyCTablesMetadata_t>(), 292);
+            assert_eq!(size_of::<ZSTD_entropyCTables_t>(), 4584);
+            assert_eq!(size_of::<ZSTD_compressedBlockState_t>(), 4596);
+        }
+    }
+
+    #[test]
+    fn repcode_updates_match_the_c_sum_type_rules() {
+        let mut reps = [1, 4, 8];
+        update_rep(&mut reps, 10, false);
+        assert_eq!(reps, [7, 1, 4]);
+        update_rep(&mut reps, 1, true);
+        assert_eq!(reps, [1, 7, 4]);
+        update_rep(&mut reps, 2, false);
+        assert_eq!(reps, [7, 1, 4]);
+        update_rep(&mut reps, 3, false);
+        assert_eq!(reps, [4, 7, 1]);
+    }
+
+    #[test]
+    fn seq_to_codes_matches_the_reference_tables() {
+        let mut store = TestSeqStore::new(
+            vec![
+                SeqDef {
+                    offBase: 4,
+                    litLength: 0,
+                    mlBase: 0,
+                },
+                SeqDef {
+                    offBase: 1,
+                    litLength: 63,
+                    mlBase: 127,
+                },
+                SeqDef {
+                    offBase: 1 << 20,
+                    litLength: 64,
+                    mlBase: 128,
+                },
+            ],
+            vec![0; 127],
+        );
+        let seq_store = store.seq_store();
+        let long_offsets = unsafe { ZSTD_seqToCodes(&seq_store) };
+        assert_eq!(long_offsets, 0);
+        assert_eq!(store.ll_codes, [0, 24, 25]);
+        assert_eq!(store.ml_codes, [0, 42, 43]);
+        assert_eq!(store.of_codes, [2, 0, 20]);
+    }
+
+    #[test]
+    fn rle_sequences_produce_one_byte_table_headers() {
+        // Five identical sequences select set_rle for all three symbol kinds;
+        // each table header is then exactly the one RLE symbol byte.
+        let mut store = TestSeqStore::new(
+            vec![
+                SeqDef {
+                    offBase: 8,
+                    litLength: 2,
+                    mlBase: 3,
+                };
+                5
+            ],
+            vec![b'x'; 10],
+        );
+        let seq_store = store.seq_store();
+        let prev = empty_fse_tables(FSE_REPEAT_NONE);
+        let mut next = empty_fse_tables(FSE_REPEAT_NONE);
+        let mut metadata =
+            unsafe { std::mem::MaybeUninit::<ZSTD_fseCTablesMetadata_t>::zeroed().assume_init() };
+        let mut workspace = vec![0u64; ENTROPY_WORKSPACE_SIZE / size_of::<u64>()];
+
+        let size = unsafe {
+            build_block_entropy_stats_sequences(
+                &seq_store,
+                &prev,
+                &mut next,
+                1,
+                &mut metadata,
+                workspace.as_mut_ptr().cast::<c_void>(),
+                ENTROPY_WORKSPACE_SIZE,
+            )
+        };
+        assert_eq!(size, 3);
+        assert_eq!(metadata.llType, SET_RLE);
+        assert_eq!(metadata.ofType, SET_RLE);
+        assert_eq!(metadata.mlType, SET_RLE);
+        assert_eq!(metadata.lastCountSize, 0);
+        assert_eq!(&metadata.fseTablesBuffer[..3], &[2, 3, 3]);
+        assert_eq!(next.litlength_repeatMode, FSE_REPEAT_NONE);
+        assert_eq!(next.offcode_repeatMode, FSE_REPEAT_NONE);
+        assert_eq!(next.matchlength_repeatMode, FSE_REPEAT_NONE);
+    }
+
+    #[test]
+    fn empty_seq_store_emits_raw_literals_and_repeats_tables() {
+        let mut store = TestSeqStore::new(Vec::new(), b"hello".to_vec());
+        let seq_store = store.seq_store();
+        let prev = ZSTD_entropyCTables_t {
+            huf: empty_huf_tables(HUF_REPEAT_NONE),
+            fse: empty_fse_tables(2),
+        };
+        let mut next = ZSTD_entropyCTables_t {
+            huf: empty_huf_tables(HUF_REPEAT_NONE),
+            fse: empty_fse_tables(FSE_REPEAT_NONE),
+        };
+        let mut workspace = vec![0u64; ENTROPY_WORKSPACE_SIZE / size_of::<u64>()];
+        let mut output = [0xA5u8; 32];
+
+        let size = unsafe {
+            ZSTD_rust_entropyCompressSeqStore_internal(
+                output.as_mut_ptr().cast::<c_void>(),
+                output.len(),
+                seq_store.litStart.cast::<c_void>(),
+                5,
+                &seq_store,
+                &prev,
+                &mut next,
+                1,
+                0,
+                workspace.as_mut_ptr().cast::<c_void>(),
+                ENTROPY_WORKSPACE_SIZE,
+                0,
+            )
+        };
+        // Raw literals header (5 << 3), five literal bytes, nbSeq == 0.
+        assert_eq!(size, 7);
+        assert_eq!(&output[..7], &[0x28, b'h', b'e', b'l', b'l', b'o', 0x00]);
+        // With no sequences, the previous FSE tables are copied unchanged.
+        assert_eq!(next.fse.offcode_repeatMode, 2);
+        assert_eq!(next.fse.matchlength_repeatMode, 2);
+        assert_eq!(next.fse.litlength_repeatMode, 2);
+    }
+
+    #[test]
+    fn literal_stats_pick_rle_and_compressed_types() {
+        let mut workspace = vec![0u64; ENTROPY_WORKSPACE_SIZE / size_of::<u64>()];
+        let prev = empty_huf_tables(HUF_REPEAT_NONE);
+        let mut next = empty_huf_tables(HUF_REPEAT_NONE);
+        let mut metadata =
+            unsafe { std::mem::MaybeUninit::<ZSTD_hufCTablesMetadata_t>::zeroed().assume_init() };
+
+        let rle = [7u8; 128];
+        let size = unsafe {
+            build_block_entropy_stats_literals(
+                rle.as_ptr().cast::<c_void>(),
+                rle.len(),
+                &prev,
+                &mut next,
+                &mut metadata,
+                0,
+                workspace.as_mut_ptr().cast::<c_void>(),
+                ENTROPY_WORKSPACE_SIZE,
+                0,
+            )
+        };
+        assert_eq!(size, 0);
+        assert_eq!(metadata.hType, SET_RLE);
+
+        let mut compressible = [0u8; 1024];
+        for (index, byte) in compressible.iter_mut().enumerate() {
+            *byte = (index % 4) as u8;
+        }
+        let size = unsafe {
+            build_block_entropy_stats_literals(
+                compressible.as_ptr().cast::<c_void>(),
+                compressible.len(),
+                &prev,
+                &mut next,
+                &mut metadata,
+                0,
+                workspace.as_mut_ptr().cast::<c_void>(),
+                ENTROPY_WORKSPACE_SIZE,
+                0,
+            )
+        };
+        assert!(!ERR_isError(size));
+        assert!(size > 0);
+        assert_eq!(metadata.hType, SET_COMPRESSED);
+        assert_eq!(metadata.hufDesSize, 0); // caller stores the returned size
+        assert_eq!(next.repeatMode, HUF_REPEAT_CHECK);
+    }
+
+    #[test]
+    fn copied_sequences_resolve_repcodes_and_append_the_delimiter() {
+        let mut store = TestSeqStore::new(
+            vec![
+                SeqDef {
+                    offBase: 3 + 100, // raw offset 100
+                    litLength: 4,
+                    mlBase: 5,
+                },
+                SeqDef {
+                    offBase: 1, // repcode 1 with literals: rep[0] == 100
+                    litLength: 2,
+                    mlBase: 7,
+                },
+                SeqDef {
+                    offBase: 3, // repcode 3 without literals: rep[0] - 1 == 99
+                    litLength: 0,
+                    mlBase: 9,
+                },
+            ],
+            vec![0; 10],
+        );
+        let seq_store = store.seq_store();
+        let mut out = [ZSTD_Sequence {
+            offset: 0xAA,
+            litLength: 0xAA,
+            matchLength: 0xAA,
+            rep: 0xAA,
+        }; 8];
+        let mut collector = SeqCollector {
+            collectSequences: 1,
+            seqStart: out.as_mut_ptr(),
+            seqIndex: 1,
+            maxSequences: 8,
+        };
+        let reps = [1u32, 4, 8];
+
+        let result =
+            unsafe { ZSTD_rust_copyBlockSequences(&mut collector, &seq_store, reps.as_ptr()) };
+        assert_eq!(result, 0);
+        assert_eq!(collector.seqIndex, 5);
+        let expect = [
+            (100, 4, 5 + 3, 0),
+            (100, 2, 7 + 3, 1),
+            (99, 0, 9 + 3, 3),
+            (0, 10 - 6, 0, 0xAA), // delimiter: last literals; rep untouched
+        ];
+        for (index, &(offset, lit, matched, rep)) in expect.iter().enumerate() {
+            assert_eq!(out[1 + index].offset, offset, "offset {index}");
+            assert_eq!(out[1 + index].litLength, lit, "litLength {index}");
+            assert_eq!(out[1 + index].matchLength, matched, "matchLength {index}");
+            assert_eq!(out[1 + index].rep, rep, "rep {index}");
+        }
+
+        collector.maxSequences = 5;
+        let result =
+            unsafe { ZSTD_rust_copyBlockSequences(&mut collector, &seq_store, reps.as_ptr()) };
+        assert_eq!(result, ERROR(ZstdErrorCode::DstSizeTooSmall));
+    }
+}

rust/src/zstd_compress_superblock.rs

@@ -6,13 +6,13 @@
 //! This is the Rust implementation of `zstd_compress_superblock.c`.  Its C
 //! entry-point shim only extracts fields from the opaque `ZSTD_CCtx`; all
 //! sequence partitioning, literal and sequence section writing, entropy
-//! fallback, and repcode repair remain here.  The leaf layouts below are
-//! intentionally kept C-shaped and checked for both supported pointer widths.
+//! fallback, and repcode repair remain here.  The C-shaped leaf layouts are
+//! shared with `zstd_compress_stats`, which also owns the block entropy
+//! statistics this module consumes.
 
 use crate::common::{
     LL_BITS, LL_DEFAULT_NORM, LL_DEFAULT_NORM_LOG, MAX_LL, MAX_ML, MAX_OFF, MINMATCH, ML_BITS,
     ML_DEFAULT_NORM, ML_DEFAULT_NORM_LOG, OF_DEFAULT_NORM, OF_DEFAULT_NORM_LOG,
-    ZSTD_MAX_FSE_HEADERS_SIZE, ZSTD_MAX_HUF_HEADER_SIZE,
 };
 use crate::errors::{ERR_isError, ZstdErrorCode, ERROR};
 use crate::hist::{HIST_countFast_wksp, HIST_count_wksp};
@@ -23,9 +23,17 @@ use crate::mem::{MEM_32bits, MEM_writeLE16, MEM_writeLE24, MEM_writeLE32};
 use crate::zstd_compress_literals::{
     ZSTD_compressRleLiteralsBlock, ZSTD_hufCTables_t, ZSTD_noCompressLiterals,
 };
+use crate::zstd_compress_sequences::{
+    SeqDef, ZSTD_crossEntropyCost, ZSTD_encodeSequences, ZSTD_fseBitCost,
+};
+use crate::zstd_compress_stats::{
+    build_block_entropy_stats, update_rep, SeqStore_t, ZSTD_compressedBlockState_t,
+    ZSTD_entropyCTablesMetadata_t, ZSTD_entropyCTables_t, ZSTD_fseCTablesMetadata_t,
+    ZSTD_fseCTables_t, ZSTD_hufCTablesMetadata_t,
+};
 use std::ffi::c_void;
 use std::mem::MaybeUninit;
-use std::os::raw::{c_int, c_short, c_uint};
+use std::os::raw::c_int;
 use std::ptr;
 
 const SET_BASIC: c_int = 0;
@@ -42,121 +50,6 @@ const LONG_NB_SEQ: usize = 0x7f00;
 const DEFAULT_MAX_OFF: u32 = 28;
 const BYTE_SCALE: usize = 256;
 
-const OFF_CTABLE_SIZE: usize = 1 + (1 << 7) + ((MAX_OFF + 1) * 2);
-const ML_CTABLE_SIZE: usize = 1 + (1 << 8) + ((MAX_ML + 1) * 2);
-const LL_CTABLE_SIZE: usize = 1 + (1 << 8) + ((MAX_LL + 1) * 2);
-
-/// ABI-compatible `SeqDef` from `zstd_compress_internal.h`.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default)]
-struct SeqDef {
-    offBase: u32,
-    litLength: u16,
-    mlBase: u16,
-}
-
-/// ABI-compatible `SeqStore_t` leaf layout.
-///
-/// The C context itself remains opaque.  The C shim passes its `seqStore`
-/// member directly, so this small, stable hot-path structure is the only
-/// sequence storage representation crossing into Rust.
-#[repr(C)]
-struct SeqStore_t {
-    sequencesStart: *mut SeqDef,
-    sequences: *mut SeqDef,
-    litStart: *mut u8,
-    lit: *mut u8,
-    llCode: *mut u8,
-    mlCode: *mut u8,
-    ofCode: *mut u8,
-    maxNbSeq: usize,
-    maxNbLit: usize,
-    longLengthType: c_int,
-    longLengthPos: u32,
-}
-
-/// C's `ZSTD_fseCTables_t`.  The table element type is `FSE_CTable`, an
-/// `unsigned`, and the table lengths are the header macros expanded above.
-#[repr(C)]
-struct ZSTD_fseCTables_t {
-    offcodeCTable: [u32; OFF_CTABLE_SIZE],
-    matchlengthCTable: [u32; ML_CTABLE_SIZE],
-    litlengthCTable: [u32; LL_CTABLE_SIZE],
-    offcode_repeatMode: c_int,
-    matchlength_repeatMode: c_int,
-    litlength_repeatMode: c_int,
-}
-
-#[repr(C)]
-struct ZSTD_entropyCTables_t {
-    huf: ZSTD_hufCTables_t,
-    fse: ZSTD_fseCTables_t,
-}
-
-#[repr(C)]
-struct ZSTD_compressedBlockState_t {
-    entropy: ZSTD_entropyCTables_t,
-    rep: [u32; 3],
-}
-
-#[repr(C)]
-struct ZSTD_hufCTablesMetadata_t {
-    hType: c_int,
-    hufDesBuffer: [u8; ZSTD_MAX_HUF_HEADER_SIZE],
-    hufDesSize: usize,
-}
-
-#[repr(C)]
-struct ZSTD_fseCTablesMetadata_t {
-    llType: c_int,
-    ofType: c_int,
-    mlType: c_int,
-    fseTablesBuffer: [u8; ZSTD_MAX_FSE_HEADERS_SIZE],
-    fseTablesSize: usize,
-    lastCountSize: usize,
-}
-
-#[repr(C)]
-struct ZSTD_entropyCTablesMetadata_t {
-    hufMetadata: ZSTD_hufCTablesMetadata_t,
-    fseMetadata: ZSTD_fseCTablesMetadata_t,
-}
-
-unsafe extern "C" {
-    fn ZSTD_buildBlockEntropyStats(
-        seq_store: *const SeqStore_t,
-        prev_entropy: *const ZSTD_entropyCTables_t,
-        next_entropy: *mut ZSTD_entropyCTables_t,
-        cctx_params: *const c_void,
-        entropy_metadata: *mut ZSTD_entropyCTablesMetadata_t,
-        workspace: *mut c_void,
-        wksp_size: usize,
-    ) -> usize;
-
-    fn ZSTD_encodeSequences(
-        dst: *mut c_void,
-        dst_capacity: usize,
-        ctable_match_length: *const u32,
-        ml_code_table: *const u8,
-        ctable_offset_bits: *const u32,
-        of_code_table: *const u8,
-        ctable_lit_length: *const u32,
-        ll_code_table: *const u8,
-        sequences: *const SeqDef,
-        nb_seq: usize,
-        long_offsets: c_int,
-        bmi2: c_int,
-    ) -> usize;
-
-    fn ZSTD_fseBitCost(ctable: *const u32, count: *const u32, max: c_uint) -> usize;
-    fn ZSTD_crossEntropyCost(
-        norm: *const c_short,
-        accuracy_log: c_uint,
-        count: *const c_uint,
-        max: c_uint,
-    ) -> usize;
-}
-
 #[inline]
 fn remaining_capacity(capacity: usize, written: usize) -> Result<usize, usize> {
     capacity
@@ -838,28 +731,6 @@ unsafe fn size_block_sequences(
     nb_seq
 }
 
-#[inline]
-fn update_rep(reps: &mut [u32; 3], off_base: u32, literal_length_is_zero: bool) {
-    if off_base > 3 {
-        reps[2] = reps[1];
-        reps[1] = reps[0];
-        reps[0] = off_base - 3;
-        return;
-    }
-    let rep_code = off_base - 1 + u32::from(literal_length_is_zero);
-    if rep_code == 0 {
-        return;
-    }
-    let current_offset = if rep_code == 3 {
-        reps[0].wrapping_sub(1)
-    } else {
-        reps[rep_code as usize]
-    };
-    reps[2] = if rep_code >= 2 { reps[1] } else { reps[2] };
-    reps[1] = reps[0];
-    reps[0] = current_offset;
-}
-
 #[allow(clippy::too_many_arguments, clippy::manual_checked_ops)]
 unsafe fn compress_subblock_multi(
     seq_store: *const SeqStore_t,
@@ -1098,16 +969,18 @@ unsafe fn compress_subblock_multi(
 
 /// C ABI implementation called by the declaration-only C superblock shim.
 ///
-/// `cctx_params` deliberately remains opaque: only its two required scalar
-/// fields are read by the shim, while the existing C entropy builder receives
-/// the original pointer unchanged.
+/// `ZSTD_CCtx_params` deliberately remains opaque: the C shim extracts the
+/// two scalar fields this path reads (the strategy and the
+/// literals-compression switch) and the crate-internal entropy statistics
+/// builder receives them directly.
 #[allow(clippy::too_many_arguments)]
 #[no_mangle]
 pub unsafe extern "C" fn ZSTD_rust_compressSuperBlock(
     seq_store: *const c_void,
     prev_cblock: *const c_void,
     next_cblock: *mut c_void,
-    cctx_params: *const c_void,
+    strategy: c_int,
+    disable_literal_compression: c_int,
     workspace: *mut c_void,
     wksp_size: usize,
     bmi2: c_int,
@@ -1122,16 +995,17 @@ pub unsafe extern "C" fn ZSTD_rust_compressSuperBlock(
     let seq_store = seq_store.cast::<SeqStore_t>();
     let prev_cblock = prev_cblock.cast::<ZSTD_compressedBlockState_t>();
     let next_cblock = next_cblock.cast::<ZSTD_compressedBlockState_t>();
-    // C only writes the used prefixes of its two metadata byte buffers. Start
-    // with initialized storage so treating the completed C struct as a Rust
-    // value never exposes uninitialized array elements.
+    // The statistics builder only writes the used prefixes of the two
+    // metadata byte buffers. Start with initialized storage so treating the
+    // completed struct as a Rust value never exposes uninitialized elements.
     let mut entropy_metadata = MaybeUninit::<ZSTD_entropyCTablesMetadata_t>::zeroed();
     let entropy_result = unsafe {
-        ZSTD_buildBlockEntropyStats(
+        build_block_entropy_stats(
             seq_store,
             ptr::addr_of!((*prev_cblock).entropy),
             ptr::addr_of_mut!((*next_cblock).entropy),
-            cctx_params,
+            strategy,
+            disable_literal_compression,
             entropy_metadata.as_mut_ptr(),
             workspace,
             wksp_size,
@@ -1163,50 +1037,34 @@ pub unsafe extern "C" fn ZSTD_rust_compressSuperBlock(
 
 #[cfg(test)]
 mod tests {
+    // The shared C leaf layouts and the repcode update rules are asserted in
+    // `zstd_compress_stats`, which owns those definitions.
     use super::*;
-    use std::mem::{align_of, offset_of, size_of};
 
     #[test]
-    fn c_leaf_layouts_match_supported_abis() {
-        assert_eq!(size_of::<SeqDef>(), 8);
-        assert_eq!(align_of::<SeqDef>(), align_of::<u32>());
-        assert_eq!(offset_of!(SeqStore_t, sequencesStart), 0);
-        assert_eq!(
-            offset_of!(SeqStore_t, longLengthPos),
-            9 * size_of::<usize>() + 4
-        );
-        assert_eq!(size_of::<SeqStore_t>(), 9 * size_of::<usize>() + 8);
-        assert_eq!(size_of::<ZSTD_fseCTables_t>(), 3552);
-        assert_eq!(offset_of!(ZSTD_compressedBlockState_t, entropy), 0);
-        assert_eq!(
-            offset_of!(ZSTD_compressedBlockState_t, rep),
-            size_of::<ZSTD_entropyCTables_t>()
-        );
-        if size_of::<usize>() == 8 {
-            assert_eq!(size_of::<ZSTD_hufCTablesMetadata_t>(), 144);
-            assert_eq!(size_of::<ZSTD_fseCTablesMetadata_t>(), 168);
-            assert_eq!(size_of::<ZSTD_entropyCTablesMetadata_t>(), 312);
-            assert_eq!(size_of::<ZSTD_entropyCTables_t>(), 5616);
-            assert_eq!(size_of::<ZSTD_compressedBlockState_t>(), 5632);
-        } else {
-            assert_eq!(size_of::<ZSTD_hufCTablesMetadata_t>(), 136);
-            assert_eq!(size_of::<ZSTD_fseCTablesMetadata_t>(), 156);
-            assert_eq!(size_of::<ZSTD_entropyCTablesMetadata_t>(), 292);
-            assert_eq!(size_of::<ZSTD_entropyCTables_t>(), 4584);
-            assert_eq!(size_of::<ZSTD_compressedBlockState_t>(), 4596);
-        }
-    }
+    fn subblock_sizing_respects_the_budget() {
+        let sequences = [SeqDef {
+            offBase: 4,
+            litLength: 10,
+            mlBase: 10,
+        }; 8];
 
-    #[test]
-    fn repcode_updates_match_the_c_sum_type_rules() {
-        let mut reps = [1, 4, 8];
-        update_rep(&mut reps, 10, false);
-        assert_eq!(reps, [7, 1, 4]);
-        update_rep(&mut reps, 1, true);
-        assert_eq!(reps, [1, 7, 4]);
-        update_rep(&mut reps, 2, false);
-        assert_eq!(reps, [7, 1, 4]);
-        update_rep(&mut reps, 3, false);
-        assert_eq!(reps, [4, 7, 1]);
+        // A generous budget keeps every sequence in one sub-block.
+        let all = unsafe {
+            size_block_sequences(
+                sequences.as_ptr(),
+                sequences.len(),
+                usize::MAX,
+                256,
+                256,
+                true,
+            )
+        };
+        assert_eq!(all, sequences.len());
+
+        // The first sequence always survives, even over budget.
+        let first =
+            unsafe { size_block_sequences(sequences.as_ptr(), sequences.len(), 0, 256, 256, true) };
+        assert_eq!(first, 1);
     }
 }