alef.toml

[workspace]
# install-alef honours this key, so it decides which alef CI validates against. The pin
# sat at 0.81.0 while 0.82.0's `alef e2e generate` was nondeterministic (2/10 runs
# divergent upstream); 0.82.2 is adopted only after a same-tree fixed-point re-run of
# `alef all` produced an empty diff, which is the check that hold existed for. ~keep
alef_version = "0.82.2"
languages = [
  "python",
  "node",
  "ruby",
  "php",
  "ffi",
  "go",
  "java",
  "csharp",
  "elixir",
  "wasm",
  "dart",
  "jni",
  "kotlin_android",
  "swift",
  "zig",
]


[workspace.tools]
python_package_manager = "uv"
node_package_manager = "pnpm"

[workspace.ownership]
user_owned = [
  "e2e/csharp/Xberg.E2eTests.csproj",
  "e2e/dart/pubspec.yaml",
  "e2e/java/pom.xml",
  "e2e/kotlin_android/build.gradle.kts",
  "e2e/node/package.json",
  "e2e/swift_e2e/Package.swift",
  "e2e/wasm/package.json",
  "e2e/zig/build.zig",
  "packages/kotlin-android/gradle/wrapper/gradle-wrapper.properties",
  "packages/kotlin-android/src/test/kotlin/io/xberg/XbergScaffoldTest.kt",
  "test_apps/csharp/Xberg.E2eTests.csproj",
  "test_apps/dart/pubspec.yaml",
  "test_apps/homebrew/README.md",
  "test_apps/java/pom.xml",
  "test_apps/kotlin_android/build.gradle.kts",
  "test_apps/kotlin_android/gradle/wrapper/gradle-wrapper.properties",
  "test_apps/node/package.json",
  "test_apps/swift_e2e/Package.swift",
  "test_apps/wasm/package.json",
  "test_apps/zig/build.zig",
]

[workspace.dto]
python = "dataclass"
python_output = "typed-dict"
node = "interface"
ruby = "struct"
php = "readonly-class"
elixir = "struct"
go = "struct"
java = "record"
csharp = "record"


[workspace.generate]
bindings = true
errors = true
configs = true
async_wrappers = true
type_conversions = true
package_metadata = true
public_api = true

[workspace.generate_overrides.wasm]
async_wrappers = false

[workspace.generate_overrides.java]
async_wrappers = false

[workspace.generate_overrides.kotlin_android]
async_wrappers = false

[workspace.docs]
reference_output = "docs-site/src/content/docs/reference"
reference_link_style = "extensionless"

# Include the command modules that define `#[command(flatten)]` structs (e.g.
[workspace.docs.cli]
sources = ["crates/xberg-cli/src/main.rs", "crates/xberg-cli/src/commands/overrides.rs"]

[workspace.docs.mcp]
sources = ["crates/xberg/src/mcp/server.rs"]

[[workspace.docs.mcp.declared]]
kind = "prompt"
name = "extract_document"
description = "Generate a Xberg extraction call for a document"

[[workspace.docs.mcp.declared]]
kind = "prompt"
name = "extract_with_ocr"
description = "Extract a document with explicit OCR language configuration"

[[workspace.docs.mcp.declared]]
kind = "prompt"
name = "semantic_search"
description = "Prepare a document for semantic search through unified extraction"

[[workspace.docs.mcp.declared]]
kind = "resource"
name = "xberg://formats"
title = "Supported Formats"
description = "All document formats and MIME types supported by Xberg"

[[workspace.docs.mcp.declared]]
kind = "resource"
name = "xberg://models"
title = "Model Manifest"
description = "Model files, sizes, and SHA256 checksums"

[[workspace.docs.mcp.declared]]
kind = "resource"
name = "xberg://languages/ocr"
title = "OCR Languages"
description = "Available OCR language codes"

[[workspace.docs.mcp.declared]]
kind = "resource"
name = "xberg://presets/embeddings"
title = "Embedding Presets"
description = "Available embedding model presets when the embeddings feature is enabled"

[workspace.docs.skills]
template_dir = "templates/docs/skills"
outputs = [".codex/skills", ".agents/skills", ".github/skills", ".claude/skills"]

[workspace.docs.snippets]
dirs = ["docs-site/src/snippets-generated"]
inline_dirs = ["docs-site/src/snippets"]
docs_dirs = ["docs-site/src/content/docs", "docs-site/src/components"]
content_collections = { apiExamples = "docs-site/src/snippets-generated" }
include_base_paths = ["docs-site/src"]
required_languages = [
  "python",
  "rust",
  "typescript",
  "go",
  "ruby",
  "elixir",
  "java",
  "csharp",
  "php",
  "dart",
  "kotlin",
  "swift",
  "zig",
  "c",
]
validation_level = "compile"
# 600s was sized for typecheck/compile-only validation of individual snippets.
# The Swift `before` hook below runs `cargo build -p xberg-swift`, which
# compiles xberg's heavy native dependency chain (onnxruntime, tesseract,
# PDF/office parsers) from a cold target dir; a from-scratch build of that
# graph routinely exceeds 10 minutes even before swift-bridge/staticlib
# linking. Raised to bound that cold build without starving it. ~keep
timeout_secs = 1800
before_timeout_secs = 1800
strict = true
report_output = ".alef/snippet-validation-report.json"

[workspace.docs.snippets.sessions.rust]
cwd = "."
manifest = "crates/xberg/Cargo.toml"
# Beyond `api`, these three are the features hand-authored snippets actually
# demonstrate. All are cheap: `keywords-yake` resolves to `stopwords`, which is
# an empty feature list (Cargo.toml:516,507), and `embedding-presets` is `[]`
# outright (:463) -- together they add ZERO crates. `pdf` (:61) pulls only
# pure-Rust parsers.
# Do NOT reach for `embeddings` (:466) to fix an embedding snippet: it enables
# `onnx-runtime` (:452) -> `dep:ort` + `ort-bundled`, which DOWNLOADS ONNX
# Runtime binaries at build time. `embedding-presets` clears the same
# unresolved-import error for free. ~keep
rust_features = ["api", "keywords-yake", "embedding-presets", "pdf"]
# `async-trait` is not optional garnish here: every plugin trait in the public
# surface (DocumentExtractor, OcrBackend, PostProcessor, Validator) is declared
# with `#[async_trait]`, so a snippet that implements one CANNOT be written
# without it. xberg itself depends on it (crates/xberg/Cargo.toml:1116); it was
# simply never mirrored into the snippet session, which is why eight
# hand-authored plugin snippets failed on `unresolved import async_trait`
# rather than on anything wrong with their own code. Kept at the workspace
# version (Cargo.toml:51). ~keep
rust_dependencies = { tokio = { version = "1.53.1", features = [
  "macros",
  "rt-multi-thread",
] }, serde_json = { version = "1.0.151" }, async-trait = { version = "0.1.92" }, tracing = { version = "0.1" }, reqwest = { version = "0.13.4", default_features = false, features = [
  "json",
  "multipart",
] } }

[workspace.docs.snippets.sessions.python]
cwd = "packages/python"
manifest = "packages/python/pyproject.toml"

[workspace.docs.snippets.sessions.node]
cwd = "crates/xberg-node"
manifest = "crates/xberg-node/package.json"

# Sessions are keyed by BINDING-PACKAGE name, but alef's session lookup falls
# back to the snippet's LANGUAGE name when a snippet carries no explicit
# `target` metadata. TypeScript is the one language where those two names never
# coincide: its packages are `node` and `wasm`, so `sessions.get("typescript")`
# missed and the 48 hand-authored snippets under docs-site/src/snippets/
# typescript/ were typechecked against a bare tsconfig with no path mapping to
# `@xberg-io/xberg` -- 64 of their 69 failures were a single TS2307
# "cannot find module". Generated snippets are unaffected either way: they
# carry `target: node`/`target: wasm`, which takes priority over this fallback.
# Aliased to the node package because every hand-authored snippet under
# docs-site/src/snippets/typescript/ imports `@xberg-io/xberg`. The handwritten
# Markdown snippets under docs-site/src/snippets/wasm/ declare `target: wasm`
# explicitly, so Alef validates them against the WASM session below. ~keep
[workspace.docs.snippets.sessions.typescript]
cwd = "crates/xberg-node"
manifest = "crates/xberg-node/package.json"

[workspace.docs.snippets.sessions.wasm]
cwd = "crates/xberg-wasm"
manifest = "crates/xberg-wasm/package.json"

[workspace.docs.snippets.sessions.go]
cwd = "packages/go"
manifest = "packages/go/go.mod"

[workspace.docs.snippets.sessions.ruby]
cwd = "packages/ruby"
manifest = "packages/ruby/xberg.gemspec"

[workspace.docs.snippets.sessions.php]
cwd = "packages/php"
manifest = "crates/xberg-php/src/composer.json"

[workspace.docs.snippets.sessions.elixir]
cwd = "packages/elixir"
manifest = "packages/elixir/mix.exs"

[workspace.docs.snippets.sessions.java]
cwd = "packages/java"
manifest = "packages/java/pom.xml"
before = [
  "if [ -x /usr/libexec/java_home ]; then JAVA_HOME=$(/usr/libexec/java_home -v 25); else JAVA_HOME=$(java -XshowSettings:properties -version 2>&1 | sed -n 's/ *java.home = //p'); fi; export JAVA_HOME; if [ ! -d target/classes ]; then mvn -q -Dcheckstyle.skip -DskipTests compile; fi && mvn -q -DskipTests dependency:copy-dependencies",
]

[workspace.docs.snippets.sessions.csharp]
cwd = "packages/csharp/Xberg"
manifest = "packages/csharp/Xberg/Xberg.csproj"

[workspace.docs.snippets.sessions.dart]
cwd = "packages/dart"
manifest = "packages/dart/pubspec.yaml"

[workspace.docs.snippets.sessions.kotlin]
cwd = "packages/kotlin-android"
manifest = "packages/kotlin-android/build.gradle.kts"
# Guarded so a machine with no Android SDK SKIPS this build instead of failing it.
# The previous form derived ANDROID_HOME inline from `readlink $(command -v
# sdkmanager)`; with sdkmanager absent that passes no argument to readlink, the
# four nested dirnames each print "usage: dirname string [...]", ANDROID_HOME
# ends up empty, and Gradle aborts. Alef isolates preparation failures per target,
# but an absent Android toolchain should be unavailable, not a Kotlin source failure.
# The wrapper JAR is also gitignored, so staged-tree validation may lack it.
# Once an explicit, structurally valid SDK is present, Gradle failures propagate
# so stale build artifacts cannot make Kotlin snippets appear valid. ~keep
before = [
  'ANDROID_HOME=${ANDROID_HOME:-${ANDROID_SDK_ROOT:-}}; export ANDROID_HOME; if [ -z "$ANDROID_HOME" ]; then echo "alef: no explicit Android SDK root; skipping gradle assembleDebug"; elif [ ! -d "$ANDROID_HOME/platforms" ] || [ ! -d "$ANDROID_HOME/build-tools" ]; then echo "alef: Android SDK root lacks platforms or build-tools; skipping gradle assembleDebug"; elif [ ! -f gradle/wrapper/gradle-wrapper.jar ]; then echo "alef: gradle/wrapper/gradle-wrapper.jar is absent; skipping gradle assembleDebug"; else ./gradlew assembleDebug; fi',
]

[workspace.docs.snippets.sessions.kotlin_android]
cwd = "packages/kotlin-android"
manifest = "packages/kotlin-android/build.gradle.kts"
# Guarded so a machine with no Android SDK SKIPS this build instead of failing it.
# The previous form derived ANDROID_HOME inline from `readlink $(command -v
# sdkmanager)`; with sdkmanager absent that passes no argument to readlink, the
# four nested dirnames each print "usage: dirname string [...]", ANDROID_HOME
# ends up empty, and Gradle aborts. Alef isolates preparation failures per target,
# but an absent Android toolchain should be unavailable, not a Kotlin source failure.
# The wrapper JAR is also gitignored, so staged-tree validation may lack it.
# Once an explicit, structurally valid SDK is present, Gradle failures propagate
# so stale build artifacts cannot make Kotlin snippets appear valid. ~keep
before = [
  'ANDROID_HOME=${ANDROID_HOME:-${ANDROID_SDK_ROOT:-}}; export ANDROID_HOME; if [ -z "$ANDROID_HOME" ]; then echo "alef: no explicit Android SDK root; skipping gradle assembleDebug"; elif [ ! -d "$ANDROID_HOME/platforms" ] || [ ! -d "$ANDROID_HOME/build-tools" ]; then echo "alef: Android SDK root lacks platforms or build-tools; skipping gradle assembleDebug"; elif [ ! -f gradle/wrapper/gradle-wrapper.jar ]; then echo "alef: gradle/wrapper/gradle-wrapper.jar is absent; skipping gradle assembleDebug"; else ./gradlew assembleDebug; fi',
]

[workspace.docs.snippets.sessions.swift]
cwd = "packages/swift"
manifest = "packages/swift/Package.swift"
# Guarded so a machine with no Swift toolchain reports Swift unavailable instead
# of a source failure. The build step also fixes xberg task #521, where every
# Swift snippet failed because `import Xberg` could not resolve.
# packages/swift/Sources/RustBridge{,C} are already-generated, committed
# swift-bridge output (see Package.swift's own header comment) -- `alef
# generate` does not need to run here. What's missing is the Rust side:
# Package.swift's `resolvedStaticLib` links target/{release,debug}/lib
# xberg_swift.a and libxberg_ffi.a explicitly, and neither exists until
# `cargo build -p xberg-swift` has run at least once. Skip that build when
# it is already satisfied (release preferred, matching resolvedStaticLib's
# own preference) so repeat runs stay fast. Always run `swift build` after
# that check: SwiftPM incrementally refreshes Xberg.swiftmodule when the
# installed Swift compiler changes, preventing an older `.build` module
# from poisoning every snippet import. An installed toolchain's Cargo or Swift
# build failure propagates so stale modules cannot make snippets appear valid;
# only an absent Swift toolchain is an explicit skip. ~keep
before = [
  'if ! command -v swift >/dev/null 2>&1; then echo "alef: swift not on PATH; skipping Swift session build (Swift snippets will fail typecheck)"; else if { [ -f ../../target/release/libxberg_swift.a ] || [ -f ../../target/debug/libxberg_swift.a ]; } && { [ -f ../../target/release/libxberg_ffi.a ] || [ -f ../../target/debug/libxberg_ffi.a ]; }; then echo "alef: required staticlibs already built; skipping cargo build"; else cargo build --manifest-path rust/Cargo.toml -p xberg-swift -p xberg-ffi || exit $?; fi; swift build; fi',
]

[workspace.docs.snippets.sessions.zig]
cwd = "packages/zig"
manifest = "packages/zig/build.zig"
# No ZIG_GLOBAL_CACHE_DIR override here on purpose. We used to set it to the
# RELATIVE path ".alef-cache/zig-global", which zig could not resolve from the
# session cwd -- every Zig snippet failed with "unable to resolve zig cache
# directory: AppDataDirUnavailable" before it ever reached the compiler, masking
# any real error underneath. alef already exports a per-fingerprint ABSOLUTE
# cache dir of its own, so overriding it bought nothing and additionally
# collapsed every Zig session onto one shared cache. ~keep
# packages/zig/src/xberg.zig:4 does `@cImport(@cInclude("xberg.h"))`, and alef
# compiles that module with a bare `zig build-exe` that never reads build.zig --
# so build.zig's addIncludePath does not apply and the header must be supplied
# here instead. ~keep
include_paths = ["crates/xberg-ffi/include"]

[workspace.docs.snippets.sessions.c]
cwd = "crates/xberg-ffi/include"
manifest = "crates/xberg-ffi/include/xberg.h"


[workspace.sync]
extra_paths = [
  "packages/python/xberg/__init__.py",
  "packages/ruby/lib/xberg/version.rb",
  "packages/ruby/ext/xberg_rb/native/Cargo.toml",
  "crates/xberg-node/package.json",
  "crates/xberg-node/npm/*/package.json",
  "packages/go/go.mod",
  "cli-proxy/pypi/pyproject.toml",
  "cli-proxy/npm/package.json",
  "Cargo.toml",
]

[workspace.poly]
exclude = [
  "docs-site/src/snippets/**",
  "**/_generated/**",
  "**/coverage/**",
  "**/pkg/**",
  "**/.next/**",
  "**/*.min.js",
  "**/vendored/**",
  "**/stopwords/**",
  "**/testdata/**",
  "e2e/**",
  "**/*.diff",
  "**/*.patch",
  "**/frb_generated.rs",
  # The Dart half of the same flutter_rust_bridge output. Only the Rust half was
  # excluded, so `poly fmt --check .` reports `would reformat` on all four Dart
  # bridge files (frb_generated{,.io,.web}.dart and lib.dart) and fails the
  # Validate (poly) job on every run. Reproduced against poly 0.20.1 locally and
  # 0.19.7 in CI. Same reasoning as the sibling `**/*.freezed.dart` exclusion
  # poly already applies: this is generator output nothing should reflow. ~keep
  "packages/dart/lib/src/xberg_bridge_generated/**",
  "charts/**",
  # ai-rulez-generated coding-agent plugin outputs: owned by `ai-rulez generate
  # --plugin`, never reformatted by poly (would break BLAKE3 provenance). Sources
  # under plugin/.ai-rulez/ + plugin/scripts/ stay poly-managed. ~keep
  "plugin/.claude-plugin/**",
  "plugin/.codex-plugin/**",
  "plugin/.cursor-plugin/**",
  "plugin/.factory-plugin/**",
  "plugin/.opencode/**",
  "plugin/.hermes/**",
  "plugin/skills/**",
  "plugin/.mcp.json",
  "plugin/gemini-extension.json",
  "plugin/kimi.plugin.json",
  "plugin/package.json",
  "plugin/.ai-rulez-generated.json",
  ".claude-plugin/marketplace.json",
  ".agents/plugins/marketplace.json",
  ".ai-rulez-generated.json",
  # Benchmark cohort manifests are BLAKE3-pinned by value in
  # tools/benchmark-harness/src/bench_matrix.rs (*_MANIFEST_BLAKE3) and verified
  # at runtime by validate_artifacts. Any reformat changes the digest and fails
  # the contract, so these are data files poly must not rewrite -- same reasoning
  # as the ai-rulez plugin outputs above. Without this, every regen that runs
  # poly silently re-breaks the pin: it collapsed the `fixtures` array onto one
  # line in 888023d75d, and 8a60458a7dd was an earlier re-pin for the same cause. ~keep
  "tools/benchmark-harness/cohorts/**",
]

# Opt-in comment-removal sweep. Preserve doc comments (rustdoc is required on
# public items), TODO/FIXME (actionable), and SAFETY/license markers. Generated
# binding output is exempted via per-file-ignores below. ~keep
[workspace.poly.uncomment]
enabled = true
remove-todos = false
remove-fixme = false
remove-docs = false
use-default-ignores = true
# clang-format owns C++ namespace-closing comments and restores them after lint fixes. ~keep
preserve-patterns = ["SAFETY", "SPDX", "Copyright", "License", "licensed under", "namespace"]

[workspace.poly.typos.extend-words]
# These exact tokens are audited corpus/language terms, tokenizer or hyphenation fragments,
# standardized glyph/PDF names, and deliberately malformed regression inputs. They must remain
# verbatim for the tests and formats they represent; this is not a blanket typo suppression. ~keep
addresss = "addresss"
alikes = "alikes"
als = "als"
ative = "ative"
certi = "certi"
cient = "cient"
compre = "compre"
controler = "controler"
diffcult = "diffcult"
dokument = "dokument"
ect = "ect"
ede = "ede"
equivalen = "equivalen"
evn = "evn"
fied = "fied"
fpt = "fpt"
fre = "fre"
garanties = "garanties"
hel = "hel"
implemen = "implemen"
indien = "indien"
ine = "ine"
# Toronto Maple Leafs is the official team name used by the XLSX fixture. ~keep
Leafs = "Leafs"
markdwon = "markdwon"
multipl = "multipl"
normale = "normale"
paeth = "paeth"
parms = "parms"
proce = "proce"
proces = "proces"
rturned = "rturned"
stap = "stap"
teh = "teh"
thic = "thic"
versoin = "versoin"
wel = "wel"
# flate2 crate + PDF FlateDecode filter (THE ORIGINAL BUG: flate -> flat)
# Corpus fixture identifier preserves this source filename spelling. ~keep
Availabilty = "Availabilty"
# OpenType table names, not truncated English: `loca` (index-to-location),
# `trak` (tracking). ~keep
loca = "loca"
trak = "trak"
flate = "flate"
delocate = "delocate"
thw = "thw"
arange = "arange"
mmaped = "mmaped"
layrnorm = "layrnorm"
seperator = "seperator"
ser = "ser"
ake = "ake"
algoritmos = "algoritmos"
kreuzberg = "kreuzberg"
tesseract = "tesseract"
onnx = "onnx"
surrealdb = "surrealdb"
tbe = "tbe"
docling = "docling"
markitdown = "markitdown"
pymupdf = "pymupdf"
openwebui = "openwebui"
webui = "webui"
rumdl = "rumdl"
opf = "opf"
# "Tower"/"lower" substring in pdf/structure/lines.rs #1291 tests + CHANGELOG. ~keep
ower = "ower"
hocr = "hocr"
odf = "odf"
multline = "multline"
headerr = "headerr"
pard = "pard"
edn = "edn"
siz = "siz"
inh = "inh"
bre = "bre"
yor = "yor"
extention = "extention"
portait = "portait"
fith = "fith"
threed = "threed"
chlidren = "chlidren"
formated = "formated"
specifing = "specifing"
similarily = "similarily"
execpt = "execpt"
faiure = "faiure"
substract = "substract"
charater = "charater"
cliper = "cliper"
splitted = "splitted"
unparseable = "unparseable"
relatie = "relatie"
traineddata = "traineddata"
tha = "tha"
ist = "ist"
internacional = "internacional"
utiliza = "utiliza"
caf = "caf"
hom = "hom"
ths = "ths"
ment = "ment"
mis = "mis"
helo = "helo"
ove = "ove"
tre = "tre"
thr = "thr"
programa = "programa"
cursos = "cursos"
excepcional = "excepcional"
ein = "ein"
legt = "legt"
# libwpd upstream enum WPD_PASSWORD_MISSMATCH_ERROR (inc/libwpd/WPDocument.h) — upstream's own spelling, cannot rename. ~keep
missmatch = "missmatch"
# benchmark fixture id ft_ACN_2009_page_102_t0 in bench_matrix.rs. ~keep
acn = "acn"

[workspace.poly.typos.extend-identifiers]
PyMuPDF = "PyMuPDF"
MarkItDown = "MarkItDown"
SurrealDB = "SurrealDB"
PDFium = "PDFium"
WebUI = "WebUI"
traineddata = "traineddata"

[workspace.poly.per-file-ignores]
# Alef-generated binding output — never hand-clean comments; regeneration owns them. ~keep
".cargo/config.toml" = ["comment", "doc-comment"]
"Package.swift" = ["comment", "doc-comment"]
"packages/**" = ["comment", "doc-comment"]
"crates/xberg-node/**" = ["comment", "doc-comment"]
"crates/xberg-php/**" = ["comment", "doc-comment"]
"crates/xberg-jni/**" = ["comment", "doc-comment"]
# xberg-ffi/py/wasm are MIXED: only src/lib.rs (+ ffi build.rs/cbindgen.toml) is
# alef-generated; the other modules are hand-written and get the uncomment sweep. ~keep
"crates/xberg-ffi/src/lib.rs" = ["comment", "doc-comment"]
"crates/xberg-ffi/build.rs" = ["comment", "doc-comment"]
"crates/xberg-ffi/cbindgen.toml" = ["comment", "doc-comment"]
"crates/xberg-ffi/include/xberg.h" = ["comment", "doc-comment"]
"crates/xberg-py/src/lib.rs" = ["comment", "doc-comment"]
"crates/xberg-wasm/src/lib.rs" = ["comment", "doc-comment"]
"**/text_repair.rs" = ["typo"]
# Executable CI helper (git mode 100755); poly runs ruff via stdin and cannot
# see the exec bit, so EXE001 always false-fires on shebang'd scripts. ~keep
"scripts/ci/docker/test_docker.py" = ["EXE001"]
"crates/xberg-node/index.js" = ["no-unused-vars"]
"crates/xberg-node/format-metadata-wrapper.js" = ["no-unused-vars"]
"docker/**" = ["DL3006", "DL3059"]
"e2e/**/*.py" = ["A001", "N801"]
"scripts/**/*.py" = [
  "B023",
  "C901",
  "D101",
  "D102",
  "D103",
  "D415",
  "E702",
  "ERA001",
  "PERF203",
  "PERF401",
  "PLC0415",
  "PLR0912",
  "PLR0915",
  "PLW2901",
  "PT018",
  "PTH108",
  "PTH123",
  "S101",
  "S108",
  "S311",
  "S607",
  "SIM105",
  "SIM115",
  "T201",
]
"tools/benchmark-harness/python_baselines/*.py" = [
  "ANN001",
  "ANN201",
  "ANN202",
  "ARG001",
  "BLE001",
  "C901",
  "D103",
  "G004",
  "INP001",
  "PERF401",
  "PLC0415",
  "PLR0911",
  "PLR0912",
  "PLR0915",
  "PLW2901",
  "PTH123",
  "S607",
  "T201",
]
"tools/benchmark-harness/scripts/*.py" = [
  "ANN001",
  "ANN201",
  "ANN202",
  "ARG001",
  "BLE001",
  "C901",
  "D103",
  "E741",
  "EXE001",
  "EXE002",
  "F841",
  "INP001",
  "N818",
  "PERF203",
  "PERF401",
  "PIE810",
  "PLC0206",
  "PLC0415",
  "PLR0911",
  "PLR0912",
  "PLR0915",
  "PLR1714",
  "PLW1510",
  "PLW2901",
  "PTH110",
  "PTH112",
  "PTH118",
  "PTH119",
  "PTH122",
  "PTH123",
  "RET504",
  "S314",
  "S607",
  "SIM108",
  "SIM115",
  "T201",
]
"tools/perf/*.py" = ["D103", "T201"]
"cli-proxy/pypi/**/*.py" = ["ANN001", "ANN202", "S310", "T201"]
"packages/python/build.py" = ["INP001"]
"tools/generate_test_fixtures/**/*.py" = [
  "D301",
  "ERA001",
  "PERF401",
  "PLC0415",
  "PT001",
  "S101",
  "SIM117",
  "T201",
  "TC003",
]
"tools/benchmark-harness/scripts/*.php" = ["no-unescaped-output"]
# alef-generated Python entrypoint; RET504 fires on the passthrough return alef
# emits. Do not hand-fix generated code — suppress instead. Uses a distinct
# glob from the builtin "**/api.py" default (same builtin key can't be
# re-declared here without producing a duplicate poly.toml key). ~keep
"packages/python/**/api.py" = ["RET504"]
# Test-code relaxations on top of the builtin "**/tests/**" defaults: tests
# access private members (SLF001), use lazy/local imports (PLC0415), and
# inject unused pytest fixtures (PT019). Scoped to *.py (a distinct glob from
# the builtin "**/tests/**" key) since these are ruff-only codes. ~keep
"**/tests/**/*.py" = ["PT019", "PLC0415", "SLF001"]
# Example scripts: legitimately print output, aren't packages, and skip full
# annotations/docstrings. Not a builtin default — declared here in full. ~keep
"**/examples/**" = ["ANN", "D100", "D103", "I001", "INP001", "PLR2004", "S101", "PLC0415", "SLF001", "T201", "typo"]

[[crates]]
name = "xberg"
core_import = "xberg"
error_type = "XbergError"
error_constructor = "xberg::XbergError::Other({msg})"
version_from = "Cargo.toml"
workspace_root = "."
sources = [
  "crates/xberg/src/lib.rs",
  "crates/xberg/src/error.rs",
  "crates/xberg/src/types/extraction.rs",
  "crates/xberg/src/types/metadata.rs",
  "crates/xberg/src/types/page.rs",
  "crates/xberg/src/types/tables.rs",
  "crates/xberg/src/types/annotations.rs",
  "crates/xberg/src/types/document_structure.rs",
  "crates/xberg/src/types/ocr_elements.rs",
  "crates/xberg/src/types/formats.rs",
  "crates/xberg/src/types/uri.rs",
  "crates/xberg/src/types/djot.rs",
  "crates/xberg/src/types/internal.rs",
  "crates/xberg/src/types/form_field.rs",
  "crates/xberg/src/types/formula.rs",
  "crates/xberg/src/core/config/mod.rs",
  "crates/xberg/src/core/config/extraction/types.rs",
  "crates/xberg/src/core/config/extraction/core.rs",
  "crates/xberg/src/core/config/extraction/file_config.rs",
  "crates/xberg/src/core/config/ocr.rs",
  "crates/xberg/src/core/config/page.rs",
  "crates/xberg/src/core/config/pdf.rs",
  "crates/xberg/src/core/config/html_output.rs",
  "crates/xberg/src/core/config/layout.rs",
  "crates/xberg/src/core/config/acceleration.rs",
  "crates/xberg/src/core/config/llm.rs",
  "crates/xberg/src/core/config/content_filter.rs",
  "crates/xberg/src/core/config/tree_sitter.rs",
  "crates/xberg/src/core/config/email.rs",
  "crates/xberg/src/core/config/formats.rs",
  "crates/xberg/src/core/mime.rs",
  "crates/xberg/src/core/formats.rs",
  "crates/xberg/src/plugins/traits.rs",
  "crates/xberg/src/plugins/embedding.rs",
  "crates/xberg/src/plugins/reranker.rs",
  "crates/xberg/src/plugins/tokenizer.rs",
  "crates/xberg/src/plugins/registry/mod.rs",
  "crates/xberg/src/plugins/registry/reranker.rs",
  "crates/xberg/src/core/config/reranker.rs",
  "crates/xberg/src/reranking/mod.rs",
  "crates/xberg/src/rendering/mod.rs",
  "crates/xberg/src/keywords/mod.rs",
  "crates/xberg/src/chunking/mod.rs",
  "crates/xberg/src/text/markdown_footnotes/mod.rs",
  "crates/xberg/src/embeddings/mod.rs",
  "crates/xberg/src/language_detection/mod.rs",
  "crates/xberg/src/cache/core.rs",
  "crates/xberg/src/presets/types.rs",
  "crates/xberg/src/presets/resolve.rs",
  "crates/xberg/src/heuristics/structured.rs",
  "crates/xberg/src/core/extract/mod.rs",
  "crates/xberg/src/pdf/render.rs",
  "crates/xberg/src/pdf/metadata.rs",
  "crates/xberg/src/extraction/office_metadata/mod.rs",
  "crates/xberg/src/extraction/office_metadata/core_properties.rs",
  "crates/xberg/src/extraction/office_metadata/app_properties.rs",
  "crates/xberg/src/extraction/office_metadata/custom_properties.rs",
  "crates/xberg/src/extraction/office_metadata/odt_properties.rs",
  "crates/xberg/src/ocr/types.rs",
  "crates/xberg/src/paddle_ocr/mod.rs",
  "crates/xberg/src/plugins/ocr.rs",
  "crates/xberg/src/plugins/extractor/trait.rs",
  "crates/xberg/src/plugins/extractor/mod.rs",
  "crates/xberg/src/plugins/renderer.rs",
  "crates/xberg/src/plugins/validator/mod.rs",
  "crates/xberg/src/plugins/processor/trait.rs",
  "crates/xberg/src/plugins/processor/mod.rs",
]

features = [
  "full",
  "pdf",
  "ocr",
  "paddle-ocr",
  "paddle-ocr-types",
  "layout-detection",
  "layout-types",
  "embeddings",
  "embedding-presets",
  "reranker",
  "reranker-presets",
  "sparse-embeddings",
  "sparse-embedding-presets",
  "late-interaction",
  "late-interaction-presets",
  "chunking",
  "keywords-yake",
  "keywords-rake",
  "language-detection",
  "html",
  "tree-sitter",
  "office",
  "email",
  "archives",
  "stopwords",
  "auto-rotate",
  "auto-rotate-types",
  "tokio-runtime",
  "api",
  "api-types",
  "mcp",
  "liter-llm",
  "quality",
  # alef-emitted `#[cfg(feature = "X")]` arms in binding lib.rs don't trip
  "svg",
  "transcription",
  "transcription-types",
  "classification",
  "captioning",
  "ner-onnx",
  "ner-llm",
  "diff",
  "markdown-footnotes",
  "redaction",
  "enrichment",
  "heuristics",
  "presets",
  "structured",
  "url-ingestion",
]

[[crates.source_crates]]
name = "crawlberg"
from_registry = true
sources = ["src/types/config.rs", "src/types/discovery.rs", "src/types/results.rs", "src/net/ssrf.rs"]
roots = ["crawlberg::CrawlConfig", "crawlberg::MapResult"]

[[crates.source_crates]]
name = "html-to-markdown-rs"
# Read from the vendored registry copy, not a sibling checkout. html-to-markdown-rs is a
# plain registry dependency, so `../html-to-markdown/...` only resolves in a developer
# checkout that happens to sit next to that repo — it is absent on CI and in any git
# worktree, where it aborts the run with "failed to compute sources hash". ~keep
from_registry = true
sources = ["src/options/conversion.rs", "src/options/preprocessing.rs", "src/options/validation.rs"]
roots = ["html_to_markdown_rs::ConversionOptions"]

[crates.extra_dependencies]
crawlberg = { workspace = true, default-features = false }
html-to-markdown-rs = { workspace = true, default-features = false }

[crates.python]
module_name = "_xberg"
exclude_types = ["PooledString"]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "register_document_extractor",
  "register_renderer",
  "unregister_document_extractor",
  "unregister_renderer",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]
reexported_types = ["ExtractionResult", "ExtractedDocument", "ExtractionDiff"]

[crates.python.stubs]
output = "packages/python/xberg/"

# Every `target_dep_overrides` block below sets `default_features = false`, which
# replaces the core crate's `default = ["tokio-runtime", "simd-utf8"]` rather than
# adding to it. Each `*-target` feature reaches `tokio-runtime` transitively, but
# none reaches `simd-utf8`, so it must be listed explicitly or SIMD UTF-8
# validation is silently compiled out of every Windows, macOS-Intel and Android
# binding build.
#
# This applies to `target_dep_overrides` ONLY, because those govern the dep on the
# core `xberg` crate. It must NOT be copied to `[[crates.swift.ffi_target_dep_overrides]]`,
# which governs the dep on `xberg-ffi` — a crate that has no `simd-utf8` feature at
# all, so listing it there makes the generated swift manifest fail to resolve. ~keep
[[crates.python.target_dep_overrides]]
cfg = 'target_os = "windows"'
features = ["windows-target", "simd-utf8"]
default_features = false

[[crates.python.target_dep_overrides]]
cfg = 'all(target_os = "macos", target_arch = "x86_64")'
features = ["macos-intel-target", "simd-utf8"]
default_features = false

[crates.node]
package_name = "@xberg-io/xberg"
# Intel macOS (darwin-x64) is dropped: Microsoft ships no x86_64-macOS ONNX
# Runtime prebuilt, so CI provisions ORT via Homebrew, whose bottle links a
# non-relocatable abseil closure that cannot be vendored into a portable .node.
# Intel Mac users run the arm64 binding under Rosetta or use the WASM package. ~keep
# Windows ARM64 (win32-arm64-msvc) is dropped for parity: no other xberg binding
# ships Windows on ARM64 (every native build targets x86_64-pc-windows-msvc only),
# so the target is excluded rather than leaving a declared-but-unbuilt sub-package. ~keep
exclude_platforms = ["darwin-x64", "win32-arm64-msvc"]
exclude_types = ["StreamReader", "PooledString"]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]

[crates.node.extra_dependencies]
# Required by alef-emitted #[serde_with::serde_as] attribute on HashMap<_, Vec<u8>>
serde_with = "3"

[[crates.node.target_dep_overrides]]
cfg = 'target_os = "windows"'
features = ["windows-target", "simd-utf8"]
default_features = false

[[crates.node.target_dep_overrides]]
cfg = 'all(target_os = "macos", target_arch = "x86_64")'
features = ["macos-intel-target", "simd-utf8"]
default_features = false

[crates.ruby]
gem_name = "xberg"
# Keep HEIC out of generated wrapper defaults and the core dependency so the
# MinGW target override cannot be widened back to the unsupported full set.
excluded_default_features = ["heic"]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]

[crates.ruby.stubs]
output = "packages/ruby/sig/"

# `windows-gnu-target`, NOT `windows-target`. RubyInstaller's Windows Ruby is a MinGW/UCRT
# build rather than MSVC, so ../actions/build-ruby-gem forces the GNU Rust toolchain and
# CARGO_BUILD_TARGET=x86_64-pc-windows-gnu. `windows-target` pulls `ort-bundled`, which has no
# prebuilt for x86_64-pc-windows-gnu, so the gem fails to link. `windows-gnu-target`
# (crates/xberg/Cargo.toml:893) mirrors `windows-target` 1:1 minus the ORT-dependent leaves.
# Ruby is the only binding that needs this — every other Windows target is MSVC. ~keep
[[crates.ruby.target_dep_overrides]]
cfg = 'target_os = "windows"'
features = ["windows-gnu-target", "simd-utf8"]
default_features = false

[[crates.ruby.target_dep_overrides]]
cfg = 'all(target_os = "macos", target_arch = "x86_64")'
features = ["macos-intel-target", "simd-utf8"]
default_features = false

[crates.php]
extension_name = "xberg"
exclude_types = [
  "ChunkerType",
  "OutputFormat",
  "EmbeddingModelType",
  "UriKind",
  "ChunkType",
  # that trigger E0716/E0596/E0507 in the #[php_impl] macro expansion.
  "PooledString",
  "ChunkSizing",
  "NodeContent",
  "OcrBoundingGeometry",
]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  # conditions to work around ext-php-rs's #[php_impl] macro unconditional
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]

[[crates.php.target_dep_overrides]]
cfg = 'target_os = "windows"'
features = ["windows-target", "simd-utf8"]
default_features = false

[[crates.php.target_dep_overrides]]
cfg = 'all(target_os = "macos", target_arch = "x86_64")'
features = ["macos-intel-target", "simd-utf8"]
default_features = false

[crates.elixir]
app_name = "xberg"
# Intel macOS (x86_64-apple-darwin) dropped: GitHub retires the last x86_64-macOS
# runner in 2027 and pyke ships no static ORT for it. rustler_precompiled would
# hard-fail its checksum step hunting for an artifact CI no longer builds. ~keep
nif_targets = ["aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-gnu"]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "register_document_extractor",
  "register_renderer",
  "unregister_document_extractor",
  "unregister_renderer",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]
exclude_types = ["Recyclable"]

[[crates.elixir.target_dep_overrides]]
cfg = 'target_os = "windows"'
features = ["windows-target", "simd-utf8"]
default_features = false

[[crates.elixir.target_dep_overrides]]
cfg = 'all(target_os = "macos", target_arch = "x86_64")'
features = ["macos-intel-target", "simd-utf8"]
default_features = false

[crates.wasm]
package_name = "@xberg-io/xberg-wasm"
# Publish only the `web` (ES module) target. Each wasm-pack target embeds a full
# copy of the ~40MB wasm binary; shipping all four exceeded jsdelivr's 150MB CDN
# limit and broke the docs live demo. The `web` build serves browsers, CDNs,
# bundlers, Deno (npm:), and Node 22+. ~keep
targets = ["web"]
features = [
  "wasm-target",
  "url-ingestion",
  # Unlike the entries below, this is a genuinely new dependency, not something
  # already compiled in transitively: `simd-utf8` is only pulled in by the
  # `default` feature set, and xberg-wasm's Cargo.toml depends on xberg with
  # `default-features = false`, so it has never been active here. Pure-Rust
  # `simdutf8` crate: an explicit `target_arch = "wasm32", target_feature =
  # "simd128"` path with a scalar fallback when simd128 is absent, no other
  # deps. Expect a small (not free) size increase -- watch the 50MB jsDelivr
  # cap when measuring the regen.
  "simd-utf8",
  # Deliberately NOT swapped for "url-ingestion-browser": that alias is
  # `url-ingestion + crawlberg/browser`, and in crawlberg's own Cargo.toml
  # `browser = ["browser-chromiumoxide"]` -> `dep:chromiumoxide, dep:dirs,
  # native-runtime`. chromiumoxide drives a real Chrome process over CDP; it
  # is an unconditional (non-target-gated) optional dependency in crawlberg,
  # not vetted for wasm32, and its own feature re-enables `native-runtime`
  # rather than replacing it -- so both runtimes would end up active at once,
  # which is worse than the status quo. Making the two mutually exclusive
  # needs an upstream crawlberg change; until then this stays "url-ingestion".
  # Listed literally because alef matches `#[cfg(feature = "...")]` against this
  # exact list rather than resolving Cargo's feature graph, so the `wasm-target`
  # alias alone satisfies no leaf gate and the generator drops the gated field
  # (#244). Both are already active transitively via wasm-target -> no-ort-target
  # -> keywords, so this adds no dependency and no wasm bytes. ~keep
  "keywords-yake",
  "keywords-rake",
  # Same reasoning as keywords-yake/keywords-rake above (#244): both are already
  # active transitively via wasm-target -> no-ort-target -> pdf / -> heuristics,
  # so listing them here adds no dependency and no wasm bytes -- it only makes
  # them visible to alef's literal cfg match.
  # "pdf": PdfConfig/HierarchyConfig are plain scalars + Option<Vec<String>> +
  # a crate-root-exported nested config -- no foreign types, no known blocker. ~keep
  "pdf",
  # "heuristics": fixes the extraction_confidence half of #244. The blocker was
  # never a missing feature flag -- ExtractionConfidence was never re-exported
  # at the crate root (see crates/xberg/src/lib.rs), so any codegen referencing
  # it would have failed regardless of this list. Re-export added; the type's
  # only field dependency (SchemaCompliance) is already crate-root exported
  # under this same feature. The ConversionOptions and WasmPageRange/PageRange
  # objections below do not apply to this field.
  "heuristics",
  # (#252) layout-types / transcription-types are `[]` in xberg's Cargo.toml --
  # zero-dependency, type-only leaves -- and "html" is already compiled into
  # xberg-wasm unconditionally (html-to-markdown-rs is a direct dependency in
  # crates/xberg-wasm/Cargo.toml), so adding it as a leaf here adds only the
  # small v_htmlescape crate. Listing all three makes their gated binding
  # fields survive generation without adding meaningful wasm bytes. ~keep
  "layout-types",
  "transcription-types",
  "html",
  # NOT listed yet, pending a one-at-a-time regen: "layout-types",
  # "transcription-types", "html".
  # - "layout-types" / "transcription-types": LayoutDetectionConfig, LayoutStrategy,
  #   TableModel, TranscriptionConfig, WhisperModel are all crate-root exported,
  #   plain scalar/enum fields. No known blocker; untried in isolation.
  # - "html": html_options: Option<html_to_markdown_rs::ConversionOptions> is a
  #   foreign type with no crate-root re-export and no TypeDef in the IR, so
  #   alef's first_unknown_named_type check should drop it via the ALEF-OMITTED
  #   marker rather than hard-failing -- but grep -c ALEF-OMITTED
  #   crates/xberg-wasm/src/lib.rs is 0 today, so that path is untested here.
  #   HtmlOutputConfig.css_file (PathBuf) maps through WasmMapper::path() -> String
  #   and should be fine. The prior "WasmPageRange/PageRange mismatch" concern
  #   does not appear anywhere in alef's wasm backend source -- treat it as
  #   unverified until an actual regen surfaces it. ~keep
]
# tract layout/orientation weights push the release .wasm past jsdelivr's 50MB
# per-file cap when wasm-pack's default wasm-opt is off. Run wasm-opt -Oz to
# claw the binary back under the cap. ~keep
wasm_opt = ["-Oz"]
# Hand-written modules (src/bridge/, src/engine.rs): the injectable OCR bridge
# and the stateful XbergEngine handle. alef declares them in the generated
# lib.rs but does not manage their contents. ~keep
custom_rust_modules = ["bridge", "engine"]
# Keep Sceptre out of the default browser artifact; consumers opt into the
# byte-fed engine when their deployment can host the models. ~keep
extra_features = ["sceptre-wasm"]
exclude_types = ["OcrFallbackDecision", "OcrProcessor", "OcrCacheStats", "TessdataManager", "PageLayoutResult"]
exclude_functions = [
  "embed_texts",
  "embed_text",
  "detect_layout",
  "detect_orientation",
  "run_ocr_pipeline",
  "process_ocr_element",
  "layout_runner",
  "record_success_on_current_span",
  "record_error_on_current_span",
  "compute_hash",
  "assemble_ocr_markdown",
  "validate_tesseract_version",
  "is_language_supported",
  "language_to_script_family",
  "map_language_code",
  "normalize",
  "list_presets",
  "calculate_optimal_dpi",
  "calculate_smart_dpi",
  "ensure_ort_available",
  "run_layout_for_page",
  "run_layout_for_pdf",
  "sanitize_path",
  "config_from_extraction",
  "detect_layout_for_images",
  "recognize_page_tables",
  "generate_embeddings_for_chunks",
  "apply_heuristics",
  "greedy_nms",
  "detect_page_breaks_from_docx",
  "detect_table_page_numbers",
  "extract_ooxml_embedded_objects",
  "extract_and_process_embedded_files",
  "cells_to_text",
  "cells_to_markdown",
  "calculate_quality_score",
  "reconstruct_table",
  "table_to_markdown",
  "build_cell_grid",
  "post_process_table",
  "is_well_formed_table",
  "parse_jotdown_attributes",
  "parse_jotdown_inline",
  "merge_segments",
  "start_mcp_server_http",
  "start_mcp_server_http_with_config",
  "batch_reduce_tokens",
  "chunk_texts_batch",
  "extract_structured_json",
  "split_and_extract_json",
  "count_tokens",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
  "max_sim_rank",
  "max_sim_score",
  # Infallible return type; alef emits a compile_error! rather than a binding for it. Excluded
  # here per that error's own remedy -- `xberg doctor` inspects host backends and model caches,
  # neither of which exists in a browser. ~keep
  "doctor",
  # Chunk classification requires liter-llm and tokio; neither is WASM-safe. ~keep
  "classify_chunks_owned",
]

[crates.wasm.extra_dependencies]
async-trait = "0.1"

# Test harness for the in-crate #[wasm_bindgen_test] suites in src/engine.rs;
# dev-only, never part of the published package's dependency graph. ~keep
[crates.wasm.extra_dev_dependencies]
wasm-bindgen-test = "0.3"

# The generated FFI lib.rs is written whole by alef and declares no modules of its
# own, so a hand-written sibling file in crates/xberg-ffi/src/ is unreachable from
# the crate root: never compiled, absent from the cdylib symbol table, and correctly
# absent from xberg.h. That silently killed 34 `extern "C"` functions when the
# hand-written lib.rs was replaced by a generated one -- cancellation.rs (4),
# config_builder.rs (19) and config/mod.rs (11) -- a link-time break for any C
# consumer, not a header cosmetic. These three wrap `CancellationToken` and the
# config builder, which are `alef(skip)`ed on purpose because they need a
# hand-authored opaque-handle surface alef cannot derive. Declaring them here is
# what makes them part of the crate again. `pub mod` alone is right: `no_mangle`
# symbols export regardless of module visibility, cbindgen parses the whole crate,
# and a glob re-export would risk colliding with generated crate-root items. ~keep
[crates.custom_modules]
# Emptied when the three hand-written modules it named were deleted. alef only
# *declares* a custom module in the generated lib.rs; it never generates the
# contents, so every name here must have a hand-written file behind it or
# generation aborts. `cancellation`, `config_builder` and `config` had rotted --
# 2073 lines and 34 `extern "C"` fns referencing `crate::helpers`,
# `crate::ffi_panic_guard` and `config/{html,parse}.rs`, none of which exist --
# and were never in the shipped ABI: not one appeared among the 2525
# declarations in `include/xberg.h`, because no `mod` statement ever compiled
# them. Re-add a name here only alongside a module that builds. ~keep
ffi = []

[crates.ffi]
prefix = "xberg"
header_name = "xberg.h"
lib_name = "xberg_ffi"
visitor_callbacks = false
# Declare `full-no-heic` as an opt-in passthrough (kept out of `default`) so the
# swift-bridge shim can depend on `xberg-ffi` with that feature — heic's
# `libheif-sys` build.rs cannot cross-compile. Not part of the auto-generated
# passthrough set, so it must be listed here.
#
# `pdf-pdfium` is here for the same reason and must stay out of `default`: the
# engine dlopen()s libpdfium at run time, so compiling it in by default would
# hand every FFI consumer a backend that fails with MissingDependency unless
# they install the library themselves. Declaring it here gives the go/csharp/
# zig/java/C consumers who build libxberg_ffi themselves a documented opt-in at
# zero cost to everyone else. `extra_features` exists only on `[crates.ffi]`
# and `[crates.wasm]`, so the other bindings have no declare-only key and
# cannot be given the same opt-in without an alef change.
#
# `ocr-wasm` appears in emitted `any(feature = "ocr", feature = "ocr-wasm")`
# gates. Alef declares every discovered gate and otherwise enables it by default,
# even though desktop FFI already satisfies those gates through `ocr`. Keep the
# WASM alternative declared for opt-in builds without pulling it into native
# artifacts.
#
# `candle-ocr` is discovered from cfg gates elsewhere in the shared OCR surface,
# but native FFI packages do not ship Candle model backends. Declare the feature
# without enabling it by default so those artifacts remain lean and portable. ~keep
extra_features = ["full-no-heic", "pdf-pdfium", "ocr-wasm", "candle-ocr"]
# Feature list for the desktop `cfg(not(any(android,ios,windows,macos-x86_64)))`
# core dep. Without this override the FFI crate inherits the global
# `[[crates]].features`, whose first entry is `full` — that pulls `heic`
# (`libheif-sys`, no pkg-config cross-compile support) and `candle-*` into the
# swift-bundle's cross-compiled desktop dep, which broke Swift publishing in
# v1.0.12. This is the v1.0.11 granular floor: `full` minus heic/candle.
#
# Go, Java, C#, and Zig consume this one native library. Their feature arrays
# below MUST remain byte-for-byte equivalent to this list: Alef filters each
# host surface using its own literal feature names and cannot reference a shared
# TOML array. Language-specific exclusions belong in exclude_types/functions,
# not in divergent feature lists. ~keep
features = [
  "pdf",
  # GH#1387: these eight must be listed explicitly here. alef matches the LITERAL
  # feature strings in this list, and this ffi list deliberately omits "full"
  # (cf7fa0533d, to keep libheif out of no-heic consumers such as Swift's
  # cross-compiled Linux targets). Without them a regen rewrites
  # crates/xberg-ffi/Cargo.toml without them and silently reverts a0583843a3 --
  # which is exactly what the pending regen had already done before this was caught.
  # Go, C, Java-native and C# all build from this crate. ~keep
  "excel",
  "hwp",
  "hwpx",
  "iwork",
  "wordperfect",
  "mdx",
  "xml",
  "qr-codes",
  "ocr",
  "sceptre-ocr",
  "paddle-ocr",
  "paddle-ocr-types",
  "layout-detection",
  "layout-types",
  "embeddings",
  "embedding-presets",
  "reranker",
  "reranker-presets",
  "sparse-embeddings",
  "sparse-embedding-presets",
  "late-interaction",
  "late-interaction-presets",
  "chunking",
  "chunking-tokenizers",
  "keywords-yake",
  "keywords-rake",
  "language-detection",
  "html",
  "tree-sitter",
  "office",
  "email",
  "archives",
  "stopwords",
  "auto-rotate",
  "auto-rotate-types",
  "tokio-runtime",
  "api",
  "api-types",
  "mcp",
  "liter-llm",
  "quality",
  "svg",
  "transcription",
  "transcription-types",
  "classification",
  "captioning",
  "ner-onnx",
  "ner-llm",
  "diff",
  "markdown-footnotes",
  "redaction",
  "enrichment",
  "heuristics",
  "presets",
  "structured",
  "url-config-types",
  "url-ingestion",
  # Restored after a second silent drop (the GH#1387 shape recurring): these were in core
  # `full` but absent here, so every C-FFI binding -- Java, Go, C#, Swift, Zig, C -- shipped
  # without them, and Java's summarization e2e got a null `summary()` while node passed the
  # same fixture. `heic`, `formats` (which contains heic), `candle-vlm-ocr` and `services`
  # stay out on purpose; the GH#1387 regression test carries the reason for each. ~keep
  "analysis",
  "redaction-ml",
  "redaction-rehydrate",
  "static-embeddings",
  "summarization",
  "summarization-llm",
  "translation",
]
plugin_error_constructor = "xberg::XbergError::Plugin { message: msg, plugin_name: String::new() }"
exclude_types = []
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "find_all",
  "scan_text",
  "embed_texts",
  "apply_strategy",
  "analyze_document",
  "analyze_with_user_chunks",
  "boundaries_from_extraction_result",
  "calculate_chunk_plan",
  "calculate_plan_from_overrides",
  "caption_image",
  "caption_image_file",
  "caption_images",
  "check_format_limits",
  "choose_call_mode",
  "classify_document",
  "classify_one",
  "classify_pages",
  "classify_text",
  "chunk_for_rag",
  "compare",
  "default_model_name",
  "detect_boundaries",
  "detect_entities",
  "detect_mime_type",
  "detect_mime_type_from_bytes",
  "detect_qr_codes",
  "download_model",
  "embed_texts_async",
  "enrich",
  "extract_keywords",
  "extract_region_with_vlm",
  "extract_region_with_vlm_usage",
  "extract_structured",
  "extract_structured_sync",
  "extract_structured_json",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "fingerprint",
  "get_embedding_preset",
  "get_extensions_for_mime",
  "get_reranker_preset",
  "known_models",
  "list_embedding_presets",
  "list_reranker_presets",
  "parse_citations",
  "parse_footnote_definitions",
  "pdf_page_count",
  "redact",
  "register_document_extractor",
  "register_builtin",
  "render_pdf_page_to_png",
  "register_renderer",
  "rerank",
  "rerank_async",
  "resolve",
  "score_confidence",
  "split_and_extract",
  "split_and_extract_sync",
  "split_and_extract_json",
  "summarize",
  "summarize_with_llm",
  "token_count",
  "translate_result",
  "unregister_document_extractor",
  "unregister_renderer",
]

[[crates.ffi.target_dep_overrides]]
cfg = 'target_os = "android"'
features = ["android-target", "simd-utf8"]
default_features = false

[[crates.ffi.target_dep_overrides]]
cfg = 'target_os = "ios"'
features = ["android-target", "simd-utf8"]
default_features = false

[[crates.ffi.target_dep_overrides]]
cfg = 'target_os = "windows"'
features = ["windows-target", "simd-utf8"]
default_features = false

[[crates.ffi.target_dep_overrides]]
cfg = 'all(target_os = "macos", target_arch = "x86_64")'
features = ["macos-intel-target", "simd-utf8"]
default_features = false

[crates.go]
module = "github.com/xberg-io/xberg/packages/go"
package_name = "xberg"
# Must match `[crates.ffi].features`; all four host bindings link the same
# generated native library, and Alef filters cfg-gated glue by this literal list. ~keep
features = [
  "pdf",
  "excel",
  "hwp",
  "hwpx",
  "iwork",
  "wordperfect",
  "mdx",
  "xml",
  "qr-codes",
  "ocr",
  "sceptre-ocr",
  "paddle-ocr",
  "paddle-ocr-types",
  "layout-detection",
  "layout-types",
  "embeddings",
  "embedding-presets",
  "reranker",
  "reranker-presets",
  "sparse-embeddings",
  "sparse-embedding-presets",
  "late-interaction",
  "late-interaction-presets",
  "chunking",
  "chunking-tokenizers",
  "keywords-yake",
  "keywords-rake",
  "language-detection",
  "html",
  "tree-sitter",
  "office",
  "email",
  "archives",
  "stopwords",
  "auto-rotate",
  "auto-rotate-types",
  "tokio-runtime",
  "api",
  "api-types",
  "mcp",
  "liter-llm",
  "quality",
  "svg",
  "transcription",
  "transcription-types",
  "classification",
  "captioning",
  "ner-onnx",
  "ner-llm",
  "diff",
  "markdown-footnotes",
  "redaction",
  "enrichment",
  "heuristics",
  "presets",
  "structured",
  "url-config-types",
  "url-ingestion",
]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "apply_strategy",
  "analyze_document",
  "analyze_with_user_chunks",
  "boundaries_from_extraction_result",
  "calculate_chunk_plan",
  "calculate_plan_from_overrides",
  "caption_image",
  "caption_image_file",
  "caption_images",
  "check_format_limits",
  "choose_call_mode",
  "classify_document",
  "classify_one",
  "classify_pages",
  "classify_text",
  "chunk_for_rag",
  "compare",
  "default_model_name",
  "detect_boundaries",
  "detect_entities",
  "detect_mime_type",
  "detect_mime_type_from_bytes",
  "detect_qr_codes",
  "download_model",
  "embed_texts_async",
  "enrich",
  "extract_keywords",
  "extract_region_with_vlm",
  "extract_region_with_vlm_usage",
  "extract_structured",
  "extract_structured_sync",
  "extract_structured_json",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "fingerprint",
  "get_embedding_preset",
  "get_extensions_for_mime",
  "get_reranker_preset",
  "known_models",
  "list_embedding_presets",
  "list_reranker_presets",
  "parse_citations",
  "parse_footnote_definitions",
  "pdf_page_count",
  "redact",
  "register_builtin",
  "render_pdf_page_to_png",
  "rerank",
  "rerank_async",
  "resolve",
  "score_confidence",
  "split_and_extract",
  "split_and_extract_sync",
  "split_and_extract_json",
  "summarize",
  "summarize_with_llm",
  "token_count",
  "translate_result",
  "register_document_extractor",
  "unregister_document_extractor",
  "register_renderer",
  "unregister_renderer",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]
exclude_types = []

[crates.java]
package = "io.xberg"
ffi_style = "panama"
# Must match `[crates.ffi].features`; Java binds that exact native ABI. ~keep
features = [
  "pdf",
  "excel",
  "hwp",
  "hwpx",
  "iwork",
  "wordperfect",
  "mdx",
  "xml",
  "qr-codes",
  "ocr",
  "sceptre-ocr",
  "paddle-ocr",
  "paddle-ocr-types",
  "layout-detection",
  "layout-types",
  "embeddings",
  "embedding-presets",
  "reranker",
  "reranker-presets",
  "sparse-embeddings",
  "sparse-embedding-presets",
  "late-interaction",
  "late-interaction-presets",
  "chunking",
  "chunking-tokenizers",
  "keywords-yake",
  "keywords-rake",
  "language-detection",
  "html",
  "tree-sitter",
  "office",
  "email",
  "archives",
  "stopwords",
  "auto-rotate",
  "auto-rotate-types",
  "tokio-runtime",
  "api",
  "api-types",
  "mcp",
  "liter-llm",
  "quality",
  "svg",
  "transcription",
  "transcription-types",
  "classification",
  "captioning",
  "ner-onnx",
  "ner-llm",
  "diff",
  "markdown-footnotes",
  "redaction",
  "enrichment",
  "heuristics",
  "presets",
  "structured",
  "url-config-types",
  "url-ingestion",
]
exclude_types = ["OcrBackendType", "ProcessingStage"]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]

[crates.dart]
pubspec_name = "xberg"
lib_name = "xberg"
style = "frb"
# `cfg(not(android/ios/windows))` target dep uses `features = ["full"]` which
# get them through the `cfg(not(android/ios/windows))` `features = ["full"]` dep.
excluded_default_features = ["heic", "embeddings", "reranker", "sparse-embeddings", "late-interaction"]
features = [
  "pdf",
  "excel",
  "office",
  "hwp",
  "hwpx",
  "iwork",
  "email",
  "html",
  "xml",
  "archives",
  "mdx",
  "svg",
  "language-detection",
  "chunking",
  "chunking-tokenizers",
  "quality",
  "keywords",
  "diff",
  "api",
  "api-types",
  "mcp",
  "ocr",
  "paddle-ocr",
  "paddle-ocr-types",
  "layout-detection",
  "layout-types",
  "embeddings",
  "embedding-presets",
  "reranker",
  "reranker-presets",
  "sparse-embeddings",
  "sparse-embedding-presets",
  "late-interaction",
  "late-interaction-presets",
  "transcription-types",
  "tree-sitter",
  "liter-llm",
  "tokio-runtime",
  "ner-llm",
  "ner-onnx",
  "redaction",
  "summarization",
  "classification",
  "captioning",
  "qr-codes",
  "auto-rotate-types",
  "stopwords",
]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]

[[crates.dart.target_dep_overrides]]
cfg = 'target_os = "android"'
features = ["android-target", "simd-utf8"]
default_features = false

[[crates.dart.target_dep_overrides]]
cfg = 'target_os = "ios"'
features = ["android-target", "simd-utf8"]
default_features = false

[[crates.dart.target_dep_overrides]]
cfg = 'target_os = "windows"'
features = ["windows-target", "simd-utf8"]
default_features = false

[[crates.dart.target_dep_overrides]]
cfg = 'all(target_os = "macos", target_arch = "x86_64")'
features = ["macos-intel-target", "simd-utf8"]
default_features = false

[crates.kotlin_android]
package = "io.xberg"
namespace = "io.xberg"
artifact_id = "xberg-android"
group_id = "io.xberg"
abis = ["arm64-v8a", "x86_64"]
# Alef matches cfg gates literally and does not expand Cargo aggregates. Keep
# `android-target` for the actual runtime, then spell out its Android-safe leaf
# surface so generated Kotlin/JNI glue retains every available DTO and method
# without exposing desktop ORT-only APIs. ~keep
features = [
  "android-target",
  "no-ort-target",
  "pdf",
  "pdf-native",
  "html",
  "notebook",
  "xml",
  "email",
  "language-detection",
  "chunking",
  "chunking-tokenizers",
  "quality",
  "keywords",
  "keywords-yake",
  "keywords-rake",
  "markdown-footnotes",
  "enrichment",
  "heuristics",
  "office",
  "iwork",
  "hwp",
  "mdx",
  "archives",
  "stopwords",
  "embedding-presets",
  "static-embeddings",
  "reranker-presets",
  "sparse-embedding-presets",
  "late-interaction-presets",
  "layout-types",
  "auto-rotate-types",
  "paddle-ocr-types",
  "ner",
  "presets",
  "redaction",
  "summarization",
  "qr-codes",
  "svg",
  "image-encode",
  "transcription-types",
  "excel",
  "tree-sitter",
  "ocr",
  "ocr-pipeline",
  "sceptre-ocr-tract",
  "tract",
  "auto-rotate-tract",
  "layout-tract",
  "paddle-ocr-tract",
  "api",
  "api-types",
  "tower-service",
  "mcp",
  "liter-llm",
  "structured",
  "hwpx",
  "diff",
  "classification",
  "captioning",
  "ner-llm",
  "url-config-types",
  "url-ingestion",
  "tokio-runtime",
]
exclude_types = []
exclude_functions = [
  "embed_texts_async",
  "calculate_quality_score",
  "count_tokens",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]

[crates.jni]

[[crates.jni.target_dep_overrides]]
cfg = 'target_os = "android"'
features = ["android-target", "simd-utf8"]
default_features = false

[[crates.jni.target_dep_overrides]]
cfg = 'target_os = "ios"'
features = ["android-target", "simd-utf8"]
default_features = false

[[crates.jni.target_dep_overrides]]
cfg = 'target_os = "windows"'
features = ["windows-target", "simd-utf8"]
default_features = false

[[crates.jni.target_dep_overrides]]
cfg = 'all(target_os = "macos", target_arch = "x86_64")'
features = ["macos-intel-target", "simd-utf8"]
default_features = false

[crates.swift]
module_name = "Xberg"
package_name = "Xberg"
# `cfg(not(ios/android/windows))` target dep uses `features = ["full"]` which
excluded_default_features = ["heic"]
# The swift shim also links `xberg-ffi` directly. Emit that dependency with
# `default-features = false` + `full-no-heic` so heic (whose `libheif-sys`
# build.rs cannot cross-compile) is dropped on every cross-compiled swift
# target. `full-no-heic` is the everything-minus-heic umbrella, so this matches
# the primary core dep's effective feature set without enumerating each flag.
ffi_features = ["full-no-heic"]
features = [
  "pdf",
  "excel",
  "office",
  "hwp",
  "hwpx",
  "iwork",
  # `wordperfect` is inert for codegen -- nothing in the parsed sources is gated on the
  # literal feature, so it adds no binding surface, and libwpd is already compiled in via
  # `ffi_features = ["full-no-heic"]` above. It is listed anyway so this dep array stays
  # correct on its own rather than only by accident of what the ffi edge happens to carry:
  # if that edge is ever narrowed the way `full` was in cf7fa0533d, swift would silently
  # lose .wpd extraction while the format table kept advertising it -- the GH#1387 shape. ~keep
  "wordperfect",
  "email",
  "html",
  "xml",
  "archives",
  "mdx",
  "svg",
  "language-detection",
  "chunking",
  "chunking-tokenizers",
  "quality",
  "keywords",
  "diff",
  "api",
  "api-types",
  "mcp",
  "ocr",
  "paddle-ocr",
  "paddle-ocr-types",
  "layout-detection",
  "layout-types",
  "embeddings",
  "embedding-presets",
  "reranker",
  "reranker-presets",
  "sparse-embeddings",
  "sparse-embedding-presets",
  "late-interaction",
  "late-interaction-presets",
  "transcription-types",
  "tree-sitter",
  "liter-llm",
  "tokio-runtime",
  "ner-llm",
  "ner-onnx",
  "redaction",
  "summarization",
  "classification",
  "captioning",
  "qr-codes",
  "auto-rotate-types",
  "stopwords",
]
exclude_types = []
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "find_all",
  "scan_text",
  "download_model",
  "embed_texts_async",
  "rerank_async",
  "register_document_extractor",
  "unregister_document_extractor",
  "register_renderer",
  "unregister_renderer",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]

[[crates.swift.target_dep_overrides]]
cfg = 'target_os = "ios"'
features = ["android-target", "simd-utf8"]
default_features = false

[[crates.swift.target_dep_overrides]]
cfg = 'target_os = "android"'
features = ["android-target", "simd-utf8"]
default_features = false

[[crates.swift.target_dep_overrides]]
cfg = 'target_os = "windows"'
features = ["windows-target", "simd-utf8"]
default_features = false

[[crates.swift.target_dep_overrides]]
cfg = 'all(target_os = "macos", target_arch = "x86_64")'
features = ["macos-intel-target", "simd-utf8"]
default_features = false

# The swift-bridge backend injects the xberg-ffi dependency itself. Without these
# overrides it emits a single unconditional `[dependencies]` entry carrying
# `ffi_features` (`full-no-heic`), which pulls `sceptre-ocr` -> `sceptre-ocr-ort`.
# Cargo unifies features across every edge to the same resolved package, so that
# would activate the desktop/server-only ORT path even on targets where the core
# `xberg` dep above only asks for `android-target`, tripping the `compile_error!`
# guards in crates/xberg/src/lib.rs and breaking the iOS and Android builds.
# These entries make alef gate the default entry on `cfg(not(any(ios, android)))`
# and emit the reduced feature set for mobile -- replacing the post-regen hand
# patch that `alef all` used to revert every time (GH#370). ~keep
# NOTE: one combined `any(...)` entry, NOT one per OS. The core `xberg` dep above
# already emits its own `cfg(target_os = "ios")` and `cfg(target_os = "android")`
# blocks, so per-OS entries here would emit a second table with an identical cfg
# key and produce a duplicate-key TOML error in the generated manifest.
[[crates.swift.ffi_target_dep_overrides]]
cfg = 'any(target_os = "ios", target_os = "android")'
features = ["android-target"]
default_features = false

[crates.csharp]
namespace = "Xberg"
package_id = "XbergIo.Xberg"
project_file = "packages/csharp/Xberg/Xberg.csproj"
# Must match `[crates.ffi].features`; C# binds that exact native ABI. ~keep
features = [
  "pdf",
  "excel",
  "hwp",
  "hwpx",
  "iwork",
  "wordperfect",
  "mdx",
  "xml",
  "qr-codes",
  "ocr",
  "sceptre-ocr",
  "paddle-ocr",
  "paddle-ocr-types",
  "layout-detection",
  "layout-types",
  "embeddings",
  "embedding-presets",
  "reranker",
  "reranker-presets",
  "sparse-embeddings",
  "sparse-embedding-presets",
  "late-interaction",
  "late-interaction-presets",
  "chunking",
  "chunking-tokenizers",
  "keywords-yake",
  "keywords-rake",
  "language-detection",
  "html",
  "tree-sitter",
  "office",
  "email",
  "archives",
  "stopwords",
  "auto-rotate",
  "auto-rotate-types",
  "tokio-runtime",
  "api",
  "api-types",
  "mcp",
  "liter-llm",
  "quality",
  "svg",
  "transcription",
  "transcription-types",
  "classification",
  "captioning",
  "ner-onnx",
  "ner-llm",
  "diff",
  "markdown-footnotes",
  "redaction",
  "enrichment",
  "heuristics",
  "presets",
  "structured",
  "url-config-types",
  "url-ingestion",
]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]

[crates.zig]
module_name = "xberg"
# Must match `[crates.ffi].features`; Zig binds that exact native ABI. ~keep
features = [
  "pdf",
  "excel",
  "hwp",
  "hwpx",
  "iwork",
  "wordperfect",
  "mdx",
  "xml",
  "qr-codes",
  "ocr",
  "sceptre-ocr",
  "paddle-ocr",
  "paddle-ocr-types",
  "layout-detection",
  "layout-types",
  "embeddings",
  "embedding-presets",
  "reranker",
  "reranker-presets",
  "sparse-embeddings",
  "sparse-embedding-presets",
  "late-interaction",
  "late-interaction-presets",
  "chunking",
  "chunking-tokenizers",
  "keywords-yake",
  "keywords-rake",
  "language-detection",
  "html",
  "tree-sitter",
  "office",
  "email",
  "archives",
  "stopwords",
  "auto-rotate",
  "auto-rotate-types",
  "tokio-runtime",
  "api",
  "api-types",
  "mcp",
  "liter-llm",
  "quality",
  "svg",
  "transcription",
  "transcription-types",
  "classification",
  "captioning",
  "ner-onnx",
  "ner-llm",
  "diff",
  "markdown-footnotes",
  "redaction",
  "enrichment",
  "heuristics",
  "presets",
  "structured",
  "url-config-types",
  "url-ingestion",
]
exclude_functions = [
  "calculate_quality_score",
  "count_tokens",
  "embed_texts",
  "extract_sync",
  "extract_batch_sync",
  "extract_bytes",
  "extract_bytes_sync",
  "extract_file",
  "extract_file_sync",
  "batch_extract_bytes",
  "batch_extract_bytes_sync",
  "batch_extract_files",
  "batch_extract_files_sync",
  "embed_sparse",
  "embed_sparse_async",
  "embed_multi_vector",
  "embed_multi_vector_async",
]

[crates.output]
python = "crates/xberg-py/src/"
node = "crates/xberg-node/src/"
ruby = "packages/ruby/ext/xberg_rb/src/"
php = "crates/xberg-php/src/"
ffi = "crates/xberg-ffi/src/"
go = "packages/go/"
elixir = "packages/elixir/native/xberg_nif/src/"
wasm = "crates/xberg-wasm/src/"
java = "packages/java/"
csharp = "packages/csharp/src/"
kotlin_android = "packages/kotlin-android/"
swift = "packages/swift/Sources/Xberg/"
dart = "packages/dart/lib/src/"
zig = "packages/zig/src/"

[crates.exclude]
types = [
  "SplitConfig",
  "SplitStrategy",
  "SplitSegment",

  "xberg::extraction::docx::parser::Table",
  "xberg::extraction::docx::parser::TableCell",
  "xberg::extraction::docx::parser::TableRow",
  "xberg::extraction::docx::parser::HeaderFooter",
  "xberg::extraction::docx::parser::Note",
  "xberg::extraction::hwp::model::Section",

  "GlineBackend",
  "LlmBackend",

  "xberg::chunking::semantic::merge::Segment",

  "NerBackend",

  "EnrichmentConfig",
  "EnrichedResult",
  "NerEnrichmentConfig",
  "ClassificationEnrichmentConfig",
  "CaptioningEnrichmentConfig",

  "xberg::enrichment::EnrichOptions",
  "xberg::enrichment::EnrichResult",
  "xberg::enrichment::EnrichStatus",
  "ChunkPlan",
  "ChunkingDecision",
  "ChunkingResult",
  "ConfidenceSignals",
  "ConfidenceWeights",
  "EmbeddingPreset",
  "RerankerPreset",
  "StructuredInput",
  "StructuredThresholds",
  "StructuredCallMode",
  "xberg::text::classification::page_classifier::ClassifyContext",

  "xberg::engine::Engine",
  "xberg::engine::EngineBuilder",

  "xberg::engine::seams::CacheBackend",
  "xberg::engine::seams::NoopCache",
  "xberg::engine::seams::ProgressSink",
  "xberg::engine::seams::ProgressEvent",
  "xberg::engine::seams::NoopProgressSink",
  "xberg::engine::seams::StructuredPolicy",
  "xberg::engine::seams::DefaultStructuredPolicy",
  "xberg::engine::seams::PresetResolver",
  "xberg::engine::seams::CorePresetResolver",
  "xberg::engine::seams::LlmClient",
  "xberg::engine::seams::LiterLlmClient",
  "xberg::engine::seams::ModelProvider",
  "xberg::engine::seams::DefaultModelProvider",
  "xberg::engine::seams::ModelId",

  "xberg::engine::structured::rasterize::PageImage",
  "xberg::engine::structured::rasterize::RasterizeError",
  "xberg::engine::structured::chunk::Batch",
  "xberg::engine::structured::chunk::ChunkerConfig",
  "xberg::engine::structured::schema::Outcome",
  "xberg::engine::structured::schema::MergedOutput",
  "xberg::engine::structured::citations::CitationSource",
  "xberg::engine::structured::citations::CitedField",
  "xberg::engine::structured::citations::CitationOutput",
  "xberg::engine::structured::prompts::BuiltPrompt",

  "xberg::engine::structured::finalize::FinalizedOutput",

  "xberg::engine::parsed::ParsedDocument",
]
methods = [
  "LayoutDetection.class",
  "LayoutRegion.class",

  "MetricsLayer.layer",
  "MultipartApi.from_request",

  "TokenCounter.next_token",

]

functions = [
  # Gated by #[cfg(feature = "prometheus")] on the `mod`/`pub use` in
  # telemetry/mod.rs, not on the fn itself, so alef parses it as ungated and emits
  # an FFI wrapper the ffi crate's feature set cannot satisfy. A prometheus
  # Registry is not a meaningful C-ABI/binding surface in any case.
  "init_prometheus",
  "fuse",
  "build_prompt",
  "build_vision_fallback_prompt",
  # Composes validate_and_merge into fuse; returns the excluded FinalizedOutput.
  "merge_and_cite",
  # Wraps build_vision_fallback_prompt with the threshold decision; returns
  # Option<BuiltPrompt>, and BuiltPrompt is already excluded above.
  "escalate_if_below_threshold",
  "build_decoder_prompt_tokens",
  "timestamp_token_to_ms",
  "parse_timestamped_segments",
  "install_pdf_render_diagnostics",
  "take_xberg_native_pdf_render_warnings",
  "ensure_initialized",
  "batch_pages",
  "pages_for_call",
  "validate_and_merge",
  "apply_strategy",

  "classify_one",

  "detect_entities",

  "caption_image",
  "caption_image_file",
  "caption_images",

  "classify_document",
  "classify_pages",
  "classify_text",
  "chunk_for_rag",
  "embed_texts",
  "get_embedding_preset",
  "list_embedding_presets",
  "rerank",
  "rerank_async",
  "get_reranker_preset",
  "list_reranker_presets",

  "enrich",

  "split_and_extract",

  "analyze_document",
  "analyze_with_user_chunks",
  "boundaries_from_extraction_result",
  "calculate_chunk_plan",
  "calculate_plan_from_overrides",
  "check_format_limits",
  "choose_call_mode",
  "detect_boundaries",
  "score_confidence",
  "compare",
  "detect_mime_type",
  "detect_mime_type_from_bytes",
  "get_extensions_for_mime",
  "extract_keywords",
  "extract_region_with_vlm",
  "extract_region_with_vlm_usage",
  "pdf_page_count",
  "render_pdf_page_to_png",
  "redact",
  "summarize",
  "summarize_with_llm",
  "translate_result",
  "find_footnote_anchors",
  "find_inference_markers",
  "parse_citations",
  "parse_footnote_definitions",
  "detect_qr_codes",
  "download_model",
  "find_all",
  "scan_text",
  "token_count",
  "default_model_name",
  "fingerprint",
  "known_models",
  "register_builtin",
  "resolve",

  # Both take `TokenizerSource<'a>`, a borrowed enum whose four variants mean
  # different things (HF model ID, model+revision pair, local `tokenizer.json`
  # path, embedded bytes). Alef cannot represent it across FFI, so it sanitizes
  # the parameter to a bare `String` — collapsing all four into one untyped
  # argument the caller has no way to disambiguate. Neither function appears in
  # any of the 15 generated bindings today, so excluding them removes nothing
  # from the published surface; it only stops a lossy one being fabricated.
  # Excluded rather than suppressed via `suppress_validation_codes` so
  # `lossy_sanitized_surface` stays armed for every other item. ~keep
  "try_count_tokens",
  "preload_tokenizer",

]

[crates.test.python]
precondition = "command -v uv >/dev/null 2>&1"
before = "bash scripts/e2e/build-mock-server.sh && cd e2e/python && uv sync --reinstall-package xberg"
e2e = "cd e2e/python && uv run --no-sync python -m pytest tests/ -q"

[crates.test.node]
precondition = "command -v pnpm >/dev/null 2>&1"
before = "bash scripts/e2e/build-mock-server.sh && cd crates/xberg-node && pnpm install && CARGO_BUILD_JOBS=1 pnpm exec napi build --output-dir . --release --platform && cd ../../e2e/node && pnpm install --frozen-lockfile=false"
e2e = "cd e2e/node && pnpm test"

[crates.test.go]
precondition = "command -v go >/dev/null 2>&1"
before = "cargo build --release -p xberg-ffi && mkdir -p packages/go/include && cp crates/xberg-ffi/include/xberg.h packages/go/include/ && bash scripts/stage_go_native_local.sh"
e2e = "cd e2e/go && go test ./... -count=1"

[crates.test.ruby]
precondition = "export PATH=\"$HOME/.rbenv/shims:$HOME/.asdf/shims:$PATH\" && command -v ruby >/dev/null 2>&1 && BUNDLE_PATH=vendor/bundle ruby -S bundle --version >/dev/null 2>&1"
before = "export PATH=\"$HOME/.rbenv/shims:$HOME/.asdf/shims:$PATH\" && cd packages/ruby && BUNDLE_PATH=vendor/bundle ruby -S bundle install && BUNDLE_PATH=vendor/bundle ruby -S bundle exec ruby -S rake compile && cd ../../e2e/ruby && BUNDLE_PATH=vendor/bundle ruby -S bundle install"
e2e = "export PATH=\"$HOME/.rbenv/shims:$HOME/.asdf/shims:$PATH\" && cd e2e/ruby && BUNDLE_PATH=vendor/bundle ruby -S bundle exec ruby -S rspec"

[crates.test.php]
precondition = "command -v composer >/dev/null 2>&1"
before = "bash scripts/e2e/build-mock-server.sh && cargo build --release -p xberg-php && cd e2e/php && composer install"
e2e = "cd e2e/php && php run_tests.php"

[crates.test.java]
precondition = "command -v mvn >/dev/null 2>&1"
before = "bash scripts/e2e/build-mock-server.sh && cargo build --release -p xberg-ffi && cd packages/java && mvn -T 1 clean package -DskipTests"
e2e = "cd e2e/java && mvn test"

[crates.test.csharp]
precondition = "command -v dotnet >/dev/null 2>&1"
before = "bash scripts/e2e/build-mock-server.sh && cargo build --release -p xberg-ffi && bash scripts/stage_csharp_native_local.sh"
e2e = "dotnet test e2e/csharp"

[crates.test.elixir]
precondition = "command -v mix >/dev/null 2>&1"
before = "cd packages/elixir && XBERG_BUILD=1 mix deps.get && XBERG_BUILD=1 mix compile && cd ../../e2e/elixir && XBERG_BUILD=1 mix deps.get"
# Fixture dirs are symlinked in, as the dart and zig legs do. alef's elixir e2e
# codegen emits "Tests construct absolute paths via test_documents_path, so no chdir
# needed" into test_helper.exs, but it only prefixes test_documents_path for top-level
# call args -- not for file paths nested inside struct/map inputs, which is what these
# fixtures use. So the paths stay relative to e2e/elixir and 10 tests die with
# `File.Error could not read file "pdf/fake_memo.pdf"`. Reported upstream; this is the
# stopgap until the generator emits a real chdir. The dir list is the same hardcoded
# set the dart and zig hooks carry and will need extending if a fixture reaches for a
# top-level dir outside it. ~keep
e2e = "cd e2e/elixir && for dir in docx html json pdf text xlsx images; do test -L $dir || ln -sf ../../test_documents/$dir $dir; done && XBERG_BUILD=1 mix test"

[crates.test.wasm]
precondition = "command -v wasm-pack >/dev/null 2>&1"
before = "wasm-pack build crates/xberg-wasm --release --target nodejs --out-dir pkg/nodejs && node crates/xberg-wasm/scripts/fix-wasi-imports.mjs && cd e2e/wasm && pnpm install --ignore-workspace"
e2e = "cd e2e/wasm && pnpm test"

[crates.test.rust]
precondition = "command -v cargo >/dev/null 2>&1"
e2e = "cd e2e/rust && cargo test"

[crates.test.kotlin_android]
precondition = "command -v gradle >/dev/null 2>&1"
before = [
  "bash scripts/e2e/build-mock-server.sh",
  "cargo build --release -p xberg-ffi",
  "ln -sf libxberg_ffi.dylib target/release/libxberg_jni.dylib 2>/dev/null || ln -sf libxberg_ffi.so target/release/libxberg_jni.so 2>/dev/null || true",
]
command = "cd packages/kotlin-android && gradle test --no-daemon"
e2e = "cd e2e/kotlin_android && gradle test --no-daemon"

[crates.test.swift]
precondition = "command -v swift >/dev/null 2>&1"
before = ["cargo build --release -p xberg-swift", "bash scripts/setup-swift-bridge.sh"]
command = "cd packages/swift && swift test"
e2e = "bash scripts/e2e/run-with-mock-server.sh bash -c 'cd e2e/swift_e2e && swift test'"

[crates.test.dart]
precondition = "command -v dart >/dev/null 2>&1"
before = """
{ command -v flutter_rust_bridge_codegen >/dev/null 2>&1 || cargo install flutter_rust_bridge_codegen --version 2.13.0; } && \
cd packages/dart && dart pub get && cd rust && \
{ \
  INPUT_HASH=$(printf '%s' "$(cat src/lib.rs flutter_rust_bridge.yaml)" | shasum | cut -d' ' -f1); \
  HASH_FILE=.frb_codegen_hash; \
  if [ -f "$HASH_FILE" ] && [ "$(cat "$HASH_FILE" 2>/dev/null)" = "$INPUT_HASH" ]; then \
    echo "FRB codegen skipped (inputs unchanged)"; \
  else \
    flutter_rust_bridge_codegen generate --config-file flutter_rust_bridge.yaml && \
    echo "$INPUT_HASH" > "$HASH_FILE"; \
  fi; \
} && cd ../../.. && cargo build --release -p xberg-dart && \
bash scripts/e2e/build-mock-server.sh
"""
command = "cd packages/dart && DYLD_FALLBACK_LIBRARY_PATH=$PWD/../../target/release LD_LIBRARY_PATH=$PWD/../../target/release FRB_DART_LOAD_EXTERNAL_LIBRARY_NATIVE_LIB_DIR=$PWD/../../target/release dart pub get && DYLD_FALLBACK_LIBRARY_PATH=$PWD/../../target/release LD_LIBRARY_PATH=$PWD/../../target/release FRB_DART_LOAD_EXTERNAL_LIBRARY_NATIVE_LIB_DIR=$PWD/../../target/release dart test"
e2e = "cd e2e/dart && for dir in docx html json pdf text xlsx images; do test -L $dir || ln -sf ../../test_documents/$dir $dir; done && DYLD_FALLBACK_LIBRARY_PATH=$PWD/../../target/release LD_LIBRARY_PATH=$PWD/../../target/release FRB_DART_LOAD_EXTERNAL_LIBRARY_NATIVE_LIB_DIR=$PWD/../../target/release dart pub get && DYLD_FALLBACK_LIBRARY_PATH=$PWD/../../target/release LD_LIBRARY_PATH=$PWD/../../target/release FRB_DART_LOAD_EXTERNAL_LIBRARY_NATIVE_LIB_DIR=$PWD/../../target/release dart test --concurrency=1"

[crates.test.zig]
precondition = "command -v zig >/dev/null 2>&1"
before = "bash scripts/e2e/build-mock-server.sh && cargo build --release -p xberg-ffi"
command = "cd packages/zig && zig build test -Dffi_path=$PWD/../../target/release -Dffi_include_path=$PWD/../../crates/xberg-ffi/include"
# Fixture dirs are symlinked in, as the dart leg does: the generated zig tests open
# fixtures by a path relative to e2e/zig ("html/html.html"), so without these the
# batch tests die with error.FileNotFound. ~keep
e2e = "cd e2e/zig && for dir in docx html json pdf text xlsx images; do test -L $dir || ln -sf ../../test_documents/$dir $dir; done && zig build test -Dffi_path=$PWD/../../target/release -Dffi_include_path=$PWD/../../crates/xberg-ffi/include"

[crates.publish]
core_crate = "crates/xberg"

[crates.publish.languages.ruby]
vendor_mode = "registry"

[crates.publish.languages.elixir]
vendor_mode = "registry"
nif_versions = ["2.16"]

[crates.publish.languages.dart]
# NOTE: resolve_binding_manifest does not yet resolve the Dart manifest path — the rewrite
vendor_mode = "registry"

[crates.publish.languages.ffi]
pkg_config = true
cmake_config = true

[crates.verify]
ignore_ephemeral = ["test_apps/**", ".codex/skills/**", ".agents/skills/**", ".github/skills/**", ".claude/skills/**"]

[crates.e2e]
fixtures = "fixtures"
output = "e2e"
languages = [
  "python",
  "rust",
  "node",
  "go",
  "ruby",
  "elixir",
  "wasm",
  "java",
  "csharp",
  "php",
  "dart",
  "kotlin_android",
  "swift",
  "zig",
  "homebrew",
]
fields_method_calls = [
  "results[0].metadata.format.excel",
  "metadata.format.excel",
  "results[0].metadata.format.html",
  "metadata.format.html",
]
fields_optional = [
  "results[0].metadata.format",
  "results[0].metadata.format.excel",
  "metadata.format.excel",
  "results[0].metadata.format.html",
  "metadata.format.html",
  "results[0].metadata.format.html.title",
  "metadata.format.html.title",
  "results[0].metadata.format.excel.sheet_count",
  "results[0].metadata.format.excel.sheet_names",
  "results[0].metadata.output_format",
  "results[0].elements",
  "results[0].document",
  "results[0].extracted_keywords",
  "results[0].quality_score",
  "results[0].summary",
  "metadata.format",
  "metadata.format.excel.sheet_count",
  "metadata.title",
  "metadata.subject",
  "metadata.authors",
  "metadata.keywords",
  "metadata.language",
  "metadata.created_at",
  "metadata.modified_at",
  "metadata.created_by",
  "metadata.modified_by",
  "metadata.output_format",
  "metadata.category",
  "metadata.tags",
  "metadata.document_version",
  "metadata.abstract_text",
  "chunks",
  "images",
  "pages",
  "elements",
  "djot_content",
  "ocr_elements",
  "document",
  "extraction_method",
  "detected_languages",
  "extracted_keywords",
  "quality_score",
  "annotations",
  "translation",
  "page_classifications",
  "redaction_report",
]
fields_array = [
  "results",
  "tables",
  "results[0].elements",
  "results[0].document.nodes",
  "results[0].extracted_keywords",
  "chunks",
  "images",
  "pages",
  "elements",
  "ocr_elements",
  "detected_languages",
  "extracted_keywords",
  "annotations",
  "processing_warnings",
  "metadata.sheet_names",
  "results[0].metadata.format.excel.sheet_names",
  "metadata.format.excel.sheet_names",
  "document.node_types",
]
fields_enum = ["results[0].summary.strategy"]
result_fields = [
  "results",
  "errors",
  "summary",
  "crawl_final_urls",
  "crawl_redirect_count",
  "crawl_unique_normalized_urls",
]


[crates.e2e.snippets]
output = "docs-site/src/snippets-generated"
mock_only = true
languages = [
  "python",
  "rust",
  "node",
  "go",
  "ruby",
  "elixir",
  "wasm",
  "java",
  "csharp",
  "php",
  "dart",
  "kotlin_android",
  "swift",
  "zig",
  "c",
]

[crates.e2e.call]
function = "extract"
module = "xberg"
result_var = "result"
async = true
returns_result = true
args = [
  { name = "input", field = "input", type = "json_object", owned = true, go_type = "ExtractInput", element_type = "ExtractInput" },
  { name = "config", field = "config", type = "json_object", optional = true },
]

[crates.e2e.call.overrides.rust]
crate_name = "xberg"
function = "extract"

[crates.e2e.call.overrides.python]
module = "xberg"
function = "extract"
options_type = "ExtractionConfig"

[crates.e2e.call.overrides.node]
module = "xberg"
function = "extract"
options_type = "ExtractionConfig"
result_enum_fields = { outputFormat = "OutputFormat", "metadata.format" = "FormatMetadata" }

[crates.e2e.call.overrides.go]
module = "github.com/xberg-io/xberg/packages/go"
function = "Extract"
alias = "xberg"
options_type = "ExtractionConfig"

[crates.e2e.call.overrides.java]
class = "io.xberg.Xberg"
function = "extract"
options_type = "ExtractionConfig"
enum_fields = { outputFormat = "OutputFormat" }

[crates.e2e.call.overrides.kotlin]
class = "Xberg"
function = "extract"
options_type = "ExtractionConfig"

[crates.e2e.call.overrides.csharp]
class = "XbergLib"
function = "Extract"
options_type = "ExtractionConfig"
nested_types = { model = "EmbeddingModelType", embedding = "EmbeddingConfig", keywords = "KeywordConfig", pages = "PageConfig", securityLimits = "SecurityLimits", treeSitter = "TreeSitterConfig" }

[crates.e2e.call.overrides.ruby]
options_type = "Xberg::ExtractionConfig"

[crates.e2e.call.overrides.elixir]
keyword_args = true

[crates.e2e.call.overrides.wasm]
options_type = "WasmExtractionConfig"
bigint_fields = ["cacheTtlSecs", "extractionTimeoutSecs"]

[crates.e2e.call.overrides.swift]
unnamed_arg_indices = [0, 1, 2]

# Must match the name the php binding emitter actually registers:
# crates/xberg-php/src/lib.rs declares `#[php(name = "Xberg\\XbergApi")]`. alef 0.82.1
# fixed the e2e class-override validator to ask the backend for its facade name
# instead of re-deriving it, so this value is now both accepted and correct; before
# that fix no value satisfied both sides and the php leg was red by construction. ~keep
[crates.e2e.call.overrides.php]
class = "Xberg\\XbergApi"
function = "extract"
options_type = "ExtractionConfig"

[crates.e2e.call.overrides.zig]
function = "extract"
result_is_json_struct = true

[crates.e2e.call.overrides.dart]
function = "extract"
options_type = "ExtractionConfig"

[crates.e2e.calls.extract]
function = "extract"
module = "xberg"
async = true
returns_result = true
streaming = false
args = [
  { name = "input", field = "input", type = "json_object", owned = true, go_type = "ExtractInput", element_type = "ExtractInput" },
  { name = "config", field = "config", type = "json_object", optional = true },
]

[crates.e2e.calls.extract.overrides.dart]
async = true
options_type = "ExtractionConfig"

[crates.e2e.calls.extract.overrides.swift]
unnamed_arg_indices = [0, 1]

[crates.e2e.calls.extract.overrides.zig]
function = "extract"
result_is_json_struct = true

[crates.e2e.calls.extract.overrides.csharp]
options_type = "ExtractionConfig"
options_via = "from_json"

[crates.e2e.calls.extract.overrides.python]
options_type = "ExtractionConfig"
options_via = "from_json"
from_json_module = "xberg._xberg"

[crates.e2e.calls.extract.overrides.node]
options_type = "ExtractionConfig"
enum_fields = { chunker_type = "ChunkerType" }

[crates.e2e.calls.list_supported_formats]
result_is_simple = true
result_is_array = true
function = "list_supported_formats"
module = "xberg"
async = false
returns_result = false
args = []

[crates.e2e.calls.extract_batch]
function = "extract_batch"
module = "xberg"
async = true
returns_result = true
args = [
  { name = "inputs", field = "input.inputs", type = "json_object", owned = true, go_type = "ExtractInput", element_type = "ExtractInput" },
  { name = "config", field = "config", type = "json_object", optional = true },
]

[crates.e2e.calls.extract_batch.overrides.node]
function = "extractBatch"
options_type = "ExtractionConfig"

[crates.e2e.calls.extract_batch.overrides.csharp]
options_type = "ExtractionConfig"

[crates.e2e.calls.extract_batch.overrides.java]
options_type = "ExtractionConfig"
enum_fields = { outputFormat = "OutputFormat" }

[crates.e2e.calls.extract_batch.overrides.python]
options_type = "ExtractionConfig"
options_via = "from_json"
from_json_module = "xberg._xberg"

[crates.e2e.calls.extract_batch.overrides.php]
function = "extractBatch"
options_type = "ExtractionConfig"

[crates.e2e.calls.extract_batch.overrides.swift]
options_type = "ExtractionConfig"

[crates.e2e.calls.extract_batch.overrides.wasm]
function = "extractBatch"
options_type = "WasmExtractionConfig"

[crates.e2e.calls.extract_batch.overrides.zig]
function = "extract_batch"
result_is_json_struct = true

[crates.e2e.calls.list_ocr_backends]
result_is_simple = true
function = "list_ocr_backends"
module = "xberg"
async = false
args = []

[crates.e2e.calls.list_ocr_backends.overrides.go]
result_is_simple = true
returns_result = true

[crates.e2e.calls.list_ocr_backends.overrides.dart]
function = "listOcrBackends"
module = "xberg"

[crates.e2e.calls.list_post_processors]
result_is_simple = true
function = "list_post_processors"
module = "xberg"
async = false
args = []

[crates.e2e.calls.list_post_processors.overrides.go]
result_is_simple = true
returns_result = true

[crates.e2e.calls.list_post_processors.overrides.dart]
function = "listPostProcessors"
module = "xberg"

[crates.e2e.calls.list_validators]
result_is_simple = true
function = "list_validators"
module = "xberg"
async = false
args = []

[crates.e2e.calls.list_validators.overrides.go]
result_is_simple = true
returns_result = true

[crates.e2e.calls.list_validators.overrides.dart]
function = "listValidators"
module = "xberg"

[crates.e2e.calls.list_embedding_backends]
result_is_simple = true
function = "list_embedding_backends"
module = "xberg"
async = false
args = []

[crates.e2e.calls.list_embedding_backends.overrides.go]
result_is_simple = true
returns_result = true

[crates.e2e.calls.list_embedding_backends.overrides.dart]
function = "listEmbeddingBackends"
module = "xberg"

[crates.e2e.calls.list_tokenizer_backends]
result_is_simple = true
function = "list_tokenizer_backends"
module = "xberg"
async = false
args = []

[crates.e2e.calls.list_tokenizer_backends.overrides.go]
result_is_simple = true
returns_result = true

[crates.e2e.calls.list_tokenizer_backends.overrides.dart]
function = "listTokenizerBackends"
module = "xberg"


[crates.e2e.calls.list_reranker_backends]
result_is_simple = true
function = "list_reranker_backends"
module = "xberg"
async = false
args = []

[crates.e2e.calls.list_reranker_backends.overrides.go]
result_is_simple = true
returns_result = true

[crates.e2e.calls.list_reranker_backends.overrides.dart]
function = "listRerankerBackends"
module = "xberg"

[crates.e2e.calls.list_renderers]
result_is_simple = true
function = "list_renderers"
module = "xberg"
async = false
args = []

[crates.e2e.calls.list_renderers.overrides.go]
result_is_simple = true
returns_result = true

[crates.e2e.calls.list_renderers.overrides.dart]
function = "listRenderers"
module = "xberg"

[crates.e2e.calls.clear_ocr_backends]
result_is_simple = true
function = "clear_ocr_backends"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.clear_ocr_backends.overrides.python]
function = "clear_ocr_backends"
module = "xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.rust]
function = "clear_ocr_backends"
module = "xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.node]
function = "clearOcrBackends"
module = "xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.go]
function = "ClearOCRBackends"

[crates.e2e.calls.clear_ocr_backends.overrides.ruby]
function = "clear_ocr_backends"
module = "Xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.php]
function = "clearOcrBackends"
module = "Xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.java]
function = "clearOcrBackends"

[crates.e2e.calls.clear_ocr_backends.overrides.csharp]
function = "ClearOcrBackends"
module = "Xberg"


[crates.e2e.calls.clear_ocr_backends.overrides.swift]
function = "clearOcrBackends"
module = "Xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.dart]
function = "clearOcrBackends"
module = "xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.wasm]
function = "clearOcrBackends"
module = "xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.elixir]
function = "clear_ocr_backends"
module = "Xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.zig]
function = "clear_ocr_backends"
module = "xberg"

[crates.e2e.calls.clear_ocr_backends.overrides.kotlin_android]
function = "clearAll"
class = "OcrBackendBridge"

[crates.e2e.calls.clear_post_processors]
result_is_simple = true
function = "clear_post_processors"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.clear_post_processors.overrides.python]
function = "clear_post_processors"
module = "xberg"

[crates.e2e.calls.clear_post_processors.overrides.rust]
function = "clear_post_processors"
module = "xberg"

[crates.e2e.calls.clear_post_processors.overrides.node]
function = "clearPostProcessors"
module = "xberg"

[crates.e2e.calls.clear_post_processors.overrides.go]
function = "ClearPostProcessors"

[crates.e2e.calls.clear_post_processors.overrides.ruby]
function = "clear_post_processors"
module = "Xberg"

[crates.e2e.calls.clear_post_processors.overrides.php]
function = "clearPostProcessors"
module = "Xberg"

[crates.e2e.calls.clear_post_processors.overrides.java]
function = "clearPostProcessors"

[crates.e2e.calls.clear_post_processors.overrides.csharp]
function = "ClearPostProcessors"
module = "Xberg"


[crates.e2e.calls.clear_post_processors.overrides.swift]
function = "clearPostProcessors"
module = "Xberg"

[crates.e2e.calls.clear_post_processors.overrides.dart]
function = "clearPostProcessors"
module = "xberg"

[crates.e2e.calls.clear_post_processors.overrides.wasm]
function = "clearPostProcessors"
module = "xberg"

[crates.e2e.calls.clear_post_processors.overrides.elixir]
function = "clear_post_processors"
module = "Xberg"

[crates.e2e.calls.clear_post_processors.overrides.zig]
function = "clear_post_processors"
module = "xberg"

[crates.e2e.calls.clear_post_processors.overrides.kotlin_android]
function = "clearAll"
class = "PostProcessorBridge"

[crates.e2e.calls.clear_validators]
result_is_simple = true
function = "clear_validators"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.clear_validators.overrides.python]
function = "clear_validators"
module = "xberg"

[crates.e2e.calls.clear_validators.overrides.rust]
function = "clear_validators"
module = "xberg"

[crates.e2e.calls.clear_validators.overrides.node]
function = "clearValidators"
module = "xberg"

[crates.e2e.calls.clear_validators.overrides.go]
function = "ClearValidators"

[crates.e2e.calls.clear_validators.overrides.ruby]
function = "clear_validators"
module = "Xberg"

[crates.e2e.calls.clear_validators.overrides.php]
function = "clearValidators"
module = "Xberg"

[crates.e2e.calls.clear_validators.overrides.java]
function = "clearValidators"

[crates.e2e.calls.clear_validators.overrides.csharp]
function = "ClearValidators"
module = "Xberg"


[crates.e2e.calls.clear_validators.overrides.swift]
function = "clearValidators"
module = "Xberg"

[crates.e2e.calls.clear_validators.overrides.dart]
function = "clearValidators"
module = "xberg"

[crates.e2e.calls.clear_validators.overrides.wasm]
function = "clearValidators"
module = "xberg"

[crates.e2e.calls.clear_validators.overrides.elixir]
function = "clear_validators"
module = "Xberg"

[crates.e2e.calls.clear_validators.overrides.zig]
function = "clear_validators"
module = "xberg"

[crates.e2e.calls.clear_validators.overrides.kotlin_android]
function = "clearAll"
class = "ValidatorBridge"

[crates.e2e.calls.unregister_ocr_backend]
result_is_simple = true
function = "unregister_ocr_backend"
module = ""
async = false
returns_result = false
returns_void = true
args = [{ name = "name", field = "input.name", type = "string" }]

[crates.e2e.calls.unregister_ocr_backend.overrides.python]
function = "unregister_ocr_backend"
module = "xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.rust]
function = "unregister_ocr_backend"
module = "xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.node]
function = "unregisterOcrBackend"
module = "xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.go]
function = "UnregisterOCRBackend"

[crates.e2e.calls.unregister_ocr_backend.overrides.ruby]
function = "unregister_ocr_backend"
module = "Xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.php]
function = "unregisterOcrBackend"
module = "Xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.java]
function = "unregisterOcrBackend"

[crates.e2e.calls.unregister_ocr_backend.overrides.csharp]
function = "UnregisterOcrBackend"
module = "Xberg"


[crates.e2e.calls.unregister_ocr_backend.overrides.swift]
function = "unregisterOcrBackend"
module = "Xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.dart]
function = "unregisterOcrBackend"
module = "xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.wasm]
function = "unregisterOcrBackend"
module = "xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.elixir]
function = "unregister_ocr_backend"
module = "Xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.zig]
function = "unregister_ocr_backend"
module = "xberg"

[crates.e2e.calls.unregister_ocr_backend.overrides.kotlin_android]
function = "unregister"
class = "OcrBackendBridge"

[crates.e2e.calls.unregister_post_processor]
result_is_simple = true
function = "unregister_post_processor"
module = ""
async = false
returns_result = false
returns_void = true
args = [{ name = "name", field = "input.name", type = "string" }]

[crates.e2e.calls.unregister_post_processor.overrides.python]
function = "unregister_post_processor"
module = "xberg"

[crates.e2e.calls.unregister_post_processor.overrides.rust]
function = "unregister_post_processor"
module = "xberg"

[crates.e2e.calls.unregister_post_processor.overrides.node]
function = "unregisterPostProcessor"
module = "xberg"

[crates.e2e.calls.unregister_post_processor.overrides.go]
function = "UnregisterPostProcessor"

[crates.e2e.calls.unregister_post_processor.overrides.ruby]
function = "unregister_post_processor"
module = "Xberg"

[crates.e2e.calls.unregister_post_processor.overrides.php]
function = "unregisterPostProcessor"
module = "Xberg"

[crates.e2e.calls.unregister_post_processor.overrides.java]
function = "unregisterPostProcessor"

[crates.e2e.calls.unregister_post_processor.overrides.csharp]
function = "UnregisterPostProcessor"
module = "Xberg"


[crates.e2e.calls.unregister_post_processor.overrides.swift]
function = "unregisterPostProcessor"
module = "Xberg"

[crates.e2e.calls.unregister_post_processor.overrides.dart]
function = "unregisterPostProcessor"
module = "xberg"

[crates.e2e.calls.unregister_post_processor.overrides.wasm]
function = "unregisterPostProcessor"
module = "xberg"

[crates.e2e.calls.unregister_post_processor.overrides.elixir]
function = "unregister_post_processor"
module = "Xberg"

[crates.e2e.calls.unregister_post_processor.overrides.zig]
function = "unregister_post_processor"
module = "xberg"

[crates.e2e.calls.unregister_post_processor.overrides.kotlin_android]
function = "unregister"
class = "PostProcessorBridge"

[crates.e2e.calls.unregister_validator]
result_is_simple = true
function = "unregister_validator"
module = ""
async = false
returns_result = false
returns_void = true
args = [{ name = "name", field = "input.name", type = "string" }]

[crates.e2e.calls.unregister_validator.overrides.python]
function = "unregister_validator"
module = "xberg"

[crates.e2e.calls.unregister_validator.overrides.rust]
function = "unregister_validator"
module = "xberg"

[crates.e2e.calls.unregister_validator.overrides.node]
function = "unregisterValidator"
module = "xberg"

[crates.e2e.calls.unregister_validator.overrides.go]
function = "UnregisterValidator"

[crates.e2e.calls.unregister_validator.overrides.ruby]
function = "unregister_validator"
module = "Xberg"

[crates.e2e.calls.unregister_validator.overrides.php]
function = "unregisterValidator"
module = "Xberg"

[crates.e2e.calls.unregister_validator.overrides.java]
function = "unregisterValidator"

[crates.e2e.calls.unregister_validator.overrides.csharp]
function = "UnregisterValidator"
module = "Xberg"


[crates.e2e.calls.unregister_validator.overrides.swift]
function = "unregisterValidator"
module = "Xberg"

[crates.e2e.calls.unregister_validator.overrides.dart]
function = "unregisterValidator"
module = "xberg"

[crates.e2e.calls.unregister_validator.overrides.wasm]
function = "unregisterValidator"
module = "xberg"

[crates.e2e.calls.unregister_validator.overrides.elixir]
function = "unregister_validator"
module = "Xberg"

[crates.e2e.calls.unregister_validator.overrides.zig]
function = "unregister_validator"
module = "xberg"

[crates.e2e.calls.unregister_validator.overrides.kotlin_android]
function = "unregister"
class = "ValidatorBridge"

[crates.e2e.calls.register_ocr_backend]
result_is_simple = true
function = "register_ocr_backend"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.register_ocr_backend.overrides.python]
function = "register_ocr_backend"
module = "xberg"

[crates.e2e.calls.register_ocr_backend.overrides.rust]
function = "register_ocr_backend"
module = "xberg"

[crates.e2e.calls.register_ocr_backend.overrides.node]
function = "registerOcrBackend"
module = "xberg"

[crates.e2e.calls.register_ocr_backend.overrides.go]
function = "RegisterOCRBackend"

[crates.e2e.calls.register_ocr_backend.overrides.ruby]
function = "register_ocr_backend"
module = "Xberg"

[crates.e2e.calls.register_ocr_backend.overrides.php]
function = "registerOcrBackend"
module = "Xberg"

[crates.e2e.calls.register_ocr_backend.overrides.java]
function = "registerOcrBackend"

[crates.e2e.calls.register_ocr_backend.overrides.csharp]
function = "RegisterOcrBackend"
module = "Xberg"


[crates.e2e.calls.register_ocr_backend.overrides.swift]
function = "registerOcrBackend"
module = "Xberg"

[crates.e2e.calls.register_ocr_backend.overrides.dart]
function = "registerOcrBackend"
module = "xberg"

[crates.e2e.calls.register_ocr_backend.overrides.wasm]
function = "registerOcrBackend"
module = "xberg"

[crates.e2e.calls.register_ocr_backend.overrides.elixir]
function = "register_ocr_backend"
module = "Xberg"

[crates.e2e.calls.register_ocr_backend.overrides.zig]
function = "register_ocr_backend"
module = "xberg"
returns_result = false

[crates.e2e.calls.register_ocr_backend.overrides.kotlin_android]
function = "register"
class = "OcrBackendBridge"

[crates.e2e.calls.register_post_processor]
result_is_simple = true
function = "register_post_processor"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.register_post_processor.overrides.python]
function = "register_post_processor"
module = "xberg"

[crates.e2e.calls.register_post_processor.overrides.rust]
function = "register_post_processor"
module = "xberg"

[crates.e2e.calls.register_post_processor.overrides.node]
function = "registerPostProcessor"
module = "xberg"

[crates.e2e.calls.register_post_processor.overrides.go]
function = "RegisterPostProcessor"

[crates.e2e.calls.register_post_processor.overrides.ruby]
function = "register_post_processor"
module = "Xberg"

[crates.e2e.calls.register_post_processor.overrides.php]
function = "registerPostProcessor"
module = "Xberg"

[crates.e2e.calls.register_post_processor.overrides.java]
function = "registerPostProcessor"

[crates.e2e.calls.register_post_processor.overrides.csharp]
function = "RegisterPostProcessor"
module = "Xberg"


[crates.e2e.calls.register_post_processor.overrides.swift]
function = "registerPostProcessor"
module = "Xberg"

[crates.e2e.calls.register_post_processor.overrides.dart]
function = "registerPostProcessor"
module = "xberg"

[crates.e2e.calls.register_post_processor.overrides.wasm]
function = "registerPostProcessor"
module = "xberg"

[crates.e2e.calls.register_post_processor.overrides.elixir]
function = "register_post_processor"
module = "Xberg"

[crates.e2e.calls.register_post_processor.overrides.zig]
function = "register_post_processor"
module = "xberg"
returns_result = false

[crates.e2e.calls.register_post_processor.overrides.kotlin_android]
function = "register"
class = "PostProcessorBridge"

[crates.e2e.calls.register_validator]
result_is_simple = true
function = "register_validator"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.register_validator.overrides.python]
function = "register_validator"
module = "xberg"

[crates.e2e.calls.register_validator.overrides.rust]
function = "register_validator"
module = "xberg"

[crates.e2e.calls.register_validator.overrides.node]
function = "registerValidator"
module = "xberg"

[crates.e2e.calls.register_validator.overrides.go]
function = "RegisterValidator"

[crates.e2e.calls.register_validator.overrides.ruby]
function = "register_validator"
module = "Xberg"

[crates.e2e.calls.register_validator.overrides.php]
function = "registerValidator"
module = "Xberg"

[crates.e2e.calls.register_validator.overrides.java]
function = "registerValidator"

[crates.e2e.calls.register_validator.overrides.csharp]
function = "RegisterValidator"
module = "Xberg"


[crates.e2e.calls.register_validator.overrides.swift]
function = "registerValidator"
module = "Xberg"

[crates.e2e.calls.register_validator.overrides.dart]
function = "registerValidator"
module = "xberg"

[crates.e2e.calls.register_validator.overrides.wasm]
function = "registerValidator"
module = "xberg"

[crates.e2e.calls.register_validator.overrides.elixir]
function = "register_validator"
module = "Xberg"

[crates.e2e.calls.register_validator.overrides.zig]
function = "register_validator"
module = "xberg"
returns_result = false

[crates.e2e.calls.register_validator.overrides.kotlin_android]
function = "register"
class = "ValidatorBridge"

[crates.e2e.calls.register_embedding_backend]
result_is_simple = true
function = "register_embedding_backend"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.register_embedding_backend.overrides.python]
function = "register_embedding_backend"
module = "xberg"

[crates.e2e.calls.register_embedding_backend.overrides.rust]
function = "register_embedding_backend"
module = "xberg"

[crates.e2e.calls.register_embedding_backend.overrides.node]
function = "registerEmbeddingBackend"
module = "xberg"

[crates.e2e.calls.register_embedding_backend.overrides.go]
function = "RegisterEmbeddingBackend"

[crates.e2e.calls.register_embedding_backend.overrides.ruby]
function = "register_embedding_backend"
module = "Xberg"

[crates.e2e.calls.register_embedding_backend.overrides.php]
function = "registerEmbeddingBackend"
module = "Xberg"

[crates.e2e.calls.register_embedding_backend.overrides.java]
function = "registerEmbeddingBackend"

[crates.e2e.calls.register_embedding_backend.overrides.csharp]
function = "RegisterEmbeddingBackend"
module = "Xberg"


[crates.e2e.calls.register_embedding_backend.overrides.swift]
function = "registerEmbeddingBackend"
module = "Xberg"

[crates.e2e.calls.register_embedding_backend.overrides.dart]
function = "registerEmbeddingBackend"
module = "xberg"

[crates.e2e.calls.register_embedding_backend.overrides.wasm]
function = "registerEmbeddingBackend"
module = "xberg"

[crates.e2e.calls.register_embedding_backend.overrides.elixir]
function = "register_embedding_backend"
module = "Xberg"

[crates.e2e.calls.register_embedding_backend.overrides.zig]
function = "register_embedding_backend"
module = "xberg"
returns_result = false

[crates.e2e.calls.register_embedding_backend.overrides.kotlin_android]
function = "register"
class = "EmbeddingBackendBridge"

[crates.e2e.calls.unregister_embedding_backend]
result_is_simple = true
function = "unregister_embedding_backend"
module = ""
async = false
returns_result = false
returns_void = true
args = [{ name = "name", field = "input.name", type = "string" }]

[crates.e2e.calls.unregister_embedding_backend.overrides.python]
function = "unregister_embedding_backend"
module = "xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.rust]
function = "unregister_embedding_backend"
module = "xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.node]
function = "unregisterEmbeddingBackend"
module = "xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.go]
function = "UnregisterEmbeddingBackend"

[crates.e2e.calls.unregister_embedding_backend.overrides.ruby]
function = "unregister_embedding_backend"
module = "Xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.php]
function = "unregisterEmbeddingBackend"
module = "Xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.java]
function = "unregisterEmbeddingBackend"

[crates.e2e.calls.unregister_embedding_backend.overrides.csharp]
function = "UnregisterEmbeddingBackend"
module = "Xberg"


[crates.e2e.calls.unregister_embedding_backend.overrides.swift]
function = "unregisterEmbeddingBackend"
module = "Xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.dart]
function = "unregisterEmbeddingBackend"
module = "xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.wasm]
function = "unregisterEmbeddingBackend"
module = "xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.elixir]
function = "unregister_embedding_backend"
module = "Xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.zig]
function = "unregister_embedding_backend"
module = "xberg"

[crates.e2e.calls.unregister_embedding_backend.overrides.kotlin_android]
function = "unregister"
class = "EmbeddingBackendBridge"

[crates.e2e.calls.clear_embedding_backends]
result_is_simple = true
function = "clear_embedding_backends"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.clear_embedding_backends.overrides.python]
function = "clear_embedding_backends"
module = "xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.rust]
function = "clear_embedding_backends"
module = "xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.node]
function = "clearEmbeddingBackends"
module = "xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.go]
function = "ClearEmbeddingBackends"

[crates.e2e.calls.clear_embedding_backends.overrides.ruby]
function = "clear_embedding_backends"
module = "Xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.php]
function = "clearEmbeddingBackends"
module = "Xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.java]
function = "clearEmbeddingBackends"

[crates.e2e.calls.clear_embedding_backends.overrides.csharp]
function = "ClearEmbeddingBackends"
module = "Xberg"


[crates.e2e.calls.clear_embedding_backends.overrides.swift]
function = "clearEmbeddingBackends"
module = "Xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.dart]
function = "clearEmbeddingBackends"
module = "xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.wasm]
function = "clearEmbeddingBackends"
module = "xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.elixir]
function = "clear_embedding_backends"
module = "Xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.zig]
function = "clear_embedding_backends"
module = "xberg"

[crates.e2e.calls.clear_embedding_backends.overrides.kotlin_android]
function = "clearAll"
class = "EmbeddingBackendBridge"


[crates.e2e.calls.register_reranker_backend]
result_is_simple = true
function = "register_reranker_backend"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.register_reranker_backend.overrides.python]
function = "register_reranker_backend"
module = "xberg"

[crates.e2e.calls.register_reranker_backend.overrides.rust]
function = "register_reranker_backend"
module = "xberg"

[crates.e2e.calls.register_reranker_backend.overrides.node]
function = "registerRerankerBackend"
module = "xberg"

[crates.e2e.calls.register_reranker_backend.overrides.go]
function = "RegisterRerankerBackend"

[crates.e2e.calls.register_reranker_backend.overrides.ruby]
function = "register_reranker_backend"
module = "Xberg"

[crates.e2e.calls.register_reranker_backend.overrides.php]
function = "registerRerankerBackend"
module = "Xberg"

[crates.e2e.calls.register_reranker_backend.overrides.java]
function = "registerRerankerBackend"

[crates.e2e.calls.register_reranker_backend.overrides.csharp]
function = "RegisterRerankerBackend"
module = "Xberg"


[crates.e2e.calls.register_reranker_backend.overrides.swift]
function = "registerRerankerBackend"
module = "Xberg"

[crates.e2e.calls.register_reranker_backend.overrides.dart]
function = "registerRerankerBackend"
module = "xberg"

[crates.e2e.calls.register_reranker_backend.overrides.wasm]
function = "registerRerankerBackend"
module = "xberg"

[crates.e2e.calls.register_reranker_backend.overrides.elixir]
function = "register_reranker_backend"
module = "Xberg"

[crates.e2e.calls.register_reranker_backend.overrides.zig]
function = "register_reranker_backend"
module = "xberg"
returns_result = false

[crates.e2e.calls.register_reranker_backend.overrides.kotlin_android]
function = "register"
class = "RerankerBackendBridge"

[crates.e2e.calls.unregister_reranker_backend]
result_is_simple = true
function = "unregister_reranker_backend"
module = ""
async = false
returns_result = false
returns_void = true
args = [{ name = "name", field = "input.name", type = "string" }]

[crates.e2e.calls.unregister_reranker_backend.overrides.python]
function = "unregister_reranker_backend"
module = "xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.rust]
function = "unregister_reranker_backend"
module = "xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.node]
function = "unregisterRerankerBackend"
module = "xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.go]
function = "UnregisterRerankerBackend"

[crates.e2e.calls.unregister_reranker_backend.overrides.ruby]
function = "unregister_reranker_backend"
module = "Xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.php]
function = "unregisterRerankerBackend"
module = "Xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.java]
function = "unregisterRerankerBackend"

[crates.e2e.calls.unregister_reranker_backend.overrides.csharp]
function = "UnregisterRerankerBackend"
module = "Xberg"


[crates.e2e.calls.unregister_reranker_backend.overrides.swift]
function = "unregisterRerankerBackend"
module = "Xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.dart]
function = "unregisterRerankerBackend"
module = "xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.wasm]
function = "unregisterRerankerBackend"
module = "xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.elixir]
function = "unregister_reranker_backend"
module = "Xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.zig]
function = "unregister_reranker_backend"
module = "xberg"

[crates.e2e.calls.unregister_reranker_backend.overrides.kotlin_android]
function = "unregister"
class = "RerankerBackendBridge"

[crates.e2e.calls.clear_reranker_backends]
result_is_simple = true
function = "clear_reranker_backends"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.clear_reranker_backends.overrides.python]
function = "clear_reranker_backends"
module = "xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.rust]
function = "clear_reranker_backends"
module = "xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.node]
function = "clearRerankerBackends"
module = "xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.go]
function = "ClearRerankerBackends"

[crates.e2e.calls.clear_reranker_backends.overrides.ruby]
function = "clear_reranker_backends"
module = "Xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.php]
function = "clearRerankerBackends"
module = "Xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.java]
function = "clearRerankerBackends"

[crates.e2e.calls.clear_reranker_backends.overrides.csharp]
function = "ClearRerankerBackends"
module = "Xberg"


[crates.e2e.calls.clear_reranker_backends.overrides.swift]
function = "clearRerankerBackends"
module = "Xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.dart]
function = "clearRerankerBackends"
module = "xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.wasm]
function = "clearRerankerBackends"
module = "xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.elixir]
function = "clear_reranker_backends"
module = "Xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.zig]
function = "clear_reranker_backends"
module = "xberg"

[crates.e2e.calls.clear_reranker_backends.overrides.kotlin_android]
function = "clearAll"
class = "RerankerBackendBridge"


[crates.e2e.calls.register_tokenizer_backend]
result_is_simple = true
function = "register_tokenizer_backend"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.register_tokenizer_backend.overrides.python]
function = "register_tokenizer_backend"
module = "xberg"

[crates.e2e.calls.register_tokenizer_backend.overrides.rust]
function = "register_tokenizer_backend"
module = "xberg"

[crates.e2e.calls.register_tokenizer_backend.overrides.node]
function = "registerTokenizerBackend"
module = "xberg"

[crates.e2e.calls.register_tokenizer_backend.overrides.go]
function = "RegisterTokenizerBackend"

[crates.e2e.calls.register_tokenizer_backend.overrides.ruby]
function = "register_tokenizer_backend"
module = "Xberg"

[crates.e2e.calls.register_tokenizer_backend.overrides.php]
function = "registerTokenizerBackend"
module = "Xberg"

[crates.e2e.calls.register_tokenizer_backend.overrides.java]
function = "registerTokenizerBackend"

[crates.e2e.calls.register_tokenizer_backend.overrides.csharp]
function = "RegisterTokenizerBackend"
module = "Xberg"


[crates.e2e.calls.register_tokenizer_backend.overrides.swift]
function = "registerTokenizerBackend"
module = "Xberg"

[crates.e2e.calls.register_tokenizer_backend.overrides.dart]
function = "registerTokenizerBackend"
module = "xberg"

[crates.e2e.calls.register_tokenizer_backend.overrides.wasm]
function = "registerTokenizerBackend"
module = "xberg"

[crates.e2e.calls.register_tokenizer_backend.overrides.elixir]
function = "register_tokenizer_backend"
module = "Xberg"

[crates.e2e.calls.register_tokenizer_backend.overrides.zig]
function = "register_tokenizer_backend"
module = "xberg"
returns_result = false

[crates.e2e.calls.register_tokenizer_backend.overrides.kotlin_android]
function = "register"
class = "TokenizerBackendBridge"

[crates.e2e.calls.unregister_tokenizer_backend]
result_is_simple = true
function = "unregister_tokenizer_backend"
module = ""
async = false
returns_result = false
returns_void = true
args = [{ name = "name", field = "input.name", type = "string" }]

[crates.e2e.calls.unregister_tokenizer_backend.overrides.python]
function = "unregister_tokenizer_backend"
module = "xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.rust]
function = "unregister_tokenizer_backend"
module = "xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.node]
function = "unregisterTokenizerBackend"
module = "xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.go]
function = "UnregisterTokenizerBackend"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.ruby]
function = "unregister_tokenizer_backend"
module = "Xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.php]
function = "unregisterTokenizerBackend"
module = "Xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.java]
function = "unregisterTokenizerBackend"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.csharp]
function = "UnregisterTokenizerBackend"
module = "Xberg"


[crates.e2e.calls.unregister_tokenizer_backend.overrides.swift]
function = "unregisterTokenizerBackend"
module = "Xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.dart]
function = "unregisterTokenizerBackend"
module = "xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.wasm]
function = "unregisterTokenizerBackend"
module = "xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.elixir]
function = "unregister_tokenizer_backend"
module = "Xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.zig]
function = "unregister_tokenizer_backend"
module = "xberg"

[crates.e2e.calls.unregister_tokenizer_backend.overrides.kotlin_android]
function = "unregister"
class = "TokenizerBackendBridge"

[crates.e2e.calls.clear_tokenizer_backends]
result_is_simple = true
function = "clear_tokenizer_backends"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.clear_tokenizer_backends.overrides.python]
function = "clear_tokenizer_backends"
module = "xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.rust]
function = "clear_tokenizer_backends"
module = "xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.node]
function = "clearTokenizerBackends"
module = "xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.go]
function = "ClearTokenizerBackends"

[crates.e2e.calls.clear_tokenizer_backends.overrides.ruby]
function = "clear_tokenizer_backends"
module = "Xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.php]
function = "clearTokenizerBackends"
module = "Xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.java]
function = "clearTokenizerBackends"

[crates.e2e.calls.clear_tokenizer_backends.overrides.csharp]
function = "ClearTokenizerBackends"
module = "Xberg"


[crates.e2e.calls.clear_tokenizer_backends.overrides.swift]
function = "clearTokenizerBackends"
module = "Xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.dart]
function = "clearTokenizerBackends"
module = "xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.wasm]
function = "clearTokenizerBackends"
module = "xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.elixir]
function = "clear_tokenizer_backends"
module = "Xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.zig]
function = "clear_tokenizer_backends"
module = "xberg"

[crates.e2e.calls.clear_tokenizer_backends.overrides.kotlin_android]
function = "clearAll"
class = "TokenizerBackendBridge"

[crates.e2e.calls.register_renderer]
result_is_simple = true
function = "register_renderer"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.register_renderer.overrides.python]
function = "register_renderer"
module = "xberg"

[crates.e2e.calls.register_renderer.overrides.rust]
function = "register_renderer"
module = "xberg"

[crates.e2e.calls.register_renderer.overrides.node]
function = "registerRenderer"
module = "xberg"

[crates.e2e.calls.register_renderer.overrides.go]
function = "RegisterRenderer"

[crates.e2e.calls.register_renderer.overrides.ruby]
function = "register_renderer"
module = "Xberg"

[crates.e2e.calls.register_renderer.overrides.php]
function = "registerRenderer"
module = "Xberg"

[crates.e2e.calls.register_renderer.overrides.java]
function = "registerRenderer"

[crates.e2e.calls.register_renderer.overrides.csharp]
function = "RegisterRenderer"
module = "Xberg"


[crates.e2e.calls.register_renderer.overrides.swift]
function = "registerRenderer"
module = "Xberg"

[crates.e2e.calls.register_renderer.overrides.dart]
function = "registerRenderer"
module = "xberg"

[crates.e2e.calls.register_renderer.overrides.wasm]
function = "registerRenderer"
module = "xberg"

[crates.e2e.calls.register_renderer.overrides.elixir]
function = "register_renderer"
module = "Xberg"

[crates.e2e.calls.register_renderer.overrides.zig]
function = "register_renderer"
module = "xberg"
returns_result = false

[crates.e2e.calls.register_renderer.overrides.kotlin_android]
function = "register"
class = "RendererBridge"

[crates.e2e.calls.unregister_renderer]
result_is_simple = true
function = "unregister_renderer"
module = ""
async = false
returns_result = false
returns_void = true
args = [{ name = "name", field = "input.name", type = "string" }]

[crates.e2e.calls.unregister_renderer.overrides.python]
function = "unregister_renderer"
module = "xberg"

[crates.e2e.calls.unregister_renderer.overrides.rust]
function = "unregister_renderer"
module = "xberg"

[crates.e2e.calls.unregister_renderer.overrides.node]
function = "unregisterRenderer"
module = "xberg"

[crates.e2e.calls.unregister_renderer.overrides.go]
function = "UnregisterRenderer"

[crates.e2e.calls.unregister_renderer.overrides.ruby]
function = "unregister_renderer"
module = "Xberg"

[crates.e2e.calls.unregister_renderer.overrides.php]
function = "unregisterRenderer"
module = "Xberg"

[crates.e2e.calls.unregister_renderer.overrides.java]
function = "unregisterRenderer"

[crates.e2e.calls.unregister_renderer.overrides.csharp]
function = "UnregisterRenderer"
module = "Xberg"


[crates.e2e.calls.unregister_renderer.overrides.swift]
function = "unregisterRenderer"
module = "Xberg"

[crates.e2e.calls.unregister_renderer.overrides.dart]
function = "unregisterRenderer"
module = "xberg"

[crates.e2e.calls.unregister_renderer.overrides.wasm]
function = "unregisterRenderer"
module = "xberg"

[crates.e2e.calls.unregister_renderer.overrides.elixir]
function = "unregister_renderer"
module = "Xberg"

[crates.e2e.calls.unregister_renderer.overrides.zig]
function = "unregister_renderer"
module = "xberg"

[crates.e2e.calls.unregister_renderer.overrides.kotlin_android]
function = "unregister"
class = "RendererBridge"

[crates.e2e.calls.clear_renderers]
result_is_simple = true
function = "clear_renderers"
module = ""
async = false
returns_result = false
returns_void = true
args = []

[crates.e2e.calls.clear_renderers.overrides.python]
function = "clear_renderers"
module = "xberg"

[crates.e2e.calls.clear_renderers.overrides.rust]
function = "clear_renderers"
module = "xberg"

[crates.e2e.calls.clear_renderers.overrides.node]
function = "clearRenderers"
module = "xberg"

[crates.e2e.calls.clear_renderers.overrides.go]
function = "ClearRenderers"

[crates.e2e.calls.clear_renderers.overrides.ruby]
function = "clear_renderers"
module = "Xberg"

[crates.e2e.calls.clear_renderers.overrides.php]
function = "clearRenderers"
module = "Xberg"

[crates.e2e.calls.clear_renderers.overrides.java]
function = "clearRenderers"

[crates.e2e.calls.clear_renderers.overrides.csharp]
function = "ClearRenderers"
module = "Xberg"


[crates.e2e.calls.clear_renderers.overrides.swift]
function = "clearRenderers"
module = "Xberg"

[crates.e2e.calls.clear_renderers.overrides.dart]
function = "clearRenderers"
module = "xberg"

[crates.e2e.calls.clear_renderers.overrides.wasm]
function = "clearRenderers"
module = "xberg"

[crates.e2e.calls.clear_renderers.overrides.elixir]
function = "clear_renderers"
module = "Xberg"

[crates.e2e.calls.clear_renderers.overrides.zig]
function = "clear_renderers"
module = "xberg"

[crates.e2e.calls.clear_renderers.overrides.kotlin_android]
function = "clearAll"
class = "RendererBridge"

[crates.e2e.calls.list_supported_formats.overrides.python]
function = "list_supported_formats"

[crates.e2e.packages.rust]
path = "../../crates/xberg"

[crates.e2e.packages.python]
name = "xberg"
path = "../../packages/python"

[crates.e2e.packages.node]
name = "@xberg-io/xberg"
path = "../../crates/xberg-node"

[crates.e2e.packages.go]
module = "github.com/xberg-io/xberg/packages/go"
path = "../../packages/go"

[crates.e2e.packages.csharp]
name = "Xberg"
path = "../../packages/csharp/Xberg/Xberg.csproj"

[crates.e2e.packages.java]
module = "io.xberg"
path = "../../packages/java"

[crates.e2e.packages.ruby]
name = "xberg"
path = "../../packages/ruby"

[crates.e2e.packages.elixir]
module = "Xberg"
path = "../../packages/elixir"

[crates.e2e.packages.php]
name = "xberg-io/xberg"
path = "../../packages/php"

[crates.e2e.packages.dart]
path = "../../packages/dart"

[crates.e2e.packages.kotlin_android]
module = "io.xberg"
path = "../../packages/kotlin-android"

[crates.e2e.packages.swift]
path = "../../packages/swift"

[crates.e2e.packages.zig]
path = "../../packages/zig"

[crates.e2e.registry.packages.zig]
hash = "xberg-v1.1.0-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"

[crates.e2e.packages.wasm]
name = "@xberg-io/xberg-wasm"
path = "../../crates/xberg-wasm/pkg/nodejs"

[crates.e2e.env]
CRAWLBERG_ALLOW_PRIVATE_NETWORK = "true"

[crates.e2e.format]
python = "uv run --no-sync ruff check --fix {dir} && uv run --no-sync ruff format {dir}"
go = "gofmt -w {dir}"
rust = "(cd {dir} && cargo fmt --all)"

[crates.e2e.extra_system_libs]
zig = ["heif"]

[crates.e2e.fields]
chunks_have_content = "chunks_have_content"

[crates.e2e.fields_c_types]
"extraction_result.metadata" = "Metadata"

[crates.e2e.registry]
output = "test_apps"
github_repo = "https://github.com/xberg-io/xberg"

[crates.scaffold]
description = "High-performance document intelligence library"
license = "MIT"
repository = "https://github.com/xberg-io/xberg"
homepage = "https://xberg.io"
authors = ["Na'aman Hirschfeld <naaman@xberg.io>"]
keywords = ["document", "extraction", "pdf", "ocr", "text"]

[crates.scaffold.cargo]

[crates.scaffold.cargo.env]
CFLAGS_x86_64_pc_windows_msvc = "/MD"
CXXFLAGS_x86_64_pc_windows_msvc = "/MD"
CFLAGS_i686_pc_windows_msvc = "/MD"
CXXFLAGS_i686_pc_windows_msvc = "/MD"

[crates.readme]
template_dir = "templates/readme"
snippets_dir = "docs-site/src/snippets"
output_pattern = "packages/{language}/README.md"
discord_url = "https://discord.gg/xt9WY3GnKR"
banner_url = "https://github.com/user-attachments/assets/419fc06c-8313-4324-b159-4b4d3cfce5c0"

[crates.readme.targets.root]
template = "root.md"
name = "Xberg"
output_path = "README.md"

[crates.readme.targets.cli]
template = "cli.md"
name = "xberg-cli"
output_path = "crates/xberg-cli/README.md"

[crates.readme.languages.rust]
template = "rust.md"
output_path = "crates/xberg/README.md"
name = "Rust"
package_name = "xberg"
badge_url = "https://img.shields.io/crates/v/xberg?label=Rust&color=007ec6"
docs_url = "https://xberg.io/"
description = "High-performance document intelligence library for Rust. Extract text, tables, metadata, and code intelligence from 107 file formats and 371 programming languages."
package_manager = ["cargo"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["system_requirements", "ocr_backends"]
snippets = { basic_extraction = "getting-started/basic_usage.md", async_extraction = "api/extract.md", batch_processing = "getting-started/extract_with_ocr.md", ocr_configuration = "ocr/ocr_extraction.md", table_extraction = "metadata/tables.md" }

[crates.readme.languages.python]
template = "python.md"
name = "Python"
package_name = "xberg"
badge_url = "https://img.shields.io/pypi/v/xberg?label=Python&color=007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Native Python bindings with async/await support, multiple OCR backends (Tesseract, PaddleOCR, Sceptre), and extensible plugin system."
package_manager = ["pip"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["async_vs_sync_performance", "ocr_backends", "system_requirements"]
snippets = { basic_extraction = "getting-started/basic_usage.md", async_extraction = "api/extract.md", batch_processing = "getting-started/extract_with_ocr.md", ocr_configuration = "getting-started/hello_world.md", table_extraction = "getting-started/read_content.md" }

[crates.readme.languages.typescript]
template = "language_package.md"
output_path = "crates/xberg-node/README.md"
name = "TypeScript (Node.js)"
package_name = "@xberg-io/xberg"
badge_url = "https://img.shields.io/npm/v/@xberg-io/xberg?label=TypeScript&color=007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Native NAPI-RS bindings for Node.js with superior performance, async/await support, and TypeScript type definitions."
package_manager = ["pnpm"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, config_discovery = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["native_vs_wasm_comparison", "ocr_support", "performance", "napi_implementation"]
snippets = { basic_extraction = "getting-started/basic_usage.md", async_extraction = "api/client_extract_single_file.md", batch_processing = "api/extract_batch.md", ocr_configuration = "config/config_ocr.md", table_extraction = "api/tables.md", config_discovery = "config/config_discovery.md" }

[crates.readme.languages.go]
template = "go.md"
output_path = "packages/go/README.md"
name = "Go"
package_name = "github.com/xberg-io/xberg/packages/go"
badge_url = "https://img.shields.io/github/v/tag/xberg-io/xberg?label=Go&color=007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Go bindings with context-aware async support, idiomatic Go API, and CGO-based native performance."
package_manager = ["go get"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["system_requirements", "ffi_build_instructions"]
snippets = { basic_extraction = "getting-started/basic_usage.md", async_extraction = "api/extract.md", batch_processing = "getting-started/extract_with_ocr.md", ocr_configuration = "getting-started/hello_world.md" }

[crates.readme.languages.java]
template = "language_package.md"
name = "Java"
package_name = "io.xberg:xberg"
badge_url = "https://img.shields.io/maven-central/v/io.xberg/xberg?label=Java&color=007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Java bindings with type-safe API, Foreign Function & Memory API integration, and native performance."
package_manager = ["maven", "gradle"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["maven_gradle_setup", "system_requirements"]
snippets = { basic_extraction = "getting-started/basic_usage.md", async_extraction = "api/extract.md", batch_processing = "api/extract_batch.md", ocr_configuration = "ocr/ocr_extraction.md", configuration = "config/config_basic.md" }

[crates.readme.languages.php]
template = "language_package.md"
name = "PHP"
package_name = "xberg-io/xberg"
badge_url = "https://img.shields.io/packagist/v/xberg-io/xberg?label=PHP&color=007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. PHP bindings with modern PHP 8.2+ support and type-safe API."
package_manager = ["composer"]
features = { ocr = true, async = false, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["composer_installation", "system_requirements"]
snippets = { basic_extraction = "quickstart/basic_extraction_oop.md", batch_processing = "extraction/batch_processing.md", ocr_configuration = "ocr/basic_ocr.md" }

[crates.readme.languages.ruby]
template = "ruby.md"
name = "Ruby"
package_name = "xberg"
badge_url = "https://img.shields.io/gem/v/xberg?label=Ruby&color=007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Ruby bindings with idiomatic Ruby API and native performance."
package_manager = ["rubygems", "bundler"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["system_requirements", "development_setup"]
snippets = { basic_extraction = "getting-started/basic_usage.md", async_extraction = "api/extract.md", batch_processing = "getting-started/install_verify.md", ocr_configuration = "getting-started/extract_with_ocr.md" }

[crates.readme.languages.csharp]
template = "language_package.md"
name = "C#"
package_name = "XbergIo.Xberg"
badge_url = "https://img.shields.io/nuget/v/XbergIo.Xberg?label=C%23&color=007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. .NET bindings with full type safety, async/await support, and .NET 10.0+ compatibility."
package_manager = ["nuget"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["dotnet_installation", "system_requirements"]
snippets = { basic_extraction = "getting-started/basic_usage.md", async_extraction = "advanced/async_extraction.md", batch_processing = "advanced/batch_processing.md", ocr_configuration = "ocr/tesseract_backend.md" }

[crates.readme.languages.elixir]
template = "language_package.md"
name = "Elixir"
package_name = "xberg"
badge_url = "https://img.shields.io/hexpm/v/xberg?label=Elixir&color=007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Elixir bindings with native BEAM concurrency, OTP integration, and idiomatic Elixir API."
package_manager = ["mix"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["mix_installation", "async_with_tasks", "plugin_system"]
snippets = { basic_extraction = "getting-started/basic_usage.md", async_extraction = "core/extract.md", batch_processing = "core/extract_batch.md", ocr_configuration = "ocr/tesseract_basic.md", plugin_system = "plugins/word_count_processor.md" }

[crates.readme.languages.wasm]
template = "language_package.md"
output_path = "crates/xberg-wasm/README.md"
name = "WebAssembly"
package_name = "@xberg-io/xberg-wasm"
badge_url = "https://img.shields.io/npm/v/@xberg-io/xberg-wasm?label=WASM&color=007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, and metadata from 107 file formats including PDF, Office documents, and images. WebAssembly bindings for browsers, Deno, and Cloudflare Workers with a single-threaded synchronous core and an async JavaScript surface."
package_manager = ["pnpm"]
features = { ocr = true, async = true, plugin_system = true, embeddings = false, code_intelligence = false }
ocr_backends = ["tesseract-wasm", "sceptre (opt-in worker API)"]
optional_sections = ["ocr_support", "performance_comparison"]
snippets = { basic_extraction = "getting-started/basic-extract.md", browser_extraction = "getting-started/browser-file-input.md", node_extraction = "getting-started/basic-extract.md", async_extraction = "getting-started/async-extraction.md", batch_processing = "getting-started/batch-processing.md", ocr_configuration = "ocr/enable-ocr.md" }

[crates.readme.languages.ffi]
template = "language_package.md"
output_path = "crates/xberg-ffi/README.md"
name = "FFI (C/C++)"
package_name = "xberg-ffi"
badge_url = "https://img.shields.io/badge/C%2FC%2B%2B-xberg--ffi-007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. C/C++ FFI bindings providing a stable ABI for native integration, shared library distribution, and cross-language interop."
package_manager = ["cargo"]
# `async = false`: the C ABI is synchronous, so the template's async section ("full
# async/await support") would be untrue here, and there is deliberately no
# `async_extraction` snippet under `docs-site/src/snippets/c/`. With `async = true`
# the template still rendered the section, `snippets.async_extraction` resolved to
# nothing, and `include_snippet` tried to read the bare `snippets/c/` directory --
# failing the whole docs render. ~keep
features = { ocr = true, async = false, plugin_system = true, embeddings = true, code_intelligence = true }
# The FFI README's quick-start examples are C code, and `docs-site/src/snippets/`
# only maintains one such set under `c/` (shared with the e2e C consumer) rather
# than a duplicate `ffi/` directory. `snippet_language` (alef >=0.54.1) points
# the README's `include_snippet(language)` calls at that directory while leaving
# `language == "ffi"` intact for template branching (installation steps, etc.). ~keep
snippet_language = "c"
snippets = { basic_extraction = "getting-started/basic_usage.md", batch_processing = "getting-started/extract_with_ocr.md", ocr_configuration = "ocr/ocr_extraction.md", table_extraction = "metadata/tables.md" }

[crates.readme.languages.kotlin_android]
# Snippets live under `docs-site/src/snippets/kotlin/`; there is no
# `kotlin_android/` directory. Same arrangement as `ffi` -> `c`: point
# include_snippet at the real directory while leaving the language key intact for
# template branching. ~keep
snippet_language = "kotlin"
template = "language_package.md"
name = "Kotlin (Android)"
package_name = "io.xberg:xberg-android"
badge_url = "https://img.shields.io/badge/Android-xberg-3DDC84"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Android library (AAR) with bundled jniLibs/arm64-v8a and jniLibs/x86_64 — Gradle automatically picks up the native cdylib for emulator and device builds. Server-side Kotlin/JVM consumers can use the Java binding directly via standard Kotlin/Java interop."
package_manager = ["gradle", "maven"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "sceptre-tract"]
optional_sections = ["system_requirements"]
snippets = { basic_extraction = "api/extract.md", async_extraction = "api/extract.md", batch_processing = "api/extract_batch.md", ocr_configuration = "ocr/ocr_extraction.md" }

[crates.readme.languages.swift]
template = "language_package.md"
name = "Swift"
package_name = "Xberg"
badge_url = "https://img.shields.io/badge/Swift-xberg-007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Swift bindings via swift-bridge for macOS and iOS, with native Swift types and async/await support."
package_manager = ["spm"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["system_requirements"]
snippets = { basic_extraction = "api/extract.md", async_extraction = "api/extract.md", batch_processing = "api/extract_batch.md", ocr_configuration = "ocr/ocr_extraction.md" }

[crates.readme.languages.dart]
template = "language_package.md"
name = "Dart / Flutter"
package_name = "xberg"
badge_url = "https://img.shields.io/badge/Dart-xberg-007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Dart bindings via flutter_rust_bridge for both Flutter apps and pure-Dart server contexts, with isolate-safe Future/Stream APIs."
package_manager = ["pub"]
features = { ocr = true, async = true, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["system_requirements"]
snippets = { basic_extraction = "api/extract.md", async_extraction = "api/extract.md", batch_processing = "api/extract_batch.md", ocr_configuration = "ocr/ocr_extraction.md" }

[crates.readme.languages.zig]
template = "language_package.md"
name = "Zig"
package_name = "xberg"
badge_url = "https://img.shields.io/badge/Zig-xberg-007ec6"
docs_url = "https://xberg.io/"
description = "Extract text, tables, images, metadata, and code intelligence from 107 file formats and 371 programming languages including PDF, Office documents, images, and audio/video transcripts where native transcription is available. Zig bindings consuming the C FFI surface via @cImport, idiomatic error sets, optional types, and slice-based memory management."
package_manager = ["zig"]
features = { ocr = true, async = false, plugin_system = true, embeddings = true, code_intelligence = true }
ocr_backends = ["tesseract", "paddleocr", "sceptre"]
optional_sections = ["system_requirements"]
snippets = { basic_extraction = "api/extract.md", async_extraction = "api/extract.md", batch_processing = "api/extract_batch.md", ocr_configuration = "ocr/ocr_extraction.md" }

[[crates.trait_bridges]]
trait_name = "OcrBackend"
super_trait = "xberg::plugins::Plugin"
registry_getter = "xberg::plugins::registry::get_ocr_backend_registry"
register_fn = "register_ocr_backend"
unregister_fn = "unregister_ocr_backend"
clear_fn = "clear_ocr_backends"

[[crates.trait_bridges]]
trait_name = "PostProcessor"
super_trait = "xberg::plugins::Plugin"
registry_getter = "xberg::plugins::registry::get_post_processor_registry"
register_fn = "register_post_processor"
unregister_fn = "unregister_post_processor"
clear_fn = "clear_post_processors"

[[crates.trait_bridges]]
trait_name = "Validator"
super_trait = "xberg::plugins::Plugin"
registry_getter = "xberg::plugins::registry::get_validator_registry"
register_fn = "register_validator"
unregister_fn = "unregister_validator"
clear_fn = "clear_validators"

[[crates.trait_bridges]]
trait_name = "DocumentExtractor"
super_trait = "xberg::plugins::Plugin"
registry_getter = "xberg::plugins::registry::get_document_extractor_registry"
register_fn = "register_document_extractor"
unregister_fn = "unregister_document_extractor"
clear_fn = "clear_document_extractors"

[[crates.trait_bridges]]
trait_name = "EmbeddingBackend"
super_trait = "xberg::plugins::Plugin"
registry_getter = "xberg::plugins::registry::get_embedding_backend_registry"
register_fn = "register_embedding_backend"
unregister_fn = "unregister_embedding_backend"
clear_fn = "clear_embedding_backends"

[[crates.trait_bridges]]
trait_name = "Renderer"
super_trait = "xberg::plugins::Plugin"
registry_getter = "xberg::plugins::registry::get_renderer_registry"
register_fn = "register_renderer"
unregister_fn = "unregister_renderer"
clear_fn = "clear_renderers"

[[crates.trait_bridges]]
trait_name = "RerankerBackend"
super_trait = "xberg::plugins::Plugin"
registry_getter = "xberg::plugins::registry::get_reranker_backend_registry"
register_fn = "register_reranker_backend"
unregister_fn = "unregister_reranker_backend"
clear_fn = "clear_reranker_backends"

[[crates.trait_bridges]]
trait_name = "TokenizerBackend"
super_trait = "xberg::plugins::Plugin"
registry_getter = "xberg::plugins::registry::get_tokenizer_backend_registry"
register_fn = "register_tokenizer_backend"
unregister_fn = "unregister_tokenizer_backend"
clear_fn = "clear_tokenizer_backends"