feat: sentence-level pruning (prune_async / open_provence) mirroring the reranker

[Goldziher]

Summary

Add a sentence-level pruning capability — prune_async / prune — that mirrors the existing
reranker, using an open_provence / Provence sentence-pruning
model. Provence drops off-topic sentences within a document (and scores relevance) in a single
ModernBERT/DeBERTa pass — complementary to the reranker, which only reorders whole documents.

The headline consumer is basemind's search_documents and compress (search → rerank → prune →
return), but this is a generally useful kreuzberg primitive.

Proposed API (mirror the reranker)

#[cfg(all(feature = "pruner", feature = "tokio-runtime"))]
pub async fn prune_async(
    query: String,
    documents: Vec<String>,
    config: &core::config::PrunerConfig,
) -> crate::Result<Vec<PruneResult>>;

pub struct PruneResult {
    pub index: usize,                          // position in input `documents`
    pub score: f32,                            // document relevance in [0,1]
    pub document: String,                      // original text, unmodified
    pub kept_sentence_spans: Vec<(usize, usize)>, // half-open byte ranges kept
    pub compression_ratio: f32,
    pub sentences_kept: usize,
}

pub struct PrunerConfig {
    pub model: PrunerModelType,                // Preset | Custom | Plugin
    pub retention_threshold: f32,              // keep sentences with score >= threshold
    pub batch_size: usize,
    pub show_download_progress: bool,
    pub cache_dir: Option<PathBuf>,
    pub acceleration: Option<AccelerationConfig>,
    pub max_prune_duration_secs: Option<u64>,
}

Return byte spans of kept sentences (never destructively rewrite text) so callers keep
provenance.

Implementation notes (reranker is the template)

• Mirror crates/kreuzberg/src/reranking/{mod.rs,engine.rs} → new pruning/{mod.rs,engine.rs,segmenter.rs}
  and core/config/reranker.rs → core/config/pruner.rs.
  • rerank_async template: reranking/mod.rs:926; ONNX inference: reranking/engine.rs:45;
    config: core/config/reranker.rs:21.
• Reuse the existing hf-hub download + cross-process lock + ort session + ONNX engine cache; pair
  encoding (query, sentence) via the tokenizers stack.
• Sentence segmentation: a splitter already exists at
  text/summarization/textrank.rs:81 (split_sentences) — adapt it to track byte offsets, or use
  the OpenProvence reference segmenter for fidelity.
• New Cargo features pruner + pruner-presets, mirroring reranker / reranker-presets
  (same deps: hf-hub, ort, ndarray, tokenizers). No new dependencies. Add to full /
  server / no-ort-target / wasm-target aggregates as the reranker does.
• Async dispatch via a dedicated PRUNE_SEMAPHORE + spawn_blocking, same as the reranker.

Blocker: no ONNX weights published

The open_provence checkpoints ship PyTorch .safetensors only — no ONNX on HF:

Model	Repo	Params	License
OpenProvence xsmall	hotchpotch/open-provence-reranker-xsmall-v1	~30M	MIT
OpenProvence base	hotchpotch/open-provence-reranker-v1	~130M	MIT
OpenProvence large	hotchpotch/open-provence-reranker-large-v1	~310M	MIT

The preset/download path runs ort on ONNX, so turnkey presets (download-on-first-use, selectable
size) require a PyTorch→ONNX export + hosting first, and the custom Provence prune+rerank head
may not export cleanly via optimum out of the box.

Suggested sequencing:

1. Land the pruner module architecture with Custom / Plugin model paths (no presets) so the
   API and consumers can be built and tested.
2. Export open_provence xsmall + large to ONNX, host under a controlled HF repo, and register them as
   pruner presets.

Acceptance

• prune_async(query, docs, &PrunerConfig) returns kept-sentence byte spans + per-doc score.
• Feature-gated pruner / pruner-presets mirroring the reranker; builds across the existing target
  matrix (WASM-safe pruner-presets).
• Tests mirror the reranker suite (empty docs, threshold filtering, serde round-trip, segmentation).
• Once ONNX exports exist: xsmall + large selectable as presets, downloaded on first use, absent
  by default.

[Goldziher]

Sentence-level pruning (prune_async) — feasibility / go-no-go

Research for #1144. Research-only document — no code was written.
Research date: 2026-06-22. All file/line citations are against main at the time of writing.

TL;DR — GO, in two phases. The Rust/binding work is a near-mechanical clone of the reranker
module with one genuinely new piece of logic (token-mask decode → sentence-span mapping). It needs
zero new dependencies. The only real blocker is that the upstream models ship .safetensors
only, so turnkey presets require a PyTorch→ONNX export + self-hosting, which is gated behind a custom
dual-head export. Land the module first with Custom/Plugin paths (unblocks basemind immediately
via a registered plugin), do the ONNX export + presets as a follow-up.

---

1. Models & licensing

Verified against the HuggingFace API on 2026-06-22.

Model	Repo	Backbone	Params	License	Weights on HF
OpenProvence xsmall	hotchpotch/open-provence-reranker-xsmall-v1	ModernBERT-ja	~30M	MIT	model.safetensors only
OpenProvence base	hotchpotch/open-provence-reranker-v1	ModernBERT-ja	~130M	MIT	model.safetensors only
OpenProvence large	hotchpotch/open-provence-reranker-large-v1	ModernBERT-ja	~310M	MIT	model.safetensors only
Naver Provence	naver/provence-reranker-debertav3-v1	DeBERTa-v3	~430M	CC-BY-NC-ND-4.0 ⚠️	model.safetensors only

Confirmed facts (re-verify before the export PR, model cards change):

• No ONNX anywhere. Every repo ships PyTorch .safetensors plus tokenizer files
  (tokenizer.json, tokenizer_config.json, special_tokens_map.json, config.json). No
  model.onnx. This is the blocker (§3).
• OpenProvence is MIT — all three sizes. Cleanly hostable and re-distributable. Each repo also
  ships a modeling_open_provence_standalone.py defining the custom dual-head module — this is the
  exact reference implementation we wrap for export (§3).
• Naver Provence is CC-BY-NC-ND-4.0, not MIT. This is non-commercial and no-derivatives.
  We cannot host a re-export of it as a Kreuzberg preset, and the ND clause arguably disallows the
  ONNX conversion itself. Treat Naver Provence as out of scope for presets — it is usable only
  via a user-supplied Custom/Plugin path on the user's own license footing. Presets ship
  OpenProvence only.

License propagation for the hosted re-exports: copy the MIT license text + attribution into each
Kreuzberg-org HF repo's model card, credit hotchpotch, and link the source repo.

---

2. Architecture — why it's a dual-head cross-encoder

Provence/OpenProvence are cross-encoders with two output heads sharing one encoder pass. This is
the conceptual crux; everything in §4 follows from it.

Input. A single concatenated sequence, exactly like the reranker:
[BOS] question [SEP] passage [EOS] (token-type/segment ids mark the passage span). The question and
the passage are not encoded separately — they attend to each other, which is what lets the model
judge each passage token's relevance to this specific question.

Two outputs from one forward pass:

1. Reranking score — a single scalar read off the BOS/CLS position ([batch, 1]). Identical in
   shape and meaning to what our existing reranker consumes. Sigmoid → [0,1] document relevance.
2. Token-level pruning mask — a per-token logit over the passage tokens ([batch, seq], or
   [batch, seq, 2] if emitted as a 2-class keep/drop head). Each passage token gets a keep/drop
   signal.

Inference-time decode (this is the new logic, all post-forward):

forward([BOS] q [SEP] passage)  ->  rerank_logit[batch,1],  prune_logit[batch, seq]
threshold prune_logit            ->  per-token keep/drop bit
segment passage into sentences   ->  sentence boundaries (byte ranges)
for each sentence:
    keep if (#keep-tokens in sentence) > (#drop-tokens in sentence)   # majority vote
emit kept sentences (as byte spans)

Critically, segmentation happens after the forward pass, on the CPU, in Rust. The model does not
emit sentences; it emits a per-token mask, and we group tokens into sentences and apply the
majority-vote (or threshold-on-mean) rule. The upstream reference uses a sentence splitter +
token→sentence assignment; we do the equivalent natively (§4). The retention behavior is a single
scalar knob (retention_threshold) applied to the per-token logits before the vote.

This is why the reranker is a perfect template: same input encoding, same session, same BOS-score
extraction. We simply stop discarding the second output tensor and add a decode stage.

---

3. ONNX export — the only real blocker

Why optimum does not do this turnkey

optimum-onnx / optimum.exporters.onnx map a model to a single task — sequence-classification
(one pooled score) or token-classification (per-token logits) — and export the head for that
task. Provence emits both heads from one pass, which is a custom architecture
(modeling_open_provence_standalone.py), not a registered optimum task config. There is no
turnkey --task that yields both rerank_score and prune_logits. So optimum-cli export onnx
will either fail to load the custom class or drop one of the two heads.

Direct torch.onnx.export is straightforward

The clean path is a thin wrapper module that loads the standalone model and returns both tensors,
then a direct export. Sketch:

import torch
from transformers import AutoModel, AutoTokenizer

# trust_remote_code loads modeling_open_provence_standalone.py
model = AutoModel.from_pretrained(REPO, trust_remote_code=True).eval()
tok = AutoTokenizer.from_pretrained(REPO)

class ProvenceExport(torch.nn.Module):
    """Wrap the dual-head model to return (prune_logits, rerank_score) as plain tensors."""
    def __init__(self, m):
        super().__init__()
        self.m = m

    def forward(self, input_ids, attention_mask, token_type_ids=None):
        out = self.m(input_ids=input_ids,
                     attention_mask=attention_mask,
                     token_type_ids=token_type_ids)
        # field names follow the standalone module; verify against the .py
        prune_logits  = out.prune_logits   # [batch, seq] or [batch, seq, 2]
        rerank_score  = out.rerank_logits  # [batch, 1]
        return prune_logits, rerank_score

wrapper = ProvenceExport(model)
enc = tok("q", "passage", return_tensors="pt")

torch.onnx.export(
    wrapper,
    (enc["input_ids"], enc["attention_mask"], enc.get("token_type_ids")),
    "model.onnx",
    input_names=["input_ids", "attention_mask", "token_type_ids"],
    output_names=["prune_logits", "rerank_score"],
    dynamic_axes={
        "input_ids":      {0: "batch", 1: "seq"},
        "attention_mask": {0: "batch", 1: "seq"},
        "token_type_ids": {0: "batch", 1: "seq"},
        "prune_logits":   {0: "batch", 1: "seq"},
        "rerank_score":   {0: "batch"},
    },
    opset_version=17,
)

Notes / risks for the export step:

• Verify head field names in modeling_open_provence_standalone.py (the out.prune_logits /
  out.rerank_logits names above are placeholders — read the actual forward return).
• ModernBERT-ja backbone: ModernBERT uses unpadded/flash-attention paths and may not take
  token_type_ids. Export with attention_mask only if the standalone module ignores segment ids;
  keep the Rust engine's optional-token_type_ids detection (it already handles this, see §4).
• opset 17 is a safe baseline for ORT; bump only if an op is missing. Validate parity (export vs
  torch) on a handful of (q, passage) pairs before publishing.
• Hosting ("the simple part"): export xsmall + large, upload to a Kreuzberg-org HF repo
  alongside the tokenizer files, propagate the MIT card. base is optional. Naver Provence is excluded
  (§1).

The export is real work but bounded — one wrapper module, one export script, parity validation, a
model card. No model retraining, no architecture surgery.

---

4. Rust implementation design (mirror the reranker 1:1)

New layout, mirroring reranking/:

crates/kreuzberg/src/pruning/mod.rs        # prune / prune_async, presets, download+lock machinery
crates/kreuzberg/src/pruning/engine.rs     # ONNX inference: dual-output extraction
crates/kreuzberg/src/pruning/segmenter.rs  # byte-offset sentence segmentation + token→sentence map
crates/kreuzberg/src/core/config/pruner.rs # PrunerConfig, PrunerModelType
crates/kreuzberg/src/plugins/pruner.rs            # PrunerBackend trait + register/unregister/clear/list
crates/kreuzberg/src/plugins/registry/pruner.rs   # PrunerBackendRegistry

What is reused verbatim (copy from reranker)

These are mechanical clones, feature-gated on pruner instead of reranker:

• Download/lock machinery — cleanup_stale_locks, ProcessDownloadLock, blocking_lock_exclusive,
  unlock_file, download_model_files, lock_acquisition_hint (reranking/mod.rs:278-496). Rename
  the lock file (.kbz-pruner-download.lock) and cache subdir ("pruners").
• ORT helper trio — onnx_runtime_install_message, looks_like_ort_error, panic_to_string
  (reranking/mod.rs:220-272).
• Tokenizer loader — load_tokenizer (reranking/mod.rs:504), unchanged: cross-encoder pair
  encoding is identical.
• Engine cache + semaphore — ENGINE_CACHE (reranking/mod.rs:42), RERANK_SEMAPHORE →
  PRUNE_SEMAPHORE (reranking/mod.rs:54), get_or_init_engine (reranking/mod.rs:591), the ORT
  session builder (reranking/mod.rs:661-690).
• Async dispatch shape — prune_async mirrors rerank_async (reranking/mod.rs:926): empty-doc
  early return, blank-query validation, Plugin short-circuit before the semaphore, then
  PRUNE_SEMAPHORE.acquire() + spawn_blocking(|| prune(...)) (reranking/mod.rs:984-992).
• Plugin trait + registry — clone plugins/reranker.rs and plugins/registry/reranker.rs
  wholesale; the PrunerBackend returns the prune result shape rather than Vec<f32> (see below).

What is genuinely new

(a) Engine: consume the second output tensor. The reranker extracts only the first output and
discards the rest (reranking/engine.rs:167 — outputs.iter().next()). The pruner reads both named
outputs:

// pruning/engine.rs — dual-output extraction (cf. reranking/engine.rs:166-178)
let prune_logits = outputs["prune_logits"].try_extract_array::<f32>()?;  // [batch, seq] (or [..,2])
let rerank_score = outputs["rerank_score"].try_extract_array::<f32>()?;  // [batch, 1]

The thread-safe &self ORT run shim (reranking/engine.rs:159-164), the optional
token_type_ids push (engine.rs:150), and the tensor-build loop (engine.rs:128-148) are reused
unchanged. The engine returns, per document, (rerank_score: f32, per_token_keep: Vec<bool>) after
thresholding the prune logits with retention_threshold.

(b) Token→sentence mapping via tokenizer offsets. This is the load-bearing new logic. After
encode_batch, each Encoding exposes encoding.get_offsets() -> &[(usize, usize)] — byte spans
of every token into the original passage string. We:

1. Segment the passage into sentences as byte ranges (new offset-tracking splitter, see (c)).
2. For each token, look up its keep/drop bit and its byte offset; assign the token to the sentence
   whose byte range contains the token's offset (passage tokens only — skip question/special tokens
   via token_type_ids / offset (0,0) sentinels).
3. Majority-vote per sentence: keep the sentence if keep-tokens > drop-tokens.
4. Emit kept sentences as (start_byte, end_byte) half-open spans into the original document.

This is the mechanism that lets us return byte spans and never rewrite the text — caller keeps
full provenance, exactly as the issue requires.

(c) Offset-tracking segmenter. The existing splitter at
text/summarization/textrank.rs:81 (split_sentences) returns Vec<&str> and does not track
byte offsets — it .trim()s each candidate, losing positions. We need a parallel
split_sentences_with_spans(text: &str) -> Vec<(usize, usize)> returning byte ranges. The algorithm
is the same terminal-punctuation scan (. ! ? \n), but it records start..end instead of slicing.
Put it in pruning/segmenter.rs (or generalize the textrank one). For multilingual fidelity
(ModernBERT-ja is Japanese-capable) the naive splitter is weak on CJK; an optional ICU-style
segmenter is a future refinement, but the token-mask majority-vote is tolerant of coarse boundaries.

Public types

// pruning/mod.rs
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
pub struct PruneResult {
    pub index: usize,                              // position in input `documents`
    pub score: f32,                                // doc relevance in [0,1] (sigmoid of rerank head)
    pub document: String,                          // original text, UNMODIFIED
    pub kept_sentence_spans: Vec<(usize, usize)>,  // half-open BYTE ranges into `document`
    pub compression_ratio: f32,                    // kept_bytes / total_bytes
    pub sentences_kept: usize,
}

#[cfg(all(feature = "pruner", feature = "tokio-runtime"))]
#[cfg_attr(alef, alef(skip))]
pub async fn prune_async(
    query: String,
    documents: Vec<String>,
    config: &crate::core::config::PrunerConfig,
) -> crate::Result<Vec<PruneResult>>;

// sync counterpart, mirrors rerank()
#[cfg(feature = "pruner")]
pub fn prune(
    query: String,
    documents: Vec<String>,
    config: &crate::core::config::PrunerConfig,
) -> crate::Result<Vec<PruneResult>>;

// core/config/pruner.rs  (mirror RerankerConfig at core/config/reranker.rs:20)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PrunerConfig {
    #[serde(default = "default_pruner_model", deserialize_with = "deserialize_null_model")]
    pub model: PrunerModelType,
    #[serde(default = "default_retention_threshold")]
    pub retention_threshold: f32,                  // keep tokens/sentences with score >= threshold
    #[serde(default = "default_batch_size")]
    pub batch_size: usize,
    #[serde(default)]
    pub show_download_progress: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_dir: Option<PathBuf>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub acceleration: Option<super::acceleration::AccelerationConfig>,
    #[serde(default = "default_max_prune_duration_secs", skip_serializing_if = "Option::is_none")]
    pub max_prune_duration_secs: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum PrunerModelType {
    Preset { name: String },
    Custom {
        model_id: String,
        #[serde(default, skip_serializing_if = "Option::is_none")] model_file: Option<String>,
        #[serde(default, skip_serializing_if = "Vec::is_empty")]   additional_files: Vec<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")] max_length: Option<i64>,
    },
    Plugin { name: String },
    // NOTE: no `Llm` variant — pruning is a token-mask task with no provider-hosted API equivalent.
}

Key differences from the reranker (summary)

Aspect	Reranker	Pruner
Outputs consumed	1 (BOS score)	2 (BOS score + token mask)
Post-forward CPU work	sort + top_k truncate	threshold mask → token→sentence map → majority vote → byte spans
Result	RerankedDocument { index, score, document }	PruneResult { …, kept_sentence_spans, compression_ratio, sentences_kept }
Tokenizer offsets	unused	encoding.get_offsets() — load-bearing
Output filter	sort descending, keep top_k	per-sentence threshold filter (no reorder)
Backend variants	Preset / Custom / Llm / Plugin	Preset / Custom / Plugin (no Llm)
PrunerBackend::prune returns	n/a	per-doc (score, kept_spans) — not bare Vec<f32>

The plugin trait returns richer data than the reranker's Vec<f32>, because pruning has no
host-side "the dispatcher sorts it" simplification — the backend owns segmentation. Define
async fn prune(&self, query: String, documents: Vec<String>) -> Result<Vec<PruneResult>> (or a
spans-only DTO the dispatcher wraps), and validate result.len() == documents.len() exactly as
validate_reranker_output does (reranking/mod.rs:744).

---

5. Feature gating & deps

Mirror the reranker block in crates/kreuzberg/Cargo.toml:273-286 verbatim, renamed:

# pruner-presets: static preset metadata (WASM/Android-safe, no ORT).
pruner-presets = []
# pruner: sentence-level pruning via ONNX Runtime (ORT-dependent, WASM-incompatible).
# pruner-presets is a subset of pruner; always implied.
pruner = [
    "pruner-presets",
    "dep:hf-hub",
    "dep:ort",
    "dep:ndarray",
    "dep:tokenizers",
    "tokio-runtime",
    "ort-bundled",
]

No new dependencies — hf-hub, ort, ndarray, tokenizers are all already pulled in by
reranker. Aggregate membership mirrors the reranker exactly:

• full (Cargo.toml:526) and server gain pruner.
• no-ort-target / wasm-target / android-target (Cargo.toml:409, 471) gain
  pruner-presets only — metadata-only, WASM-safe, no ORT. (The reranker does exactly this:
  presets-only into the no-ORT aggregates, full reranker only in full.)

pruner-presets is pure metadata (preset name/repo/file/max_length structs), so it compiles on every
target including wasm32. The ORT-bearing pruner path is excluded from wasm/android the same way
reranker is.

---

6. Binding parity (alef)

Mirror every reranker touch-point in alef.toml:

• [crate].sources (alef.toml:135-139): add the five new files —
  pruning/mod.rs, core/config/pruner.rs, plugins/pruner.rs,
  plugins/registry/pruner.rs (engine/segmenter stay internal, alef(skip) like
  reranking/engine.rs).
• [crate].features (alef.toml:196-197): add "pruner", "pruner-presets".
• e2e calls (alef.toml:3186-3328): add prune + prune_async call blocks mirroring
  rerank/rerank_async, including the per-language sync→async redirects (Python/Ruby/Elixir/Go/
  Java/Swift/Dart/Zig/R/C#/Node/PHP all redirect sync prune → async prune_async, same pattern).
  Add nested_types = { pruner = "PrunerConfig", pruner_model = "PrunerModelType" }.
• Plugin lifecycle calls (alef.toml:2969-3184): clone the register_/unregister_/clear_/ list_*_reranker_backend blocks → *_pruner_backend, with the same per-language name overrides.
• Trait bridge (alef.toml:4372-4378): add a [[crates.trait_bridges]] entry for
  PrunerBackend (registry getter get_pruner_backend_registry, register/unregister/clear fns).
• Always-true cfg note (alef.toml:800): add prune_async alongside rerank_async /
  embed_texts_async so it is generated with the always-true cfg.

This regenerates all bindings (task alef:generate) — expected and correct; commit Rust source +
alef.toml + regenerated packages/ atomically per the alef workflow.

---

7. Effort & risk

Effort. The module clone (§4 reused parts) + config + plugin + registry + feature gating +
alef wiring is mechanical: ~1-1.5 days of careful copy-rename-and-test. The genuinely new logic —
dual-output extraction, token→sentence offset mapping, offset-tracking segmenter, majority-vote — is
contained and unit-testable without a model (feed synthetic logits + offsets): ~1-1.5 days. Binding
regen + e2e fixtures: ~0.5-1 day. Phase 1 (no presets): ~3-4 days. The ONNX export + host +
parity validation + preset registration is a separate ~2-3 day workstream (Phase 2), most of it
validation and HF hosting, not Rust.

Risks.

• ONNX export fidelity of the custom dual head (medium). The standalone modeling_*.py must
  export both heads; ModernBERT's attention path may need attention_mask-only export. Mitigation:
  validate token-mask + score parity against torch on fixed inputs before publishing; this is the
  one step that could surprise us.
• Tokenizer offset alignment for byte spans (low-medium). get_offsets() is byte-accurate, but
  special tokens and the question segment must be excluded cleanly, and ModernBERT's tokenizer must
  emit usable offsets (verify it isn't a fast-tokenizer config that zeroes offsets). Test with a
  fixture that asserts exact byte spans.
• Multilingual segmentation (low). Naive . ! ? \n splitting is weak on CJK/Japanese (the
  ja backbone's home turf). The majority-vote tolerates coarse sentences; a better segmenter is a
  non-blocking follow-up.
• Plugin-result contract churn (low). PrunerBackend returns a richer type than the reranker —
  get the DTO right once so binding regen doesn't thrash.

---

8. Recommendation / sequencing

GO. The architecture is proven (it is the reranker plus one decode stage), it adds no
dependencies, and it fits the existing feature/aggregate/alef structure exactly. Sequence it to
unblock the consumer immediately and defer the only hard part:

1. Phase 1 — land the pruner module with Custom + Plugin paths and tests, no presets.
   This ships the full public API (prune / prune_async, PrunerConfig, PruneResult,
   PrunerBackend + registry), the dual-output engine, the offset-tracking segmenter, and all
   bindings. basemind's search_documents / compress pipeline is unblocked now by registering
   an in-process PrunerBackend (or pointing Custom at a user-exported ONNX). Tests mirror the
   reranker suite: empty docs, threshold filtering, serde round-trip, segmentation byte-span
   assertions, synthetic-logit decode, plugin round-trip.

2. Phase 2 — ONNX export + host + register presets (follow-up). Export OpenProvence xsmall +
   large to ONNX via the §3 wrapper, validate parity, upload to a Kreuzberg-org HF repo with MIT
   cards, and register them as pruner presets (fast = xsmall, quality = large). Naver Provence
   stays out of presets on license grounds (§1).

This split lands consumer value in days while the export/hosting is validated independently, and it
de-risks the one genuinely uncertain step (custom-head export) by keeping it off the critical path
for the API and its bindings.