Nomad changes

e2e/kotlin_android/build.gradle.kts

@@ -0,0 +1,92 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    id("com.android.library") version "8.13.0"
+    kotlin("android") version "2.3.21"
+}
+
+group = "dev.kreuzberg"
+version = "0.1.0"
+
+android {
+    namespace = "dev.kreuzberg.e2e"
+    compileSdk = 35
+
+    defaultConfig {
+        minSdk = 21
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    sourceSets {
+        getByName("test") {
+            // Include the AAR-bundled Java facade as test sources
+            java.srcDir("../../packages/kotlin-android/src/main/java")
+            // Include the AAR-bundled Kotlin wrapper as test sources
+            kotlin.srcDir("../../packages/kotlin-android/src/main/kotlin")
+        }
+    }
+
+    testOptions {
+        // Host JVM unit tests: no Android device/emulator required.
+        // Tests run against the published AAR and JVM-side deps via `gradle test`.
+        unitTests {
+            isReturnDefaultValues = true
+        }
+    }
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget = JvmTarget.JVM_17
+    }
+}
+
+// Repositories declared in settings.gradle.kts via
+// dependencyResolutionManagement (FAIL_ON_PROJECT_REPOS). Re-declaring them
+// here triggers Gradle "repository was added by build file" errors.
+
+dependencies {
+
+    // Jackson for JSON assertion helpers
+    testImplementation("com.fasterxml.jackson.core:jackson-annotations:2.18.2")
+    testImplementation("com.fasterxml.jackson.core:jackson-databind:2.18.2")
+    testImplementation("com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.18.2")
+
+    // jackson-module-kotlin registers constructors/properties for Kotlin data
+    // classes, which have no default constructor and cannot be deserialized by
+    // plain Jackson without this module.
+    testImplementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.18.2")
+
+    // jspecify for null-safety annotations on wrapped types
+    testImplementation("org.jspecify:jspecify:1.0.0")
+
+    // Kotlin coroutines for async test helpers
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.11.0")
+
+    // JUnit 5 API and engine
+    testImplementation("org.junit.jupiter:junit-jupiter-api:6.1.0")
+    testImplementation("org.junit.jupiter:junit-jupiter-engine:6.1.0")
+
+
+    // Kotlin stdlib test helpers
+    testImplementation(kotlin("test"))
+
+    // JNA for loading the native library from java.library.path
+    testImplementation("net.java.dev.jna:jna:5.18.1")
+
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
+
+    // Resolve the native library location (e.g., ../../target/release)
+    val libPath = System.getProperty("kb.lib.path") ?: "${rootDir}/../../target/release"
+    systemProperty("java.library.path", libPath)
+    systemProperty("jna.library.path", libPath)
+
+    // Resolve fixture paths (e.g. "docx/fake.docx") against test_documents/
+    workingDir = file("${rootDir}/../../test_documents")
+}

e2e/kotlin_android/settings.gradle.kts

@@ -0,0 +1,19 @@
+// Generated by alef. Do not edit by hand.
+
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "kreuzberg-e2e"

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/AsyncTest.kt

@@ -0,0 +1,40 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class AsyncTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_async_extract_bytes() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: async_extract_bytes */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_async_extract_bytes_empty_mime() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: async_extract_bytes_empty_mime */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_async_extract_bytes_invalid_mime() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: async_extract_bytes_invalid_mime */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/BatchTest.kt

@@ -0,0 +1,89 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class BatchTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_batch_bytes_invalid_mime() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_bytes_invalid_mime */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_batch_extract_bytes_happy() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_extract_bytes_happy */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_batch_extract_bytes_mixed_format() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_extract_bytes_mixed_format */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_batch_extract_bytes_sync_empty_list() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_extract_bytes_sync_empty_list */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_batch_extract_bytes_sync_invalid_mime() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_extract_bytes_sync_invalid_mime */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_batch_file_async_basic() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_file_async_basic */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_batch_file_async_not_found() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_file_async_not_found */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_batch_file_not_found() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_file_not_found */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_batch_file_partial() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_file_partial */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_batch_file_sync_basic() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: batch_file_sync_basic */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/CodeTest.kt

@@ -0,0 +1,26 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class CodeTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_code_shebang_detection() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: code_shebang_detection */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/ContractTest.kt

@@ -0,0 +1,138 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class ContractTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_api_batch_bytes_async() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: api_batch_bytes_async */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_api_batch_bytes_with_configs_async() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: api_batch_bytes_with_configs_async */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_api_batch_file_async() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: api_batch_file_async */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_api_batch_file_with_configs_async() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: api_batch_file_with_configs_async */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_api_extract_bytes_async() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: api_extract_bytes_async */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_api_extract_file_async() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: api_extract_file_async */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_config_chunking_prepend_heading_context() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: config_chunking_prepend_heading_context */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_config_document_structure_with_headings() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: config_document_structure_with_headings */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_config_element_types() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: config_element_types */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_config_extraction_timeout() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: config_extraction_timeout */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_config_keywords() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: config_keywords */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_config_pages() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: config_pages */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_config_quality_enabled() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: config_quality_enabled */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_config_security_limits() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: config_security_limits */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_config_tree_sitter() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: config_tree_sitter */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_output_format_bytes_markdown() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: output_format_bytes_markdown */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_output_format_markdown() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: output_format_markdown */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/DetectionTest.kt

@@ -0,0 +1,47 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class DetectionTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_detect_mime_bytes_html() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: detect_mime_bytes_html */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_detect_mime_bytes_pdf() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: detect_mime_bytes_pdf */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_detect_mime_bytes_png() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: detect_mime_bytes_png */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_get_extensions_unknown_mime() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: get_extensions_unknown_mime */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/DocumentExtractorManagementTest.kt

@@ -0,0 +1,26 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class DocumentExtractorManagementTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_extractors_list() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: extractors_list */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/EmbedAsyncPendingTest.kt

@@ -0,0 +1,40 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class EmbedAsyncPendingTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_embed_texts_async_empty_input() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: embed_texts_async_empty_input */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_embed_texts_async_happy() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: embed_texts_async_happy */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_embed_texts_async_preset_switch() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: embed_texts_async_preset_switch */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/EmbedExtraTest.kt

@@ -0,0 +1,26 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class EmbedExtraTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_embed_texts_batch() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: embed_texts_batch */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/EmbeddingBackendManagementTest.kt

@@ -0,0 +1,26 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class EmbeddingBackendManagementTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_embedding_backends_list() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: embedding_backends_list */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/EmbeddingsTest.kt

@@ -0,0 +1,54 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class EmbeddingsTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_embed_texts_different_preset() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: embed_texts_different_preset */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_get_embedding_preset_known() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: get_embedding_preset_known */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_get_embedding_preset_nominal() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: get_embedding_preset_nominal */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_get_embedding_preset_unknown() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: get_embedding_preset_unknown */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_list_embedding_presets_sanity() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: list_embedding_presets_sanity */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/ErrorTest.kt

@@ -0,0 +1,54 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class ErrorTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_error_empty_bytes() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: error_empty_bytes */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_error_empty_mime() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: error_empty_mime */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_error_extract_bytes_conflicting_ocr() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: error_extract_bytes_conflicting_ocr */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_error_invalid_mime_format() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: error_invalid_mime_format */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_error_unsupported_mime() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: error_unsupported_mime */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/FormatSpecificTest.kt

@@ -0,0 +1,54 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class FormatSpecificTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_format_docx_standalone() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: format_docx_standalone */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_format_hwpx_standalone() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: format_hwpx_standalone */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_format_pdf_text() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: format_pdf_text */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_format_pptx() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: format_pptx */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_format_xlsx() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: format_xlsx */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/MimeUtilitiesTest.kt

@@ -0,0 +1,40 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class MimeUtilitiesTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_mime_detect_bytes() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: mime_detect_bytes */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_mime_detect_image() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: mime_detect_image */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_mime_get_extensions() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: mime_get_extensions */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/OcrBackendManagementTest.kt

@@ -0,0 +1,26 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class OcrBackendManagementTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_ocr_backends_list() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: ocr_backends_list */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/PdfTest.kt

@@ -0,0 +1,33 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class PdfTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_render_pdf_page_first() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: render_pdf_page_first */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_render_pdf_page_out_of_range() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: render_pdf_page_out_of_range */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/PostProcessorManagementTest.kt

@@ -0,0 +1,26 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class PostProcessorManagementTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_post_processors_list() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: post_processors_list */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/RegistryOperationsTest.kt

@@ -0,0 +1,40 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class RegistryOperationsTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_extensions_docx() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: extensions_docx */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_extensions_html() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: extensions_html */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_extensions_pdf() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: extensions_pdf */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/RegistryTest.kt

@@ -0,0 +1,61 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class RegistryTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_list_document_extractors() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: list_document_extractors */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_list_embedding_backends() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: list_embedding_backends */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_list_ocr_backends() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: list_ocr_backends */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_list_post_processors() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: list_post_processors */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_list_renderers() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: list_renderers */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_list_validators() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: list_validators */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/RendererManagementTest.kt

@@ -0,0 +1,26 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class RendererManagementTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_renderers_list() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: renderers_list */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/SmokeTest.kt

@@ -0,0 +1,75 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class SmokeTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_ocr_image_png() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: ocr_image_png */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_smoke_docx_basic() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: smoke_docx_basic */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_smoke_html_basic() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: smoke_html_basic */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_smoke_image_png() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: smoke_image_png */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_smoke_json_basic() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: smoke_json_basic */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_smoke_pdf_basic() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: smoke_pdf_basic */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_smoke_txt_basic() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: smoke_txt_basic */)
+        // TODO: assert result is not an error
+    }
+
+    @Test
+    fun test_smoke_xlsx_basic() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: smoke_xlsx_basic */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/androidTest/kotlin/dev/kreuzberg/e2e/ValidatorManagementTest.kt

@@ -0,0 +1,26 @@
+package dev.kreuzberg.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.BeforeClass
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class ValidatorManagementTest {
+
+    companion object {
+        @BeforeClass
+        @JvmStatic
+        fun loadNativeLibrary() {
+            System.loadLibrary("kreuzberg_jni")
+        }
+    }
+
+    @Test
+    fun test_validators_list() {
+        val client = Kreuzberg()
+        val result = client.extract_file(/* fixture: validators_list */)
+        // TODO: assert result is not an error
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/AsyncTest.kt

@@ -0,0 +1,54 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.ExtractionConfig
+
+/** E2e tests for category: async. */
+class AsyncTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testAsyncExtractBytes() = runBlocking {
+        // Async extract_bytes call on PDF document
+        val result = Kreuzberg.extractBytes("pdf/fake_memo.pdf", "application/pdf", ExtractionConfig())
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 50, "expected length >= 50")
+    }
+
+    @Test
+    fun testAsyncExtractBytesEmptyMime() = runBlocking {
+        // extract_bytes empty MIME async
+        assertFailsWith<Exception> {
+            val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+            Kreuzberg.extractBytes("text/plain.txt", "", config)
+        }
+        Unit
+    }
+
+    @Test
+    fun testAsyncExtractBytesInvalidMime() = runBlocking {
+        // extract_bytes unsupported MIME async
+        assertFailsWith<Exception> {
+            val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+            Kreuzberg.extractBytes("text/plain.txt", "application/x-nonexistent", config)
+        }
+        Unit
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/BatchTest.kt

@@ -0,0 +1,90 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.ExtractionConfig
+import dev.kreuzberg.BatchBytesItem
+import dev.kreuzberg.BatchFileItem
+
+/** E2e tests for category: batch. */
+class BatchTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testBatchBytesInvalidMime() = runBlocking {
+        // batch_extract_bytes_sync invalid MIME
+        val result = Kreuzberg.batchExtractBytesSync(listOf(BatchBytesItem(byteArrayOf(72, 101, 108, 108, 111), "application/x-nonexistent", null)), ExtractionConfig())
+    }
+
+    @Test
+    fun testBatchExtractBytesHappy() = runBlocking {
+        // batch_extract_bytes: happy path with mixed inputs
+        val result = Kreuzberg.batchExtractBytes(listOf(BatchBytesItem(byteArrayOf(72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33), "text/plain", null), BatchBytesItem(byteArrayOf(60, 104, 116, 109, 108, 62, 60, 98, 111, 100, 121, 62, 84, 101, 115, 116, 60, 47, 98, 111, 100, 121, 62, 60, 47, 104, 116, 109, 108, 62), "text/html", null)), ExtractionConfig())
+        assertTrue(result.size >= 1, "expected at least 1 elements")
+    }
+
+    @Test
+    fun testBatchExtractBytesMixedFormat() = runBlocking {
+        // batch_extract_bytes: handles unsupported MIME gracefully
+        val result = Kreuzberg.batchExtractBytes(listOf(BatchBytesItem(byteArrayOf(80, 68, 70, 32, 112, 108, 97, 99, 101, 104, 111, 108, 100, 101, 114), "application/x-unknown", null)), ExtractionConfig())
+    }
+
+    @Test
+    fun testBatchExtractBytesSyncEmptyList() = runBlocking {
+        // batch_extract_bytes_sync: empty batch
+        val result = Kreuzberg.batchExtractBytesSync(listOf(), ExtractionConfig())
+        assertEquals(0, result.size, "expected exactly 0 elements")
+    }
+
+    @Test
+    fun testBatchExtractBytesSyncInvalidMime() = runBlocking {
+        // batch_extract_bytes_sync: unsupported MIME
+        val result = Kreuzberg.batchExtractBytesSync(listOf(BatchBytesItem(byteArrayOf(100, 97, 116, 97), "application/x-unknown", null)), ExtractionConfig())
+    }
+
+    @Test
+    fun testBatchFileAsyncBasic() = runBlocking {
+        // Extract text from multiple files asynchronously
+        val result = Kreuzberg.batchExtractFiles(listOf(BatchFileItem(java.nio.file.Paths.get("pdf/fake_memo.pdf"), null), BatchFileItem(java.nio.file.Paths.get("text/fake_text.txt"), null)), ExtractionConfig())
+    }
+
+    @Test
+    fun testBatchFileAsyncNotFound() = runBlocking {
+        // batch_extract_file async nonexistent
+        val result = Kreuzberg.batchExtractFiles(listOf(BatchFileItem(java.nio.file.Paths.get("/nonexistent/a.pdf"), null)), ExtractionConfig())
+    }
+
+    @Test
+    fun testBatchFileNotFound() = runBlocking {
+        // batch_extract_file_sync nonexistent
+        val result = Kreuzberg.batchExtractFilesSync(listOf(BatchFileItem(java.nio.file.Paths.get("/nonexistent/a.pdf"), null), BatchFileItem(java.nio.file.Paths.get("/nonexistent/b.txt"), null)), ExtractionConfig())
+    }
+
+    @Test
+    fun testBatchFilePartial() = runBlocking {
+        // batch_extract_file_sync mixed
+        val result = Kreuzberg.batchExtractFilesSync(listOf(BatchFileItem(java.nio.file.Paths.get("text/plain.txt"), null), BatchFileItem(java.nio.file.Paths.get("/nonexistent/missing.pdf"), null)), ExtractionConfig())
+    }
+
+    @Test
+    fun testBatchFileSyncBasic() = runBlocking {
+        // Extract text from multiple files synchronously
+        val result = Kreuzberg.batchExtractFilesSync(listOf(BatchFileItem(java.nio.file.Paths.get("pdf/fake_memo.pdf"), null), BatchFileItem(java.nio.file.Paths.get("text/fake_text.txt"), null)), ExtractionConfig())
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/CodeTest.kt

@@ -0,0 +1,36 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.ExtractionConfig
+
+/** E2e tests for category: code. */
+class CodeTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testCodeShebangDetection() = runBlocking {
+        // Test language detection from shebang line via bytes input
+        val result = Kreuzberg.extractFileSync("code/script.sh", "text/x-source-code", ExtractionConfig())
+        assertEquals("text/x-source-code", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        assertTrue(result.content.contains("build"), "expected to contain: " + "build")
+        assertTrue(result.content.contains("clean"), "expected to contain: " + "clean")
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/ContractTest.kt

@@ -0,0 +1,191 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.ExtractionConfig
+
+/** E2e tests for category: contract. */
+class ContractTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testApiBatchBytesAsync() = runBlocking {
+        // Tests async batch bytes extraction API (batch_extract_bytes)
+        val result = Kreuzberg.extractFile("pdf/fake_memo.pdf", null, ExtractionConfig())
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        assertTrue(result.content.contains("May 5, 2023") || result.content.contains("Mallori"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testApiBatchBytesWithConfigsAsync() = runBlocking {
+        // Tests async batch bytes extraction with per-file configs (batch_extract_bytes with file_configs parameter)
+        val result = Kreuzberg.extractFile("pdf/fake_memo.pdf", null, "{\"output_format\":\"markdown\"}")
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        // skipped: field 'metadata.output_format' not available on result type
+    }
+
+    @Test
+    fun testApiBatchFileAsync() = runBlocking {
+        // Tests async batch file extraction API (batch_extract_file)
+        val result = Kreuzberg.extractFile("pdf/fake_memo.pdf", null, ExtractionConfig())
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        assertTrue(result.content.contains("May 5, 2023") || result.content.contains("Mallori"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testApiBatchFileWithConfigsAsync() = runBlocking {
+        // Tests async batch file extraction with per-file configs (batch_extract_files with file_configs parameter)
+        val result = Kreuzberg.extractFile("pdf/fake_memo.pdf", null, "{\"output_format\":\"markdown\"}")
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        // skipped: field 'metadata.output_format' not available on result type
+    }
+
+    @Test
+    fun testApiExtractBytesAsync() = runBlocking {
+        // Tests async bytes extraction API (extract_bytes)
+        val result = Kreuzberg.extractFile("pdf/fake_memo.pdf", null, ExtractionConfig())
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        assertTrue(result.content.contains("May 5, 2023") || result.content.contains("Mallori"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testApiExtractFileAsync() = runBlocking {
+        // Tests async file extraction API (extract_file)
+        val result = Kreuzberg.extractFile("pdf/fake_memo.pdf", null, ExtractionConfig())
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        assertTrue(result.content.contains("May 5, 2023") || result.content.contains("Mallori"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testConfigChunkingPrependHeadingContext() = runBlocking {
+        // Tests markdown chunker prepends heading hierarchy to chunk content
+        val config = MAPPER.readValue("{\"chunking\":{\"chunker_type\":\"markdown\",\"max_chars\":300,\"max_overlap\":50,\"prepend_heading_context\":true}}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("markdown/extraction_test.md", null, config)
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        // skipped: field 'chunks' not available on result type
+        // skipped: field 'chunks_have_content' not available on result type
+        // skipped: field 'chunks_have_heading_context' not available on result type
+        // skipped: field 'first_chunk_starts_with_heading' not available on result type
+    }
+
+    @Test
+    fun testConfigDocumentStructureWithHeadings() = runBlocking {
+        // Tests document structure with DOCX heading-driven nesting
+        val config = MAPPER.readValue("{\"include_document_structure\":true}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("docx/fake.docx", null, config)
+        assertEquals("application/vnd.openxmlformats-officedocument.wordprocessingml.document", result.mimeType.trim())
+        // skipped: field 'document' not available on result type
+        // skipped: field 'document.nodes' not available on result type
+    }
+
+    @Test
+    fun testConfigElementTypes() = runBlocking {
+        // Tests element-based result format with element type assertions on DOCX
+        val config = MAPPER.readValue("{\"result_format\":\"element_based\"}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("docx/unit_test_headers.docx", null, config)
+        assertTrue(result.mimeType.contains("application/vnd.openxmlformats-officedocument.wordprocessingml.document"), "expected to contain at least one of the specified values")
+        // skipped: field 'elements' not available on result type
+    }
+
+    @Test
+    fun testConfigExtractionTimeout() = runBlocking {
+        // Tests that extraction_timeout_secs config field is accepted and does not affect fast extractions
+        val config = MAPPER.readValue("{\"extraction_timeout_secs\":300}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("pdf/fake_memo.pdf", null, config)
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+    }
+
+    @Test
+    fun testConfigKeywords() = runBlocking {
+        // Tests keyword extraction via YAKE algorithm
+        val config = MAPPER.readValue("{\"keywords\":{\"algorithm\":\"yake\",\"max_keywords\":10}}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("pdf/fake_memo.pdf", null, config)
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        // skipped: field 'keywords' not available on result type
+        // skipped: field 'keywords' not available on result type
+    }
+
+    @Test
+    fun testConfigPages() = runBlocking {
+        // Tests page extraction and page marker configuration
+        val config = MAPPER.readValue("{\"pages\":{\"extract_pages\":true,\"insert_page_markers\":true}}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("pdf/fake_memo.pdf", null, config)
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        assertTrue(result.content.contains("PAGE"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testConfigQualityEnabled() = runBlocking {
+        // Tests quality scoring produces a score value in [0.0, 1.0]
+        val config = MAPPER.readValue("{\"enable_quality_processing\":true}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("pdf/fake_memo.pdf", null, config)
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        // skipped: field 'quality_score' not available on result type
+        // skipped: field 'quality_score' not available on result type
+        // skipped: field 'quality_score' not available on result type
+    }
+
+    @Test
+    fun testConfigSecurityLimits() = runBlocking {
+        // Tests archive extraction with custom security limits
+        val config = MAPPER.readValue("{\"security_limits\":{\"max_archive_size\":104857600,\"max_compression_ratio\":50,\"max_files_in_archive\":100}}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("archives/documents.zip", null, config)
+        assertTrue(result.mimeType.contains("application/zip") || result.mimeType.contains("application/x-zip-compressed"), "expected to contain at least one of the specified values")
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+    }
+
+    @Test
+    fun testConfigTreeSitter() = runBlocking {
+        // Tests tree-sitter configuration round-trip
+        val config = MAPPER.readValue("{\"tree_sitter\":{\"groups\":[\"web\"],\"languages\":[\"python\",\"rust\"],\"process\":{\"comments\":false,\"diagnostics\":false,\"docstrings\":false,\"exports\":true,\"imports\":true,\"structure\":true,\"symbols\":false}}}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("code/hello.py", null, config)
+        assertEquals("text/x-source-code", result.mimeType.trim())
+        assertTrue(result.content.length >= 5, "expected length >= 5")
+    }
+
+    @Test
+    fun testOutputFormatBytesMarkdown() = runBlocking {
+        // Tests markdown output format via bytes extraction API
+        val config = MAPPER.readValue("{\"output_format\":\"markdown\"}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractBytesSync("pdf/fake_memo.pdf", "application/pdf", config)
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        // skipped: field 'metadata.output_format' not available on result type
+    }
+
+    @Test
+    fun testOutputFormatMarkdown() = runBlocking {
+        // Tests Markdown output format
+        val config = MAPPER.readValue("{\"output_format\":\"markdown\"}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFileSync("pdf/fake_memo.pdf", null, config)
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        // skipped: field 'metadata.output_format' not available on result type
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/DetectionTest.kt

@@ -0,0 +1,45 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: detection. */
+class DetectionTest {
+    @Test
+    fun testDetectMimeBytesHtml() = runBlocking {
+        // Detect HTML MIME from bytes
+        val result = Kreuzberg.detectMimeTypeFromBytes("html/html.html")
+    }
+
+    @Test
+    fun testDetectMimeBytesPdf() = runBlocking {
+        // Detect PDF MIME type from bytes
+        val result = Kreuzberg.detectMimeTypeFromBytes("pdf/fake_memo.pdf")
+    }
+
+    @Test
+    fun testDetectMimeBytesPng() = runBlocking {
+        // Detect PNG MIME type from bytes
+        val result = Kreuzberg.detectMimeTypeFromBytes("images/test_hello_world.png")
+    }
+
+    @Test
+    fun testGetExtensionsUnknownMime() = runBlocking {
+        // get_extensions unknown MIME
+        assertFailsWith<Exception> {
+            Kreuzberg.getExtensionsForMime("application/x-totally-unknown")
+        }
+        Unit
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/DocumentExtractorManagementTest.kt

@@ -0,0 +1,30 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: document_extractor_management. */
+class DocumentExtractorManagementTest {
+    @Test
+    fun testDocumentExtractorsClear() = runBlocking {
+        // Clear all document extractors and verify list is empty
+        val result = DocumentExtractorBridge.clearAll()
+    }
+
+    @Test
+    fun testExtractorsList() = runBlocking {
+        // List all registered document extractors
+        val result = Kreuzberg.listDocumentExtractors()
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/EmbedAsyncPendingTest.kt

@@ -0,0 +1,47 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.EmbeddingConfig
+
+/** E2e tests for category: embed_async_pending. */
+class EmbedAsyncPendingTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testEmbedTextsAsyncEmptyInput() = runBlocking {
+        // embed_texts_async: empty text list
+        val result = Kreuzberg.embedTextsAsync(listOf(), EmbeddingConfig())
+        // skipped: field 'embeddings' not available on result type
+    }
+
+    @Test
+    fun testEmbedTextsAsyncHappy() = runBlocking {
+        // embed_texts_async: basic async embedding
+        val result = Kreuzberg.embedTextsAsync(listOf("First", "Second"), EmbeddingConfig())
+        // skipped: field 'embeddings' not available on result type
+    }
+
+    @Test
+    fun testEmbedTextsAsyncPresetSwitch() = runBlocking {
+        // embed_texts_async: preset override
+        val config = MAPPER.readValue("{\"model\":{\"name\":\"balanced\",\"type\":\"preset\"}}", EmbeddingConfig::class.java)
+        val result = Kreuzberg.embedTextsAsync(listOf("Text"), config)
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/EmbedExtraTest.kt

@@ -0,0 +1,33 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.EmbeddingConfig
+
+/** E2e tests for category: embed_extra. */
+class EmbedExtraTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testEmbedTextsBatch() = runBlocking {
+        // Batch embed texts
+        val config = MAPPER.readValue("{\"model\":{\"name\":\"balanced\",\"type\":\"preset\"}}", EmbeddingConfig::class.java)
+        val result = Kreuzberg.embedTexts(listOf("Hello", "World"), config)
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/EmbeddingBackendManagementTest.kt

@@ -0,0 +1,30 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: embedding_backend_management. */
+class EmbeddingBackendManagementTest {
+    @Test
+    fun testEmbeddingBackendsClear() = runBlocking {
+        // Clear all embedding backends and verify list is empty
+        val result = EmbeddingBackendBridge.clearAll()
+    }
+
+    @Test
+    fun testEmbeddingBackendsList() = runBlocking {
+        // List all registered embedding backends
+        val result = Kreuzberg.listEmbeddingBackends()
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/EmbeddingsTest.kt

@@ -0,0 +1,60 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.EmbeddingConfig
+
+/** E2e tests for category: embeddings. */
+class EmbeddingsTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testEmbedTextsDifferentPreset() = runBlocking {
+        // embed_texts: multilingual preset
+        val config = MAPPER.readValue("{\"model\":{\"name\":\"multilingual\",\"type\":\"preset\"}}", EmbeddingConfig::class.java)
+        val result = Kreuzberg.embedTexts(listOf("Hello world", "Test"), config)
+        // skipped: field 'embeddings' not available on result type
+    }
+
+    @Test
+    fun testGetEmbeddingPresetKnown() = runBlocking {
+        // get_embedding_preset: known preset
+        val result = Kreuzberg.getEmbeddingPreset("balanced")
+    }
+
+    @Test
+    fun testGetEmbeddingPresetNominal() = runBlocking {
+        // get_embedding_preset: nominal case
+        val result = Kreuzberg.getEmbeddingPreset("balanced")
+    }
+
+    @Test
+    fun testGetEmbeddingPresetUnknown() = runBlocking {
+        // get_embedding_preset: unknown preset fails
+        val result = Kreuzberg.getEmbeddingPreset("nonexistent-xyz")
+        assertTrue(result == null, "expected empty value")
+    }
+
+    @Test
+    fun testListEmbeddingPresetsSanity() = runBlocking {
+        // list_embedding_presets: returns at least one
+        val result = Kreuzberg.listEmbeddingPresets()
+        assertFalse(result.isEmpty(), "expected non-empty value")
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/ErrorTest.kt

@@ -0,0 +1,73 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.ExtractionConfig
+
+/** E2e tests for category: error. */
+class ErrorTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testErrorEmptyBytes() = runBlocking {
+        // Graceful handling of empty bytes (should not error)
+        val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractBytesSync("text/empty.txt", "text/plain", config)
+    }
+
+    @Test
+    fun testErrorEmptyMime() = runBlocking {
+        // Error when extracting with empty MIME type
+        assertFailsWith<Exception> {
+            val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+            Kreuzberg.extractBytesSync("text/plain.txt", "", config)
+        }
+        Unit
+    }
+
+    @Test
+    fun testErrorExtractBytesConflictingOcr() = runBlocking {
+        // extract_bytes force+disable OCR
+        assertFailsWith<Exception> {
+            val config = MAPPER.readValue("{\"disable_ocr\":true,\"force_ocr\":true}", ExtractionConfig::class.java)
+            Kreuzberg.extractBytesSync("text/fake_text.txt", "text/plain", config)
+        }
+        Unit
+    }
+
+    @Test
+    fun testErrorInvalidMimeFormat() = runBlocking {
+        // Error when extracting with invalid MIME type format
+        assertFailsWith<Exception> {
+            val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+            Kreuzberg.extractBytesSync("text/plain.txt", "not-a-mime", config)
+        }
+        Unit
+    }
+
+    @Test
+    fun testErrorUnsupportedMime() = runBlocking {
+        // Error when extracting with unsupported MIME type
+        assertFailsWith<Exception> {
+            val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+            Kreuzberg.extractBytesSync("text/plain.txt", "application/x-nonexistent", config)
+        }
+        Unit
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/FormatSpecificTest.kt

@@ -0,0 +1,61 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.ExtractionConfig
+
+/** E2e tests for category: format_specific. */
+class FormatSpecificTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testFormatDocxStandalone() = runBlocking {
+        // Standalone DOCX extraction using extract_bytes_sync
+        val result = Kreuzberg.extractBytesSync("docx/fake.docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", ExtractionConfig())
+        assertTrue(result.content.length >= 20, "expected length >= 20")
+    }
+
+    @Test
+    fun testFormatHwpxStandalone() = runBlocking {
+        // Standalone HWPX extraction using extract_bytes_sync
+        val result = Kreuzberg.extractBytesSync("hwpx/simple.hwpx", "application/haansofthwpx", ExtractionConfig())
+        assertTrue(result.content.length >= 20, "expected length >= 20")
+        assertTrue(result.content.contains("Hello from HWPX"), "expected to contain: " + "Hello from HWPX")
+    }
+
+    @Test
+    fun testFormatPdfText() = runBlocking {
+        // Standalone PDF text extraction using extract_bytes_sync
+        val result = Kreuzberg.extractBytesSync("pdf/fake_memo.pdf", "application/pdf", ExtractionConfig())
+        assertTrue(result.content.length >= 50, "expected length >= 50")
+        assertTrue(result.content.contains("Mallori") || result.content.contains("May"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testFormatPptx() = runBlocking {
+        // PPTX presentation extraction using extract_file_sync
+        val result = Kreuzberg.extractFileSync("pptx/simple.pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation", ExtractionConfig())
+    }
+
+    @Test
+    fun testFormatXlsx() = runBlocking {
+        // XLSX spreadsheet extraction using extract_file_sync
+        val result = Kreuzberg.extractFileSync("xlsx/stanley_cups.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", ExtractionConfig())
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/MimeUtilitiesTest.kt

@@ -0,0 +1,39 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: mime_utilities. */
+class MimeUtilitiesTest {
+    @Test
+    fun testMimeDetectBytes() = runBlocking {
+        // Detect MIME type from file bytes
+        val result = Kreuzberg.detectMimeTypeFromBytes("pdf/fake_memo.pdf")
+        assertTrue(result.contains("pdf"), "expected to contain: " + "pdf")
+    }
+
+    @Test
+    fun testMimeDetectImage() = runBlocking {
+        // Detect MIME type from PNG image bytes
+        val result = Kreuzberg.detectMimeTypeFromBytes("images/test_hello_world.png")
+        assertTrue(result.contains("png"), "expected to contain: " + "png")
+    }
+
+    @Test
+    fun testMimeGetExtensions() = runBlocking {
+        // Get file extensions for a MIME type
+        val result = Kreuzberg.getExtensionsForMime("application/pdf")
+        assertTrue(result.contains("pdf"), "expected to contain: " + "pdf")
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/OcrBackendManagementTest.kt

@@ -0,0 +1,36 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: ocr_backend_management. */
+class OcrBackendManagementTest {
+    @Test
+    fun testOcrBackendsClear() = runBlocking {
+        // Clear all OCR backends and verify list is empty
+        val result = OcrBackendBridge.clearAll()
+    }
+
+    @Test
+    fun testOcrBackendsList() = runBlocking {
+        // List all registered OCR backends
+        val result = Kreuzberg.listOcrBackends()
+    }
+
+    @Test
+    fun testOcrBackendsUnregister() = runBlocking {
+        // Unregister nonexistent OCR backend gracefully
+        val result = OcrBackendBridge.unregister("nonexistent-backend-xyz")
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/PdfTest.kt

@@ -0,0 +1,34 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: pdf. */
+class PdfTest {
+    @Test
+    fun testRenderPdfPageFirst() = runBlocking {
+        // render_pdf_page_to_png: first page
+        val result = Kreuzberg.renderPdfPageToPng("pdf/fake_memo.pdf", 0)
+        assertTrue(result.size >= 100, "expected size >= 100")
+    }
+
+    @Test
+    fun testRenderPdfPageOutOfRange() = runBlocking {
+        // render_pdf_page_to_png: page out of range
+        assertFailsWith<Exception> {
+            Kreuzberg.renderPdfPageToPng("pdf/fake_memo.pdf", 999)
+        }
+        Unit
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/PluginApiTest.kt

@@ -0,0 +1,125 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: plugin_api. */
+class PluginApiTest {
+    @Test
+    fun testRegisterDocumentExtractorTraitBridge() = runBlocking {
+        // register_document_extractor: trait bridge
+        class TestStubRegisterDocumentExtractorTraitBridge : IDocumentExtractor {
+    override fun name(): String = "register_document_extractor_trait_bridge"
+    override suspend fun extractBytes(content: ByteArray, mimeType: String, config: ExtractionConfig): InternalDocument = InternalDocument()
+    override fun supportedMimeTypes(): List<String> = emptyList()
+}
+// register via: DocumentExtractorBridge.register(TestStubRegisterDocumentExtractorTraitBridge())
+
+        val result = DocumentExtractorBridge.register(TestStubRegisterDocumentExtractorTraitBridge())
+    }
+
+    @Test
+    fun testRegisterEmbeddingBackendTraitBridge() = runBlocking {
+        // register_embedding_backend: trait bridge
+        class TestStubRegisterEmbeddingBackendTraitBridge : IEmbeddingBackend {
+    override fun name(): String = "register_embedding_backend_trait_bridge"
+    override fun dimensions(): Long = 0
+    override suspend fun embed(texts: List<String>): List<List<Float>> = emptyList()
+}
+// register via: EmbeddingBackendBridge.register(TestStubRegisterEmbeddingBackendTraitBridge())
+
+        val result = EmbeddingBackendBridge.register(TestStubRegisterEmbeddingBackendTraitBridge())
+    }
+
+    @Test
+    fun testRegisterOcrBackendTraitBridge() = runBlocking {
+        // register_ocr_backend: trait bridge
+        class TestStubRegisterOcrBackendTraitBridge : IOcrBackend {
+    override fun name(): String = "register_ocr_backend_trait_bridge"
+    override suspend fun processImage(imageBytes: ByteArray, config: OcrConfig): ExtractionResult = ExtractionResult()
+    override fun supportsLanguage(lang: String): Boolean = false
+    override fun backendType(): OcrBackendType = OcrBackendType()
+}
+// register via: OcrBackendBridge.register(TestStubRegisterOcrBackendTraitBridge())
+
+        val result = OcrBackendBridge.register(TestStubRegisterOcrBackendTraitBridge())
+    }
+
+    @Test
+    fun testRegisterPostProcessorTraitBridge() = runBlocking {
+        // register_post_processor: trait bridge
+        class TestStubRegisterPostProcessorTraitBridge : IPostProcessor {
+    override fun name(): String = "register_post_processor_trait_bridge"
+    override suspend fun process(result: ExtractionResult, config: ExtractionConfig): Unit = null
+    override fun processingStage(): ProcessingStage = ProcessingStage()
+}
+// register via: PostProcessorBridge.register(TestStubRegisterPostProcessorTraitBridge())
+
+        val result = PostProcessorBridge.register(TestStubRegisterPostProcessorTraitBridge())
+    }
+
+    @Test
+    fun testRegisterRendererTraitBridge() = runBlocking {
+        // register_renderer: trait bridge
+        class TestStubRegisterRendererTraitBridge : IRenderer {
+    override fun name(): String = "register_renderer_trait_bridge"
+    override fun render(doc: InternalDocument): String = ""
+}
+// register via: RendererBridge.register(TestStubRegisterRendererTraitBridge())
+
+        val result = RendererBridge.register(TestStubRegisterRendererTraitBridge())
+    }
+
+    @Test
+    fun testRegisterValidatorTraitBridge() = runBlocking {
+        // register_validator: trait bridge
+        class TestStubRegisterValidatorTraitBridge : IValidator {
+    override fun name(): String = "register_validator_trait_bridge"
+    override suspend fun validate(result: ExtractionResult, config: ExtractionConfig): Unit = null
+}
+// register via: ValidatorBridge.register(TestStubRegisterValidatorTraitBridge())
+
+        val result = ValidatorBridge.register(TestStubRegisterValidatorTraitBridge())
+    }
+
+    @Test
+    fun testUnregisterDocumentExtractorAfterRegister() = runBlocking {
+        // unregister_document_extractor
+        val result = DocumentExtractorBridge.unregister("test-extractor")
+    }
+
+    @Test
+    fun testUnregisterEmbeddingBackendAfterRegister() = runBlocking {
+        // unregister_embedding_backend
+        val result = EmbeddingBackendBridge.unregister("test-embedding-backend")
+    }
+
+    @Test
+    fun testUnregisterPostProcessorAfterRegister() = runBlocking {
+        // unregister_post_processor
+        val result = PostProcessorBridge.unregister("test-processor")
+    }
+
+    @Test
+    fun testUnregisterRendererAfterRegister() = runBlocking {
+        // unregister_renderer
+        val result = RendererBridge.unregister("test-renderer")
+    }
+
+    @Test
+    fun testUnregisterValidatorAfterRegister() = runBlocking {
+        // unregister_validator
+        val result = ValidatorBridge.unregister("test-validator")
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/PostProcessorManagementTest.kt

@@ -0,0 +1,30 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: post_processor_management. */
+class PostProcessorManagementTest {
+    @Test
+    fun testPostProcessorsClear() = runBlocking {
+        // Clear all post-processors and verify list is empty
+        val result = PostProcessorBridge.clearAll()
+    }
+
+    @Test
+    fun testPostProcessorsList() = runBlocking {
+        // List all registered post-processors
+        val result = Kreuzberg.listPostProcessors()
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/RegistryOperationsTest.kt

@@ -0,0 +1,36 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: registry_operations. */
+class RegistryOperationsTest {
+    @Test
+    fun testExtensionsDocx() = runBlocking {
+        // Get file extensions for DOCX MIME type
+        val result = Kreuzberg.getExtensionsForMime("application/vnd.openxmlformats-officedocument.wordprocessingml.document")
+    }
+
+    @Test
+    fun testExtensionsHtml() = runBlocking {
+        // Get file extensions for HTML MIME type
+        val result = Kreuzberg.getExtensionsForMime("text/html")
+    }
+
+    @Test
+    fun testExtensionsPdf() = runBlocking {
+        // Get file extensions for PDF MIME type
+        val result = Kreuzberg.getExtensionsForMime("application/pdf")
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/RegistryTest.kt

@@ -0,0 +1,54 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: registry. */
+class RegistryTest {
+    @Test
+    fun testListDocumentExtractors() = runBlocking {
+        // List document extractors
+        val result = Kreuzberg.listDocumentExtractors()
+    }
+
+    @Test
+    fun testListEmbeddingBackends() = runBlocking {
+        // List embedding backends
+        val result = Kreuzberg.listEmbeddingBackends()
+    }
+
+    @Test
+    fun testListOcrBackends() = runBlocking {
+        // List OCR backends
+        val result = Kreuzberg.listOcrBackends()
+    }
+
+    @Test
+    fun testListPostProcessors() = runBlocking {
+        // List post-processors
+        val result = Kreuzberg.listPostProcessors()
+    }
+
+    @Test
+    fun testListRenderers() = runBlocking {
+        // List renderers
+        val result = Kreuzberg.listRenderers()
+    }
+
+    @Test
+    fun testListValidators() = runBlocking {
+        // List validators
+        val result = Kreuzberg.listValidators()
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/RendererManagementTest.kt

@@ -0,0 +1,30 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: renderer_management. */
+class RendererManagementTest {
+    @Test
+    fun testRenderersClear() = runBlocking {
+        // Clear all renderers and verify list is empty
+        val result = RendererBridge.clearAll()
+    }
+
+    @Test
+    fun testRenderersList() = runBlocking {
+        // List all registered renderers
+        val result = Kreuzberg.listRenderers()
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/SmokeTest.kt

@@ -0,0 +1,113 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.module.kotlin.registerKotlinModule
+import dev.kreuzberg.ExtractionConfig
+
+/** E2e tests for category: smoke. */
+class SmokeTest {
+
+    companion object {
+        private val MAPPER = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule().setPropertyNamingStrategy(com.fasterxml.jackson.databind.PropertyNamingStrategies.SNAKE_CASE)
+    }
+    @Test
+    fun testOcrImagePng() = runBlocking {
+        // OCR: PNG image extraction with OCR enabled. In WASM this exercises the Uint8Array bridge parameter and Promise await in the generated OcrBackend bridge.
+        val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractBytes("images/test_hello_world.png", "image/png", config)
+        assertEquals("image/png", result.mimeType.trim())
+        assertTrue(result.content.length >= 1, "expected length >= 1")
+        assertTrue(result.content.contains("Hello") || result.content.contains("World") || result.content.contains("hello") || result.content.contains("world"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testSmokeDocxBasic() = runBlocking {
+        // Smoke test: DOCX with formatted text
+        val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFile("docx/fake.docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", config)
+        assertEquals("application/vnd.openxmlformats-officedocument.wordprocessingml.document", result.mimeType.trim())
+        assertTrue(result.content.length >= 20, "expected length >= 20")
+        assertTrue(result.content.contains("Lorem") || result.content.contains("ipsum") || result.content.contains("document") || result.content.contains("text"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testSmokeHtmlBasic() = runBlocking {
+        // Smoke test: HTML table extraction
+        val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFile("html/simple_table.html", "text/html", config)
+        assertEquals("text/html", result.mimeType.trim())
+        assertTrue(result.content.length >= 10, "expected length >= 10")
+        assertTrue(result.content.contains("Sample Data Table") || result.content.contains("Laptop") || result.content.contains("Electronics") || result.content.contains("Product"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testSmokeImagePng() = runBlocking {
+        // Smoke test: PNG image (without OCR, metadata only)
+        val config = MAPPER.readValue("{\"disable_ocr\":true}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFile("images/sample.png", null, config)
+        assertEquals("image/png", result.mimeType.trim())
+    }
+
+    @Test
+    fun testSmokeJsonBasic() = runBlocking {
+        // Smoke test: JSON file extraction
+        val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFile("json/simple.json", "application/json", config)
+        assertEquals("application/json", result.mimeType.trim())
+        assertTrue(result.content.length >= 5, "expected length >= 5")
+    }
+
+    @Test
+    fun testSmokePdfBasic() = runBlocking {
+        // Smoke test: PDF with simple text extraction
+        val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFile("pdf/fake_memo.pdf", "application/pdf", config)
+        assertEquals("application/pdf", result.mimeType.trim())
+        assertTrue(result.content.length >= 50, "expected length >= 50")
+        assertTrue(result.content.contains("May 5, 2023") || result.content.contains("To Whom it May Concern"), "expected to contain at least one of the specified values")
+    }
+
+    @Test
+    fun testSmokeTxtBasic() = runBlocking {
+        // Smoke test: Plain text file
+        val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFile("text/report.txt", "text/plain", config)
+        assertEquals("text/plain", result.mimeType.trim())
+        assertTrue(result.content.length >= 5, "expected length >= 5")
+    }
+
+    @Test
+    fun testSmokeXlsxBasic() = runBlocking {
+        // Smoke test: XLSX with basic spreadsheet data including tables
+        val config = MAPPER.readValue("{}", ExtractionConfig::class.java)
+        val result = Kreuzberg.extractFile("xlsx/stanley_cups.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", config)
+        assertEquals("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", result.mimeType.trim())
+        assertTrue(result.content.length >= 100, "expected length >= 100")
+        assertTrue(result.content.contains("Team"), "expected to contain: " + "Team")
+        assertTrue(result.content.contains("Location"), "expected to contain: " + "Location")
+        assertTrue(result.content.contains("Stanley Cups"), "expected to contain: " + "Stanley Cups")
+        assertTrue(result.content.contains("Blues"), "expected to contain: " + "Blues")
+        assertTrue(result.content.contains("Flyers"), "expected to contain: " + "Flyers")
+        assertTrue(result.content.contains("Maple Leafs"), "expected to contain: " + "Maple Leafs")
+        assertTrue(result.content.contains("STL"), "expected to contain: " + "STL")
+        assertTrue(result.content.contains("PHI"), "expected to contain: " + "PHI")
+        assertTrue(result.content.contains("TOR"), "expected to contain: " + "TOR")
+        // skipped: field 'tables' not available on result type
+        // skipped: field 'metadata.format.excel.sheet_count' not available on result type
+        // skipped: field 'metadata.format.excel.sheet_names' not available on result type
+    }
+
+}

e2e/kotlin_android/src/test/kotlin/dev/kreuzberg/e2e/ValidatorManagementTest.kt

@@ -0,0 +1,30 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:4e15143f4af1ae8bafbdb1506ef057da924484c66a19483966333558ad437e75
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+// Issues & docs: https://github.com/kreuzberg-dev/alef
+package dev.kreuzberg.e2e
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.runBlocking
+import dev.kreuzberg.Kreuzberg
+
+/** E2e tests for category: validator_management. */
+class ValidatorManagementTest {
+    @Test
+    fun testValidatorsClear() = runBlocking {
+        // Clear all validators and verify list is empty
+        val result = ValidatorBridge.clearAll()
+    }
+
+    @Test
+    fun testValidatorsList() = runBlocking {
+        // List all registered validators
+        val result = Kreuzberg.listValidators()
+    }
+
+}