diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 14f1f078..ebbfb89e 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,49 +1,98 @@
 ---
 name: Bug report
-about: Create a report to help us improve
+about: You found a bug in ObjectBox causing an application to crash or throw an exception, or something does not work right.
 title: ''
 labels: 'bug'
 assignees: ''
 
 ---
 
-:rotating_light: First, please check:
- - existing issues,
- - Docs https://docs.objectbox.io/
- - Troubleshooting page https://docs.objectbox.io/troubleshooting
- - FAQ page https://docs.objectbox.io/faq
-
-**Describe the bug**
-A clear and concise description in English of what the bug is.
-
-**Basic info (please complete the following information):**
- - ObjectBox version (are you using the latest version?): [e.g. 2.7.0]
- - Reproducibility: [e.g. occurred once only | occasionally without visible pattern | always]
- - Device: [e.g. Galaxy S20]
- - OS: [e.g. Android 10]
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Put '...'
-2. Make changes to '....'
-3. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Code**
-If applicable, add code to help explain your problem.
- - Include affected entity classes.
- - Please remove any unnecessary or confidential parts.
- - At best, link to or attach a project with a failing test.
-
-**Logs, stack traces**
-If applicable, add relevant logs, or a stack trace.
- - For __build issues__, use `--stacktrace` for the Gradle build (`./gradlew build --stacktrace`).
- - For __runtime errors__, check Android's Logcat (also check logs before the issue!).
-
-**Additional context**
-Add any other context about the problem here.
- - Is there anything special about your app?
- - May transactions or multi-threading play a role?
- - Did you find any workarounds to prevent the issue?
+<!--
+
+If you are looking for support, please check out our documentation:
+- https://docs.objectbox.io
+- https://docs.objectbox.io/faq
+- https://docs.objectbox.io/troubleshooting
+
+-->
+
+### Is there an existing issue?
+
+- [ ] I have searched [existing issues](https://github.com/objectbox/objectbox-java/issues)
+
+### Build info
+
+- ObjectBox version: [e.g. 3.7.0]
+- OS: [e.g. Android 14 | Ubuntu 22.04 | Windows 11 ]
+- Device/ABI/architecture: [e.g. Galaxy S23 | arm64-v8a | x86-64 ]
+
+### Steps to reproduce
+
+_TODO Tell us exactly how to reproduce the problem._
+
+1. ...
+2. ...
+3. ...
+
+### Expected behavior
+
+_TODO Tell us what you expect to happen._
+
+### Actual behavior
+
+_TODO Tell us what actually happens._
+
+
+### Code
+
+_TODO Add a code example to help us reproduce your problem._
+
+<!--
+
+Please provide a minimal code example.
+
+Things you maybe should also include:
+- the entity class
+- the Gradle build script
+
+You can also create a public GitHub repository and link to it below.
+
+Please do not upload screenshots of text, use code blocks like below instead.
+
+Add any other context about the problem:
+- Is there anything special about your app?
+- May transactions or multi-threading play a role?
+- Did you find any workarounds to prevent the issue?
+
+-->
+
+<details><summary>Code</summary>
+
+```java
+[Paste your code here]
+```
+
+</details>
+
+### Logs, stack traces
+
+_TODO Add relevant logs, a stack trace or crash report._
+
+<!-- 
+
+- For build issues, use `--stacktrace` to run the failing Gradle task. E.g. ./gradlew build --stacktrace
+- For runtime errors, check log output (e.g. Logcat on Android).
+  - For Java/Kotlin exceptions include the full stack trace.
+  - For native crashes on Android, include Logcat output starting from the *** *** *** line. Note that crash reporting tools like Crashlytics may hide this line.
+  - For native crashes on JVM, include the hs_err_pidXXXX.log file.
+  - Also check logs before the error. ObjectBox logs are tagged with e.g. Box.
+
+-->
+
+<details><summary>Logs</summary>
+
+```console
+[Paste your logs here]
+```
+
+</details>
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
index 975b320b..1846a02e 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,26 +1,37 @@
 ---
 name: Feature request
-about: Suggest an idea
+about: Suggest an improvement for ObjectBox.
 title: ''
-labels: 'feature'
+labels: 'enhancement'
 assignees: ''
 
 ---
 
-:rotating_light: First, please check:
- - existing issues,
- - Docs https://docs.objectbox.io/
- - Troubleshooting page https://docs.objectbox.io/troubleshooting
- - FAQ page https://docs.objectbox.io/faq
+<!--
 
-Start with a clear and concise description of what problem you are trying to solve.
-Often there is already a solution! 
+If you are looking for support, please check out our documentation:
+- https://docs.objectbox.io
+- https://docs.objectbox.io/faq
+- https://docs.objectbox.io/troubleshooting
 
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
+-->
 
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
+### Is there an existing issue?
 
-**Additional context**
-Add any other context (e.g. platform or language) about the feature request here.
+- [ ] I have searched [existing issues](https://github.com/objectbox/objectbox-java/issues)
+
+### Use case
+
+_TODO Describe what problem you are trying to solve._
+
+### Proposed solution
+
+_TODO Describe what you want to be able to do with ObjectBox._
+
+### Alternatives
+
+_TODO Describe any alternative solutions or features you've considered._
+
+### Additional context
+
+_TODO Add any other context (e.g. platform or language) about the feature request here._
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000..2c431b0b
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,9 @@
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
diff --git a/.github/workflows/close-no-response.yml b/.github/workflows/close-no-response.yml
index 9500c6e7..3e906671 100644
--- a/.github/workflows/close-no-response.yml
+++ b/.github/workflows/close-no-response.yml
@@ -2,6 +2,11 @@ name: Close inactive issues
 on:
   schedule:
     - cron: "15 1 * * *" # “At 01:15.”
+  workflow_dispatch: # To support running manually.
+
+# Minimal access by default
+permissions:
+  contents: read
 
 jobs:
   close-issues:
@@ -11,7 +16,7 @@ jobs:
       pull-requests: write
     steps:
       # https://github.com/marketplace/actions/close-stale-issues
-      - uses: actions/stale@v5
+      - uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
         with:
           days-before-stale: -1 # Add the stale label manually.
           days-before-close: 21
diff --git a/.gitignore b/.gitignore
index 5f02f8d1..1bedca93 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,7 +12,9 @@ gen/
 target/
 out/
 classes/
-gradle.properties
+
+# Kotlin
+.kotlin
 
 # Local build properties
 build.properties
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 58b31c18..63a5ea1d 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,165 +1,238 @@
-# Default image for linux builds
-image: objectboxio/buildenv:21.11.11-centos7
+# https://docs.gitlab.com/ci/yaml/
 
 # Assumes these environment variables are configured in GitLab CI/CD Settings:
+# - OBX_READ_PACKAGES_TOKEN
 # - SONATYPE_USER
 # - SONATYPE_PWD
 # - GOOGLE_CHAT_WEBHOOK_JAVA_CI
-# Additionally, Gradle scripts assume these Gradle project properties are set:
-# https://docs.gradle.org/current/userguide/build_environment.html#sec:project_properties
+# Additionally, these environment variables used by the objectbox-publish Gradle script:
 # - ORG_GRADLE_PROJECT_signingKeyFile
 # - ORG_GRADLE_PROJECT_signingKeyId
 # - ORG_GRADLE_PROJECT_signingPassword
 
 variables:
+  OBX_PUBLISH_RELEASE:
+    value: "false"
+    options: [ "false", "true" ]
+    description: "If enabled, builds and depends on release versions and triggers publishing a
+                  release of the Java library artifacts to the internal GitLab repository and Maven Central.
+                  Don't run multiple times to avoid duplicate artifacts in the GitLab repository.
+                  Consult the release checklist before turning this on."
+  # If enabled, builds and depends on release versions. Doesn't publish a release.
+  # See the root Gradle build script for details.
+  OBX_RELEASE: "false"
+
   # Disable the Gradle daemon. Gradle may run in a Docker container with a shared
   # Docker volume containing GRADLE_USER_HOME. If the container is stopped after a job
   # Gradle daemons may get killed, preventing proper clean-up of lock files in GRADLE_USER_HOME.
-  # Configure file.encoding to always use UTF-8 when running Gradle.
   # Use low priority processes to avoid Gradle builds consuming all build machine resources.
-  GRADLE_OPTS: "-Dorg.gradle.daemon=false -Dfile.encoding=UTF-8 -Dorg.gradle.priority=low"
-  GITLAB_REPO_ARGS: "-PgitlabUrl=$CI_SERVER_URL -PgitlabTokenName=Job-Token -PgitlabPrivateToken=$CI_JOB_TOKEN"
-  CENTRAL_REPO_ARGS: "-PsonatypeUsername=$SONATYPE_USER -PsonatypePassword=$SONATYPE_PWD"
+  GRADLE_OPTS: "-Dorg.gradle.daemon=false -Dorg.gradle.priority=low"
+  GITLAB_REPO_ARGS: "-PgitlabUrl=$CI_SERVER_URL -PgitlabPrivateTokenName=Deploy-Token -PgitlabPrivateToken=$OBX_READ_PACKAGES_TOKEN"
+  GITLAB_PUBLISH_ARGS: "-PgitlabPublishTokenName=Job-Token -PgitlabPublishToken=$CI_JOB_TOKEN"
+  CENTRAL_PUBLISH_ARGS: "-PsonatypeUsername=$SONATYPE_USER -PsonatypePassword=$SONATYPE_PWD"
   # CI_COMMIT_REF_SLUG is the branch or tag name, but web-safe (only 0-9, a-z)
-  VERSION_ARGS: "-PversionPostFix=$CI_COMMIT_REF_SLUG"
+  VERSION_ARGS: "-PversionSuffix=$CI_COMMIT_REF_SLUG"
 
 # Using multiple test stages to avoid running some things in parallel (see job notes).
 stages:
   - test
-  - upload-to-internal
-  - upload-to-central
+  - publish-maven-internal
+  - publish-maven-central
   - package-api-docs
   - triggers
 
-test:
-  stage: test
-  tags: [ docker, linux, x64 ]
+workflow:
+  rules:
+    # Disable merge request pipelines https://docs.gitlab.com/ci/jobs/job_rules/#ci_pipeline_source-predefined-variable
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      when: never
+    # On main branch, always use release versions as old snapshots of dependencies are deleted
+    - if: $CI_COMMIT_REF_NAME == "main"
+      variables:
+        OBX_RELEASE: "true"
+    # To publish a release must use release versions
+    - if: $OBX_PUBLISH_RELEASE == "true"
+      variables:
+        OBX_RELEASE: "true"
+    # In all other cases, create a pipeline
+    - when: always
+
+.docker_linux_x64_android: &docker_linux_x64_android
+  tags:
+    - docker
+    - linux
+    - x64
+  image: objectboxio/buildenv-android:2026-05-12 # With JDK 21, Android build-tools;35.0.0 and platforms;android-35 pre-installed
   variables:
-    # CentOS 7 defaults to ASCII, use a UTF-8 compatible locale so UTF-8 tests that interact with file system work.
-    LC_ALL: "en_US.UTF-8"
+    # Image defaults to POSIX (ASCII), set a compatible locale so UTF-8 tests that interact with the file system work.
+    # Check with 'locale -a' for available locales.
+    LC_ALL: "C.UTF-8"
+
+.test_base:
   before_script:
     # Print Gradle and JVM version info
     - ./gradlew -version
     # Remove any previous JVM (Hotspot) crash log.
     # "|| true" for an OK exit code if no file is found
     - rm **/hs_err_pid*.log || true
-  script:
-    - ./ci/test-with-asan.sh $GITLAB_REPO_ARGS $VERSION_ARGS clean build
+  # By default, don't compile and test the Android APIs (only do in test job), there is currently no benefit to test
+  # them using multiple platforms or JDKs.
+  script: ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build -PexcludeAndroid=true
   artifacts:
     when: always
     paths:
-      - "**/hs_err_pid*.log" # Only on JVM (Hotspot) crash.
-      - "**/build/reports/spotbugs/*.html"
+      - "**/hs_err_pid*.log" # Only on JVM (Hotspot) crash
     reports:
       junit: "**/build/test-results/**/TEST-*.xml"
 
-.test-template:
-  before_script:
-    # Print Gradle and JVM version info
-    - ./gradlew -version
-    # Remove any previous JVM (Hotspot) crash log.
-    # "|| true" for an OK exit code if no file is found
-    - rm **/hs_err_pid*.log || true
+test:
+  <<: *docker_linux_x64_android
+  extends: .test_base
+  stage: test
+  # Overwrite script key to run through ASAN script, compile and test Android APIs and test build of Web API docs.
+  # Note: Address sanitizer is only available on Linux runners (see script).
+  script:
+    # build to assemble, run tests and spotbugs
+    # javadocForWeb to catch API docs errors before releasing
+    # Temporarily disable testing with Address Sanitizer until buildenv images are modernized, see #273
+    # - ./scripts/test-with-asan.sh $GITLAB_REPO_ARGS $VERSION_ARGS clean build javadocForWeb
+    - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build javadocForWeb
+  # Overwrite artifacts key to archive spotbugs reports
   artifacts:
     when: always
     paths:
       - "**/hs_err_pid*.log" # Only on JVM (Hotspot) crash.
+      - "**/build/reports/spotbugs/*.html"
     reports:
       junit: "**/build/test-results/**/TEST-*.xml"
 
-test-windows:
-  extends: .test-template
-  needs: ["test"]
-  tags: [ windows ]
-  script: ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build
-
-test-macos:
-  extends: .test-template
-  needs: ["test"]
-  tags: [mac11+, x64]
-  script: ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build
-
-# Address sanitizer is only available on Linux runners (see script).
-.test-asan-template:
-  extends: .test-template
-  tags: [ docker, linux, x64 ]
-  variables:
-    # CentOS 7 defaults to ASCII, use a UTF-8 compatible locale so UTF-8 tests that interact with file system work.
-    LC_ALL: "en_US.UTF-8"
+.test_jdks:
+  <<: *docker_linux_x64_android
+  extends: .test_base
+  # Overwrite script key to run through ASAN script and to run test task directly to avoid
+  # running SpotBugs (build runs check runs SpotBugs tasks).
+  # Note: Address sanitizer is only available on Linux runners (see script).
   script:
-    # Note: do not run check task as it includes SpotBugs.
-    - ./ci/test-with-asan.sh $GITLAB_REPO_ARGS $VERSION_ARGS clean :tests:objectbox-java-test:test
+    # Temporarily disable testing with Address Sanitizer until buildenv images are modernized, see #273
+    # - ./scripts/test-with-asan.sh $GITLAB_REPO_ARGS $VERSION_ARGS clean :tests:objectbox-java-test:test
+    - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean :tests:objectbox-java-test:test
 
 # Test oldest supported and a recent JDK.
-# Note: can not run these in parallel using a matrix configuration as Gradle would step over itself.
 test-jdk-8:
-  extends: .test-asan-template
+  extends: .test_jdks
   needs: ["test"]
   variables:
     TEST_JDK: 8
 
-# JDK 17 is the latest LTS release.
-test-jdk-17:
-  extends: .test-asan-template
-  needs: ["test-jdk-8"]
+# JDK 21 is the default of the current build image, so test the latest LTS JDK 25
+test-jdk-25:
+  extends: .test_jdks
+  needs: ["test"]
   variables:
-    TEST_JDK: 17
+    TEST_JDK: 25
+
+test-macos:
+  extends: .test_base
+  tags:
+    - jdk
+    - mac
+
+test-windows:
+  extends: .test_base
+  tags:
+    - jdk
+    - windows
+    - x64
 
-test-jdk-x86:
-  extends: .test-template
-  needs: ["test-windows"]
-  tags: [ windows ]
+test-windows-jdk-x86:
+  extends: .test_base
+  tags:
+    - jdk-x86
+    - windows
   variables:
     # TEST_WITH_JAVA_X86 makes objectbox-java-test use 32-bit java executable and therefore
     # 32-bit ObjectBox to run tests (see build.gradle file).
     # Note: assumes JAVA_HOME_X86 is set to 32-bit JDK path.
     TEST_WITH_JAVA_X86: "true"
-  script: ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build
 
-upload-to-internal:
-  stage: upload-to-internal
-  tags: [ docker, x64 ]
-  except:
-    - tags # Only publish from branches.
+# Publish Maven artifacts to internal Maven repo
+publish-maven-internal:
+  <<: *docker_linux_x64_android
+  stage: publish-maven-internal
+  rules:
+    # Not for tag pipelines (Maven artifact snapshots are versioned using the branch name)
+    - if: $CI_COMMIT_TAG
+      when: never
+    # Not when using release versions and not publishing a release to avoid duplicate artifacts
+    # (GitLab would allow to upload duplicates for a release version)
+    - if: $OBX_RELEASE == "true" && $OBX_PUBLISH_RELEASE != "true"
+      when: never
+    # Not if triggered by upstream project to save on disk space
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+      when: never
+    # Not for scheduled pipelines to save on disk space
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+      when: never
+    # Otherwise, only if no previous stages failed
+    - when: on_success
   script:
-    - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS publishMavenJavaPublicationToGitLabRepository
+    - ./gradlew $GITLAB_REPO_ARGS $GITLAB_PUBLISH_ARGS $VERSION_ARGS publishAllPublicationsToGitLabRepository
 
-upload-to-central:
-  stage: upload-to-central
-  tags: [ docker, x64 ]
-  only:
-    - publish
+# Publish Maven artifacts to public Maven Central repo
+publish-maven-central:
+  <<: *docker_linux_x64_android
+  stage: publish-maven-central
+  rules:
+    # Only if publishing a release, only if no previous stages failed
+    - if: $OBX_PUBLISH_RELEASE == "true"
+      when: on_success
   before_script:
-    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java library:* job $CI_JOB_NAME from branch $CI_COMMIT_BRANCH ($CI_COMMIT_SHORT_SHA)..."
+    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java libraries (job = $CI_JOB_NAME, ref = $CI_COMMIT_REF_NAME, commit = $CI_COMMIT_SHORT_SHA) ..."
   script:
-    # Note: supply internal repo as tests use native dependencies that might not be published, yet.
-    - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS $CENTRAL_REPO_ARGS publishMavenJavaPublicationToSonatypeRepository closeAndReleaseSonatypeStagingRepository
+    # Note: supply internal repo as tests use native dependencies that might not be available publicly, yet.
+    - ./gradlew $GITLAB_REPO_ARGS $CENTRAL_PUBLISH_ARGS publishAllPublicationsToSonatypeRepository closeAndReleaseSonatypeStagingRepository
   after_script:
-    # Also runs on failure, so show CI_JOB_STATUS.
-    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java library:* *$CI_JOB_STATUS* for $CI_JOB_NAME"
+    # Also runs on failure, so print CI_JOB_STATUS
+    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java libraries (job = $CI_JOB_NAME, ref = $CI_COMMIT_REF_NAME, commit = $CI_COMMIT_SHORT_SHA) job status = *$CI_JOB_STATUS*"
     - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "Check https://repo1.maven.org/maven2/io/objectbox/ in a few minutes."
 
+# Create Java API docs archive
 package-api-docs:
+  <<: *docker_linux_x64_android
   stage: package-api-docs
-  tags: [ docker, x64 ]
-  only:
-    - publish
+  rules:
+    # Only if publishing a release, only if no previous stages failed
+    - if: $OBX_PUBLISH_RELEASE == "true"
+      when: on_success
   script:
-    - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS :objectbox-java:packageJavadocForWeb
+    - ./gradlew $GITLAB_REPO_ARGS :objectbox-java:packageJavadocForWeb
   after_script:
     - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "API docs for web available as job artifact $CI_JOB_URL"
   artifacts:
     paths:
       - "objectbox-java/build/dist/objectbox-java-web-api-docs.zip"
 
+# Trigger Gradle plugin build to test new Maven snapshots of this project
 trigger-plugin:
   stage: triggers
-  except:
-    - schedules # Do not trigger when run on schedule, e.g. integ tests have own schedule.
-    - publish
+  rules:
+    # Not for tag pipelines
+    - if: $CI_COMMIT_TAG
+    - when: never
+    # Not when publishing a release
+    - if: $OBX_PUBLISH_RELEASE == "true"
+      when: never
+    # Do not trigger publishing of plugin
+    - if: $CI_COMMIT_BRANCH == "publish"
+      when: never
+    # Not for scheduled pipelines where Maven snapshots of this project do not change
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+      when: never
+    # Otherwise, only if no previous stages failed. Also set allow_failure in case branch does not exist downstream.
+    - when: on_success
   inherit:
     variables: false
-  allow_failure: true # Branch might not exist, yet, in plugin project.
+  allow_failure: true # Branch might not exist in plugin project
   trigger:
     project: objectbox/objectbox-plugin
     branch: $CI_COMMIT_BRANCH
diff --git a/.gitlab/merge_request_templates/Default.md b/.gitlab/merge_request_templates/Default.md
index 4ebced4c..100c5fd0 100644
--- a/.gitlab/merge_request_templates/Default.md
+++ b/.gitlab/merge_request_templates/Default.md
@@ -1,23 +1,28 @@
-## What does this MR do?
+## What does this merge request do?
 
-<!-- Briefly describe what this MR is about. -->
+TODO Link associated issue from title, like: `<title> #NUMBER`
+
+TODO Briefly list what this merge request is about
 
 ## Author's checklist
 
-- [ ] The MR fully addresses the requirements of the associated task.
-- [ ] I did a self-review of the changes and did not spot any issues. Among others, this includes:
-  * I added unit tests for new/changed behavior; all test pass.
-  * My code conforms to our coding standards and guidelines.
-  * My changes are prepared in a way that makes the review straightforward for the reviewer.
+- [ ] This merge request fully addresses the requirements of the associated task
+- [ ] I did a self-review of the changes and did not spot any issues, among others:
+  - I added unit tests for new or changed behavior; existing and new tests pass
+  - I checked the SpotBugs report for new issues
+  - My code conforms to our coding standards and guidelines
+  - My changes are prepared (focused commits, good messages) so reviewing them is easy for the reviewer
+- [ ] I amended the [changelog](/CHANGELOG.md) if this affects users in any way
+- [ ] I assigned a reviewer to request review
 
-## Review checklist
+## Reviewer's checklist
 
-- [ ] I reviewed all changes line-by-line and addressed relevant issues 
+- [ ] I reviewed all changes line-by-line and addressed relevant issues. However:
+  - for quickly resolved issues, I considered creating a fixup commit and discussing that, and
+  - instead of many or long comments, I considered a meeting with or a draft commit for the author.
 - [ ] The requirements of the associated task are fully met
-- [ ] I can confirm that:  
-  * CI passes
-  * Coverage percentages do not decrease
-  * New code conforms to standards and guidelines
-  * If applicable, additional checks were done for special code changes (e.g. core performance, binary size, OSS licenses)
-
-/assign me
+- [ ] I can confirm that:
+  - CI passes
+  - If applicable, coverage percentages do not decrease
+  - New code conforms to standards and guidelines
+  - If applicable, additional checks were done for special code changes (e.g. core performance, binary size, OSS licenses)
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..ece02fa5
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,42 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+- Multi-module Gradle build. Core modules live at the repo root: `objectbox-java-api`, `objectbox-java`, `objectbox-kotlin`, `objectbox-rxjava`, `objectbox-rxjava3`, and `objectbox-android`.
+- `objectbox-android` requires the Android SDK; exclude it with `-PexcludeAndroid=true` if the SDK is unavailable.
+- Test modules live under `tests/`, notably `tests/objectbox-java-test` and `tests/test-proguard`.
+- Shared build logic (e.g., publishing conventions) lives in the `build-logic/` included build.
+- Source follows standard Gradle layout per module (e.g., `src/main/java`, `src/main/kotlin`, `src/test/java`).
+- CI config: `.gitlab-ci.yml` (primary; Jenkins is obsolete); helper scripts live in `scripts/`; build outputs go to `build/`.
+
+## Build, Test, and Development Commands
+- `./gradlew clean build` — full build across modules.
+- `./gradlew :objectbox-java:build` — build a single module.
+- `./gradlew :tests:objectbox-java-test:test` — run the main test suite.
+- `./gradlew :tests:objectbox-java-test:test --tests io.objectbox.query.QueryTest` — run a single test class.
+- `./gradlew -version` — verify Gradle/JDK setup.
+- `./scripts/test-with-asan.sh --stacktrace clean build` — CI-style run with ASAN (requires native deps; currently disabled in CI, see issue #273).
+
+## Coding Style & Naming Conventions
+- No repo-wide formatter config is present; follow existing Java/Kotlin style in the touched files and keep changes minimal.
+- Use 4-space indentation and standard Java/Kotlin naming conventions; prefer package naming under `io.objectbox`.
+- New tests in `tests/objectbox-java-test` should name methods as `{attribute}_{queryCondition}_{expectation}` (see `tests/README.md`).
+
+## Testing Guidelines
+- Tests are JUnit-based (see `tests/objectbox-java-test/build.gradle.kts`).
+- Tests run against the real native database library (`io.objectbox:objectbox-linux`/`-macos`/`-windows` from Maven).
+  Snapshot versions of these resolve only via the internal GitLab repository (`gitlabUrl`/`gitlabPrivateToken` Gradle properties, see `settings.gradle.kts`).
+- Place new tests under `tests/objectbox-java-test/src/test/java` (or Kotlin equivalents).
+- Legacy tests may still use the `test*` prefix; new tests should follow the naming convention above.
+
+## Key Classes & Hotspots
+- Core API: `io.objectbox.BoxStore`, `io.objectbox.Box`, and `io.objectbox.Transaction` (see `tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java` and `tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java`).
+- Queries: `io.objectbox.query.Query`, `QueryBuilder`, and `QueryCondition` (see `tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java` and `tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest2.java`).
+- Relations: `io.objectbox.relation.ToOne` and `ToMany` (see `tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java`).
+- Sync: `io.objectbox.sync.SyncClient`, `SyncServer`, and `SyncCredentials` (see `tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncTest.java`).
+
+## Commit & Pull Request Guidelines
+- The default branch for development and PRs is `dev`; the `publish` branch is used for releases to Maven Central.
+- Recent history uses a short area prefix, e.g., `QueryTest: use new API...` or `TargetIdProperty: improve...`. Follow this pattern for new commits.
+- Add user-facing changes to the "Next release" section of `CHANGELOG.md`.
+- PRs should include a concise summary, rationale, and the exact test commands run.
+- If changes affect native or CI behavior, call that out explicitly (CI tests against the oldest supported JDK 8 and a recent JDK, see `.gitlab-ci.yml`).
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 00000000..3d89fa82
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,318 @@
+# Changelog
+
+Notable changes to the ObjectBox Java library.
+
+For more insights into what changed in the database libraries, [check the ObjectBox C changelog](https://github.com/objectbox/objectbox-c/blob/main/CHANGELOG.md).
+
+## 6.0.0-beta - 2026-07-14
+
+* Update Android and JVM libraries to database version `6.0.0-beta-2026-07-13`
+  * Admin: modernized user interface based on Vue.js 3 and Material Design 3
+  * Admin: optimized pages now loading faster
+  * Android: log messages now use the logcat tag "ObjectBox" (previously "Box")
+  * Internal fixes and improvements
+* objectbox-kotlin: requires at least Kotlin compiler and standard library 2.2.0
+
+### Sync
+
+* **New** [Mesh Sync API](https://sync.objectbox.io/mesh-sync): peer-to-peer (P2P) synchronization between sync clients without a central server.  
+  * Attach a `MeshConfig` via `SyncBuilder.mesh()` and query the running mesh via `SyncClient.getMesh()` (state, connected peer count, statistics counters). 
+    Mesh configurations are created by ObjectBox platform libraries that provide a mesh network (transport).
+  * New artifact `objectbox-meshsync-android`: provides the mesh network for Android using Google Nearby Connections. Add it next to the Sync variant of the Android library (like `objectbox-sync-android`) and create a mesh configuration with `AndroidMeshSync.createConfig(context, meshId)`. It includes the permissions required by Nearby Connections and the `play-services-nearby` dependency. See [its README for details](objectbox-meshsync-android/README.md).
+
+## 5.4.2 - 2026-05-05
+
+- Update Android and JVM libraries to database version `5.3.2-2026-05-05`
+  - Fixed a corner case with "unique replace on conflict" and absent (e.g. null) sync clock value
+  - Internal fixes and improvements
+
+## 5.4.1 - 2026-03-26
+
+- Update Android and JVM libraries to database version `5.3.1-2026-03-26`
+
+### Sync
+
+- Critical fix for sync clock property handling
+
+## 5.4.0 - 2026-03-24
+
+- Update Android and JVM libraries to database version `5.3.0-2026-03-23`
+- Admin: Status tab "Count and Sizes" and "System and Info" improved
+
+### Sync
+
+- Conflict resolution via the new annotations `@SyncClock` and `@SyncPrecedence` (allows last win with custom conflict
+  resolution)
+- Fix bad Sync client state after multiple full sync messages were interrupted
+- Fix adding indexes to Sync types
+
+## 5.3.0 - 2026-03-10
+
+- Gradle plugin: to apply the plugin, it is no longer necessary to add a manual mapping of the plugin ID in your
+  projects Gradle settings file. This was resolved by publishing Gradle plugin marker artifacts.
+  [#960](https://github.com/objectbox/objectbox-java/issues/960)
+- Gradle plugin: it is no longer necessary to apply the plugin after the dependencies block when manually including
+  ObjectBox dependencies.
+- Update database libraries for Android and JVM to database version `5.2.0-next-2026-03-10`
+- (Minor) performance improvements of HNSW vector search on Linux ARM targets
+                    
+### Sync
+
+- Sync protocol version 10
+- SyncClient: support updating filter variables. After login, stage updates using put and remove, then schedule to send
+  them to the server with `applyFilterVariables()`.
+- Update client sync filters variables when online
+- Clients report errors to the server
+
+### Migration instructions
+
+#### Drop the Gradle plugin ID mapping
+
+If your `settings.gradle.kts` or `settings.gradle` file contains lines similar to:
+
+```kotlin
+pluginManagement {
+    repositories {
+        mavenCentral()
+    }
+    
+    resolutionStrategy {
+        eachPlugin {
+            if (requested.id.id == "io.objectbox") {
+                useModule("io.objectbox:objectbox-gradle-plugin:${requested.version}")
+            }
+        }
+    }
+}
+```
+
+Update them to remove the plugin mapping configuration:
+
+```kotlin
+pluginManagement {
+    repositories {
+        mavenCentral()
+    }
+}
+```
+
+#### Apply the plugin using plugins syntax
+
+If your build scripts are applying the plugin after the dependencies block similar to:
+
+```kotlin
+dependencies {
+    // ...  
+} 
+
+apply(plugin = "io.objectbox")
+```
+
+Change them to apply the plugin using plugins syntax:
+
+```kotlin
+plugins {
+    id("io.objectbox")
+}
+
+dependencies {
+    // ...  
+}
+```
+
+## 5.2.0 - 2026-02-16
+
+- The [ObjectBox Gradle plugin](https://github.com/objectbox/objectbox-java-generator) requires JDK 11 and Android
+  Gradle Plugin 8.1 or newer.
+- Update database libraries for Android and JVM to database version `5.1.1-pre-2026-02-16`.
+- Admin: new "Counts and Sizes" view (via Status page) to give an overview over all types their object counts and sizes
+- Admin: fix reload via browser to stay on the page
+- Admin: schema view to display flags as text
+- Admin: refresh button for the data view
+
+### Sync
+
+- Add simplified `Sync.client(boxStore)` helper method. Move URL and credentials options to builder, add variants that 
+  accept multiple URLs and credentials. Deprecate the existing helper methods.
+- Add Sync client builder option to configure Sync behavior using 
+  [SyncFlags](objectbox-java/src/main/java/io/objectbox/sync/SyncFlags.java).
+
+## 5.1.0 - 2026-01-26
+
+- Add [ObjectBoxThreadPoolExecutor](objectbox-java/src/main/java/io/objectbox/ObjectBoxThreadPoolExecutor.java), a
+  default implementation of a `ThreadPoolExecutor` that properly cleans up thread-local Box resources.
+- Add methods `newCachedThreadPoolExecutor()` and `newFixedThreadPoolExecutor()` to `BoxStore` to help create instances
+  of `ObjectBoxThreadPoolExecutor` for common uses.
+- Add methods `newCachedThreadPoolDispatcher()` and `newFixedThreadPoolDispatcher()` to the Kotlin extension functions
+  for `BoxStore` to help create common coroutine dispatchers backed by an `ObjectBoxThreadPoolExecutor`.
+- `BoxStore.runInTx` and `callInTx` close a write cursor even if the runnable or callable throws. This would previously
+  result in cursor not closed warnings when the cursor was closed by the finalizer daemon. 
+- `BoxStore` no longer gets stuck while closing when deleting transactions created in other threads with open relation
+  cursors.
+- Admin: the Schema view now shows if external name of types and properties if configured.
+- Admin: the Schema view now shows the type as text (e.g. "String") instead of the internal type ID.
+                          
+### Sync
+
+- New Sync protocol V8: using new clients also requires a server update
+- Remove superfluous sync listener triggers when sync filters "report updates" (SKIP_TX)
+- Sync clients compress earlier: reduces disk storage for outgoing data
+- Reworked certificates for Apple platforms
+- Removed support for older Sync protocol versions before 2024-09; protocol V5+ is now required.
+
+## 5.0.1 - 2025-09-30
+
+- Update runtime libraries for Android and JVM to database version `5.0.0-2025-09-27`.
+- Fix a race condition with a closing store and still active transactions that kept the store from closing.
+  For Android this may fix some rare ANR issues.
+
+### Sync
+
+- Add `filterVariables` option to `SyncClient` builder for [Sync filters](https://sync.objectbox.io/sync-server/sync-filters)
+  introduced in version 5.0.
+
+## 5.0.0 - 2025-09-17
+
+- Includes runtime libraries for Android and JVM with database version `5.0.0-2025-09-16`.
+  - Android: Prior to Android 8.0, don't crash when inserting objects with string lists whose size exceeds the local
+    reference table size. [#1215](https://github.com/objectbox/objectbox-java/issues/1215) 
+  - ToOne relations: when deleting an object with an ID larger than the maximum 32-bit unsigned integer 
+    (`4_294_967_295`) that is used as the target object of a ToOne, correctly re-set the target ID of the ToOne to
+    `0`. [objectbox-dart#740](https://github.com/objectbox/objectbox-dart/issues/740) 
+- When re-creating a `BoxStore` for the same directory and `close()` wasn't called on the previous instance, don't throw
+  an "Another BoxStore is still open for this directory" exception. Note that calling `close()` *is recommended* before 
+  creating a new instance. [#1201](https://github.com/objectbox/objectbox-java/issues/1201)
+- When using `BoxStoreBuilder.buildDefault()`, don't leak the Store when setting it as default fails.
+- To help diagnose, print stacks of all threads in the internal thread pool if shutting it down takes too long when
+  closing `BoxStore`.
+- Remove deprecated APIs:
+  - `Query.setParameters` methods that set a single parameter, use the `setParameter` methods instead.
+  - `Box.removeByKeys`, use `Box.removeByIds` instead.
+  - `BoxStore.sizeOnDisk`, use `getDbSize` or `getDbSizeOnDisk` instead which properly handle in-memory databases.
+  - `BoxStoreBuilder.debugTransactions`, use `debugFlags(DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE)` instead.
+  - `SyncServerBuilder` `peer` configuration options, use the `clusterPeer` options instead.
+  - `io.objectbox.DebugFlags`, use `io.objectbox.config.DebugFlags` instead.
+  - `ValidateOnOpenMode` constants, use `ValidateOnOpenModePages` instead.
+  - DAOcompat compatibility query methods. Use the regular query API instead.           
+
+### Sync
+
+- Support Sync server version 5.0.
+  - **User-Specific Data Sync**: support configuring [Sync filter](https://sync.objectbox.io/sync-server/sync-filters) 
+    variables on `SyncClient`.
+
+## 4.3.1 - 2025-08-12
+
+- Requires at least Kotlin compiler and standard library 1.7.
+- Data Observers: closing a Query now waits on a running publisher to finish its query, preventing a VM crash. [#1147](https://github.com/objectbox/objectbox-java/issues/1147)
+- Update database libraries for Android and JVM to version `4.3.1` (include database version `4.3.1-2025-08-02`).
+
+## 4.3.0 - 2025-05-13
+
+- Basic support for boolean array properties (`boolean[]` in Java or `BooleanArray` in Kotlin).
+- The Windows database library now statically links the MSVC runtime to avoid crashes in incompatible `msvcp140.dll` 
+  shipped with some JDKs.
+- External property types (via [MongoDB connector](https://sync.objectbox.io/mongodb-sync-connector)):
+  - add `JSON_TO_NATIVE` to support sub (embedded/nested) documents/arrays in MongoDB
+  - support ID mapping to UUIDs (v4 and v7)
+- Admin: add class and dependency diagrams to the schema page (view and download).
+- Admin: improved data view for large vectors by displaying only the first elements and the full vector in a dialog.
+- Admin: detects images stored as bytes and shows them as such (PNG, GIF, JPEG, SVG, WEBP).
+
+### Sync
+
+- Add "Log Events" for important server events, which can be viewed on a new Admin page.
+- Detect and ignore changes for objects that were put but were unchanged.
+- The limit for message size was raised to 32 MB.
+- Transactions above the message size limit now already fail on the client (to better enforce the limit).
+
+## 4.2.0 - 2025-03-04
+
+- Add new query conditions `equalKeyValue`, `greaterKeyValue`, `lessKeyValue`, `lessOrEqualKeyValue`, and 
+  `greaterOrEqualKeyValue` that are helpful to write complex queries for [string maps](https://docs.objectbox.io/advanced/custom-types#flex-properties).
+  These methods support `String`, `long` and `double` data types for the values in the string map.
+- Deprecate the `containsKeyValue` condition, use the new `equalKeyValue` condition instead.
+- Android: to build, at least Android Plugin 8.1.1 and Gradle 8.2.1 are required.
+
+## 4.1.0 - 2025-01-30
+
+- Vector Search: add new `VectorDistanceType.GEO` distance type to perform vector searches on geographical coordinates.
+  This is particularly useful for location-based applications.
+- Android: require Android 5.0 (API level 21) or higher.
+- Note on Windows JVM: We've seen crashes on Windows when creating a BoxStore on some JVM versions.
+  If this should happen to you, make sure to update your JVM to the latest patch release
+  (8.0.432+6, 11.0.25+9, 17.0.13+11 and 21.0.5+11-LTS are known to work).
+
+### Sync
+
+- Add JWT authentication
+- Sync clients can now send multiple credentials for login
+
+## 4.0.3 - 2024-10-15
+
+- Make closing the Store more robust. In addition to transactions, it also waits for ongoing queries. This is just an
+  additional safety net. Your apps should still make sure to finish all Store operations, like queries, before closing it.
+- [Flex properties](https://docs.objectbox.io/advanced/custom-types#flex-properties) support `null` map and list values.
+- Some minor vector search performance improvements.
+
+### Sync
+
+- **Fix a serious regression, please update as soon as possible.**
+- Add new options, notably for cluster configuration, when building `SyncServer`. Improve documentation.
+  Deprecate the old peer options in favor of the new cluster options.
+- Add `SyncHybrid`, a combination of a Sync client and a Sync server. It can be used in local cluster setups, in
+  which a "hybrid" functions as a client & cluster peer (server).
+
+## 4.0.2 - 2024-08-20
+
+- Add convenience `oneOf` and `notOneOf` conditions that accept `Date` to avoid manual conversion using `getTime()`.
+- When `BoxStore` is closing, briefly wait on active transactions to finish.
+- Guard against crashes when `BoxStore` was closed, but database operations do still occur concurrently (transactions are still active).
+
+## 4.0.1 - 2024-06-03
+
+- Examples: added [Vector Search example](https://github.com/objectbox/objectbox-examples/tree/main/java-main-vector-search) that demonstrates how to perform on-device [approximate nearest neighbor (ANN) search](https://docs.objectbox.io/on-device-vector-search).
+- Revert deprecation of `Box.query()`, it is still useful for queries without any condition.
+- Add note on old query API methods of `QueryBuilder` that they are not recommended for new projects. Use [the new query APIs](https://docs.objectbox.io/queries) instead.
+- Update and expand documentation on `ToOne` and `ToMany`.
+
+## 4.0.0 - Vector Search - 2024-05-16
+
+**ObjectBox now supports** [**Vector Search**](https://docs.objectbox.io/ann-vector-search) to enable efficient similarity searches.
+
+This is particularly useful for AI/ML/RAG applications, e.g. image, audio, or text similarity. Other use cases include semantic search or recommendation engines.
+
+Create a Vector (HNSW) index for a floating point vector property. For example, a `City` with a location vector:
+
+```java
+@Entity
+public class City {
+
+    @HnswIndex(dimensions = 2)
+    float[] location;
+    
+}
+```
+
+Perform a nearest neighbor search using the new `nearestNeighbors(queryVector, maxResultCount)` query condition and the new "find with scores" query methods (the score is the distance to the query vector). For example, find the 2 closest cities:
+
+```java
+final float[] madrid = {40.416775F, -3.703790F};
+final Query<City> query = box
+        .query(City_.location.nearestNeighbors(madrid, 2))
+        .build();
+final City closest = query.findWithScores().get(0).get();
+```
+
+For an introduction to Vector Search, more details and other supported languages see the [Vector Search documentation](https://docs.objectbox.io/ann-vector-search).
+
+- BoxStore: deprecated `BoxStore.sizeOnDisk()`. Instead use one of the new APIs to determine the size of a database:
+  - `BoxStore.getDbSize()` which for a file-based database returns the file size and for an in-memory database returns the approximately used memory,
+  - `BoxStore.getDbSizeOnDisk()` which only returns a non-zero size for a file-based database.
+- Query: add properly named `setParameter(prop, value)` methods that only accept a single parameter value, deprecated the old `setParameters(prop, value)` variants.
+- Sync: add `SyncCredentials.userAndPassword(user, password)`.
+- Gradle plugin: the license of the [Gradle plugin](https://github.com/objectbox/objectbox-java-generator) has changed to the GNU Affero General Public License (AGPL).
+
+## Previous versions
+
+See the [Changelogs in the documentation](https://docs.objectbox.io/changelogs).
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..5cbfa334
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+See @AGENTS.md for repository guidelines
diff --git a/Jenkinsfile b/Jenkinsfile
index 2495fb7c..0b821e72 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -6,7 +6,7 @@ String buildsToKeep = '500'
 
 String gradleArgs = '--stacktrace'
 boolean isPublish = BRANCH_NAME == 'publish'
-String versionPostfix = isPublish ? '' : BRANCH_NAME // Build script detects empty string as not set.
+String versionSuffix = isPublish ? '' : BRANCH_NAME // Build script detects empty string as not set.
 
 // Note: using single quotes to avoid Groovy String interpolation leaking secrets.
 def signingArgs = '-PsigningKeyFile=$SIGNING_FILE -PsigningKeyId=$SIGNING_ID -PsigningPassword=$SIGNING_PWD'
@@ -56,7 +56,7 @@ pipeline {
 
         stage('build-java') {
             steps {
-                sh "./ci/test-with-asan.sh $gradleArgs $signingArgs $gitlabRepoArgs clean build"
+                sh "./scripts/test-with-asan.sh $gradleArgs $signingArgs $gitlabRepoArgs clean build"
             }
             post {
                 always {
@@ -78,7 +78,7 @@ pipeline {
                 // "|| true" for an OK exit code if no file is found
                 sh 'rm tests/objectbox-java-test/hs_err_pid*.log || true'
                 // Note: do not run check task as it includes SpotBugs.
-                sh "./ci/test-with-asan.sh $gradleArgs $gitlabRepoArgs clean :tests:objectbox-java-test:test"
+                sh "./scripts/test-with-asan.sh $gradleArgs $gitlabRepoArgs clean :tests:objectbox-java-test:test"
             }
             post {
                 always {
@@ -95,7 +95,7 @@ pipeline {
                 // "|| true" for an OK exit code if no file is found
                 sh 'rm tests/objectbox-java-test/hs_err_pid*.log || true'
                 // Note: do not run check task as it includes SpotBugs.
-                sh "./ci/test-with-asan.sh $gradleArgs $gitlabRepoArgs clean :tests:objectbox-java-test:test"
+                sh "./scripts/test-with-asan.sh $gradleArgs $gitlabRepoArgs clean :tests:objectbox-java-test:test"
             }
             post {
                 always {
@@ -107,7 +107,7 @@ pipeline {
 
         stage('upload-to-internal') {
             steps {
-                sh "./gradlew $gradleArgs $signingArgs $gitlabRepoArgs -PversionPostFix=$versionPostfix publishMavenJavaPublicationToGitLabRepository"
+                sh "./gradlew $gradleArgs $signingArgs $gitlabRepoArgs -PversionSuffix=$versionSuffix publishMavenJavaPublicationToGitLabRepository"
             }
         }
 
diff --git a/README.md b/README.md
index 5b4a5baf..761ae1ad 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-<p align="center"><img width="466" src="https://raw.githubusercontent.com/objectbox/objectbox-java/master/logo.png"></p>
+<p align="center"><img width="466" src="https://raw.githubusercontent.com/objectbox/objectbox-java/master/logo.png" alt="ObjectBox"></p>
 
 <p align="center">
   <a href="https://docs.objectbox.io/getting-started">Getting Started</a> •
@@ -8,10 +8,12 @@
 </p>
 
 <p align="center">
-  <a href="https://docs.objectbox.io/#objectbox-changelog">
+  <a href="https://github.com/objectbox/objectbox-java/releases/latest">
     <img src="https://img.shields.io/github/v/release/objectbox/objectbox-java?color=7DDC7D&style=flat-square" alt="Latest Release">
   </a>
-  <img src="https://img.shields.io/github/stars/objectbox/objectbox-java?color=17A6A6&logo=github&style=flat-square" alt="Star objectbox-java">
+  <a href="https://github.com/objectbox/objectbox-java/stargazers">
+    <img src="https://img.shields.io/github/stars/objectbox/objectbox-java?color=17A6A6&logo=github&style=flat-square" alt="Star objectbox-java">
+  </a>
   <a href="https://github.com/objectbox/objectbox-java/blob/main/LICENSE.txt">
     <img src="https://img.shields.io/github/license/objectbox/objectbox-java?color=7DDC7D&logo=apache&style=flat-square" alt="Apache 2.0 license">
   </a>
@@ -20,164 +22,434 @@
   </a>
 </p>
 
-# ObjectBox Java Database (Kotlin, Android)
+# ObjectBox - Fast and Efficient Java Database (Android, JVM) with Vector Search
+
+ObjectBox Java is a lightweight yet powerful on-device database & vector database designed specifically for **Java and Kotlin** applications.
+Store and manage data effortlessly in your Android or JVM Linux, macOS or Windows app with ObjectBox.
+Easily manage vector data alongside your objects and perform superfast on-device vector search to empower your apps with RAG AI, generative AI, and similarity search.
+Enjoy exceptional speed, battery-friendly resource usage, and environmentally-friendly development. 💚
 
-Java database - simple but powerful, frugal but fast. Embedded into your Android, Linux, macOS, iOS, or Windows app, store and manage data easily, enjoy ludicrous speed, build ecoconciously 💚 
+ObjectBox provides a store with boxes to put objects into:
 
-### Demo code
+#### JVM + Java example
 
 ```java
-// Java
-Playlist playlist = new Playlist("My Favorites");
-playlist.songs.add(new Song("Lalala"));
-playlist.songs.add(new Song("Lololo"));
-box.put(playlist);
+// Annotate a class to create a Box
+@Entity
+public class Person {
+  private @Id long id;
+  private String firstName;
+  private String lastName;
+
+  // Constructor, getters and setters left out for simplicity
+}
+ 
+BoxStore store = MyObjectBox.builder()
+        .name("person-db")
+        .build();
+ 
+Box<Person> box = store.boxFor(Person.class);
+ 
+Person person = new Person("Joe", "Green");
+long id = box.put(person);    // Create
+person = box.get(id);         // Read
+person.setLastName("Black");
+box.put(person);              // Update
+box.remove(person);           // Delete
 ```
---> [More details in the docs](https://docs.objectbox.io/)
+
+#### Android + Kotlin example
 
 ```kotlin
-// Kotlin
-val playlist = Playlist("My Favorites")
-playlist.songs.add(Song("Lalala"))
-playlist.songs.add(Song("Lololo"))
-box.put(playlist)
+// Annotate a class to create a Box
+@Entity
+data class Person(
+    @Id var id: Long = 0,
+    var firstName: String? = null,
+    var lastName: String? = null
+)
+ 
+val store = MyObjectBox.builder()
+                .androidContext(context)
+                .build()
+ 
+val box = store.boxFor(Person::class)
+ 
+var person = Person(firstName = "Joe", lastName = "Green")
+val id = box.put()   // Create
+person = box.get(id) // Read
+person.lastName = "Black"
+box.put(person)     // Update
+box.remove(person)  // Delete
 ```
 
 ## Table of Contents
-- [Why use ObjectBox](#why-use-objectbox-for-java-data-management--kotlin-data-management)
-  - [Features](#features)
-- [How to get started](#how-to-get-started)
+
+- [Key Features](#key-features)
+- [Getting Started](#getting-started)
   - [Gradle setup](#gradle-setup)
-  - [First steps](#first-steps)
-- [Already using ObjectBox?](#already-using-objectbox)
+  - [Maven setup](#maven-setup)
+- [Why use ObjectBox?](#why-use-objectbox-for-java-data-management)
+- [Community and Support](#community-and-support)
+- [Changelog](#changelog)
 - [Other languages/bindings](#other-languagesbindings)
 - [License](#license)
 
+## Key Features
 
-## Why use ObjectBox for Java data management / Kotlin data management?
+🧠 **First on-device vector database:** easily manage vector data and perform fast vector search
+🏁 **High performance:** exceptional speed, outperforming alternatives like SQLite and Realm in all CRUD operations.\
+💚 **Efficient Resource Usage:** minimal CPU, power and memory consumption for maximum flexibility and sustainability.\
+🔗 **[Built-in Object Relations](https://docs.objectbox.io/relations):** built-in support for object relations, allowing you to easily establish and manage relationships between objects.\
+👌 **Ease of use:** concise API that eliminates the need for complex SQL queries, saving you time and effort during development.
 
-The NoSQL Java database is built for storing data locally, offline-first on resource-restricted devices like phones.
+## Getting Started
 
-The database is optimized for high speed and low resource consumption on restricted devices, making it ideal for use on mobile devices. It uses minimal CPU, RAM, and power, which is not only great for users but also for the environment.
+> [!NOTE]
+> Prefer to look at example code? Check out [our examples repository](https://github.com/objectbox/objectbox-examples).
 
-Being fully ACID-compliant, ObjectBox is faster than any alternative, outperforming SQLite and Realm across all CRUD (Create, Read, Update, Delete) operations. Check out our [Performance Benchmarking App repository](https://github.com/objectbox/objectbox-performance).
+You can add the ObjectBox Java SDK using a:
 
-Our concise native-language API is easy to pick up and only requires a fraction of the code compared to SQLite. No more rows or columns, just plain objects (true POJOS) with built-in relations. It's great for handling large data volumes and allows changing your model whenever needed.
+- [Gradle setup](#gradle-setup)
+- [Maven setup](#maven-setup)
 
-All of this makes ObjectBox a smart choice for local data persistence with Java and Kotlin - it's efficient, easy and sustainable.
+ObjectBox tools and dependencies are available on [the Maven Central repository](https://central.sonatype.com/namespace/io.objectbox).
 
-### Features
+The database libraries available for the ObjectBox Java SDK support:
 
-🏁 **High performance** on restricted devices, like IoT gateways, micro controllers, ECUs etc.\
-💚 **Resourceful** with minimal CPU, power and Memory usage for maximum flexibility and sustainability\
-🔗 **[Relations](https://docs.objectbox.io/relations):** object links / relationships are built-in\
-💻 **Multiplatform:** Linux, Windows, Android, iOS, macOS, any POSIX system
+- JVM 8 or newer
+  - Linux (x64, arm64, armv7)
+  - macOS (x64, arm64)
+  - Windows (x64)
+- Android 5.0 (API level 21) or newer
 
-🌱 **Scalable:** handling millions of objects resource-efficiently with ease\
-💐 **[Queries](https://docs.objectbox.io/queries):** filter data as needed, even across relations\
-🦮 **Statically typed:** compile time checks & optimizations\
-📃 **Automatic schema migrations:** no update scripts needed
+The ObjectBox Java SDK supports:
 
-**And much more than just data persistence**\
-🔄 **[ObjectBox Sync](https://objectbox.io/sync/):** keeps data in sync between devices and servers\
-🕒 **[ObjectBox TS](https://objectbox.io/time-series-database/):** time series extension for time based data
+- Java 8 or newer
+- Kotlin 1.7 or newer
+
+The [ObjectBox Gradle plugin](https://github.com/objectbox/objectbox-java-generator) supports:
+
+- Gradle 7.0 or newer
+- Android Gradle Plugin 8.1 or newer
+- JDK 11 or newer
 
-## How to get started
 ### Gradle setup
 
-For Android projects, add the ObjectBox Gradle plugin to your root `build.gradle`: 
+For Gradle projects, add the required plugins to your root Gradle script.
+
+When using a [TOML version catalog](https://docs.gradle.org/current/userguide/version_catalogs.html) and plugins syntax 
+(for alternatives see below):
+          
+```toml
+# gradle/libs.versions.toml
+
+[versions]
+# For an Android project
+agp = "AGP_VERSION"
+# If using Kotlin
+kotlin = "KOTLIN_VERSION"
+
+# Define a variable for the version of the ObjectBox plugin
+objectbox = "6.0.0-beta"
+
+[plugins]
+# For an Android project, using Android Gradle Plugin 9.0 or newer
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-kapt = { id = "com.android.legacy-kapt", version.ref = "agp" }
+
+# For an Android project, using Android Gradle Plugin 8.13 or older
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" }
+
+# For a JVM project, if using Kotlin 
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" }
+
+# Add an alias for the ObjectBox plugin
+objectbox = { id = "io.objectbox", version.ref = "objectbox" }
+```
+
+```kotlin
+// build.gradle.kts
+
+plugins {
+    // For an Android project, using Android Gradle Plugin 9.0 or newer
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.kotlin.kapt) apply false  
+  
+    // For an Android project, using Android Gradle Plugin 8.13 or older
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.kotlin.android) apply false
+    alias(libs.plugins.kotlin.kapt) apply false
+
+    // For a JVM project, if using Kotlin
+    alias(libs.plugins.kotlin.jvm) apply false
+    alias(libs.plugins.kotlin.kapt) apply false
+  
+    // Add the ObjectBox plugin
+    alias(libs.plugins.objectbox) apply false  
+}
+```
+
+```kotlin
+// settings.gradle.kts
+
+pluginManagement {
+    repositories {
+        // Add Maven Central to the plugin repositories
+        mavenCentral()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        // Add Maven Central to the dependency repositories
+        mavenCentral()
+    }
+}
+```
+
+Then, in the Gradle script of your subproject apply the necessary plugins:
+
+```kotlin
+// app/build.gradle.kts
+
+plugins {
+    // For an Android project, using Android Gradle Plugin 9.0 or newer
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.kapt)
+    
+    // For an Android project, using Android Gradle Plugin 8.13 or older
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.kapt)
+    
+    // For a JVM project
+    id("application") // or id("java-library")
+    // Optional, if using Kotlin
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.kotlin.kapt)
+
+    // Finally, apply the ObjectBox plugin
+    alias(libs.plugins.objectbox)
+}
+```
+
+Finally, sync the Gradle project with your IDE (for ex. using "Sync Project with Gradle Files" in Android Studio).
+
+Your project can now use ObjectBox, continue by [defining entity classes](https://docs.objectbox.io/getting-started#define-entity-classes).
+
+#### Alternatives
+
+<details><summary>Using plugins syntax with plugin IDs</summary>
+
+```kotlin
+// build.gradle.kts
+
+plugins {
+    // Add the ObjectBox plugin
+    id("io.objectbox") version "6.0.0-beta" apply false
+}
+```
+
+```kotlin
+// settings.gradle.kts
+
+pluginManagement {
+    repositories {
+        // Add Maven Central to the plugin repositories
+        mavenCentral()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        // Add Maven Central to the dependency repositories
+        mavenCentral()
+    }
+}
+```
+
+</details>
+
+<details><summary>Using buildscript syntax (KTS)</summary>
+
+```kotlin
+// build.gradle.kts
 
-```groovy
 buildscript {
-    ext.objectboxVersion = "3.3.1"
-    repositories {        
+    // Define a variable for the ObjectBox plugin version
+    val objectboxVersion by extra("6.0.0-beta")
+  
+    repositories {
+        // Add Maven Central to the plugin repositories     
         mavenCentral()    
     }
+  
     dependencies {
+        // Add the ObjectBox plugin
         classpath("io.objectbox:objectbox-gradle-plugin:$objectboxVersion")
     }
 }
+
+allprojects {
+    repositories {
+        // Add Maven Central to the dependency repositories
+        mavenCentral()
+    }
+}
 ```
 
-And in your app's `build.gradle` apply the plugin:
+</details>
+
+<details><summary>Using buildscript syntax (Groovy)</summary>
 
 ```groovy
-// Using plugins syntax:
-plugins {
-    id("io.objectbox") // Add after other plugins.
+// build.gradle
+
+buildscript {
+    // Define a variable for the ObjectBox plugin version
+    ext.objectboxVersion = "6.0.0-beta"
+  
+    repositories {        
+        // Add Maven Central to the plugin repositories
+        mavenCentral()    
+    }
+  
+    dependencies {
+        // Add the ObjectBox plugin
+        classpath("io.objectbox:objectbox-gradle-plugin:$objectboxVersion")
+    }
 }
 
-// Or using the old apply syntax:
-apply plugin: "io.objectbox" // Add after other plugins.
+allprojects {
+    repositories {
+        // Add Maven Central to the dependency repositories
+        mavenCentral()
+    }
+}
 ```
 
-### First steps
+</details>
 
-Create a data object class `@Entity`, for example "Playlist".
-```
-// Kotlin
-@Entity data class Playlist( ... )
+Then, in the Gradle script of your subproject apply the necessary plugins using their IDs:
 
-// Java
-@Entity public class Playlist { ... }
+```kotlin
+// app/build.gradle.kts
+
+plugins {
+    // For an Android project, using Android Gradle Plugin 9.0 or newer
+    id("com.android.application") // or id("com.android.library")
+    id("com.android.legacy-kapt") 
+  
+    // For an Android project, using Android Gradle Plugin 8.13 or older
+    id("com.android.application") // or id("com.android.library")
+    id("org.jetbrains.kotlin.android") // or kotlin("android")
+    id("org.jetbrains.kotlin.kapt") // or kotlin("kapt")  
+  
+    // For a JVM project
+    id("application") // or id("java-library")
+    // Optional, if using Kotlin
+    id("org.jetbrains.kotlin.jvm") // or kotlin("jvm")
+    id("org.jetbrains.kotlin.kapt") // or kotlin("kapt")  
+
+    // Finally, apply the ObjectBox plugin
+    id("io.objectbox")
+}
 ```
-Now build the project to let ObjectBox generate the class `MyObjectBox` for you.
 
-Prepare the BoxStore object once for your app, e.g. in `onCreate` in your Application class:
+### Maven setup
 
-```java
-boxStore = MyObjectBox.builder().androidContext(this).build();
-```
+This is currently only supported for JVM projects.
 
-Then get a `Box` class for the Playlist entity class:
+To set up a Maven project, see the [README of the Java Maven example project](https://github.com/objectbox/objectbox-examples/blob/main/java-main-maven/README.md).
 
-```java
-Box<Playlist> box = boxStore.boxFor(Playlist.class);
-```
+## Frequently Asked Questions and Troubleshooting
+
+If you encounter any problems, check out the [FAQ](https://docs.objectbox.io/faq) and [Troubleshooting](https://docs.objectbox.io/troubleshooting) pages.
+
+## Why use ObjectBox for Java data management?
+
+ObjectBox is a NoSQL Java database designed for local data storage on resource-restricted devices, prioritizing
+offline-first functionality. It is a smart and sustainable choice for local data persistence in Java and Kotlin
+applications. It offers efficiency, ease of use, and flexibility.
+
+### Fast but resourceful
+
+Optimized for speed and minimal resource consumption, ObjectBox is an ideal solution for mobile devices. It has
+excellent performance, while also minimizing CPU, RAM, and power usage. ObjectBox outperforms SQLite and Realm across
+all CRUD (Create, Read, Update, Delete) operations. Check out our [Performance Benchmarking App repository](https://github.com/objectbox/objectbox-performance).
+
+### Simple but powerful
+
+With its concise language-native API, ObjectBox simplifies development by requiring less code compared to SQLite. It
+operates on plain objects (POJOs) with built-in relations, eliminating the need to manage rows and columns. This
+approach is efficient for handling large data volumes and allows for easy model modifications.
+
+### Functionality
+
+💐 **[Queries](https://docs.objectbox.io/queries):** filter data as needed, even across relations\
+💻 **[Multiplatform](https://docs.objectbox.io/faq#on-which-platforms-does-objectbox-run):** supports Android and JVM on Linux (also on ARM), Windows and macOS\
+🌱 **Scalable:** handling millions of objects resource-efficiently with ease\
+🦮 **Statically typed:** compile time checks & optimizations\
+📃 **Automatic schema migrations:** no update scripts needed
+
+**And much more than just data persistence**\
+🔄 **[ObjectBox Sync](https://objectbox.io/sync/):** keeps data in sync between devices and servers\
+🕒 **[ObjectBox TS](https://objectbox.io/time-series-database/):** time series extension for time based data
 
-The `Box` object gives you access to all major functions, like `put`, `get`, `remove`, and `query`.
+## Community and Support
 
-For details please check the [docs](https://docs.objectbox.io).     
+❤ **Tell us what you think!** Share your thoughts through our [Anonymous Feedback Form](https://forms.gle/bdktGBUmL4m48ruj7).
 
-## Already using ObjectBox?
+At ObjectBox, we are dedicated to bringing joy and delight to app developers by providing intuitive and fun-to-code-with
+APIs. We genuinely want to hear from you: What do you love about ObjectBox? What could be improved? Where do you face
+challenges in everyday app development?
 
-❤ **Your opinion matters to us!** Please fill in this 2-minute [Anonymous Feedback Form](https://forms.gle/bdktGBUmL4m48ruj7).
+**We eagerly await your comments and requests, so please feel free to reach out to us:**
 
-We believe, ObjectBox is super easy to use. We want to bring joy and delight to app developers with intuitive and fun to code with APIs. To do that, we want your feedback: what do you love? What's amiss? Where do you struggle in everyday app development?
+- Add [GitHub issues](https://github.com/ObjectBox/objectbox-java/issues)
+- Upvote important issues 👍
+- Drop us a line via contact[at]objectbox.io
+- ⭐ us on GitHub if you like what you see!
 
-**We're looking forward to receiving your comments and requests:**
-- Add [GitHub issues](https://github.com/ObjectBox/objectbox-java/issues) 
-- Upvote issues you find important by hitting the 👍/+1 reaction button
-- Drop us a line via [@ObjectBox_io](https://twitter.com/ObjectBox_io/) or contact[at]objectbox.io
-- ⭐ us, if you like what you see 
+Thank you! Stay updated with our [blog](https://objectbox.io/blog).
 
-Thank you! 🙏
+## Changelog
 
-Keep in touch: For general news on ObjectBox, [check our blog](https://objectbox.io/blog)!
+For notable and important changes in new releases, read the [changelog](CHANGELOG.md).
 
 ## Other languages/bindings
 
 ObjectBox supports multiple platforms and languages.
-Besides JVM based languages like Java and Kotlin, ObjectBox also offers: 
-
-* [Swift Database](https://github.com/objectbox/objectbox-swift): build fast mobile apps for iOS (and macOS) 
-* [Dart/Flutter Database](https://github.com/objectbox/objectbox-dart): cross-platform for mobile and desktop apps 
-* [Go Database](https://github.com/objectbox/objectbox-go): great for data-driven tools and embedded server applications 
-* [C and C++ Database](https://github.com/objectbox/objectbox-c): native speed with zero copy access to FlatBuffer objects
+Besides JVM based languages like Java and Kotlin, ObjectBox also offers:
 
+- [C and C++ SDK](https://github.com/objectbox/objectbox-c): native speed with zero copy access to FlatBuffer objects
+- [Dart and Flutter SDK](https://github.com/objectbox/objectbox-dart): cross-platform for mobile and desktop apps
+- [Go SDK](https://github.com/objectbox/objectbox-go): great for data-driven tools and embedded server applications
+- [Swift SDK](https://github.com/objectbox/objectbox-swift): build fast mobile apps for iOS (and macOS)
 
 ## License
 
-    Copyright 2017-2022 ObjectBox Ltd. All rights reserved.
-    
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-    
-        http://www.apache.org/licenses/LICENSE-2.0
-    
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
+```text
+Copyright 2017-2025 ObjectBox Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+Note that this license applies to the code in this repository only.
+See our website on details about all [licenses for ObjectBox components](https://objectbox.io/faq/#license-pricing).
diff --git a/build-logic/README.md b/build-logic/README.md
new file mode 100644
index 00000000..06701235
--- /dev/null
+++ b/build-logic/README.md
@@ -0,0 +1,26 @@
+# Build logic project
+
+This project provides common build logic and is included as a composite build in
+the root settings file (as it provides plugins, in the `pluginManagement` block
+instead of before the usual include statements):
+
+```kotlin
+pluginManagement {
+    includeBuild("build-logic")
+}
+```
+
+## Convention Plugins
+
+- [objectbox.dokka-conventions](src/main/kotlin/objectbox.dokka-conventions.gradle.kts):
+  creates a "javadocJar" task that builds a JAR from HTML API docs generated by
+  Dokka
+- [objectbox.publishing-conventions](src/main/kotlin/objectbox.publishing-conventions.gradle.kts):
+  adds GitLab repo, configures common Maven POM values, configures signing of
+  artifacts
+
+## Related Gradle documentation
+
+- https://docs.gradle.org/current/userguide/composite_builds.html#included_plugin_builds
+- https://docs.gradle.org/current/userguide/best_practices_structuring_builds.html#use_convention_plugins
+- https://github.com/gradle/gradle/tree/master/platforms/documentation/docs/src/snippets/best-practices/useConventionPlugins-do
diff --git a/build-logic/build.gradle.kts b/build-logic/build.gradle.kts
new file mode 100644
index 00000000..8de1b45f
--- /dev/null
+++ b/build-logic/build.gradle.kts
@@ -0,0 +1,7 @@
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    implementation(libs.buildLogic.dokka)
+}
diff --git a/build-logic/settings.gradle.kts b/build-logic/settings.gradle.kts
new file mode 100644
index 00000000..036a9328
--- /dev/null
+++ b/build-logic/settings.gradle.kts
@@ -0,0 +1,16 @@
+rootProject.name = "build-logic"
+
+// While this is an incubating API, it is the recommended way of declaring repositories:
+// https://docs.gradle.org/current/userguide/best_practices_dependencies.html#set_up_repositories_in_settings
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        mavenCentral()
+    }
+    // To avoid creating a separate version catalog in build-logic re-use the existing one
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
diff --git a/build-logic/src/main/kotlin/objectbox.dokka-conventions.gradle.kts b/build-logic/src/main/kotlin/objectbox.dokka-conventions.gradle.kts
new file mode 100644
index 00000000..c72fd464
--- /dev/null
+++ b/build-logic/src/main/kotlin/objectbox.dokka-conventions.gradle.kts
@@ -0,0 +1,36 @@
+// This convention plugin creates a task named "javadocJar" that creates a JAR
+// from HTML API docs generated with Dokka suitable to publish to Maven Central.
+
+import org.gradle.jvm.tasks.Jar
+
+plugins {
+    id("org.jetbrains.dokka")
+}
+
+// Web API docs for objectbox-java packages, URL must end with a /
+private val javaApiDocsBaseUrl = "https://objectbox.io/docfiles/java/current/"
+// Note: In JDK 9+ the package-list file was renamed to element-list
+private val javaApiDocsPackageListUrl = "${javaApiDocsBaseUrl}element-list"
+
+// https://kotlinlang.org/docs/dokka-gradle-configuration-options.html
+dokka {
+    dokkaPublications.html {
+        outputDirectory.set(layout.buildDirectory.dir("docs/javadoc"))
+    }
+    dokkaSourceSets.configureEach {
+        // Create external links to ObjectBox Java API docs
+        externalDocumentationLinks.register("objectbox-java-docs") {
+            url(javaApiDocsBaseUrl)
+            packageListUrl(javaApiDocsPackageListUrl)
+        }
+    }
+}
+
+val javadocJar by tasks.registering(Jar::class) {
+    description = "Javadoc JAR containing HTML API docs generated by Dokka"
+    group = "build"
+    // Classifier as required by Maven Central
+    // https://central.sonatype.org/publish/requirements/#supply-javadoc-and-sources
+    archiveClassifier.set("javadoc")
+    from(tasks.dokkaGeneratePublicationHtml.flatMap { it.outputDirectory })
+}
diff --git a/build-logic/src/main/kotlin/objectbox.publishing-conventions.gradle.kts b/build-logic/src/main/kotlin/objectbox.publishing-conventions.gradle.kts
new file mode 100644
index 00000000..7215aa46
--- /dev/null
+++ b/build-logic/src/main/kotlin/objectbox.publishing-conventions.gradle.kts
@@ -0,0 +1,102 @@
+// This convention plugin expects some Gradle project properties to be set
+// (to set as environment variable prefix with ORG_GRADLE_PROJECT_):
+// https://docs.gradle.org/current/userguide/build_environment.html#sec:project_properties
+//
+// To publish artifacts to the internal GitLab repo set:
+// - gitlabUrl
+// - gitlabPublishToken: a token with permission to publish to the GitLab Package Repository
+// - gitlabPublishTokenName: optional, if set used instead of "Private-Token". Use for CI to specify e.g. "Job-Token".
+//
+// To sign artifacts using an ASCII encoded PGP key given via a file set:
+// - signingKeyFile
+// - signingKeyId
+// - signingPassword
+
+// Gradle properties
+val gitlabUrl = providers.gradleProperty("gitlabUrl")
+val gitlabPublishToken = providers.gradleProperty("gitlabPublishToken")
+val gitlabPublishTokenName = providers.gradleProperty("gitlabPublishTokenName")
+// The following properties are used for signing in CI using a key file
+val signingKeyFile = providers.gradleProperty("signingKeyFile")
+val signingKeyId = providers.gradleProperty("signingKeyId")
+val signingPassword = providers.gradleProperty("signingPassword")
+
+plugins {
+    id("maven-publish")
+    id("signing")
+}
+
+publishing {
+    repositories {
+        // If the applied to project has the required properties, configures the "GitLab" repository for publishing
+        // (Note: always adding it, even without credentials, so it's possible to see the tasks created for it.)
+        maven {
+            name = "GitLab"
+            if (gitlabUrl.isPresent && gitlabPublishToken.isPresent) {
+                // "https://gitlab.example.com/api/v4/projects/<PROJECT_ID>/packages/maven"
+                url = uri("${gitlabUrl.get()}/api/v4/projects/14/packages/maven")
+                credentials(HttpHeaderCredentials::class) {
+                    name = gitlabPublishTokenName.orNull ?: "Private-Token"
+                    value = gitlabPublishToken.get()
+                }
+                authentication {
+                    create<HttpHeaderAuthentication>("header")
+                }
+                println("Publishing: configured GitLab repository $url")
+            } else {
+                println("Publishing: GitLab repository NOT configured, see publishing-conventions plugin for required project properties")
+            }
+        }
+        // Note: Sonatype repo created by publish-plugin, see root build.gradle.kts.
+    }
+
+    publications {
+        // Common settings for all Maven publications
+        withType<MavenPublication> {
+            // Note: Projects set additional specific properties.
+            pom {
+                url.set("https://objectbox.io")
+                licenses {
+                    license {
+                        name.set("The Apache Software License, Version 2.0")
+                        url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
+                        distribution.set("repo")
+                    }
+                }
+                developers {
+                    developer {
+                        id.set("ObjectBox")
+                        name.set("ObjectBox")
+                    }
+                }
+                issueManagement {
+                    system.set("GitHub Issues")
+                    url.set("https://github.com/objectbox/objectbox-java/issues")
+                }
+                organization {
+                    name.set("ObjectBox Ltd.")
+                    url.set("https://objectbox.io")
+                }
+                scm {
+                    connection.set("scm:git@github.com:objectbox/objectbox-java.git")
+                    developerConnection.set("scm:git@github.com:objectbox/objectbox-java.git")
+                    url.set("https://github.com/objectbox/objectbox-java")
+                }
+            }
+        }
+    }
+}
+
+signing {
+    if (signingKeyFile.isPresent && signingKeyId.isPresent && signingPassword.isPresent) {
+        // Sign using an ASCII-armored key read from a file
+        // https://docs.gradle.org/current/userguide/signing_plugin.html#using_in_memory_ascii_armored_openpgp_subkeys
+        val keyFilePath = signingKeyFile.get()
+        val signingKey = File(keyFilePath).readText()
+        useInMemoryPgpKeys(signingKeyId.get(), signingKey, signingPassword.get())
+        println("Publishing: signing configured with key file $keyFilePath")
+    } else {
+        isRequired = false // Don't run sign tasks
+        println("Publishing: signing NOT configured, see publishing-conventions plugin for required project properties")
+    }
+}
diff --git a/build.gradle.kts b/build.gradle.kts
index dea45ed9..a0791ce2 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,50 +1,72 @@
+/*
+ * This script supports some Gradle project properties:
+ *
+ * - versionSuffix: appended to snapshot version number, e.g. "1.2.3-<versionSuffix>-SNAPSHOT".
+ * Use to create different versions based on branch/tag.
+ * - sonatypeUsername: Maven Central credential used by Nexus publishing.
+ * - sonatypePassword: Maven Central credential used by Nexus publishing.
+ *
+ * This script supports the following environment variables:
+ *
+ * - OBX_RELEASE: If set to "true" builds and depends on release versions, without branch name and snapshot suffix.
+ */
+
+// Gradle properties (more defined in buildscript block below)
+val propertySonatypeUsername = providers.gradleProperty("sonatypeUsername")
+val propertySonatypePassword = providers.gradleProperty("sonatypePassword")
+
+plugins {
+    alias(libs.plugins.kotlin.jvm) apply false
+    alias(libs.plugins.kotlin.dokka) apply false
+    alias(libs.plugins.versions)
+    alias(libs.plugins.spotbugs) apply false
+    alias(libs.plugins.publish)
+    alias(libs.plugins.android.library) apply false
+}
+
 buildscript {
-    // Typically, only edit those two:
-    val objectboxVersionNumber = "3.3.2" // without "-SNAPSHOT", e.g. "2.5.0" or "2.4.0-RC"
-    val objectboxVersionRelease =
-        false  // set to true for releasing to ignore versionPostFix to avoid e.g. "-dev" versions
-
-    // version post fix: "-<value>" or "" if not defined; e.g. used by CI to pass in branch name
-    val versionPostFixValue = project.findProperty("versionPostFix")
-    val versionPostFix = if (versionPostFixValue != null) "-$versionPostFixValue" else ""
-    val obxJavaVersion by extra(objectboxVersionNumber + (if (objectboxVersionRelease) "" else "$versionPostFix-SNAPSHOT"))
-
-    // Native library version for tests
-    // Be careful to diverge here; easy to forget and hard to find JNI problems
-    val nativeVersion = objectboxVersionNumber + (if (objectboxVersionRelease) "" else "-dev-SNAPSHOT")
-    val osName = System.getProperty("os.name").toLowerCase()
-    val objectboxPlatform = when {
-        osName.contains("linux") -> "linux"
-        osName.contains("windows") -> "windows"
-        osName.contains("mac") -> "macos"
-        else -> "unsupported"
-    }
-    val obxJniLibVersion by extra("io.objectbox:objectbox-$objectboxPlatform:$nativeVersion")
-
-    val essentialsVersion by extra("3.1.0")
-    val juniVersion by extra("4.13.2")
-    val mockitoVersion by extra("3.8.0")
-    val kotlinVersion by extra("1.7.0")
-    val coroutinesVersion by extra("1.6.2")
-    val dokkaVersion by extra("1.6.10")
-
-    println("version=$obxJavaVersion")
-    println("objectboxNativeDependency=$obxJniLibVersion")
-
-    repositories {
-        mavenCentral()
-        maven {
-            url = uri("https://plugins.gradle.org/m2/")
-        }
-    }
+    // Environment variables (see notes at the top of this file)
+    // https://docs.gitlab.com/ci/variables/predefined_variables/
+    val envIsCI: Boolean = System.getenv("CI") == "true"
+    val envRelease: String? = System.getenv("OBX_RELEASE")
+    // Gradle properties (see notes at the top of this file)
+    val propertyVersionSuffixName = "versionSuffix"
+    val propertyVersionSuffix = providers.gradleProperty(propertyVersionSuffixName)
+
+    // Version of Maven artifacts
+    // Should only be changed as part of the release process, see the release checklist in the objectbox repo
+    val versionNumber = "6.0.0-beta"
+
+    // If OBX_RELEASE is set, build and depend on release versions. Doesn't publish a release.
+    // See the release checklist in the objectbox repo on how to publish a release.
+    // If true, Maven artifacts use a release version, so without branch name and snapshot suffix
+    // (such as "-dev-SNAPSHOT"), including for dependencies (such as objectbox-java).
+    val isRelease = envRelease == "true"
 
-    dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
-        classpath("org.jetbrains.dokka:dokka-gradle-plugin:$dokkaVersion")
-        // https://github.com/spotbugs/spotbugs-gradle-plugin/releases
-        classpath("gradle.plugin.com.github.spotbugs.snom:spotbugs-gradle-plugin:4.7.0")
-        classpath("io.github.gradle-nexus:publish-plugin:1.1.0")
+    if (!isRelease && envIsCI) {
+        throw GradleException("Publishing: property $propertyVersionSuffixName must be set in CI to calculate version suffix.")
     }
+
+    // version suffix: "-<value>" or "" if not defined; e.g. used by CI to pass in branch name
+    val versionSuffix = if (propertyVersionSuffix.isPresent) "-${propertyVersionSuffix.get()}" else ""
+    val obxJavaVersion by extra(versionNumber + (if (isRelease) "" else "$versionSuffix-SNAPSHOT"))
+    println("Publishing: version = $obxJavaVersion")
+
+    // JVM and Android database library versions
+    val versionDbJvm = if (isRelease) versionNumber else "$versionNumber-dev-SNAPSHOT"
+    val versionDbJvmSync = if (isRelease) versionNumber else "$versionNumber-sync-SNAPSHOT"
+    val versionDbAndroid = if (isRelease) versionNumber else "$versionNumber-dev-SNAPSHOT"
+    val versionDbAndroidSync = if (isRelease) versionNumber else "$versionNumber-sync-SNAPSHOT"
+
+    println("Database dependencies (JVM) = $versionDbJvm")
+    println("Database dependencies (JVM + Sync) = $versionDbJvmSync")
+    println("Database dependencies (Android) = $versionDbAndroid")
+    println("Database dependencies (Android + Sync) = $versionDbAndroidSync")
+
+    val versionDatabaseLibraryJvm by extra(versionDbJvm)
+    val versionDatabaseLibraryJvmSync by extra(versionDbJvmSync)
+    val versionDatabaseLibraryAndroid by extra(versionDbAndroid)
+    val versionDatabaseLibraryAndroidSync by extra(versionDbAndroidSync)
 }
 
 allprojects {
@@ -52,38 +74,55 @@ allprojects {
     val obxJavaVersion: String by rootProject.extra
     version = obxJavaVersion
 
-    repositories {
-        mavenCentral()
-    }
-
     configurations.all {
         // Projects are using snapshot dependencies that may update more often than 24 hours.
         resolutionStrategy {
             cacheChangingModulesFor(0, "seconds")
         }
     }
+
+    tasks.withType<Javadoc>().configureEach {
+        // To support Unicode characters in API docs force the javadoc tool to use UTF-8 encoding.
+        // Otherwise, it defaults to the system file encoding. This is required even though setting file.encoding
+        // for the Gradle daemon (see gradle.properties) as Gradle does not pass it on to the javadoc tool.
+        options.encoding = "UTF-8"
+    }
+}
+
+// Exclude pre-release versions from dependencyUpdates task
+fun isNonStable(version: String): Boolean {
+    val stableKeyword = listOf("RELEASE", "FINAL", "GA").any { version.uppercase().contains(it) }
+    val regex = "^[0-9,.v-]+(-r)?$".toRegex()
+    val isStable = stableKeyword || regex.matches(version)
+    return isStable.not()
+}
+tasks.withType<com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask> {
+    rejectVersionIf {
+        isNonStable(candidate.version)
+    }
 }
 
 tasks.wrapper {
     distributionType = Wrapper.DistributionType.ALL
 }
 
-// Plugin to publish to Central https://github.com/gradle-nexus/publish-plugin/
+// Plugin to publish to Maven Central https://github.com/gradle-nexus/publish-plugin/
 // This plugin ensures a separate, named staging repo is created for each build when publishing.
-apply(plugin = "io.github.gradle-nexus.publish-plugin")
-configure<io.github.gradlenexus.publishplugin.NexusPublishExtension> {
-    repositories {
+nexusPublishing {
+    this.repositories {
         sonatype {
-            if (project.hasProperty("sonatypeUsername") && project.hasProperty("sonatypePassword")) {
-                println("nexusPublishing credentials supplied.")
-                username.set(project.property("sonatypeUsername").toString())
-                password.set(project.property("sonatypePassword").toString())
+            // Use the Portal OSSRH Staging API as this plugin does not support the new Portal API
+            // https://central.sonatype.org/publish/publish-portal-ossrh-staging-api/#configuring-your-plugin
+            nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
+            snapshotRepositoryUrl.set(uri("https://central.sonatype.com/repository/maven-snapshots/"))
+
+            if (propertySonatypeUsername.isPresent && propertySonatypePassword.isPresent) {
+                println("Publishing: Maven Central credentials supplied")
+                username.set(propertySonatypeUsername.get())
+                password.set(propertySonatypePassword.get())
             } else {
-                println("nexusPublishing credentials NOT supplied.")
+                println("Publishing: Maven Central credentials NOT supplied, see root build script for required project properties")
             }
         }
     }
-    transitionCheckOptions {  // Maven Central may become very, very slow in extreme situations
-        maxRetries.set(900)  // with default delay of 10s, that's 150 minutes total; default is 60 (10 minutes)
-    }
 }
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
deleted file mode 100644
index 876c922b..00000000
--- a/buildSrc/build.gradle.kts
+++ /dev/null
@@ -1,7 +0,0 @@
-plugins {
-    `kotlin-dsl`
-}
-
-repositories {
-    mavenCentral()
-}
diff --git a/buildSrc/settings.gradle.kts b/buildSrc/settings.gradle.kts
deleted file mode 100644
index d6467987..00000000
--- a/buildSrc/settings.gradle.kts
+++ /dev/null
@@ -1,2 +0,0 @@
-// Recommended to create, but keep empty
-// https://docs.gradle.org/current/userguide/custom_plugins.html#sec:precompiled_plugins
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/objectbox-publish.gradle.kts b/buildSrc/src/main/kotlin/objectbox-publish.gradle.kts
deleted file mode 100644
index bc04e84e..00000000
--- a/buildSrc/src/main/kotlin/objectbox-publish.gradle.kts
+++ /dev/null
@@ -1,92 +0,0 @@
-plugins {
-    id("maven-publish")
-    id("signing")
-}
-
-// Make javadoc task errors not break the build, some are in third-party code.
-if (JavaVersion.current().isJava8Compatible) {
-    tasks.withType<Javadoc> {
-        isFailOnError = false
-    }
-}
-
-publishing {
-    repositories {
-        maven {
-            name = "GitLab"
-            if (project.hasProperty("gitlabUrl") && project.hasProperty("gitlabPrivateToken")) {
-                // "https://gitlab.example.com/api/v4/projects/<PROJECT_ID>/packages/maven"
-                val gitlabUrl = project.property("gitlabUrl")
-                url = uri("$gitlabUrl/api/v4/projects/14/packages/maven")
-                println("GitLab repository set to $url.")
-
-                credentials(HttpHeaderCredentials::class) {
-                    name = project.findProperty("gitlabTokenName")?.toString() ?: "Private-Token"
-                    value = project.property("gitlabPrivateToken").toString()
-                }
-                authentication {
-                    create<HttpHeaderAuthentication>("header")
-                }
-            } else {
-                println("WARNING: Can not publish to GitLab: gitlabUrl or gitlabPrivateToken not set.")
-            }
-        }
-        // Note: Sonatype repo created by publish-plugin, see root build.gradle.kts.
-    }
-
-    publications {
-        create<MavenPublication>("mavenJava") {
-            // Note: Projects set additional specific properties.
-            pom {
-                packaging = "jar"
-                url.set("https://objectbox.io")
-                licenses {
-                    license {
-                        name.set("The Apache Software License, Version 2.0")
-                        url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
-                        distribution.set("repo")
-                    }
-                }
-                developers {
-                    developer {
-                        id.set("ObjectBox")
-                        name.set("ObjectBox")
-                    }
-                }
-                issueManagement {
-                    system.set("GitHub Issues")
-                    url.set("https://github.com/objectbox/objectbox-java/issues")
-                }
-                organization {
-                    name.set("ObjectBox Ltd.")
-                    url.set("https://objectbox.io")
-                }
-                scm {
-                    connection.set("scm:git@github.com:objectbox/objectbox-java.git")
-                    developerConnection.set("scm:git@github.com:objectbox/objectbox-java.git")
-                    url.set("https://github.com/objectbox/objectbox-java")
-                }
-            }
-        }
-    }
-}
-
-signing {
-    if (hasSigningProperties()) {
-        val signingKey = File(project.property("signingKeyFile").toString()).readText()
-        useInMemoryPgpKeys(
-            project.property("signingKeyId").toString(),
-            signingKey,
-            project.property("signingPassword").toString()
-        )
-        sign(publishing.publications["mavenJava"])
-    } else {
-        println("Signing information missing/incomplete for ${project.name}")
-    }
-}
-
-fun hasSigningProperties(): Boolean {
-    return (project.hasProperty("signingKeyId")
-            && project.hasProperty("signingKeyFile")
-            && project.hasProperty("signingPassword"))
-}
diff --git a/ci/test-with-asan.sh b/ci/test-with-asan.sh
deleted file mode 100755
index 8220f44b..00000000
--- a/ci/test-with-asan.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-if [ -z "$ASAN_LIB_SO" ]; then
-    export ASAN_LIB_SO="$(find /usr/lib/llvm-7/ -name libclang_rt.asan-x86_64.so | head -1)"
-fi
-
-if [ -z "$ASAN_SYMBOLIZER_PATH" ]; then
-    export ASAN_SYMBOLIZER_PATH="$(find /usr/lib/llvm-7 -name llvm-symbolizer | head -1 )"
-fi
-
-if [ -z "$ASAN_OPTIONS" ]; then
-    export ASAN_OPTIONS="detect_leaks=0"
-fi
-
-echo "ASAN_LIB_SO: $ASAN_LIB_SO"
-echo "ASAN_SYMBOLIZER_PATH: $ASAN_SYMBOLIZER_PATH"
-echo "ASAN_OPTIONS: $ASAN_OPTIONS"
-ls -l $ASAN_LIB_SO
-ls -l $ASAN_SYMBOLIZER_PATH
-
-if [[ $# -eq 0 ]] ; then
-    args=test
-else
-    args=$@
-fi
-echo "Starting Gradle for target(s) \"$args\"..."
-pwd
-
-LD_PRELOAD=${ASAN_LIB_SO} ./gradlew ${args}
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 00000000..481e0078
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,15 @@
+# Gradle configuration
+# https://docs.gradle.org/current/userguide/build_environment.html
+
+# 1) Increase heap size from the default 512 MB for Android builds (using default value from Android
+# Studio project template).
+# https://docs.gradle.org/current/userguide/config_gradle.html#sec:configuring_jvm_memory
+# 2) To support Unicode characters in source code, set UTF-8 as the file encoding for the Gradle daemon,
+# which will make most Java tools use it instead of the default system file encoding. Note that for API docs,
+# the javadoc tool must be configured separately, see the root build script.
+# https://docs.gradle.org/current/userguide/common_caching_problems.html#system_file_encoding
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+
+# Android Plugin: use AndroidX dependencies
+# https://developer.android.com/jetpack/androidx/migrate
+android.useAndroidX=true
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
new file mode 100644
index 00000000..f6b25144
--- /dev/null
+++ b/gradle/libs.versions.toml
@@ -0,0 +1,76 @@
+[versions]
+# The versions of Gradle, Kotlin, Kotlin Coroutines and Android Gradle Plugin must be compatible.
+# Check
+# - https://kotlinlang.org/docs/gradle-configure-project.html#apply-the-plugin
+# - https://github.com/Kotlin/kotlinx.coroutines#readme
+# Note: when updating to a new minor version also have to increase the minimum
+# compiler and standard library version supported by consuming projects, see
+# objectbox-kotlin/ build script.
+# Note: if AGP Upgrade Assitant doesn't open, temporarily change to the com.android.application
+# plugin below. Also be aware that the latest version is likely not supported by IntelliJ IDEA.
+agp = "9.0.1" # https://developer.android.com/build/releases/gradle-plugin
+kotlin = "2.4.0"
+kotlin-coroutines = "1.11.0"
+# For objectbox-kotlin: a version of coroutines that depends on the same or older version of the
+# Kotlin standard library (org.jetbrains.kotlin:kotlin-stdlib) set as coreLibrariesVersion in its
+# build script. To find a suitable version, maybe use
+# https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core
+kotlin-coroutines-compat = "1.10.2" # 1.11.0 requires stdlib 2.2.20, so use 1.10.2
+# Dokka includes its own version of the Kotlin compiler, so it does not have to match the used
+# Kotlin version. But it might not understand new language features.
+kotlin-dokka = "2.2.0" # https://github.com/Kotlin/dokka/releases
+
+androidx-lifecycle = "2.6.1" # https://developer.android.com/jetpack/androidx/releases/lifecycle
+# Not using Paging v3 as it pulls in Kotlin
+androidx-paging = "2.1.2" # https://developer.android.com/jetpack/androidx/releases/paging
+androidx-test = "1.7.0" # https://developer.android.com/jetpack/androidx/releases/test
+androidx-test-junit = "1.3.0" # https://developer.android.com/jetpack/androidx/releases/test
+essentials = "3.1.0"
+jsr305 = "3.0.2"
+junit = "4.13.2"
+# Mockito 5 requires Java 11: this is fine as CI doesn't run RxJava tests with older JDKs
+mockito = "5.23.0" # https://github.com/mockito/mockito/releases/
+mockito-kotlin = "6.3.0" # https://github.com/mockito/mockito-kotlin/releases
+play-services-nearby = "19.3.0" # https://developers.google.com/android/guides/releases
+publish-plugin = "2.0.0" # https://github.com/gradle-nexus/publish-plugin/releases
+robolectric = "4.16.1" # https://github.com/robolectric/robolectric/releases
+rxjava2 = "2.2.21"
+rxjava3 = "3.0.11"
+spotbugs-annotations = "4.10.2" # https://github.com/spotbugs/spotbugs/blob/master/CHANGELOG.md
+spotbugs-plugin = "6.5.8" # https://github.com/spotbugs/spotbugs-gradle-plugin/releases
+turbine = "1.2.1" # https://github.com/cashapp/turbine/releases
+versions = "0.54.0" # https://github.com/ben-manes/gradle-versions-plugin/releases
+
+[libraries]
+androidx-lifecycle-livedata = { module = "androidx.lifecycle:lifecycle-livedata", version.ref = "androidx-lifecycle" }
+androidx-paging-runtime = { module = "androidx.paging:paging-runtime", version.ref = "androidx-paging" }
+androidx-test-core = { module = "androidx.test:core", version.ref = "androidx-test" }
+androidx-test-junit = { module = "androidx.test.ext:junit", version.ref = "androidx-test-junit" }
+androidx-test-rules = { module = "androidx.test:rules", version.ref = "androidx-test" }
+essentials = { module = "org.greenrobot:essentials", version.ref = "essentials" }
+jsr305 = { module = "com.google.code.findbugs:jsr305", version.ref = "jsr305" }
+junit = { module = "junit:junit", version.ref = "junit" }
+#noinspection SimilarGradleDependency
+kotlin-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines" }
+#noinspection SimilarGradleDependency
+kotlin-coroutines-core-compat = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines-compat" }
+kotlin-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlin-coroutines" }
+mockito = { module = "org.mockito:mockito-core", version.ref = "mockito" }
+mockito-kotlin = { module = "org.mockito.kotlin:mockito-kotlin", version.ref = "mockito-kotlin" }
+play-services-nearby = { module = "com.google.android.gms:play-services-nearby", version.ref = "play-services-nearby" }
+robolectric = { module = "org.robolectric:robolectric", version.ref = "robolectric" }
+rxjava2 = { module = "io.reactivex.rxjava2:rxjava", version.ref = "rxjava2" }
+rxjava3 = { module = "io.reactivex.rxjava3:rxjava", version.ref = "rxjava3" }
+spotbugs-annotations = { module = "com.github.spotbugs:spotbugs-annotations", version.ref = "spotbugs-annotations" }
+turbine = { module = "app.cash.turbine:turbine", version.ref = "turbine" }
+
+# build-logic dependencies
+buildLogic-dokka = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "kotlin-dokka" }
+
+[plugins]
+android-library = { id = "com.android.library", version.ref = "agp" }
+kotlin-dokka = { id = "org.jetbrains.dokka", version.ref = "kotlin-dokka" }
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+publish = { id = "io.github.gradle-nexus.publish-plugin", version.ref = "publish-plugin" }
+spotbugs = { id = "com.github.spotbugs", version.ref = "spotbugs-plugin" }
+versions = { id = "com.github.ben-manes.versions", version.ref = "versions" }
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 7454180f..b1b8ef56 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 669386b8..e74c8700 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,9 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-all.zip
+networkTimeout=10000
+retries=0
+retryBackOffMs=500
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index c53aefaa..b9bb139f 100755
--- a/gradlew
+++ b/gradlew
@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright � 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -32,10 +34,10 @@
 #       Busybox and similar reduced shells will NOT work, because this script
 #       requires all of these POSIX shell features:
 #         * functions;
-#         * expansions �$var�, �${var}�, �${var:-default}�, �${var+SET}�,
-#           �${var#prefix}�, �${var%suffix}�, and �$( cmd )�;
-#         * compound commands having a testable exit status, especially �case�;
-#         * various built-in commands including �command�, �set�, and �ulimit�.
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
 #
 #   Important for patching:
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -80,13 +82,11 @@ do
     esac
 done
 
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
+# This is normally unused
+# shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -114,7 +114,6 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
 # Determine the Java command to use to start the JVM.
@@ -133,22 +132,29 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
 if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
     case $MAX_FD in  #(
       '' | soft) :;; #(
       *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -165,7 +171,6 @@ fi
 # For Cygwin or MSYS, switch paths to Windows format before running java
 if "$cygwin" || "$msys" ; then
     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
     JAVACMD=$( cygpath --unix "$JAVACMD" )
 
@@ -193,18 +198,27 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
 # Use "xargs" to parse quoted args.
 #
 # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
diff --git a/gradlew.bat b/gradlew.bat
index 107acd32..24c62d56 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -13,19 +13,22 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
 @rem
 @rem ##########################################################################
 
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
+@rem Set local scope for the variables, and ensure extensions are enabled
+setlocal EnableExtensions
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,15 +43,15 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
-goto fail
+"%COMSPEC%" /c exit 1
 
 :findJavaFromJavaHome
 set JAVA_HOME=%JAVA_HOME:"=%
@@ -56,34 +59,24 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
-goto fail
+"%COMSPEC%" /c exit 1
 
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
+@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
+@rem which allows us to clear the local environment before executing the java command
+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
 
-:omega
+:exitWithErrorLevel
+@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
+"%COMSPEC%" /c exit %ERRORLEVEL%
diff --git a/objectbox-android/README.md b/objectbox-android/README.md
new file mode 100644
index 00000000..266ea777
--- /dev/null
+++ b/objectbox-android/README.md
@@ -0,0 +1,24 @@
+# ObjectBox Android APIs
+
+Builds Android libraries (AAR) published as Maven artifacts to [use ObjectBox on Android](../README.md#getting-started).
+
+Each Android library contains Android-specific ObjectBox APIs and has a dependency on a matching Android database library.
+
+Available public APIs:
+
+- [Admin](src/adminIncluded/java/io/objectbox/android/Admin.java): API to use the [Admin web app on Android](https://docs.objectbox.io/data-browser#admin-for-android)
+- [AndroidScheduler](src/main/java/io/objectbox/android/AndroidScheduler.java): can be used to [observe query results](https://docs.objectbox.io/data-observers-and-rx#thread-scheduling) on the Android main thread
+- [ObjectBoxDataSource](src/main/java/io/objectbox/android/ObjectBoxDataSource.java): reference implementation of a data source for the AndroidX paging library
+- [ObjectBoxLiveData](src/main/java/io/objectbox/android/ObjectBoxLiveData.java): reference implementation of an AndroidX LiveData
+
+The following Maven artifacts are currently published by this project:
+
+| Artifact ID                            | Admin                                              | Android database library |
+|----------------------------------------|----------------------------------------------------|--------------------------|
+| `objectbox-android`                    | no-op API                                          | Basic                    |
+| `objectbox-android-objectbrowser`      | API, [resources][res], [custom manifest][manifest] | Basic + Admin            |
+| `objectbox-sync-android`               | no-op API                                          | Sync                     |
+| `objectbox-sync-android-objectbrowser` | API, [resources][res], [custom manifest][manifest] | Sync + Admin             |
+
+[manifest]: src/adminIncluded/AndroidManifest.xml
+[res]: src/adminIncluded/res
diff --git a/objectbox-android/build.gradle.kts b/objectbox-android/build.gradle.kts
new file mode 100644
index 00000000..d24e12c5
--- /dev/null
+++ b/objectbox-android/build.gradle.kts
@@ -0,0 +1,239 @@
+import org.gradle.kotlin.dsl.support.uppercaseFirstChar
+
+
+plugins {
+    alias(libs.plugins.android.library)
+    id("objectbox.publishing-conventions")
+}
+
+val flavorAdminExcluded = "adminExcluded"
+val flavorAdminIncluded = "adminIncluded"
+val flavorBasic = "basic"
+val flavorSync = "sync"
+// Note: build variant names also match names of created components
+val variantAdminExcludedBasicRelease = "${flavorAdminExcluded}${flavorBasic.uppercaseFirstChar()}Release"
+val variantAdminIncludedBasicRelease = "${flavorAdminIncluded}${flavorBasic.uppercaseFirstChar()}Release"
+val variantAdminExcludedSyncRelease = "${flavorAdminExcluded}${flavorSync.uppercaseFirstChar()}Release"
+val variantAdminIncludedSyncRelease = "${flavorAdminIncluded}${flavorSync.uppercaseFirstChar()}Release"
+
+android {
+    namespace = "io.objectbox.android"
+    // Note: increasing compile SDK also signals this library is compatible with any changes in that
+    // API level, see "behavior changes" for each Android version at https://developer.android.com/about/versions
+    // Due to an oversight previous versions of this library relied on the ignored, now removed,
+    // target SDK property. So this library actually only supports up to Android 13. But as only
+    // the Admin foreground helper service is broken (on Android 14 and up, see objectbox-java#226)
+    // keeping at SDK 35.
+    compileSdk = 35 // Android 15 (Vanilla Ice Cream)
+
+    // Not using Kotlin source code, so prevent the Kotlin standard library from getting added,
+    // avoid Kotlin compiler task run.
+    enableKotlin = false
+
+    // Common configuration for all variants (variant = flavor + build type).
+    defaultConfig {
+        minSdk = 21 // Android 5.0 (Lollipop), the minimum of NDK r27 used by the database library
+
+        consumerProguardFiles("consumer-proguard-rules.pro")
+    }
+
+    signingConfigs {
+        getByName("debug") {
+            storeFile = file(System.getProperty("user.home") + "/.android/debug.keystore")
+        }
+    }
+
+    // https://developer.android.com/studio/build/build-variants#build-types
+    // Common configuration for release build types (debug currently left at default).
+    buildTypes {
+        release {
+            // Currently not obfuscating/minifying with ProGuard/R8.
+            isMinifyEnabled = false
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+            // Just to use without checkjni
+            signingConfig = signingConfigs.getByName("debug")
+        }
+    }
+
+    // Configure a flavor dimension based on if Admin is included in the Android database library.
+    // The Admin included flavor adds additional source files, resources and a different Android
+    // manifest to help using Admin. The excluded flavor adds source files with no-op Admin APIs.
+    // See the directories in "src/" named like the flavors.
+    // Configure another flavor dimension purely to add a regular or a Sync variant of the Android
+    // database library dependency. See the dependencies block.
+    // Note: common configuration defined in defaultConfig and buildTypes blocks above.
+    // https://developer.android.com/studio/build/build-variants#product-flavors
+    val dimensionAdmin = "admin"
+    val dimensionDatabase = "database"
+    flavorDimensions += listOf(dimensionAdmin, dimensionDatabase)
+    productFlavors {
+        create(flavorAdminExcluded) {
+            dimension = dimensionAdmin
+        }
+        create(flavorAdminIncluded) {
+            dimension = dimensionAdmin
+            // Set Admin included flavor as default in Android Studio as it's most likely to display
+            // errors on breaking changes to the Java API dependency.
+            isDefault = true
+        }
+        create(flavorBasic) {
+            dimension = dimensionDatabase
+        }
+        create(flavorSync) {
+            dimension = dimensionDatabase
+        }
+    }
+
+    // Publish the release variants (variant = flavor combination + build type)
+    // https://developer.android.com/studio/publish-library/configure-pub-variants
+    publishing {
+        singleVariant(variantAdminExcludedBasicRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+        singleVariant(variantAdminIncludedBasicRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+        singleVariant(variantAdminExcludedSyncRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+        singleVariant(variantAdminIncludedSyncRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+    }
+
+    // Java 8 features support https://developer.android.com/studio/write/java8-support
+    // Note: this requires consuming projects to also enable this.
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    lint {
+        // Due to an oversight (see notes on compileSdk above) AdminKeepAliveService is not
+        // compatible with Android 14, temporarily ignore the error lint produces as a result.
+        disable += "ForegroundServiceType"
+    }
+
+    // For local unit tests enable use of Android framework with Robolectric
+    testOptions {
+        unitTests.isIncludeAndroidResources = true
+    }
+}
+
+val versionDatabaseLibraryAndroid: String by rootProject.extra
+val versionDatabaseLibraryAndroidSync: String by rootProject.extra
+
+// Must manually create configurations for flavor combinations to add dependencies
+// (they are still picked up automatically by the Android plugin).
+// https://developer.android.com/build/dependencies#configure_dependencies_for_a_specific_build_variant
+val adminExcludedBasicImplementation by configurations.creating
+val adminIncludedBasicImplementation by configurations.creating
+val adminExcludedSyncImplementation by configurations.creating
+val adminIncludedSyncImplementation by configurations.creating
+
+dependencies {
+    // Use "api" to add the Java library as a "compile" dependency in the POM as this library
+    // exposes APIs from it (such as Scheduler in AndroidScheduler, BoxStore in Admin). Regardless,
+    // it is expected that most consumers (or the Gradle plugin) add the Java library as a direct
+    // dependency.
+    api(project(":objectbox-java"))
+    // Use "implementation" to add the database library as a "runtime" dependency in the POM as it
+    // has no Java APIs to expose.
+    adminExcludedBasicImplementation("io.objectbox:objectbox-android-db:$versionDatabaseLibraryAndroid")
+    adminIncludedBasicImplementation("io.objectbox:objectbox-android-db-admin:$versionDatabaseLibraryAndroid")
+    adminExcludedSyncImplementation("io.objectbox:objectbox-sync-android-db:$versionDatabaseLibraryAndroidSync")
+    adminIncludedSyncImplementation("io.objectbox:objectbox-sync-android-db-admin:$versionDatabaseLibraryAndroidSync")
+
+    // Use "compileOnly" to not add these as dependencies in the POM to avoid consumer projects
+    // pulling in unused dependencies. It is expected that consumers did already add these
+    // dependencies when using related classes of this library.
+    compileOnly(libs.androidx.lifecycle.livedata)
+    compileOnly(libs.androidx.paging.runtime)
+
+    // Dependencies for unit tests running on the JVM (so not on an Android device/emulator)
+    testImplementation(libs.androidx.test.core)
+    testImplementation(libs.androidx.test.rules)
+    testImplementation(libs.junit)
+    testImplementation(libs.androidx.test.junit)
+    testImplementation(libs.robolectric)
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxAndroid = "objectboxAndroid"
+val publicationObjectboxAndroidObjectbrowser = "objectboxAndroidObjectbrowser"
+val publicationObjectboxSyncAndroid = "objectboxSyncAndroid"
+val publicationObjectboxSyncAndroidObjectbrowser = "objectboxSyncAndroidObjectbrowser"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxAndroid) {
+            artifactId = "objectbox-android"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminExcludedBasicRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Android")
+            }
+        }
+        create<MavenPublication>(publicationObjectboxAndroidObjectbrowser) {
+            artifactId = "objectbox-android-objectbrowser"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminIncludedBasicRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Android with Admin")
+            }
+        }
+        create<MavenPublication>(publicationObjectboxSyncAndroid) {
+            artifactId = "objectbox-sync-android"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminExcludedSyncRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Android with Sync")
+            }
+        }
+        create<MavenPublication>(publicationObjectboxSyncAndroidObjectbrowser) {
+            artifactId = "objectbox-sync-android-objectbrowser"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminIncludedSyncRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Android with Admin and Sync")
+            }
+        }
+        // Additional common configuration for all Maven publications
+        withType<MavenPublication> {
+            pom {
+                description.set("ObjectBox is a fast NoSQL database for Objects")
+                packaging = "aar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxAndroid])
+    sign(publishing.publications[publicationObjectboxAndroidObjectbrowser])
+    sign(publishing.publications[publicationObjectboxSyncAndroid])
+    sign(publishing.publications[publicationObjectboxSyncAndroidObjectbrowser])
+}
diff --git a/objectbox-android/consumer-proguard-rules.pro b/objectbox-android/consumer-proguard-rules.pro
new file mode 100644
index 00000000..bff3c650
--- /dev/null
+++ b/objectbox-android/consumer-proguard-rules.pro
@@ -0,0 +1,10 @@
+# When editing this file, also look at objectbox-java.pro of objectbox-java.
+
+# Accessed by objectbox-java through reflection.
+-keep class io.objectbox.android.internal.AndroidPlatform {*;}
+
+# For provided android.arch.lifecycle:extensions
+-dontwarn io.objectbox.android.ObjectBoxLiveData
+
+# For provided android.arch.paging:runtime
+-dontwarn io.objectbox.android.ObjectBoxDataSource*
diff --git a/objectbox-android/proguard-rules.pro b/objectbox-android/proguard-rules.pro
new file mode 100644
index 00000000..481bb434
--- /dev/null
+++ b/objectbox-android/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
\ No newline at end of file
diff --git a/objectbox-android/src/adminExcluded/java/io/objectbox/android/Admin.java b/objectbox-android/src/adminExcluded/java/io/objectbox/android/Admin.java
new file mode 100644
index 00000000..f1f12487
--- /dev/null
+++ b/objectbox-android/src/adminExcluded/java/io/objectbox/android/Admin.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2022 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.content.Context;
+
+import io.objectbox.BoxStore;
+
+/**
+ * A helper class to start the ObjectBox Admin web app used to browse and gain insights into the database.
+ * <p>
+ * Usage requires manually configuring some ObjectBox dependencies, see the
+ * <a href="https://docs.objectbox.io/data-browser">documentation</a> for more details.
+ *
+ * <pre>
+ * if (BuildConfig.DEBUG) {
+ *     boolean started = new Admin(boxStore).start(this);
+ *     Log.i("ObjectBoxAdmin", "Started: " + started);
+ * }
+ * </pre>
+ * After {@link #start} is called a notification is displayed. Tap it to open this Admin URL on the device.
+ * Alternatively, look for a logcat message from Admin to obtain the URL. Use {@code adb forward} to access
+ * the URL on your development machine.
+ * <p>
+ * Tapping the notification starts a foreground service to keep this app running in the background.
+ * Stop this keep-alive service from the notification.
+ * <p>
+ * See the web <a href="https://docs.objectbox.io/data-browser">documentation</a> for details.
+ */
+public class Admin {
+
+    private int notificationId;
+
+    /**
+     * Creates a helper to control Admin for the given {@code boxStore}.
+     * <p>
+     * See the {@link Admin class documentation} for details.
+     */
+    public Admin(BoxStore boxStore) {
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     */
+    public int getNotificationId() {
+        return notificationId;
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     */
+    public void setNotificationId(int notificationId) {
+        this.notificationId = notificationId;
+    }
+
+    /**
+     * Starts the ObjectBox Admin HTTP server.
+     * <p>
+     * See the {@link Admin class documentation} for details.
+     */
+    public boolean start(Context context) {
+        return false;
+    }
+
+}
diff --git a/objectbox-android/src/adminExcluded/java/io/objectbox/android/AndroidObjectBrowser.java b/objectbox-android/src/adminExcluded/java/io/objectbox/android/AndroidObjectBrowser.java
new file mode 100644
index 00000000..f5651a56
--- /dev/null
+++ b/objectbox-android/src/adminExcluded/java/io/objectbox/android/AndroidObjectBrowser.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.content.Context;
+
+import io.objectbox.BoxStore;
+
+/**
+ * A helper class to start the ObjectBox Admin web app used to browse and gain insights into the database.
+ * <p>
+ * Usage requires manually configuring some ObjectBox dependencies, see the
+ * <a href="https://docs.objectbox.io/data-browser">documentation</a> for more details.
+ *
+ * <pre>
+ * if (BuildConfig.DEBUG) {
+ *     boolean started = new AndroidObjectBrowser(boxStore).start(this);
+ *     Log.i("ObjectBoxAdmin", "Started: " + started);
+ * }
+ * </pre>
+ * After {@link #start} is called a notification is displayed. Tap it to open this Admin URL on the device.
+ * Alternatively, look for a logcat message from Admin to obtain the URL. Use {@code adb forward} to access
+ * the URL on your development machine.
+ * <p>
+ * Tapping the notification starts a foreground service to keep this app running in the background.
+ * Stop this keep-alive service from the notification.
+ * <p>
+ * See the web <a href="https://docs.objectbox.io/data-browser">documentation</a> for details.
+ *
+ * @deprecated Use {@link Admin} instead.
+ */
+@Deprecated
+public class AndroidObjectBrowser extends Admin {
+
+    /**
+     * Creates a helper to control Admin for the given {@code boxStore}.
+     * <p>
+     * See the {@link AndroidObjectBrowser class documentation} for details.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public AndroidObjectBrowser(BoxStore boxStore) {
+        super(boxStore);
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public int getNotificationId() {
+        return super.getNotificationId();
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public void setNotificationId(int notificationId) {
+        super.setNotificationId(notificationId);
+    }
+
+    /**
+     * Starts the ObjectBox Admin HTTP server.
+     * <p>
+     * See the {@link AndroidObjectBrowser class documentation} for details.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public boolean start(Context context) {
+        return super.start(context);
+    }
+}
diff --git a/objectbox-android/src/adminIncluded/AndroidManifest.xml b/objectbox-android/src/adminIncluded/AndroidManifest.xml
new file mode 100644
index 00000000..508901c5
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/AndroidManifest.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- Note that the objectbox-android AAR ships a different manifest! -->
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <!-- When targeting API level 28 or higher to run ObjectBox Admin foreground service -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <!-- When targeting API level 33 or higher to post the initial ObjectBox Admin notification -->
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+
+    <application>
+        <!-- ObjectBox Admin -->
+        <service
+            android:name=".AdminKeepAliveService"
+            android:exported="false" />
+
+        <receiver
+            android:name=".AdminNotificationReceiver"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="io.objectbox.action.KEEP_ALIVE" />
+            </intent-filter>
+        </receiver>
+    </application>
+
+</manifest>
diff --git a/objectbox-android/src/adminIncluded/java/io/objectbox/android/Admin.java b/objectbox-android/src/adminIncluded/java/io/objectbox/android/Admin.java
new file mode 100644
index 00000000..5bad3ddb
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/java/io/objectbox/android/Admin.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2022 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.Manifest;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Process;
+import android.util.Log;
+
+import io.objectbox.BoxStore;
+
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+
+/**
+ * A helper class to start the ObjectBox Admin web app used to browse and gain insights into the database.
+ * <p>
+ * Usage requires manually configuring some ObjectBox dependencies, see the
+ * <a href="https://docs.objectbox.io/data-browser">documentation</a> for more details.
+ *
+ * <pre>
+ * if (BuildConfig.DEBUG) {
+ *     boolean started = new Admin(boxStore).start(this);
+ *     Log.i("ObjectBoxAdmin", "Started: " + started);
+ * }
+ * </pre>
+ * After {@link #start} is called a notification is displayed. Tap it to open this Admin URL on the device.
+ * Alternatively, look for a logcat message from Admin to obtain the URL. Use {@code adb forward} to access
+ * the URL on your development machine.
+ * <p>
+ * Tapping the notification starts a foreground service to keep this app running in the background.
+ * Stop this keep-alive service from the notification.
+ * <p>
+ * See the web <a href="https://docs.objectbox.io/data-browser">documentation</a> for details.
+ */
+public class Admin {
+
+    private static final String TAG = "ObjectBoxAdmin";
+    private static final String NOTIFICATION_CHANNEL_ID = "objectbox-browser";
+
+    private final BoxStore boxStore;
+    private int notificationId;
+
+    /**
+     * Creates a helper to control Admin for the given {@code boxStore}.
+     * <p>
+     * See the {@link Admin class documentation} for details.
+     */
+    public Admin(BoxStore boxStore) {
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     */
+    public int getNotificationId() {
+        return notificationId;
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     */
+    public void setNotificationId(int notificationId) {
+        this.notificationId = notificationId;
+    }
+
+    /**
+     * Starts the ObjectBox Admin HTTP server.
+     * <p>
+     * See the {@link Admin class documentation} for details.
+     */
+    public boolean start(Context context) {
+        if (!BoxStore.isObjectBrowserAvailable()) {
+            return false;
+        }
+
+        // compare with objectbox-android-objectbrowser/src/main/AndroidManifest.xml
+        // SecurityException if no INTERNET permission
+        context.enforcePermission(Manifest.permission.INTERNET, Process.myPid(), Process.myUid(), null);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P
+                && context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.P) {
+            // SecurityException if no FOREGROUND_SERVICE permission
+            context.enforcePermission(Manifest.permission.FOREGROUND_SERVICE, Process.myPid(), Process.myUid(), null);
+        }
+
+        int alreadyRunningPort = boxStore.getObjectBrowserPort();
+        if (alreadyRunningPort != 0) {
+            Log.w(TAG, "ObjectBox Admin is already running at port " + alreadyRunningPort);
+            return false;
+        }
+        String url = boxStore.startObjectBrowser();
+        if (url == null) {
+            return false;
+        }
+        Log.i(TAG, "ObjectBox Admin running at URL: " + url);
+        int port = boxStore.getObjectBrowserPort();
+        Log.i(TAG, "To access the ObjectBox Admin URL on your machine run: adb forward tcp:" + port + " tcp:" + port);
+
+
+        if (notificationId == 0) {
+            notificationId = 19770000 + port;
+        }
+
+        // build intent and show notification
+        Intent intent = new Intent(context, AdminNotificationReceiver.class);
+        intent.setAction(AdminNotificationReceiver.ACTION_KEEP_ALIVE);
+        intent.putExtra(AdminKeepAliveService.EXTRA_KEY_URL, url);
+        intent.putExtra(AdminKeepAliveService.EXTRA_KEY_PORT, port);
+        intent.putExtra(AdminKeepAliveService.EXTRA_KEY_NOTIFICATION_ID, notificationId);
+        PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intent,
+                buildPendingIntentFlags(PendingIntent.FLAG_CANCEL_CURRENT));
+
+        NotificationManager manager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        // Note: may be null in case where notification service is not available on device (e.g. custom Android OS).
+        if (manager != null) {
+            // On Android 13 or newer notifications for apps are turned off by default,
+            // developers need to turn on notifications for the app through system settings
+            // or request the permission from the user.
+            // https://developer.android.com/develop/ui/views/notifications/notification-permission
+            // Already on Android 7 or newer, notifications can been turned off in system settings. This may happen
+            // while developers are testing an app, so also warn in this case.
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && !manager.areNotificationsEnabled()) {
+                Log.w(TAG, "To use the ObjectBox Admin keep-alive notification turn on notifications for this app");
+            }
+            Notification.Builder builder = buildBaseNotification(context, port, manager);
+            builder.setContentIntent(pendingIntent);
+            manager.notify(notificationId, builder.build());
+        }
+
+        return true;
+    }
+
+    static Notification.Builder buildBaseNotification(Context context, int port, NotificationManager manager) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            // Note: IMPORTANCE_LOW so no sound is played to avoid distractions while testing.
+            NotificationChannel channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID,
+                    "ObjectBox Admin", NotificationManager.IMPORTANCE_LOW);
+            // if channel already exists, create call will be ignored
+            manager.createNotificationChannel(channel);
+        }
+
+        Notification.Builder builder;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            builder = new Notification.Builder(context, NOTIFICATION_CHANNEL_ID);
+        } else {
+            builder = new Notification.Builder(context);
+        }
+
+        builder.setContentTitle(context.getString(R.string.objectbox_objectBrowserNotificationTitle))
+                .setContentText(context.getString(R.string.objectbox_objectBrowserNotificationText, port))
+                .setSmallIcon(R.drawable.objectbox_notification);
+
+        return builder;
+    }
+
+    static Intent viewIntent(String url) {
+        Intent viewIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
+        viewIntent.setFlags(FLAG_ACTIVITY_NEW_TASK);
+        return viewIntent;
+    }
+
+    /**
+     * Targeting Android 12 requires to mark PendingIntents explicitly as immutable or mutable.
+     * https://developer.android.com/about/versions/12/behavior-changes-12#pending-intent-mutability
+     */
+    static int buildPendingIntentFlags(int flags) {
+        if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            return flags | PendingIntent.FLAG_IMMUTABLE;
+        } else {
+            return flags;
+        }
+    }
+
+}
diff --git a/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminKeepAliveService.java b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminKeepAliveService.java
new file mode 100644
index 00000000..1d0f1c78
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminKeepAliveService.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.app.Notification;
+import android.app.Notification.Action.Builder;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.os.IBinder;
+import android.util.Log;
+
+import javax.annotation.Nullable;
+
+/**
+ * Foreground service to keep app alive which displays a notification to view {@link Admin} URL or stop this service.
+ */
+public class AdminKeepAliveService extends Service {
+
+    private static final String ACTION_STOP = "objectBox_keepAliveStop";
+
+    static final String EXTRA_KEY_PORT = "port";
+    static final String EXTRA_KEY_URL = "url";
+    static final String EXTRA_KEY_NOTIFICATION_ID = "notificationId";
+
+    private static final String TAG = AdminKeepAliveService.class.getSimpleName();
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (ACTION_STOP.equals(intent.getAction())) {
+            Log.d(TAG, "Stopping");
+            stopForeground(true);
+            stopSelf();
+            return START_NOT_STICKY;
+        }
+        String url = intent.getStringExtra(EXTRA_KEY_URL);
+        int port = intent.getIntExtra(EXTRA_KEY_PORT, 0);
+        int notificationId = intent.getIntExtra(EXTRA_KEY_NOTIFICATION_ID, 0);
+
+        if (url != null && url.startsWith("http") && port > 0 && notificationId > 0) {
+            Intent stopIntent = new Intent(this, getClass());
+            stopIntent.setAction(ACTION_STOP);
+            PendingIntent stopPendingIntent = PendingIntent.getService(this, 0, stopIntent,
+                    Admin.buildPendingIntentFlags(PendingIntent.FLAG_CANCEL_CURRENT));
+            PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
+                    Admin.viewIntent(url), Admin.buildPendingIntentFlags(0));
+
+            NotificationManager manager =
+                    (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+            Notification.Builder builder = Admin.buildBaseNotification(this, port, manager);
+            builder.setContentIntent(pendingIntent);
+            // Actually useless because Foreground notifications cannot be deleted
+            builder.setDeleteIntent(stopPendingIntent);
+            builder.addAction(new Builder(R.drawable.objectbox_stop, "Stop", stopPendingIntent).build());
+
+            startForeground(notificationId, builder.getNotification());
+            Log.d(TAG, "Started");
+            return START_REDELIVER_INTENT; // with START_STICKY would not get intent on restart
+        } else {
+            Log.w(TAG, "Ignoring start command due to incomplete data");
+            return START_NOT_STICKY;
+        }
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+}
diff --git a/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminNotificationReceiver.java b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminNotificationReceiver.java
new file mode 100644
index 00000000..51db3850
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminNotificationReceiver.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.util.Log;
+
+/**
+ * Handles actions of the {@link Admin} notification.
+ */
+public class AdminNotificationReceiver extends BroadcastReceiver {
+
+    private static final String TAG = AdminNotificationReceiver.class.getSimpleName();
+    static final String ACTION_KEEP_ALIVE = "io.objectbox.action.KEEP_ALIVE";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (!ACTION_KEEP_ALIVE.equals(intent.getAction())) {
+            return;
+        }
+        if (!intent.hasExtra(AdminKeepAliveService.EXTRA_KEY_URL)) {
+            Log.w(TAG, "Ignoring keep alive intent due to incomplete data");
+            return;
+        }
+
+        // start foreground service to keep app process alive
+        Intent serviceIntent = new Intent(context, AdminKeepAliveService.class);
+        serviceIntent.putExtras(intent);
+        if (VERSION.SDK_INT >= VERSION_CODES.O) {
+            context.startForegroundService(serviceIntent);
+        } else {
+            context.startService(serviceIntent);
+        }
+
+        // launch browser
+        String url = intent.getStringExtra(AdminKeepAliveService.EXTRA_KEY_URL);
+        context.startActivity(Admin.viewIntent(url));
+    }
+
+}
diff --git a/objectbox-android/src/adminIncluded/java/io/objectbox/android/AndroidObjectBrowser.java b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AndroidObjectBrowser.java
new file mode 100644
index 00000000..f5651a56
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AndroidObjectBrowser.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.content.Context;
+
+import io.objectbox.BoxStore;
+
+/**
+ * A helper class to start the ObjectBox Admin web app used to browse and gain insights into the database.
+ * <p>
+ * Usage requires manually configuring some ObjectBox dependencies, see the
+ * <a href="https://docs.objectbox.io/data-browser">documentation</a> for more details.
+ *
+ * <pre>
+ * if (BuildConfig.DEBUG) {
+ *     boolean started = new AndroidObjectBrowser(boxStore).start(this);
+ *     Log.i("ObjectBoxAdmin", "Started: " + started);
+ * }
+ * </pre>
+ * After {@link #start} is called a notification is displayed. Tap it to open this Admin URL on the device.
+ * Alternatively, look for a logcat message from Admin to obtain the URL. Use {@code adb forward} to access
+ * the URL on your development machine.
+ * <p>
+ * Tapping the notification starts a foreground service to keep this app running in the background.
+ * Stop this keep-alive service from the notification.
+ * <p>
+ * See the web <a href="https://docs.objectbox.io/data-browser">documentation</a> for details.
+ *
+ * @deprecated Use {@link Admin} instead.
+ */
+@Deprecated
+public class AndroidObjectBrowser extends Admin {
+
+    /**
+     * Creates a helper to control Admin for the given {@code boxStore}.
+     * <p>
+     * See the {@link AndroidObjectBrowser class documentation} for details.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public AndroidObjectBrowser(BoxStore boxStore) {
+        super(boxStore);
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public int getNotificationId() {
+        return super.getNotificationId();
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public void setNotificationId(int notificationId) {
+        super.setNotificationId(notificationId);
+    }
+
+    /**
+     * Starts the ObjectBox Admin HTTP server.
+     * <p>
+     * See the {@link AndroidObjectBrowser class documentation} for details.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public boolean start(Context context) {
+        return super.start(context);
+    }
+}
diff --git a/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_notification.png
new file mode 100644
index 00000000..84236e32
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_stop.png
new file mode 100644
index 00000000..dfff26ce
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_notification.png
new file mode 100644
index 00000000..da2b3038
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_stop.png
new file mode 100644
index 00000000..9f6dc9ef
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_notification.png
new file mode 100644
index 00000000..0719e380
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_stop.png
new file mode 100644
index 00000000..3ad2c9c4
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_notification.png
new file mode 100644
index 00000000..97af3800
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_stop.png
new file mode 100644
index 00000000..801d3411
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_notification.png
new file mode 100644
index 00000000..a6bc5520
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_stop.png
new file mode 100644
index 00000000..52393366
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/values/strings.xml b/objectbox-android/src/adminIncluded/res/values/strings.xml
new file mode 100644
index 00000000..d6de685e
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/res/values/strings.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<resources>
+    <string name="objectbox_objectBrowserNotificationTitle">ObjectBox Admin</string>
+    <!-- Text should not be too long, or it is cut off. -->
+    <string name="objectbox_objectBrowserNotificationText">Running on port %1$d. Tap to open and keep app running.</string>
+</resources>
diff --git a/objectbox-android/src/main/AndroidManifest.xml b/objectbox-android/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..44cfa242
--- /dev/null
+++ b/objectbox-android/src/main/AndroidManifest.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- Note that the objectbox-android-objectbrowser AAR ships a different manifest! -->
+
+    <!-- Required for Android library https://developer.android.com/studio/projects/android-library#aar-contents -->
+
+</manifest>
diff --git a/objectbox-android/src/main/java/io/objectbox/android/AndroidScheduler.java b/objectbox-android/src/main/java/io/objectbox/android/AndroidScheduler.java
new file mode 100644
index 00000000..ac2c358c
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/AndroidScheduler.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+import androidx.annotation.NonNull;
+import io.objectbox.reactive.RunWithParam;
+import io.objectbox.reactive.Scheduler;
+
+/**
+ * A Looper-based Scheduler implementation, see {@link #mainThread()} for most common usage.
+ */
+public class AndroidScheduler extends Handler implements Scheduler {
+    private static AndroidScheduler MAIN_THREAD;
+
+    /**
+     * Returns a Scheduler that runs tasks on Android's main thread.
+     */
+    public static synchronized Scheduler mainThread() {
+        if (MAIN_THREAD == null) {
+            MAIN_THREAD = new AndroidScheduler(Looper.getMainLooper());
+        }
+        return MAIN_THREAD;
+    }
+
+    private final Deque<Runner> freeRunners = new ArrayDeque<>();
+
+    /**
+     * If you run your own Looper, you can create a custom Scheduler using it.
+     */
+    public AndroidScheduler(Looper looper) {
+        super(looper);
+    }
+
+    // Note: need to cast to RunWithParam<Object>, not sure how to solve differently.
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> void run(@NonNull RunWithParam<T> runnable, @NonNull T param) {
+        Runner runner;
+        synchronized (freeRunners) {
+            runner = freeRunners.poll();
+        }
+        if (runner == null) {
+            runner = new Runner();
+        }
+        runner.runWithParam = (RunWithParam<Object>) runnable;
+        runner.param = param;
+        post(runner);
+    }
+
+    class Runner implements Runnable {
+        RunWithParam<Object> runWithParam;
+        Object param;
+
+        @Override
+        public void run() {
+            runWithParam.run(param);
+            runWithParam = null;
+            param = null;
+            synchronized (freeRunners) {
+                if (freeRunners.size() < 20) {
+                    freeRunners.add(this);
+                }
+            }
+        }
+    }
+
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxDataSource.java b/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxDataSource.java
new file mode 100644
index 00000000..9a62561c
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxDataSource.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2018 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import java.util.Collections;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.paging.DataSource;
+import androidx.paging.PositionalDataSource;
+import io.objectbox.query.Query;
+import io.objectbox.reactive.DataObserver;
+
+/**
+ * A {@link PositionalDataSource} that loads entities based on an ObjectBox {@link Query} using
+ * offset and limit to implement paging support. The data source is invalidated if the query results
+ * change.
+ */
+public class ObjectBoxDataSource<T> extends PositionalDataSource<T> {
+
+    private final Query<T> query;
+    @SuppressWarnings("FieldCanBeLocal")
+    private final DataObserver<List<T>> observer;
+
+    public static class Factory<Item> extends DataSource.Factory<Integer, Item> {
+
+        private final Query<Item> query;
+
+        public Factory(Query<Item> query) {
+            this.query = query;
+        }
+
+        @NonNull
+        @Override
+        public DataSource<Integer, Item> create() {
+            return new ObjectBoxDataSource<>(query);
+        }
+    }
+
+    public ObjectBoxDataSource(Query<T> query) {
+        this.query = query;
+        this.observer = data -> {
+            // if data changes invalidate this data source and create a new one
+            invalidate();
+        };
+        // observer will be automatically removed once GC'ed
+        query.subscribe().onlyChanges().weak().observer(observer);
+    }
+
+    @Override
+    public void loadInitial(@NonNull LoadInitialParams params, @NonNull LoadInitialCallback<T> callback) {
+        // note: limiting to int should be fine for Android apps
+        int totalCount = (int) query.count();
+        if (totalCount == 0) {
+            callback.onResult(Collections.emptyList(), 0, 0);
+            return;
+        }
+
+        int position = computeInitialLoadPosition(params, totalCount);
+        int loadSize = computeInitialLoadSize(params, position, totalCount);
+
+        List<T> list = loadRange(position, loadSize);
+        if (list.size() == loadSize) {
+            callback.onResult(list, position, totalCount);
+        } else {
+            invalidate(); // size doesn't match request - DB modified between count and load
+        }
+    }
+
+    @Override
+    public void loadRange(@NonNull LoadRangeParams params, @NonNull LoadRangeCallback<T> callback) {
+        callback.onResult(loadRange(params.startPosition, params.loadSize));
+    }
+
+    private List<T> loadRange(int startPosition, int loadCount) {
+        // note: find interprets loadCount 0 as no limit
+        return query.find(startPosition, loadCount);
+    }
+
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxLiveData.java b/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxLiveData.java
new file mode 100644
index 00000000..3a130aa3
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxLiveData.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import java.util.List;
+
+import androidx.lifecycle.LiveData;
+import io.objectbox.query.Query;
+import io.objectbox.reactive.DataObserver;
+import io.objectbox.reactive.DataSubscription;
+
+/**
+ * A {@link LiveData} which allows to observe changes to results of the given query.
+ */
+public class ObjectBoxLiveData<T> extends LiveData<List<T>> {
+    private final Query<T> query;
+    private DataSubscription subscription;
+
+    private final DataObserver<List<T>> listener = this::postValue;
+
+    public ObjectBoxLiveData(Query<T> query) {
+        this.query = query;
+    }
+
+    @Override
+    protected void onActive() {
+        // called when the LiveData object has an active observer
+        if (subscription == null) {
+            subscription = query.subscribe().observer(listener);
+        }
+    }
+
+    @Override
+    protected void onInactive() {
+        // called when the LiveData object doesn't have any active observers
+        if (!hasObservers()) {
+            subscription.cancel();
+            subscription = null;
+        }
+    }
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidConnectivityMonitor.java b/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidConnectivityMonitor.java
new file mode 100644
index 00000000..0c79ad27
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidConnectivityMonitor.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2020 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android.internal;
+
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+
+import androidx.annotation.Nullable;
+import io.objectbox.sync.ConnectivityMonitor;
+
+/**
+ * A {@link ConnectivityMonitor} that registers a {@link AndroidNetworkStateReceiver}
+ * while it has an observer set.
+ */
+class AndroidConnectivityMonitor extends ConnectivityMonitor {
+
+    private final Context context;
+
+    @Nullable
+    private AndroidNetworkStateReceiver receiver;
+
+    AndroidConnectivityMonitor(Context context) {
+        this.context = context.getApplicationContext();
+    }
+
+    @Override
+    public void onObserverSet() {
+        AndroidNetworkStateReceiver receiver = new AndroidNetworkStateReceiver();
+        IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
+        context.registerReceiver(receiver, filter);
+        this.receiver = receiver;
+    }
+
+    @Override
+    public void onObserverRemoved() {
+        AndroidNetworkStateReceiver receiverToRemove = this.receiver;
+        this.receiver = null;
+        if (receiverToRemove != null) {
+            context.unregisterReceiver(receiverToRemove);
+        }
+    }
+
+    /**
+     * Notifies the given monitor on the main thread if a network connection is available
+     * after a {@link ConnectivityManager#CONNECTIVITY_ACTION} was broadcast.
+     */
+    class AndroidNetworkStateReceiver extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (!ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
+                return; // Ignore unexpected broadcasts.
+            }
+
+            ConnectivityManager cm =
+                    (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+
+            @SuppressLint("MissingPermission") // Permission checked before registering.
+                    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
+            boolean isConnected = activeNetwork != null && activeNetwork.isConnected();
+
+            if (isConnected) {
+                notifyConnectionAvailable();
+            }
+        }
+
+    }
+
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidPlatform.java b/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidPlatform.java
new file mode 100644
index 00000000..be14f987
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidPlatform.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android.internal;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Process;
+
+import androidx.annotation.Nullable;
+import io.objectbox.sync.ConnectivityMonitor;
+import io.objectbox.sync.internal.Platform;
+
+/**
+ * Provides Android-specific features.
+ * <p>
+ * Requires the {@link Manifest.permission#ACCESS_NETWORK_STATE ACCESS_NETWORK_STATE} permission.
+ */
+public class AndroidPlatform extends Platform {
+
+    public static AndroidPlatform create(Context context) {
+        return new AndroidPlatform(context.getApplicationContext());
+    }
+
+    private final ConnectivityMonitor connectivityMonitor;
+
+    private AndroidPlatform(Context context) {
+        // AndroidConnectivityMonitor requires the ACCESS_NETWORK_STATE permission.
+        // Most apps have it, so just do not provide a connectivity monitor if not.
+        if (context.checkPermission(Manifest.permission.ACCESS_NETWORK_STATE,
+                Process.myPid(), Process.myUid()) == PackageManager.PERMISSION_GRANTED) {
+            connectivityMonitor = new AndroidConnectivityMonitor(context);
+        } else {
+            connectivityMonitor = null;
+        }
+    }
+
+    @Override
+    @Nullable
+    public ConnectivityMonitor getConnectivityMonitor() {
+        return connectivityMonitor;
+    }
+
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/sync/ObjectBoxForegroundService.java b/objectbox-android/src/main/java/io/objectbox/android/sync/ObjectBoxForegroundService.java
new file mode 100644
index 00000000..830ca4dc
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/sync/ObjectBoxForegroundService.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2021 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android.sync;
+
+import android.Manifest;
+import android.app.Notification;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+import android.os.Process;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+/**
+ * A no-op foreground {@link Service} to make it less likely an app is killed by the system.
+ * Use {@link #start} and {@link #stop} to control the service.
+ */
+public class ObjectBoxForegroundService extends Service {
+
+    public static final String ACTION_START = "obx_foreground_start";
+    public static final String ACTION_STOP = "obx_foreground_stop";
+    private static final String TAG = "OBX_FOREGROUND";
+
+    private static int notificationId;
+    @Nullable
+    private static Notification notification;
+
+    public static void start(Context context, int notificationId, Notification notification) {
+        // Require FOREGROUND_SERVICE permission on Android 9 (API level 28)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P
+                && context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.P) {
+            // SecurityException if no FOREGROUND_SERVICE permission
+            context.enforcePermission(Manifest.permission.FOREGROUND_SERVICE, Process.myPid(), Process.myUid(), null);
+        }
+
+        ObjectBoxForegroundService.notificationId = notificationId;
+        ObjectBoxForegroundService.notification = notification;
+        Intent intent = new Intent(context, ObjectBoxForegroundService.class);
+        intent.setAction(ACTION_START);
+        startServiceIntent(context, intent);
+    }
+
+    public static void stop(Context context) {
+        Intent intent = new Intent(context, ObjectBoxForegroundService.class);
+        intent.setAction(ACTION_STOP);
+        startServiceIntent(context, intent);
+    }
+
+    private static void startServiceIntent(Context context, Intent intent) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(intent);
+        } else {
+            context.startService(intent);
+        }
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (ACTION_STOP.equals(intent.getAction())) {
+            Log.d(TAG, "Stopping...");
+            stopForeground(true);
+            stopSelf();
+            return START_NOT_STICKY;
+        } else if (ACTION_START.equals(intent.getAction())) {
+            Log.d(TAG, "Starting...");
+            int notificationId = ObjectBoxForegroundService.notificationId;
+            Notification notification = ObjectBoxForegroundService.notification;
+            if (notificationId == 0 || notification == null) {
+                throw new IllegalArgumentException("No arguments given: notificationId or notification not set.");
+            }
+            startForeground(notificationId, notification);
+            // Note: with START_STICKY would not get intent on restart.
+            return START_REDELIVER_INTENT;
+        } else {
+            Log.w(TAG, "Ignoring start command: no action specified.");
+            return START_NOT_STICKY;
+        }
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+}
diff --git a/objectbox-android/src/test/java/io/objectbox/android/AndroidPlatformTest.java b/objectbox-android/src/test/java/io/objectbox/android/AndroidPlatformTest.java
new file mode 100644
index 00000000..710afd08
--- /dev/null
+++ b/objectbox-android/src/test/java/io/objectbox/android/AndroidPlatformTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2020 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.Manifest;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.rule.GrantPermissionRule;
+import io.objectbox.android.internal.AndroidPlatform;
+
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(AndroidJUnit4.class)
+public class AndroidPlatformTest {
+
+    @Rule
+    public GrantPermissionRule mRuntimePermissionRule = GrantPermissionRule
+            .grant(Manifest.permission.ACCESS_NETWORK_STATE);
+
+    @Test
+    public void builds() {
+        AndroidPlatform platform = AndroidPlatform.create(ApplicationProvider.getApplicationContext());
+        assertNotNull(platform);
+        assertNotNull(platform.getConnectivityMonitor());
+    }
+}
diff --git a/objectbox-java-api/build.gradle b/objectbox-java-api/build.gradle
deleted file mode 100644
index 30460e12..00000000
--- a/objectbox-java-api/build.gradle
+++ /dev/null
@@ -1,33 +0,0 @@
-plugins {
-    id("java-library")
-    id("objectbox-publish")
-}
-
-// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
-// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
-tasks.withType(JavaCompile) {
-    options.release.set(8)
-}
-
-task javadocJar(type: Jar, dependsOn: javadoc) {
-    archiveClassifier.set('javadoc')
-    from 'build/docs/javadoc'
-}
-
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    archiveClassifier.set('sources')
-}
-
-// Set project-specific properties.
-publishing.publications {
-    mavenJava(MavenPublication) {
-        from components.java
-        artifact sourcesJar
-        artifact javadocJar
-        pom {
-            name = 'ObjectBox API'
-            description = 'ObjectBox is a fast NoSQL database for Objects'
-        }
-    }
-}
diff --git a/objectbox-java-api/build.gradle.kts b/objectbox-java-api/build.gradle.kts
new file mode 100644
index 00000000..e7c48d62
--- /dev/null
+++ b/objectbox-java-api/build.gradle.kts
@@ -0,0 +1,45 @@
+plugins {
+    id("java-library")
+    id("objectbox.publishing-conventions")
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+val javadocJar by tasks.registering(Jar::class) {
+    dependsOn(tasks.javadoc)
+    archiveClassifier.set("javadoc")
+    from("build/docs/javadoc")
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    from(sourceSets.main.get().allSource)
+    archiveClassifier.set("sources")
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxJavaApi = "objectboxJavaApi"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxJavaApi) {
+            artifactId = "objectbox-java-api"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            artifact(javadocJar)
+
+            pom {
+                name.set("ObjectBox Java Annotations")
+                description.set("ObjectBox is a fast NoSQL database for Objects")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxJavaApi])
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Backlink.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Backlink.java
index 2000ac4a..352d2237 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Backlink.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Backlink.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/BaseEntity.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/BaseEntity.java
index 0cf80d11..e19f851d 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/BaseEntity.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/BaseEntity.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2017-2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.annotation;
 
 import java.lang.annotation.ElementType;
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/ConflictStrategy.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/ConflictStrategy.java
index 7ea244cc..38632aca 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/ConflictStrategy.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/ConflictStrategy.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2018-2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.annotation;
 
 /**
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Convert.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Convert.java
index 8c9daff9..c7d256b6 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Convert.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Convert.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/DatabaseType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/DatabaseType.java
index 910f08d6..8b38596b 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/DatabaseType.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/DatabaseType.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2019 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.annotation;
 
 /**
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/DefaultValue.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/DefaultValue.java
index 1b50f0e5..a6e0300b 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/DefaultValue.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/DefaultValue.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.annotation;
 
 import java.lang.annotation.ElementType;
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Entity.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Entity.java
index 768e5f81..64518500 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Entity.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Entity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalName.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalName.java
new file mode 100644
index 00000000..7b196e78
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalName.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Sets the name of an {@link Entity @Entity}, a property or a ToMany in an external system (like another database).
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.TYPE, ElementType.FIELD})
+public @interface ExternalName {
+
+    /**
+     * The name assigned to the annotated element in the external system.
+     */
+    String value();
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalPropertyType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalPropertyType.java
new file mode 100644
index 00000000..29e0296c
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalPropertyType.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+
+/**
+ * A property type of an external system (e.g. another database) that has no default mapping to an ObjectBox type.
+ * <p>
+ * Use with {@link ExternalType @ExternalType}.
+ */
+public enum ExternalPropertyType {
+
+    /**
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation, little endian (16 bytes)
+     */
+    INT_128,
+    /**
+     * A UUID (Universally Unique Identifier) as defined by RFC 9562.
+     * <p>
+     * ObjectBox uses the UUIDv7 scheme (timestamp + random) to create new UUIDs. UUIDv7 is a good choice for database
+     * keys as it's mostly sequential and encodes a timestamp. However, if keys are used externally, consider
+     * {@link #UUID_V4} for better privacy by not exposing any time information.
+     * <p>
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation (16 bytes)
+     */
+    UUID,
+    /**
+     * IEEE 754 decimal128 type, e.g. supported by MongoDB.
+     * <p>
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation (16 bytes)
+     */
+    DECIMAL_128,
+    /**
+     * UUID represented as a string of 36 characters, e.g. "019571b4-80e3-7516-a5c1-5f1053d23fff".
+     * <p>
+     * For efficient storage, consider the {@link #UUID} type instead, which occupies only 16 bytes (20 bytes less).
+     * This type may still be a convenient alternative as the string type is widely supported and more human-readable.
+     * In accordance to standards, new UUIDs generated by ObjectBox use lowercase hexadecimal digits.
+     * <p>
+     * Representing type: String
+     */
+    UUID_STRING,
+    /**
+     * A UUID (Universally Unique Identifier) as defined by RFC 9562.
+     * <p>
+     * ObjectBox uses the UUIDv4 scheme (completely random) to create new UUIDs.
+     * <p>
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation (16 bytes)
+     */
+    UUID_V4,
+    /**
+     * Like {@link #UUID_STRING}, but using the UUIDv4 scheme (completely random) to create new UUID.
+     * <p>
+     * Representing type: String
+     */
+    UUID_V4_STRING,
+    /**
+     * A key/value map; e.g. corresponds to a JSON object or a MongoDB document (although not keeping the key order).
+     * Unlike the Flex type, this must contain a map value (e.g. not a vector or a scalar).
+     * <p>
+     * Representing type: Flex
+     * <p>
+     * Encoding: Flex
+     */
+    FLEX_MAP,
+    /**
+     * A vector (aka list or array) of flexible elements; e.g. corresponds to a JSON array or a MongoDB array. Unlike
+     * the Flex type, this must contain a vector value (e.g. not a map or a scalar).
+     * <p>
+     * Representing type: Flex
+     * <p>
+     * Encoding: Flex
+     */
+    FLEX_VECTOR,
+    /**
+     * Placeholder (not yet used) for a JSON document.
+     * <p>
+     * Representing type: String
+     */
+    JSON,
+    /**
+     * Placeholder (not yet used) for a BSON document.
+     * <p>
+     * Representing type: ByteVector
+     */
+    BSON,
+    /**
+     * JavaScript source code.
+     * <p>
+     * Representing type: String
+     */
+    JAVASCRIPT,
+    /**
+     * A JSON string that is converted to a native "complex" representation in the external system.
+     * <p>
+     * For example in MongoDB, embedded/nested documents are converted to a JSON string in ObjectBox and vice versa.
+     * This allows a quick and simple way to work with non-normalized data from MongoDB in ObjectBox. Alternatively, you
+     * can use {@link #FLEX_MAP} and {@link #FLEX_VECTOR} to map to language primitives (e.g. maps with string keys; not
+     * supported by all ObjectBox languages yet).
+     * <p>
+     * For MongoDB, (nested) documents and arrays are supported.
+     * <p>
+     * Note that this is very close to the internal representation, e.g. the key order is preserved (unlike Flex).
+     * <p>
+     * Representing type: String
+     */
+    JSON_TO_NATIVE,
+    /**
+     * A vector (array) of Int128 values.
+     */
+    INT_128_VECTOR,
+    /**
+     * A vector (array) of Uuid values.
+     */
+    UUID_VECTOR,
+    /**
+     * The 12-byte ObjectId type in MongoDB.
+     * <p>
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation (12 bytes)
+     */
+    MONGO_ID,
+    /**
+     * A vector (array) of MongoId values.
+     */
+    MONGO_ID_VECTOR,
+    /**
+     * Representing type: Long
+     * <p>
+     * Encoding: Two unsigned 32-bit integers merged into a 64-bit integer.
+     */
+    MONGO_TIMESTAMP,
+    /**
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 3 zero bytes (reserved, functions as padding), fourth byte is the sub-type, followed by the binary
+     * data.
+     */
+    MONGO_BINARY,
+    /**
+     * Representing type: string vector with 2 elements (index 0: pattern, index 1: options)
+     * <p>
+     * Encoding: 1:1 string representation
+     */
+    MONGO_REGEX
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalType.java
new file mode 100644
index 00000000..d72d27a4
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalType.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Sets the type of a property or the type of object IDs of a ToMany in an external system (like another database).
+ * <p>
+ * This is useful if there is no default mapping of the ObjectBox type to the type in the external system.
+ * <p>
+ * Carefully look at the documentation of the external type to ensure it is compatible with the ObjectBox type.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.FIELD})
+public @interface ExternalType {
+
+    ExternalPropertyType value();
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswFlags.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswFlags.java
new file mode 100644
index 00000000..27073a6b
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswFlags.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+/**
+ * Flags as a part of the {@link HnswIndex} configuration.
+ */
+public @interface HnswFlags {
+
+    /**
+     * Enables debug logs.
+     */
+    boolean debugLogs() default false;
+
+    /**
+     * Enables "high volume" debug logs, e.g. individual gets/puts.
+     */
+    boolean debugLogsDetailed() default false;
+
+    /**
+     * Padding for SIMD is enabled by default, which uses more memory but may be faster. This flag turns it off.
+     */
+    boolean vectorCacheSimdPaddingOff() default false;
+
+    /**
+     * If the speed of removing nodes becomes a concern in your use case, you can speed it up by setting this flag. By
+     * default, repairing the graph after node removals creates more connections to improve the graph's quality. The
+     * extra costs for this are relatively low (e.g. vs. regular indexing), and thus the default is recommended.
+     */
+    boolean reparationLimitCandidates() default false;
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswIndex.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswIndex.java
new file mode 100644
index 00000000..3ced6191
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswIndex.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Parameters to configure HNSW-based approximate nearest neighbor (ANN) search. Some of the parameters can influence
+ * index construction and searching. Changing these values causes re-indexing, which can take a while due to the complex
+ * nature of HNSW.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface HnswIndex {
+
+    /**
+     * Dimensions of vectors; vector data with fewer dimensions are ignored. Vectors with more dimensions than specified
+     * here are only evaluated up to the given dimension value. Changing this value causes re-indexing.
+     */
+    long dimensions();
+
+    /**
+     * Aka "M": the max number of connections per node (default: 30). Higher numbers increase the graph connectivity,
+     * which can lead to more accurate search results. However, higher numbers also increase the indexing time and
+     * resource usage. Try e.g. 16 for faster but less accurate results, or 64 for more accurate results. Changing this
+     * value causes re-indexing.
+     */
+    long neighborsPerNode() default 0;
+
+    /**
+     * Aka "efConstruction": the number of neighbor searched for while indexing (default: 100). The higher the value,
+     * the more accurate the search, but the longer the indexing. If indexing time is not a major concern, a value of at
+     * least 200 is recommended to improve search quality. Changing this value causes re-indexing.
+     */
+    long indexingSearchCount() default 0;
+
+    /**
+     * See {@link HnswFlags}.
+     */
+    HnswFlags flags() default @HnswFlags;
+
+    /**
+     * The distance type used for the HNSW index. Changing this value causes re-indexing.
+     */
+    VectorDistanceType distanceType() default VectorDistanceType.DEFAULT;
+
+    /**
+     * When repairing the graph after a node was removed, this gives the probability of adding backlinks to the repaired
+     * neighbors. The default is 1.0 (aka "always") as this should be worth a bit of extra costs as it improves the
+     * graph's quality.
+     */
+    float reparationBacklinkProbability() default 1.0F;
+
+    /**
+     * A non-binding hint at the maximum size of the vector cache in KB (default: 2097152 or 2 GB/GiB). The actual size
+     * max cache size may be altered according to device and/or runtime settings. The vector cache is used to store
+     * vectors in memory to speed up search and indexing.
+     * <p>
+     * Note 1: cache chunks are allocated only on demand, when they are actually used. Thus, smaller datasets will use
+     * less memory.
+     * <p>
+     * Note 2: the cache is for one specific HNSW index; e.g. each index has its own cache.
+     * <p>
+     * Note 3: the memory consumption can temporarily exceed the cache size, e.g. for large changes, it can double due
+     * to multi-version transactions.
+     */
+    long vectorCacheHintSizeKB() default 0;
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Id.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Id.java
index c07579f8..9656d733 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Id.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Id.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/IdCompanion.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/IdCompanion.java
index 9f89b564..29a80ec9 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/IdCompanion.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/IdCompanion.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 ObjectBox Ltd. All rights reserved.
+ * Copyright 2021 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Index.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Index.java
index d6f07f0a..799c9e51 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Index.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Index.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2018 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/IndexType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/IndexType.java
index 33217349..998a8031 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/IndexType.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/IndexType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2018 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/NameInDb.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/NameInDb.java
index 692dcda3..151fc465 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/NameInDb.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/NameInDb.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/NotNull.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/NotNull.java
index 4e6f2681..c185cde2 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/NotNull.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/NotNull.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/OrderBy.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/OrderBy.java
index 5ec7d2f0..380eb07a 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/OrderBy.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/OrderBy.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Sync.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Sync.java
index 70b0ea63..9a9e6a4a 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Sync.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Sync.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.annotation;
 
 import java.lang.annotation.ElementType;
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncClock.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncClock.java
new file mode 100644
index 00000000..d51684ae
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncClock.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a {@code long} (64-bit integer) field of a {@link Sync}-enabled {@link Entity} class as the sync clock, a
+ * "hybrid logical clock" to resolve Sync conflicts.
+ * <p>
+ * These clock values allow "last write wins" conflict resolution.
+ * <p>
+ * There can be only one sync clock per sync entity type; which is also recommended for basic conflict resolution.
+ * <p>
+ * For new objects, initialize the property value to {@code 0} to reserve "a slot" in the object data. ObjectBox Sync
+ * will update this property automatically on put operations.
+ * <p>
+ * As a hybrid clock, it combines a wall clock with a logical counter to compensate for some clock skew effects.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface SyncClock {
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncPrecedence.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncPrecedence.java
new file mode 100644
index 00000000..472893c9
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncPrecedence.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a {@code long} (64-bit integer) field of a {@link Sync}-enabled {@link Entity} class as the "sync precedence"
+ * to customize Sync conflict resolution.
+ * <p>
+ * Developer-assigned precedence values are then used to resolve conflicts via "higher precedence wins". Defining and
+ * assigning precedence values are completely in the hands of the developer (the ObjectBox user).
+ * <p>
+ * There can be only one sync precedence per sync entity type.
+ * <p>
+ * Typically, it is combined with a {@link SyncClock}, with the latter being the tie-breaker for equal precedence
+ * values.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface SyncPrecedence {
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/TargetIdProperty.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/TargetIdProperty.java
index d18859ae..9b96f855 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/TargetIdProperty.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/TargetIdProperty.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,8 +22,27 @@
 import java.lang.annotation.Target;
 
 /**
- * Defines the property serving as the target ID of a ToOne.
- * This allows exposing an explicit property, which may be convenient for other parsers/serializers (e.g. JSON).
+ * For a ToOne, changes the name of its associated target ID (or "relation") property.
+ * <p>
+ * <pre>{@code
+ * @Entity
+ * public class Order {
+ *     // Change from default "customerId" to "customerRef"
+ *     @TargetIdProperty("customerRef")
+ *     ToOne<Customer> customer;
+ *     // Optional: expose target ID property (using changed name)
+ *     long customerRef;
+ * }
+ * }</pre>
+ * <p>
+ * A target ID property is implicitly created (so without defining it in the {@link Entity @Entity} class) for each
+ * ToOne and stores the ID of the referenced target object. By default, it's named like the ToOne field plus the suffix
+ * "Id" (for example {@code customerId}).
+ * <p>
+ * Like in the example above, it's still possible to expose the target ID property as an actual field (useful for other
+ * parsers or serializers, like for JSON). But make sure to use the changed name for the field.
+ * <p>
+ * See the <a href="https://docs.objectbox.io/relations">relations documentation</a> for details.
  */
 @Retention(RetentionPolicy.CLASS)
 @Target({ElementType.FIELD, ElementType.TYPE})
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Transient.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Transient.java
index 679d92dc..c4f4c9b4 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Transient.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Transient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Type.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Type.java
index 033b1835..0656b42c 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Type.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Type.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Uid.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Uid.java
index 94f1b2f6..4085c8bf 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Uid.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Uid.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Unique.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Unique.java
index 6448a50e..25394aab 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Unique.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Unique.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Unsigned.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Unsigned.java
index dd9bcb1d..7fd47511 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Unsigned.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Unsigned.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/VectorDistanceType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/VectorDistanceType.java
new file mode 100644
index 00000000..84682eb8
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/VectorDistanceType.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2024-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+/**
+ * The vector distance algorithm used by an {@link HnswIndex} (vector search).
+ */
+public enum VectorDistanceType {
+
+    /**
+     * The default; currently {@link #EUCLIDEAN}.
+     */
+    DEFAULT,
+
+    /**
+     * Typically "Euclidean squared" internally.
+     */
+    EUCLIDEAN,
+
+    /**
+     * Cosine similarity compares two vectors irrespective of their magnitude (compares the angle of two vectors).
+     * <p>
+     * Often used for document or semantic similarity.
+     * <p>
+     * Value range: 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)
+     */
+    COSINE,
+
+    /**
+     * For normalized vectors (vector length == 1.0), the dot product is equivalent to the cosine similarity.
+     * <p>
+     * Because of this, the dot product is often preferred as it performs better.
+     * <p>
+     * Value range (normalized vectors): 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)
+     */
+    DOT_PRODUCT,
+
+    /**
+     * For geospatial coordinates, more specifically latitude and longitude pairs.
+     * <p>
+     * Note, the vector dimension should be 2, with the latitude being the first element and longitude the second.
+     * If the vector has more than 2 dimensions, only the first 2 dimensions are used.
+     * If the vector has fewer than 2 dimensions, the distance is always zero.
+     * <p>
+     * Internally, this uses haversine distance.
+     * <p>
+     * Value range: 0 km - 6371 * π km (approx. 20015.09 km; half the Earth's circumference)
+     */
+    GEO,
+
+    /**
+     * A custom dot product similarity measure that does not require the vectors to be normalized.
+     * <p>
+     * Note: this is no replacement for cosine similarity (like DotProduct for normalized vectors is). The non-linear
+     * conversion provides a high precision over the entire float range (for the raw dot product). The higher the dot
+     * product, the lower the distance is (the nearer the vectors are). The more negative the dot product, the higher
+     * the distance is (the farther the vectors are).
+     * <p>
+     * Value range: 0.0 - 2.0 (nonlinear; 0.0: nearest, 1.0: orthogonal, 2.0: farthest)
+     */
+    DOT_PRODUCT_NON_NORMALIZED
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Beta.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Beta.java
index eed18b4f..b7966aea 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Beta.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Beta.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Experimental.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Experimental.java
index bf541cfb..6136adee 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Experimental.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Experimental.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Internal.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Internal.java
index 783e0168..e1a61883 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Internal.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Internal.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/package-info.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/package-info.java
index 6bcafc47..d4fa34ea 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/package-info.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/package-info.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/package-info.java
index 0439d85c..0fd5d42f 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/package-info.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/converter/PropertyConverter.java b/objectbox-java-api/src/main/java/io/objectbox/converter/PropertyConverter.java
index 6d65717f..44be7bf7 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/converter/PropertyConverter.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/converter/PropertyConverter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/converter/package-info.java b/objectbox-java-api/src/main/java/io/objectbox/converter/package-info.java
index 05bb31b8..5a066a67 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/converter/package-info.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/converter/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/build.gradle b/objectbox-java/build.gradle
deleted file mode 100644
index e36b63c4..00000000
--- a/objectbox-java/build.gradle
+++ /dev/null
@@ -1,150 +0,0 @@
-plugins {
-    id("java-library")
-    id("objectbox-publish")
-    id("com.github.spotbugs")
-}
-
-// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
-// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
-tasks.withType(JavaCompile) {
-    options.release.set(8)
-}
-
-ext {
-    javadocForWebDir = "$buildDir/docs/web-api-docs"
-}
-
-dependencies {
-    api project(':objectbox-java-api')
-    implementation "org.greenrobot:essentials:$essentialsVersion"
-    api 'com.google.code.findbugs:jsr305:3.0.2'
-
-    // https://github.com/spotbugs/spotbugs/blob/master/CHANGELOG.md
-    compileOnly 'com.github.spotbugs:spotbugs-annotations:4.2.2'
-}
-
-spotbugs {
-    ignoreFailures = true
-    excludeFilter = file("spotbugs-exclude.xml")
-}
-
-tasks.spotbugsMain {
-    reports.create("html") {
-        required.set(true)
-    }
-}
-
-javadoc {
-    // Hide internal API from javadoc artifact.
-    exclude("**/io/objectbox/Cursor.java")
-    exclude("**/io/objectbox/KeyValueCursor.java")
-    exclude("**/io/objectbox/ModelBuilder.java")
-    exclude("**/io/objectbox/Properties.java")
-    exclude("**/io/objectbox/Transaction.java")
-    exclude("**/io/objectbox/model/**")
-    exclude("**/io/objectbox/ideasonly/**")
-    exclude("**/io/objectbox/internal/**")
-    exclude("**/io/objectbox/reactive/DataPublisherUtils.java")
-    exclude("**/io/objectbox/reactive/WeakDataObserver.java")
-}
-
-// Note: use packageJavadocForWeb to get as ZIP.
-task javadocForWeb(type: Javadoc) {
-    group = 'documentation'
-    description = 'Builds Javadoc incl. objectbox-java-api classes with web tweaks.'
-
-    javadocTool = javaToolchains.javadocToolFor {
-        // Note: the style changes only work if using JDK 10+, 11 is latest LTS.
-        languageVersion = JavaLanguageVersion.of(11)
-    }
-
-    def srcApi = project(':objectbox-java-api').file('src/main/java/')
-    if (!srcApi.directory) throw new GradleScriptException("Not a directory: ${srcApi}", null)
-    // Hide internal API from javadoc artifact.
-    def filteredSources = sourceSets.main.allJava.matching {
-        exclude("**/io/objectbox/Cursor.java")
-        exclude("**/io/objectbox/KeyValueCursor.java")
-        exclude("**/io/objectbox/ModelBuilder.java")
-        exclude("**/io/objectbox/Properties.java")
-        exclude("**/io/objectbox/Transaction.java")
-        exclude("**/io/objectbox/model/**")
-        exclude("**/io/objectbox/ideasonly/**")
-        exclude("**/io/objectbox/internal/**")
-        exclude("**/io/objectbox/reactive/DataPublisherUtils.java")
-        exclude("**/io/objectbox/reactive/WeakDataObserver.java")
-    }
-    source = filteredSources + srcApi
-
-    classpath = sourceSets.main.output + sourceSets.main.compileClasspath
-    destinationDir = file(javadocForWebDir)
-
-    title = "ObjectBox Java ${version} API"
-    options.overview = "$projectDir/src/web/overview.html"
-    options.bottom = 'Available under the Apache License, Version 2.0 - <i>Copyright &#169; 2017-2022 <a href="https://objectbox.io/">ObjectBox Ltd</a>. All Rights Reserved.</i>'
-
-    doLast {
-        // Note: frequently check the vanilla stylesheet.css if values still match.
-        def stylesheetPath = "$destinationDir/stylesheet.css"
-
-        // Primary background
-        ant.replace(file: stylesheetPath, token: "#4D7A97", value: "#17A6A6")
-
-        // "Active" background
-        ant.replace(file: stylesheetPath, token: "#F8981D", value: "#7DDC7D")
-
-        // Hover
-        ant.replace(file: stylesheetPath, token: "#bb7a2a", value: "#E61955")
-
-        // Note: in CSS stylesheets the last added rule wins, so append to default stylesheet.
-        // Code blocks
-        file(stylesheetPath).append("pre {\nwhite-space: normal;\noverflow-x: auto;\n}\n")
-        // Member summary tables
-        file(stylesheetPath).append(".memberSummary {\noverflow: auto;\n}\n")
-        // Descriptions and signatures
-        file(stylesheetPath).append(".block {\n" +
-                "    display:block;\n" +
-                "    margin:3px 10px 2px 0px;\n" +
-                "    color:#474747;\n" +
-                "    overflow:auto;\n" +
-                "}")
-
-        println "Javadoc for web created at $destinationDir"
-    }
-}
-
-task packageJavadocForWeb(type: Zip, dependsOn: javadocForWeb) {
-    group = 'documentation'
-    description = 'Packages Javadoc incl. objectbox-java-api classes with web tweaks as ZIP.'
-
-    archiveFileName = "objectbox-java-web-api-docs.zip"
-    destinationDirectory = file("$buildDir/dist")
-
-    from file(javadocForWebDir)
-
-    doLast {
-        println "Javadoc for web packaged to ${file("$buildDir/dist/objectbox-java-web-api-docs.zip")}"
-    }
-}
-
-task javadocJar(type: Jar, dependsOn: javadoc) {
-    archiveClassifier.set('javadoc')
-    from 'build/docs/javadoc'
-}
-
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    archiveClassifier.set('sources')
-}
-
-// Set project-specific properties.
-publishing.publications {
-    mavenJava(MavenPublication) {
-        from components.java
-        artifact sourcesJar
-        artifact javadocJar
-        pom {
-            name = 'ObjectBox Java (only)'
-            description = 'ObjectBox is a fast NoSQL database for Objects'
-        }
-    }
-}
diff --git a/objectbox-java/build.gradle.kts b/objectbox-java/build.gradle.kts
new file mode 100644
index 00000000..78364f9f
--- /dev/null
+++ b/objectbox-java/build.gradle.kts
@@ -0,0 +1,177 @@
+plugins {
+    id("java-library")
+    id("objectbox.publishing-conventions")
+    alias(libs.plugins.spotbugs)
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+val javadocForWebDir = layout.buildDirectory.dir("docs/web-api-docs")
+
+dependencies {
+    api(project(":objectbox-java-api"))
+    implementation(libs.essentials)
+    api(libs.jsr305)
+
+    compileOnly(libs.spotbugs.annotations)
+}
+
+spotbugs {
+    ignoreFailures.set(true)
+    showStackTraces.set(true)
+    excludeFilter.set(file("spotbugs-exclude.xml"))
+}
+
+tasks.spotbugsMain {
+    reports.create("html") {
+        required.set(true)
+    }
+}
+
+// Note: used for the Maven javadoc artifact, a separate task is used to build API docs to publish online
+tasks.javadoc {
+    // Internal Java APIs
+    exclude("**/io/objectbox/Cursor.java")
+    exclude("**/io/objectbox/InternalAccess.java")
+    exclude("**/io/objectbox/KeyValueCursor.java")
+    exclude("**/io/objectbox/ModelBuilder.java")
+    exclude("**/io/objectbox/Properties.java")
+    exclude("**/io/objectbox/Transaction.java")
+    exclude("**/io/objectbox/ideasonly/**")
+    exclude("**/io/objectbox/internal/**")
+    exclude("**/io/objectbox/query/InternalAccess.java")
+    exclude("**/io/objectbox/reactive/DataPublisherUtils.java")
+    exclude("**/io/objectbox/reactive/WeakDataObserver.java")
+    exclude("**/io/objectbox/sync/server/ClusterPeerInfo.java")
+    // Repackaged FlatBuffers distribution
+    exclude("**/io/objectbox/flatbuffers/**")
+    // FlatBuffers generated files only used internally (note: some are part of the public API)
+    exclude("**/io/objectbox/model/**")
+    exclude("**/io/objectbox/sync/Credentials.java")
+    exclude("**/io/objectbox/sync/CredentialsType.java")
+    exclude("**/io/objectbox/sync/server/ClusterPeerConfig.java")
+    exclude("**/io/objectbox/sync/server/JwtConfig.java")
+    exclude("**/io/objectbox/sync/server/SyncServerOptions.java")
+}
+
+// Note: use packageJavadocForWeb to get as ZIP.
+val javadocForWeb by tasks.registering(Javadoc::class) {
+    group = "documentation"
+    description = "Builds Javadoc incl. objectbox-java-api classes with web tweaks."
+
+    // Register used files as inputs so task is re-run if they change
+    // https://docs.gradle.org/current/userguide/incremental_build.html
+    val customOverview = layout.projectDirectory.file("src/web/overview.html")
+    inputs.file(customOverview)
+        .withPropertyName("customOverview")
+        .withPathSensitivity(PathSensitivity.NONE)
+    val customStylesheet = layout.projectDirectory.file("src/web/objectbox-stylesheet.css")
+    inputs.file(customStylesheet)
+        .withPropertyName("customStylesheet")
+        .withPathSensitivity(PathSensitivity.NONE)
+
+    javadocTool.set(javaToolchains.javadocToolFor {
+        // Note: the style changes only work if using JDK 10+, 21 is the LTS release used to publish this
+        languageVersion.set(JavaLanguageVersion.of(21))
+    })
+
+    val srcApi = project(":objectbox-java-api").file("src/main/java/")
+    if (!srcApi.isDirectory) throw GradleException("Not a directory: $srcApi")
+    // Hide internal API from javadoc artifact.
+    val filteredSources = sourceSets.main.get().allJava.matching {
+        // Internal Java APIs
+        exclude("**/io/objectbox/Cursor.java")
+        exclude("**/io/objectbox/InternalAccess.java")
+        exclude("**/io/objectbox/KeyValueCursor.java")
+        exclude("**/io/objectbox/ModelBuilder.java")
+        exclude("**/io/objectbox/Properties.java")
+        exclude("**/io/objectbox/Transaction.java")
+        exclude("**/io/objectbox/ideasonly/**")
+        exclude("**/io/objectbox/internal/**")
+        exclude("**/io/objectbox/query/InternalAccess.java")
+        exclude("**/io/objectbox/reactive/DataPublisherUtils.java")
+        exclude("**/io/objectbox/reactive/WeakDataObserver.java")
+        exclude("**/io/objectbox/sync/server/ClusterPeerInfo.java")
+        // Repackaged FlatBuffers distribution
+        exclude("**/io/objectbox/flatbuffers/**")
+        // FlatBuffers generated files only used internally (note: some are part of the public API)
+        exclude("**/io/objectbox/model/**")
+        exclude("**/io/objectbox/sync/Credentials.java")
+        exclude("**/io/objectbox/sync/CredentialsType.java")
+        exclude("**/io/objectbox/sync/server/ClusterPeerConfig.java")
+        exclude("**/io/objectbox/sync/server/JwtConfig.java")
+        exclude("**/io/objectbox/sync/server/SyncServerOptions.java")
+    }
+    source = filteredSources + fileTree(srcApi)
+
+    classpath = sourceSets.main.get().output + sourceSets.main.get().compileClasspath
+    destinationDir = javadocForWebDir.get().asFile
+
+    title = "ObjectBox Java ${project.version} API"
+    (options as StandardJavadocDocletOptions).apply {
+        overview = customOverview.toString()
+        bottom = "Available under the Apache License, Version 2.0 - <i>Copyright &#169; 2017-2026 <a href=\"https://objectbox.io/\">ObjectBox Ltd</a>. All Rights Reserved.</i>"
+        // Customize the default stylesheet https://docs.oracle.com/en/java/javase/21/javadoc/javadoc-css-themes.html
+        // Note: the javadoc option is "--add-stylesheet", but addStringOption already ads a single dash ("-")
+        addStringOption("-add-stylesheet", customStylesheet.toString())
+    }
+
+    doLast {
+        println("Javadoc for web created at $destinationDir")
+    }
+}
+
+tasks.register<Zip>("packageJavadocForWeb") {
+    dependsOn(javadocForWeb)
+    group = "documentation"
+    description = "Packages Javadoc incl. objectbox-java-api classes with web tweaks as ZIP."
+
+    archiveFileName.set("objectbox-java-web-api-docs.zip")
+    val distDir = layout.buildDirectory.dir("dist")
+    destinationDirectory.set(distDir)
+
+    from(file(javadocForWebDir))
+
+    doLast {
+        println("Javadoc for web packaged to ${distDir.get().file("objectbox-java-web-api-docs.zip")}")
+    }
+}
+
+val javadocJar by tasks.registering(Jar::class) {
+    dependsOn(tasks.javadoc)
+    archiveClassifier.set("javadoc")
+    from("build/docs/javadoc")
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    from(sourceSets.main.get().allSource)
+    archiveClassifier.set("sources")
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxJava = "objectboxJava"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxJava) {
+            artifactId = "objectbox-java"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            artifact(javadocJar)
+
+            pom {
+                name.set("ObjectBox Java API")
+                description.set("ObjectBox is a fast NoSQL database for Objects")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxJava])
+}
diff --git a/objectbox-java/spotbugs-exclude.xml b/objectbox-java/spotbugs-exclude.xml
index 345ac71c..701a5970 100644
--- a/objectbox-java/spotbugs-exclude.xml
+++ b/objectbox-java/spotbugs-exclude.xml
@@ -5,6 +5,9 @@
     <Match>
         <Class name="io.objectbox.DebugFlags" />
     </Match>
+    <Match>
+        <Package name="io.objectbox.config" />
+    </Match>
     <Match>
         <Package name="io.objectbox.model" />
     </Match>
diff --git a/objectbox-java/src/main/java/io/objectbox/Box.java b/objectbox-java/src/main/java/io/objectbox/Box.java
index 0cf8da69..ef252e61 100644
--- a/objectbox-java/src/main/java/io/objectbox/Box.java
+++ b/objectbox-java/src/main/java/io/objectbox/Box.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,12 +23,12 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.Callable;
 
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
-import io.objectbox.annotation.apihint.Beta;
+import io.objectbox.annotation.Backlink;
+import io.objectbox.annotation.Id;
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.exception.DbException;
@@ -38,6 +38,8 @@
 import io.objectbox.query.QueryBuilder;
 import io.objectbox.query.QueryCondition;
 import io.objectbox.relation.RelationInfo;
+import io.objectbox.relation.ToMany;
+import io.objectbox.relation.ToOne;
 
 /**
  * A Box to put and get Objects of a specific Entity class.
@@ -163,20 +165,23 @@ public void closeThreadResources() {
         }
     }
 
-    void txCommitted(Transaction tx) {
-        // Thread local readers will be renewed on next get, so we do not need clean them up
-
-        Cursor<T> cursor = activeTxCursor.get();
-        if (cursor != null) {
-            activeTxCursor.remove();
-            cursor.close();
-        }
+    /**
+     * Returns if for the calling thread this has a reader Cursor.
+     */
+    boolean hasReaderCursorForCurrentThread() {
+        return threadLocalReader.get() != null;
     }
 
     /**
-     * Called by {@link BoxStore#callInReadTx(Callable)} - does not throw so caller does not need try/finally.
+     * If there is one, and it was created using the given {@code tx}, removes and closes the {@link #activeTxCursor}
+     * for the current thread.
+     * <p>
+     * This should be called before the active transaction is closed to clean up native resources.
+     * <p>
+     * Note: {@link #threadLocalReader} is either renewed by the next call to {@link #getReader()} or cleaned up by
+     * {@link #closeThreadResources()}.
      */
-    void readTxFinished(Transaction tx) {
+    void closeActiveTxCursorForCurrentThread(Transaction tx) {
         Cursor<T> cursor = activeTxCursor.get();
         if (cursor != null && cursor.getTx() == tx) {
             activeTxCursor.remove();
@@ -184,6 +189,13 @@ void readTxFinished(Transaction tx) {
         }
     }
 
+    /**
+     * Returns if for the calling thread this has a Cursor, if any, for the currently active transaction.
+     */
+    boolean hasActiveTxCursorForCurrentThread() {
+        return activeTxCursor.get() != null;
+    }
+
     /** Used by tests */
     int getPropertyId(String propertyName) {
         Cursor<T> reader = getReader();
@@ -302,6 +314,7 @@ public boolean isEmpty() {
 
     /**
      * Returns all stored Objects in this Box.
+     *
      * @return since 2.4 the returned list is always mutable (before an empty result list was immutable)
      */
     public List<T> getAll() {
@@ -320,8 +333,9 @@ public List<T> getAll() {
     /**
      * Check if an object with the given ID exists in the database.
      * This is more efficient than a {@link #get(long)} and comparing against null.
+     *
+     * @return true if an object with the given ID was found, false otherwise.
      * @since 2.7
-     * @return true if a object with the given ID was found, false otherwise
      */
     public boolean contains(long id) {
         Cursor<T> reader = getReader();
@@ -333,12 +347,25 @@ public boolean contains(long id) {
     }
 
     /**
-     * Puts the given object in the box (aka persisting it). If this is a new entity (its ID property is 0), a new ID
-     * will be assigned to the entity (and returned). If the entity was already put in the box before, it will be
-     * overwritten.
+     * Puts the given object and returns its (new) ID.
+     * <p>
+     * This means that if its {@link Id @Id} property is 0 or null, it is inserted as a new object and assigned the next
+     * available ID. For example, if there is an object with ID 1 and another with ID 100, it will be assigned ID 101.
+     * The new ID is also set on the given object before this returns.
+     * <p>
+     * If instead the object has an assigned ID set, if an object with the same ID exists it is updated. Otherwise, it
+     * is inserted with that ID.
      * <p>
-     * Performance note: if you want to put several entities, consider {@link #put(Collection)},
-     * {@link #put(Object[])}, {@link BoxStore#runInTx(Runnable)}, etc. instead.
+     * If the ID was not assigned before an {@link IllegalArgumentException} is thrown.
+     * <p>
+     * When the object contains {@link ToOne} or {@link ToMany} relations, they are created (or updated) to point to the
+     * (new) target objects. The target objects themselves are typically not updated or removed. To do so, put or remove
+     * them using their {@link Box}. However, for convenience, if a target object is new, it will be inserted and
+     * assigned an ID in its Box before creating or updating the relation. Also, for ToMany relations based on a
+     * {@link Backlink} the target objects are updated (to store changes in the linked ToOne or ToMany relation).
+     * <p>
+     * Performance note: if you want to put several objects, consider {@link #put(Collection)}, {@link #put(Object[])},
+     * {@link BoxStore#runInTx(Runnable)}, etc. instead.
      */
     public long put(T entity) {
         Cursor<T> cursor = getWriter();
@@ -353,6 +380,8 @@ public long put(T entity) {
 
     /**
      * Puts the given entities in a box using a single transaction.
+     * <p>
+     * See {@link #put(Object)} for more details.
      */
     @SafeVarargs // Not using T... as Object[], no ClassCastException expected.
     public final void put(@Nullable T... entities) {
@@ -373,6 +402,8 @@ public final void put(@Nullable T... entities) {
 
     /**
      * Puts the given entities in a box using a single transaction.
+     * <p>
+     * See {@link #put(Object)} for more details.
      *
      * @param entities It is fine to pass null or an empty collection:
      *                 this case is handled efficiently without overhead.
@@ -395,6 +426,8 @@ public void put(@Nullable Collection<T> entities) {
 
     /**
      * Puts the given entities in a box in batches using a separate transaction for each batch.
+     * <p>
+     * See {@link #put(Object)} for more details.
      *
      * @param entities  It is fine to pass null or an empty collection:
      *                  this case is handled efficiently without overhead.
@@ -424,8 +457,11 @@ public void putBatched(@Nullable Collection<T> entities, int batchSize) {
     }
 
     /**
-     * Removes (deletes) the Object by its ID.
-     * @return true if an entity was actually removed (false if no entity exists with the given ID)
+     * Removes (deletes) the object with the given ID.
+     * <p>
+     * If the object is part of a relation, it will be removed from that relation as well.
+     *
+     * @return true if the object did exist and was removed, otherwise false.
      */
     public boolean remove(long id) {
         Cursor<T> cursor = getWriter();
@@ -440,7 +476,7 @@ public boolean remove(long id) {
     }
 
     /**
-     * Removes (deletes) Objects by their ID in a single transaction.
+     * Like {@link #remove(long)}, but removes multiple objects in a single transaction.
      */
     public void remove(@Nullable long... ids) {
         if (ids == null || ids.length == 0) {
@@ -459,15 +495,7 @@ public void remove(@Nullable long... ids) {
     }
 
     /**
-     * @deprecated use {@link #removeByIds(Collection)} instead.
-     */
-    @Deprecated
-    public void removeByKeys(@Nullable Collection<Long> ids) {
-        removeByIds(ids);
-    }
-
-    /**
-     * Due to type erasure collision, we cannot simply use "remove" as a method name here.
+     * Like {@link #remove(long)}, but removes multiple objects in a single transaction.
      */
     public void removeByIds(@Nullable Collection<Long> ids) {
         if (ids == null || ids.isEmpty()) {
@@ -485,8 +513,7 @@ public void removeByIds(@Nullable Collection<Long> ids) {
     }
 
     /**
-     * Removes (deletes) the given Object.
-     * @return true if an entity was actually removed (false if no entity exists with the given ID)
+     * Like {@link #remove(long)}, but obtains the ID from the {@link Id @Id} property of the given object instead.
      */
     public boolean remove(T object) {
         Cursor<T> cursor = getWriter();
@@ -502,7 +529,7 @@ public boolean remove(T object) {
     }
 
     /**
-     * Removes (deletes) the given Objects in a single transaction.
+     * Like {@link #remove(Object)}, but removes multiple objects in a single transaction.
      */
     @SafeVarargs // Not using T... as Object[], no ClassCastException expected.
     @SuppressWarnings("Duplicates") // Detected duplicate has different type
@@ -523,7 +550,7 @@ public final void remove(@Nullable T... objects) {
     }
 
     /**
-     * Removes (deletes) the given Objects in a single transaction.
+     * Like {@link #remove(Object)}, but removes multiple objects in a single transaction.
      */
     @SuppressWarnings("Duplicates") // Detected duplicate has different type
     public void remove(@Nullable Collection<T> objects) {
@@ -543,7 +570,7 @@ public void remove(@Nullable Collection<T> objects) {
     }
 
     /**
-     * Removes (deletes) ALL Objects in a single transaction.
+     * Like {@link #remove(long)}, but removes <b>all</b> objects in a single transaction.
      */
     public void removeAll() {
         Cursor<T> cursor = getWriter();
@@ -567,15 +594,15 @@ public long panicModeRemoveAll() {
     }
 
     /**
-     * Returns a builder to create queries for Object matching supplied criteria.
+     * Create a query with no conditions.
+     *
+     * @see #query(QueryCondition)
      */
     public QueryBuilder<T> query() {
-        return new QueryBuilder<>(this, store.internalHandle(), store.getDbName(entityClass));
+        return new QueryBuilder<>(this, store.getNativeStore(), store.getDbName(entityClass));
     }
 
     /**
-     * Experimental. This API might change or be removed in the future based on user feedback.
-     * <p>
      * Applies the given query conditions and returns the builder for further customization, such as result order.
      * Build the condition using the properties from your entity underscore classes.
      * <p>
@@ -595,7 +622,6 @@ public QueryBuilder<T> query() {
      *
      * @see QueryBuilder#apply(QueryCondition)
      */
-    @Experimental
     public QueryBuilder<T> query(QueryCondition<T> queryCondition) {
         return query().apply(queryCondition);
     }
@@ -616,7 +642,14 @@ public synchronized EntityInfo<T> getEntityInfo() {
         return entityInfo;
     }
 
-    @Beta
+    /**
+     * Attaches the given object to this.
+     * <p>
+     * This typically should only be used when <a
+     * href="https://docs.objectbox.io/advanced/object-ids#self-assigned-object-ids">manually assigning IDs</a>.
+     *
+     * @param entity The object to attach this to.
+     */
     public void attach(T entity) {
         if (boxStoreField == null) {
             try {
diff --git a/objectbox-java/src/main/java/io/objectbox/BoxStore.java b/objectbox-java/src/main/java/io/objectbox/BoxStore.java
index 3ffc77f6..b4983ce1 100644
--- a/objectbox-java/src/main/java/io/objectbox/BoxStore.java
+++ b/objectbox-java/src/main/java/io/objectbox/BoxStore.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2021 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,12 +16,12 @@
 
 package io.objectbox;
 
-import io.objectbox.internal.Feature;
 import org.greenrobot.essentials.collections.LongHashMap;
 
 import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
+import java.io.PrintStream;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.ArrayList;
@@ -36,7 +36,11 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
 
 import javax.annotation.Nullable;
@@ -45,10 +49,13 @@
 import io.objectbox.annotation.apihint.Beta;
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.config.DebugFlags;
+import io.objectbox.config.FlatStoreOptions;
 import io.objectbox.converter.PropertyConverter;
 import io.objectbox.exception.DbException;
 import io.objectbox.exception.DbExceptionListener;
 import io.objectbox.exception.DbSchemaException;
+import io.objectbox.internal.Feature;
 import io.objectbox.internal.NativeLibraryLoader;
 import io.objectbox.internal.ObjectBoxThreadPool;
 import io.objectbox.reactive.DataObserver;
@@ -68,10 +75,26 @@ public class BoxStore implements Closeable {
     @Nullable private static Object context;
     @Nullable private static Object relinker;
 
-    /** Change so ReLinker will update native library when using workaround loading. */
-    public static final String JNI_VERSION = "3.3.1";
+    /** Prefix supplied with database directory to signal a file-less and in-memory database should be used. */
+    public static final String IN_MEMORY_PREFIX = "memory:";
+
+    /**
+     * ReLinker uses this as a suffix for the extracted shared library file. If different, it will update it. Should be
+     * unique to avoid conflicts.
+     */
+    public static final String JNI_VERSION = "6.0.0-2026-07-13";
 
-    private static final String VERSION = "3.3.1-2022-09-05";
+    /**
+     * The ObjectBox database version this Java library is known to work with.
+     * <p>
+     * This should be a version number followed by a date (MAJOR.MINOR.PATCH-YYYY-MM-DD).
+     * <p>
+     * This is used (currently only in tests) to make sure a database library has a compatible JNI API by checking the
+     * version number matches exactly and the date is the same or newer.
+     */
+    private static final String VERSION = "6.0.0-2026-07-13";
+
+    private static final String OBJECTBOX_PACKAGE_NAME = "objectbox";
     private static BoxStore defaultStore;
 
     /** Currently used DB dirs with values from {@link #getCanonicalPath(File)}. */
@@ -123,21 +146,31 @@ public static synchronized boolean clearDefaultStore() {
         return existedBefore;
     }
 
-    /** Gets the Version of ObjectBox Java. */
+    /**
+     * Returns the version of this ObjectBox Java SDK.
+     */
     public static String getVersion() {
         return VERSION;
     }
 
     static native String nativeGetVersion();
 
-    /** Gets the Version of ObjectBox Core. */
+    /**
+     * Returns the version of the loaded ObjectBox database library.
+     */
     public static String getVersionNative() {
         NativeLibraryLoader.ensureLoaded();
         return nativeGetVersion();
     }
 
     /**
-     * Creates a native BoxStore instance with FlatBuffer {@link io.objectbox.model.FlatStoreOptions} {@code options}
+     * @return true if DB files did not exist or were successfully removed,
+     * false if DB files exist that could not be removed.
+     */
+    static native boolean nativeRemoveDbFiles(String directory, boolean removeDir);
+
+    /**
+     * Creates a native BoxStore instance with FlatBuffer {@link FlatStoreOptions} {@code options}
      * and a {@link ModelBuilder} {@code model}. Returns the handle of the native store instance.
      */
     static native long nativeCreateWithFlatOptions(byte[] options, byte[] model);
@@ -183,7 +216,9 @@ static native void nativeRegisterCustomType(long store, int entityId, int proper
 
     static native boolean nativeIsObjectBrowserAvailable();
 
-    native long nativeSizeOnDisk(long store);
+    native long nativeDbSize(long store);
+
+    native long nativeDbSizeOnDisk(long store);
 
     native long nativeValidate(long store, long pageLimit, boolean checkLeafLevel);
 
@@ -193,6 +228,11 @@ static native void nativeRegisterCustomType(long store, int entityId, int proper
 
     private static native boolean nativeHasFeature(int feature);
 
+    /**
+     * Returns if the loaded database library supports the given feature.
+     *
+     * @param feature the feature to check for
+     */
     public static boolean hasFeature(Feature feature) {
         try {
             NativeLibraryLoader.ensureLoaded();
@@ -217,9 +257,14 @@ public static boolean isSyncServerAvailable() {
 
     native long nativePanicModeRemoveAllObjects(long store, int entityId);
 
+    private final PrintStream errorOutputStream;
     private final File directory;
     private final String canonicalPath;
-    private final long handle;
+
+    /** Reference to the native store. Should probably get through {@link #getNativeStore()} instead. */
+    volatile private long handle;
+    volatile private boolean nativeStoreDestroyed = false;
+
     private final Map<Class<?>, String> dbNameByClass = new HashMap<>();
     private final Map<Class<?>, Integer> entityTypeIdByClass = new HashMap<>();
     private final Map<Class<?>, EntityInfo<?>> propertiesByClass = new HashMap<>();
@@ -261,13 +306,14 @@ public static boolean isSyncServerAvailable() {
         relinker = builder.relinker;
         NativeLibraryLoader.ensureLoaded();
 
+        errorOutputStream = builder.errorOutputStream;
         directory = builder.directory;
         canonicalPath = getCanonicalPath(directory);
         verifyNotAlreadyOpen(canonicalPath);
 
         try {
             handle = nativeCreateWithFlatOptions(builder.buildFlatStoreOptions(canonicalPath), builder.model);
-            if(handle == 0) throw new DbException("Could not create native store");
+            if (handle == 0) throw new DbException("Could not create native store");
 
             int debugFlags = builder.debugFlags;
             if (debugFlags != 0) {
@@ -316,6 +362,12 @@ public static boolean isSyncServerAvailable() {
     }
 
     static String getCanonicalPath(File directory) {
+        // Skip directory check if in-memory prefix is used.
+        if (directory.getPath().startsWith(IN_MEMORY_PREFIX)) {
+            // Just return the path as is (e.g. "memory:data"), safe to use for string-based open check as well.
+            return directory.getPath();
+        }
+
         if (directory.exists()) {
             if (!directory.isDirectory()) {
                 throw new DbException("Is not a directory: " + directory.getAbsolutePath());
@@ -331,16 +383,34 @@ static String getCanonicalPath(File directory) {
     }
 
     static void verifyNotAlreadyOpen(String canonicalPath) {
+        // Call isFileOpen before, but without checking the result, to try to close any unreferenced instances where
+        // it was forgotten to close them.
+        // Only obtain the lock on openFiles afterward as the checker thread created by isFileOpen needs to obtain it to
+        // do anything.
+        isFileOpen(canonicalPath);
         synchronized (openFiles) {
-            isFileOpen(canonicalPath); // for retries
             if (!openFiles.add(canonicalPath)) {
-                throw new DbException("Another BoxStore is still open for this directory: " + canonicalPath +
-                        ". Hint: for most apps it's recommended to keep a BoxStore for the app's life time.");
+                throw new DbException("Another BoxStore is still open for this directory (" + canonicalPath +
+                        "). Make sure the existing instance is explicitly closed before creating a new one.");
             }
         }
     }
 
-    /** Also retries up to 500ms to improve GC race condition situation. */
+    /**
+     * Returns if the given path is in {@link #openFiles}.
+     * <p>
+     * If it is, (creates and) briefly waits on an existing "checker" thread before checking again and returning the
+     * result.
+     * <p>
+     * The "checker" thread locks {@link #openFiles} while it triggers garbage collection and finalization in this Java
+     * Virtual Machine to try to close any unreferenced BoxStore instances. These might exist if it was forgotten to
+     * close them explicitly.
+     * <p>
+     * Note that the finalization mechanism relied upon here is scheduled for removal in future versions of Java and may
+     * already be disabled depending on JVM configuration.
+     *
+     * @see #finalize()
+     */
     static boolean isFileOpen(final String canonicalPath) {
         synchronized (openFiles) {
             if (!openFiles.contains(canonicalPath)) return false;
@@ -435,6 +505,7 @@ public static boolean isDatabaseOpen(File directory) throws IOException {
      */
     @Experimental
     public static long sysProcMeminfoKb(String key) {
+        NativeLibraryLoader.ensureLoaded();
         return nativeSysProcMeminfoKb(key);
     }
 
@@ -457,21 +528,38 @@ public static long sysProcMeminfoKb(String key) {
      */
     @Experimental
     public static long sysProcStatusKb(String key) {
+        NativeLibraryLoader.ensureLoaded();
         return nativeSysProcStatusKb(key);
     }
 
     /**
-     * The size in bytes occupied by the data file on disk.
+     * Get the size of this store. For a disk-based store type, this corresponds to the size on disk, and for the
+     * in-memory store type, this is roughly the used memory bytes occupied by the data.
      *
-     * @return 0 if the size could not be determined (does not throw unless this store was already closed)
+     * @return The size in bytes of the database, or 0 if the file does not exist or some error occurred.
      */
-    public long sizeOnDisk() {
-        checkOpen();
-        return nativeSizeOnDisk(handle);
+    public long getDbSize() {
+        return nativeDbSize(getNativeStore());
+    }
+
+    /**
+     * The size in bytes occupied by the database on disk (if any).
+     *
+     * @return The size in bytes of the database on disk, or 0 if the underlying database is in-memory only
+     * or the size could not be determined.
+     */
+    public long getDbSizeOnDisk() {
+        return nativeDbSizeOnDisk(getNativeStore());
     }
 
     /**
-     * Explicitly call {@link #close()} instead to avoid expensive finalization.
+     * Calls {@link #close()}.
+     * <p>
+     * It is strongly recommended to instead explicitly close a Store and not rely on finalization. For example, on
+     * Android finalization has a timeout that might be exceeded if closing needs to wait on transactions to finish.
+     * <p>
+     * Also finalization is scheduled for removal in future versions of Java and may already be disabled depending on
+     * JVM configuration (see documentation on super method).
      */
     @SuppressWarnings("deprecation") // finalize()
     @Override
@@ -480,8 +568,11 @@ protected void finalize() throws Throwable {
         super.finalize();
     }
 
+    /**
+     * Verifies this has not been {@link #close() closed}.
+     */
     private void checkOpen() {
-        if (closed) {
+        if (isClosed()) {
             throw new IllegalStateException("Store is closed");
         }
     }
@@ -532,14 +623,13 @@ <T> EntityInfo<T> getEntityInfo(Class<T> entityClass) {
      */
     @Internal
     public Transaction beginTx() {
-        checkOpen();
         // Because write TXs are typically not cached, initialCommitCount is not as relevant than for read TXs.
         int initialCommitCount = commitCount;
         if (debugTxWrite) {
-            System.out.println("Begin TX with commit count " + initialCommitCount);
+            getOutput().println("Begin TX with commit count " + initialCommitCount);
         }
-        long nativeTx = nativeBeginTx(handle);
-        if(nativeTx == 0) throw new DbException("Could not create native transaction");
+        long nativeTx = nativeBeginTx(getNativeStore());
+        if (nativeTx == 0) throw new DbException("Could not create native transaction");
 
         Transaction tx = new Transaction(this, nativeTx, initialCommitCount);
         synchronized (transactions) {
@@ -554,7 +644,6 @@ public Transaction beginTx() {
      */
     @Internal
     public Transaction beginReadTx() {
-        checkOpen();
         // initialCommitCount should be acquired before starting the tx. In race conditions, there is a chance the
         // commitCount is already outdated. That's OK because it only gives a false positive for an TX being obsolete.
         // In contrast, a false negative would make a TX falsely not considered obsolete, and thus readers would not be
@@ -562,10 +651,10 @@ public Transaction beginReadTx() {
         // TODO add multithreaded test for this
         int initialCommitCount = commitCount;
         if (debugTxRead) {
-            System.out.println("Begin read TX with commit count " + initialCommitCount);
+            getOutput().println("Begin read TX with commit count " + initialCommitCount);
         }
-        long nativeTx = nativeBeginReadTx(handle);
-        if(nativeTx == 0) throw new DbException("Could not create native read transaction");
+        long nativeTx = nativeBeginReadTx(getNativeStore());
+        if (nativeTx == 0) throw new DbException("Could not create native read transaction");
 
         Transaction tx = new Transaction(this, nativeTx, initialCommitCount);
         synchronized (transactions) {
@@ -574,6 +663,9 @@ public Transaction beginReadTx() {
         return tx;
     }
 
+    /**
+     * If this was {@link #close() closed}.
+     */
     public boolean isClosed() {
         return closed;
     }
@@ -583,25 +675,25 @@ public boolean isClosed() {
      * If true the schema is not updated and write transactions are not possible.
      */
     public boolean isReadOnly() {
-        checkOpen();
-        return nativeIsReadOnly(handle);
+        return nativeIsReadOnly(getNativeStore());
     }
 
     /**
-     * Closes the BoxStore and frees associated resources.
-     * This method is useful for unit tests;
-     * most real applications should open a BoxStore once and keep it open until the app dies.
+     * Closes this BoxStore and releases associated resources.
      * <p>
-     * WARNING:
-     * This is a somewhat delicate thing to do if you have threads running that may potentially still use the BoxStore.
-     * This results in undefined behavior, including the possibility of crashing.
+     * Before calling, <b>all database operations must have finished</b> (there are no more active transactions).
+     * <p>
+     * If that is not the case, the method will briefly wait on any active transactions, but then will forcefully close
+     * them to avoid crashes and print warning messages ("Transactions are still active"). If this occurs,
+     * analyze your code to make sure all database operations, notably in other threads or data observers,
+     * are properly finished.
      */
     public void close() {
         boolean oldClosedState;
         synchronized (this) {
             oldClosedState = closed;
             if (!closed) {
-                if(objectBrowserPort != 0) { // not linked natively (yet), so clean up here
+                if (objectBrowserPort != 0) { // not linked natively (yet), so clean up here
                     try {
                         stopObjectBrowser();
                     } catch (Throwable e) {
@@ -610,22 +702,49 @@ public void close() {
                 }
 
                 // Closeable recommendation: mark as closed before any code that might throw.
+                // Also, before checking on transactions to avoid any new transactions from getting created
+                // (due to all Java APIs doing closed checks).
                 closed = true;
+
+                // Stop accepting new tasks (async calls, query publishers) on the internal thread pool
+                internalThreadPool().shutdown();
+                // Give running tasks some time to finish, print warnings if they do not to help callers fix their code
+                checkThreadTermination();
+
                 List<Transaction> transactionsToClose;
                 synchronized (transactions) {
+                    // Give open transactions some time to close (BoxStore.unregisterTransaction() calls notify),
+                    // 1000 ms should be long enough for most small operations and short enough to avoid ANRs on Android.
+                    if (hasActiveTransaction()) {
+                        getOutput().println("Briefly waiting for active transactions before closing the Store...");
+                        try {
+                            // It is fine to hold a lock on BoxStore.this as well as BoxStore.unregisterTransaction()
+                            // only synchronizes on "transactions".
+                            //noinspection WaitWhileHoldingTwoLocks
+                            transactions.wait(1000);
+                        } catch (InterruptedException e) {
+                            // If interrupted, continue with releasing native resources
+                        }
+                        if (hasActiveTransaction()) {
+                            getErrorOutput().println("Transactions are still active:"
+                                    + " ensure that all database operations are finished before closing the Store!");
+                        }
+                    }
                     transactionsToClose = new ArrayList<>(this.transactions);
                 }
+                // Close all transactions, including recycled (not active) ones stored in Box threadLocalReader.
+                // It is expected that this prints a warning if a transaction is not owned by the current thread.
                 for (Transaction t : transactionsToClose) {
                     t.close();
                 }
-                if (handle != 0) { // failed before native handle was created?
-                    nativeDelete(handle);
-                    // TODO set handle to 0 and check in native methods
-                }
 
-                // When running the full unit test suite, we had 100+ threads before, hope this helps:
-                threadPool.shutdown();
-                checkThreadTermination();
+                long handleToDelete = handle;
+                // Make isNativeStoreClosed() return true before actually closing to avoid Transaction.close() crash
+                handle = 0;
+                if (handleToDelete != 0) { // failed before native handle was created?
+                    nativeDelete(handleToDelete);
+                    nativeStoreDestroyed = true;
+                }
             }
         }
         if (!oldClosedState) {
@@ -636,24 +755,52 @@ public void close() {
         }
     }
 
-    /** dump thread stacks if pool does not terminate promptly. */
+    /**
+     * Waits briefly for the internal {@link #internalThreadPool()} to terminate. If it does not terminate in time,
+     * prints stack traces of the pool threads.
+     */
     private void checkThreadTermination() {
         try {
-            if (!threadPool.awaitTermination(1, TimeUnit.SECONDS)) {
-                int activeCount = Thread.activeCount();
-                System.err.println("Thread pool not terminated in time; printing stack traces...");
-                Thread[] threads = new Thread[activeCount + 2];
+            if (!internalThreadPool().awaitTermination(1, TimeUnit.SECONDS)) {
+                getErrorOutput().println("ObjectBox thread pool not terminated in time." +
+                        " Ensure all async calls have completed and subscriptions are cancelled before closing the Store." +
+                        "\nDumping stack traces of threads on the pool and any using ObjectBox APIs:" +
+                        "\n=== BEGIN OF DUMP ===");
+                // Note: this may not print any pool threads if other threads are started while enumerating
+                // (and the pool threads do not make it into the threads array).
+                Thread[] threads = new Thread[Thread.activeCount()];
                 int count = Thread.enumerate(threads);
                 for (int i = 0; i < count; i++) {
-                    System.err.println("Thread: " + threads[i].getName());
-                    Thread.dumpStack();
+                    Thread thread = threads[i];
+                    if (shouldDumpThreadStackTrace(thread)) {
+                        getErrorOutput().println("Thread: " + thread.getName());
+                        StackTraceElement[] trace = thread.getStackTrace();
+                        for (StackTraceElement traceElement : trace) {
+                            getErrorOutput().println("\tat " + traceElement);
+                        }
+                    }
                 }
+                getErrorOutput().println("=== END OF DUMP ===");
             }
         } catch (InterruptedException e) {
-            e.printStackTrace();
+            e.printStackTrace(getErrorOutput());
         }
     }
 
+    private boolean shouldDumpThreadStackTrace(Thread thread) {
+        // Dump any threads of the internal thread pool
+        if (thread.getName().startsWith(ObjectBoxThreadPool.THREAD_NAME_PREFIX)) return true;
+
+        // Any other thread might be blocking a thread on the internal pool, so also dump any that appear to use
+        // ObjectBox APIs.
+        StackTraceElement[] trace = thread.getStackTrace();
+        for (StackTraceElement traceElement : trace) {
+            if (traceElement.getClassName().contains(OBJECTBOX_PACKAGE_NAME)) return true;
+        }
+
+        return false;
+    }
+
     /**
      * Danger zone! This will delete all data (files) of this BoxStore!
      * You must call {@link #close()} before and read the docs of that method carefully!
@@ -664,7 +811,7 @@ private void checkThreadTermination() {
      * Note: If false is returned, any number of files may have been deleted before the failure happened.
      */
     public boolean deleteAllFiles() {
-        if (!closed) {
+        if (!isClosed()) {
             throw new IllegalStateException("Store must be closed");
         }
         return deleteAllFiles(directory);
@@ -673,38 +820,31 @@ public boolean deleteAllFiles() {
     /**
      * Danger zone! This will delete all files in the given directory!
      * <p>
-     * No {@link BoxStore} may be alive using the given directory.
+     * No {@link BoxStore} may be alive using the given directory. E.g. call this before building a store. When calling
+     * this after {@link #close() closing} a store, read the docs of that method carefully first!
      * <p>
-     * If you did not use a custom name with BoxStoreBuilder, you can pass "new File({@link
-     * BoxStoreBuilder#DEFAULT_NAME})".
+     * If no {@link BoxStoreBuilder#name(String) name} was specified when building the store, use like:
+     *
+     * <pre>{@code
+     *     BoxStore.deleteAllFiles(new File(BoxStoreBuilder.DEFAULT_NAME));
+     * }</pre>
+     *
+     * <p>For an {@link BoxStoreBuilder#inMemory(String) in-memory} database, this will just clean up the in-memory
+     * database.
      *
      * @param objectStoreDirectory directory to be deleted; this is the value you previously provided to {@link
-     *                             BoxStoreBuilder#directory(File)}
+     * BoxStoreBuilder#directory(File)}
      * @return true if the directory 1) was deleted successfully OR 2) did not exist in the first place.
      * Note: If false is returned, any number of files may have been deleted before the failure happened.
-     * @throws IllegalStateException if the given directory is still used by a open {@link BoxStore}.
+     * @throws IllegalStateException if the given directory is still used by an open {@link BoxStore}.
      */
     public static boolean deleteAllFiles(File objectStoreDirectory) {
-        if (!objectStoreDirectory.exists()) {
-            return true;
-        }
-        if (isFileOpen(getCanonicalPath(objectStoreDirectory))) {
+        String canonicalPath = getCanonicalPath(objectStoreDirectory);
+        if (isFileOpen(canonicalPath)) {
             throw new IllegalStateException("Cannot delete files: store is still open");
         }
-
-        File[] files = objectStoreDirectory.listFiles();
-        if (files == null) {
-            return false;
-        }
-        for (File file : files) {
-            if (!file.delete()) {
-                // OK if concurrently deleted. Fail fast otherwise.
-                if (file.exists()) {
-                    return false;
-                }
-            }
-        }
-        return objectStoreDirectory.delete();
+        NativeLibraryLoader.ensureLoaded();
+        return nativeRemoveDbFiles(canonicalPath, true);
     }
 
     /**
@@ -715,9 +855,9 @@ public static boolean deleteAllFiles(File objectStoreDirectory) {
      * If you did not use a custom name with BoxStoreBuilder, you can pass "new File({@link
      * BoxStoreBuilder#DEFAULT_NAME})".
      *
-     * @param androidContext     provide an Android Context like Application or Service
+     * @param androidContext provide an Android Context like Application or Service
      * @param customDbNameOrNull use null for default name, or the name you previously provided to {@link
-     *                           BoxStoreBuilder#name(String)}.
+     * BoxStoreBuilder#name(String)}.
      * @return true if the directory 1) was deleted successfully OR 2) did not exist in the first place.
      * Note: If false is returned, any number of files may have been deleted before the failure happened.
      * @throws IllegalStateException if the given name is still used by a open {@link BoxStore}.
@@ -736,9 +876,9 @@ public static boolean deleteAllFiles(Object androidContext, @Nullable String cus
      * BoxStoreBuilder#DEFAULT_NAME})".
      *
      * @param baseDirectoryOrNull use null for no base dir, or the value you previously provided to {@link
-     *                            BoxStoreBuilder#baseDirectory(File)}
-     * @param customDbNameOrNull  use null for default name, or the name you previously provided to {@link
-     *                            BoxStoreBuilder#name(String)}.
+     * BoxStoreBuilder#baseDirectory(File)}
+     * @param customDbNameOrNull use null for default name, or the name you previously provided to {@link
+     * BoxStoreBuilder#name(String)}.
      * @return true if the directory 1) was deleted successfully OR 2) did not exist in the first place.
      * Note: If false is returned, any number of files may have been deleted before the failure happened.
      * @throws IllegalStateException if the given directory (+name) is still used by a open {@link BoxStore}.
@@ -764,36 +904,58 @@ public static boolean deleteAllFiles(@Nullable File baseDirectoryOrNull, @Nullab
      * </ul>
      */
     public void removeAllObjects() {
-        checkOpen();
-        nativeDropAllData(handle);
+        nativeDropAllData(getNativeStore());
     }
 
     @Internal
     public void unregisterTransaction(Transaction transaction) {
         synchronized (transactions) {
             transactions.remove(transaction);
+            // For close(): notify if there are no more open transactions
+            if (!hasActiveTransaction()) {
+                transactions.notifyAll();
+            }
         }
     }
 
+    /**
+     * Returns if {@link #transactions} has a single transaction that {@link Transaction#isActive() isActive()}.
+     * <p>
+     * Callers must synchronize on {@link #transactions}.
+     */
+    private boolean hasActiveTransaction() {
+        for (Transaction tx : transactions) {
+            if (tx.isActive()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     void txCommitted(Transaction tx, @Nullable int[] entityTypeIdsAffected) {
         // Only one write TX at a time, but there is a chance two writers race after commit: thus synchronize
         synchronized (txCommitCountLock) {
             commitCount++; // Overflow is OK because we check for equality
             if (debugTxWrite) {
-                System.out.println("TX committed. New commit count: " + commitCount + ", entity types affected: " +
+                getOutput().println("TX committed. New commit count: " + commitCount + ", entity types affected: " +
                         (entityTypeIdsAffected != null ? entityTypeIdsAffected.length : 0));
             }
         }
 
-        for (Box<?> box : boxes.values()) {
-            box.txCommitted(tx);
-        }
-
         if (entityTypeIdsAffected != null) {
             objectClassPublisher.publish(entityTypeIdsAffected);
         }
     }
 
+    /**
+     * For all boxes, calls {@link Box#closeActiveTxCursorForCurrentThread(Transaction)}.
+     */
+    void closeActiveTxCursorsForCurrentThread(Transaction tx) {
+        for (Box<?> box : boxes.values()) {
+            box.closeActiveTxCursorForCurrentThread(tx);
+        }
+    }
+
     /**
      * Returns a Box for the given type. Objects are put into (and get from) their individual Box.
      * <p>
@@ -836,6 +998,7 @@ public void runInTx(Runnable runnable) {
                 tx.commit();
             } finally {
                 activeTx.remove();
+                closeActiveTxCursorsForCurrentThread(tx);
                 tx.close();
             }
         } else {
@@ -862,13 +1025,9 @@ public void runInReadTx(Runnable runnable) {
                 runnable.run();
             } finally {
                 activeTx.remove();
-
                 // TODO That's rather a quick fix, replace with a more general solution
                 // (that could maybe be a TX listener with abort callback?)
-                for (Box<?> box : boxes.values()) {
-                    box.readTxFinished(tx);
-                }
-
+                closeActiveTxCursorsForCurrentThread(tx);
                 tx.close();
             }
         } else {
@@ -899,10 +1058,10 @@ public <T> T callInReadTxWithRetry(Callable<T> callable, int attempts, int initi
                 String diagnose = diagnose();
                 String message = attempt + " of " + attempts + " attempts of calling a read TX failed:";
                 if (logAndHeal) {
-                    System.err.println(message);
+                    getErrorOutput().println(message);
                     e.printStackTrace();
-                    System.err.println(diagnose);
-                    System.err.flush();
+                    getErrorOutput().println(diagnose);
+                    getErrorOutput().flush();
 
                     System.gc();
                     System.runFinalization();
@@ -948,10 +1107,7 @@ public <T> T callInReadTx(Callable<T> callable) {
 
                 // TODO That's rather a quick fix, replace with a more general solution
                 // (that could maybe be a TX listener with abort callback?)
-                for (Box<?> box : boxes.values()) {
-                    box.readTxFinished(tx);
-                }
-
+                closeActiveTxCursorsForCurrentThread(tx);
                 tx.close();
             }
         } else {
@@ -978,6 +1134,7 @@ public <R> R callInTx(Callable<R> callable) throws Exception {
                 return result;
             } finally {
                 activeTx.remove();
+                closeActiveTxCursorsForCurrentThread(tx);
                 tx.close();
             }
         } else {
@@ -1007,7 +1164,7 @@ public <R> R callInTxNoException(Callable<R> callable) {
      * See also {@link #runInTx(Runnable)}.
      */
     public void runInTxAsync(final Runnable runnable, @Nullable final TxCallback<Void> callback) {
-        threadPool.submit(() -> {
+        internalScheduleThread(() -> {
             try {
                 runInTx(runnable);
                 if (callback != null) {
@@ -1028,7 +1185,7 @@ public void runInTxAsync(final Runnable runnable, @Nullable final TxCallback<Voi
      * * See also {@link #callInTx(Callable)}.
      */
     public <R> void callInTxAsync(final Callable<R> callable, @Nullable final TxCallback<R> callback) {
-        threadPool.submit(() -> {
+        internalScheduleThread(() -> {
             try {
                 R result = callInTx(callable);
                 if (callback != null) {
@@ -1048,15 +1205,15 @@ public <R> void callInTxAsync(final Callable<R> callable, @Nullable final TxCall
      * @return String that is typically logged by the application.
      */
     public String diagnose() {
-        checkOpen();
-        return nativeDiagnose(handle);
+        return nativeDiagnose(getNativeStore());
     }
 
     /**
      * Validate database pages, a lower level storage unit (integrity check).
      * Do not call this inside a transaction (currently unsupported).
+     *
      * @param pageLimit the maximum of pages to validate (e.g. to limit time spent on validation).
-     *        Pass zero set no limit and thus validate all pages.
+     * Pass zero set no limit and thus validate all pages.
      * @param checkLeafLevel Flag to validate leaf pages. These do not point to other pages but contain data.
      * @return Number of pages validated, which may be twice the given pageLimit as internally there are "two DBs".
      * @throws DbException if validation failed to run (does not tell anything about DB file consistency).
@@ -1067,19 +1224,20 @@ public long validate(long pageLimit, boolean checkLeafLevel) {
         if (pageLimit < 0) {
             throw new IllegalArgumentException("pageLimit must be zero or positive");
         }
-        checkOpen();
-        return nativeValidate(handle, pageLimit, checkLeafLevel);
+        return nativeValidate(getNativeStore(), pageLimit, checkLeafLevel);
     }
 
     public int cleanStaleReadTransactions() {
-        checkOpen();
-        return nativeCleanStaleReadTransactions(handle);
+        return nativeCleanStaleReadTransactions(getNativeStore());
     }
 
     /**
-     * Call this method from a thread that is about to be shutdown or likely not to use ObjectBox anymore:
-     * it frees any cached resources tied to the calling thread (e.g. readers). This method calls
-     * {@link Box#closeThreadResources()} for all initiated boxes ({@link #boxFor(Class)}).
+     * Frees any cached resources tied to the calling thread (e.g. readers).
+     * <p>
+     * Call this method from a thread that is about to be shut down or likely not to use ObjectBox anymore.
+     * <b>Careful:</b> ensure all transactions, like a query fetching results, have finished before.
+     * <p>
+     * This method calls {@link Box#closeThreadResources()} for all initiated boxes ({@link #boxFor(Class)}).
      */
     public void closeThreadResources() {
         for (Box<?> box : boxes.values()) {
@@ -1088,11 +1246,6 @@ public void closeThreadResources() {
         // activeTx is cleaned up in finally blocks, so do not free them here
     }
 
-    @Internal
-    long internalHandle() {
-        return handle;
-    }
-
     /**
      * A {@link io.objectbox.reactive.DataObserver} can be subscribed to data changes using the returned builder.
      * The observer is supplied via {@link SubscriptionBuilder#observer(DataObserver)} and will be notified once a
@@ -1144,8 +1297,7 @@ public String startObjectBrowser() {
     @Nullable
     public String startObjectBrowser(int port) {
         verifyObjectBrowserNotRunning();
-        checkOpen();
-        String url = nativeStartObjectBrowser(handle, null, port);
+        String url = nativeStartObjectBrowser(getNativeStore(), null, port);
         if (url != null) {
             objectBrowserPort = port;
         }
@@ -1156,14 +1308,13 @@ public String startObjectBrowser(int port) {
     @Nullable
     public String startObjectBrowser(String urlToBindTo) {
         verifyObjectBrowserNotRunning();
-        checkOpen();
         int port;
         try {
             port = new URL(urlToBindTo).getPort(); // Gives -1 if not available
         } catch (MalformedURLException e) {
             throw new RuntimeException("Can not start Object Browser at " + urlToBindTo, e);
         }
-        String url = nativeStartObjectBrowser(handle, urlToBindTo, 0);
+        String url = nativeStartObjectBrowser(getNativeStore(), urlToBindTo, 0);
         if (url != null) {
             objectBrowserPort = port;
         }
@@ -1172,12 +1323,11 @@ public String startObjectBrowser(String urlToBindTo) {
 
     @Experimental
     public synchronized boolean stopObjectBrowser() {
-        if(objectBrowserPort == 0) {
+        if (objectBrowserPort == 0) {
             throw new IllegalStateException("ObjectBrowser has not been started before");
         }
         objectBrowserPort = 0;
-        checkOpen();
-        return nativeStopObjectBrowser(handle);
+        return nativeStopObjectBrowser(getNativeStore());
     }
 
     @Experimental
@@ -1202,17 +1352,69 @@ private void verifyObjectBrowserNotRunning() {
      * This for example allows central error handling or special logging for database-related exceptions.
      */
     public void setDbExceptionListener(@Nullable DbExceptionListener dbExceptionListener) {
-        checkOpen();
-        nativeSetDbExceptionListener(handle, dbExceptionListener);
+        nativeSetDbExceptionListener(getNativeStore(), dbExceptionListener);
+    }
+
+    /**
+     * Like {@link Executors#newCachedThreadPool()} but uses {@link ObjectBoxThreadPoolExecutor} to ensure proper
+     * cleanup of thread-local resources.
+     *
+     * @return a new {@link ObjectBoxThreadPoolExecutor}
+     */
+    public ObjectBoxThreadPoolExecutor newCachedThreadPoolExecutor() {
+        return new ObjectBoxThreadPoolExecutor(this, 0, Integer.MAX_VALUE,
+                60L, TimeUnit.SECONDS,
+                new SynchronousQueue<>());
+    }
+
+    /**
+     * Like {@link Executors#newCachedThreadPool(ThreadFactory)} but uses {@link ObjectBoxThreadPoolExecutor} to ensure
+     * proper cleanup of thread-local resources.
+     *
+     * @return a new {@link ObjectBoxThreadPoolExecutor}
+     */
+    public ObjectBoxThreadPoolExecutor newCachedThreadPoolExecutor(ThreadFactory threadFactory) {
+        return new ObjectBoxThreadPoolExecutor(this, 0, Integer.MAX_VALUE,
+                60L, TimeUnit.SECONDS,
+                new SynchronousQueue<>(),
+                threadFactory);
+    }
+
+    /**
+     * Like {@link Executors#newFixedThreadPool(int)} but uses {@link ObjectBoxThreadPoolExecutor} to ensure proper
+     * cleanup of thread-local resources.
+     *
+     * @param nThreads the number of threads in the pool
+     * @return a new {@link ObjectBoxThreadPoolExecutor}
+     */
+    public ObjectBoxThreadPoolExecutor newFixedThreadPoolExecutor(int nThreads) {
+        return new ObjectBoxThreadPoolExecutor(this, nThreads, nThreads,
+                0L, TimeUnit.MILLISECONDS,
+                new LinkedBlockingQueue<>());
+    }
+
+    /**
+     * Like {@link Executors#newFixedThreadPool(int, ThreadFactory)} but uses {@link ObjectBoxThreadPoolExecutor} to
+     * ensure proper cleanup of thread-local resources.
+     *
+     * @param nThreads the number of threads in the pool
+     * @param threadFactory the factory to use when creating new threads
+     * @return a new {@link ObjectBoxThreadPoolExecutor}
+     */
+    public ObjectBoxThreadPoolExecutor newFixedThreadPoolExecutor(int nThreads, ThreadFactory threadFactory) {
+        return new ObjectBoxThreadPoolExecutor(this, nThreads, nThreads,
+                0L, TimeUnit.MILLISECONDS,
+                new LinkedBlockingQueue<>(),
+                threadFactory);
     }
 
     @Internal
     public Future<?> internalScheduleThread(Runnable runnable) {
-        return threadPool.submit(runnable);
+        return internalThreadPool().submit(runnable);
     }
 
     @Internal
-    public ExecutorService internalThreadPool() {
+    ExecutorService internalThreadPool() {
         return threadPool;
     }
 
@@ -1231,19 +1433,34 @@ public TxCallback<?> internalFailedReadTxAttemptCallback() {
         return failedReadTxAttemptCallback;
     }
 
+    /**
+     * The output stream to print log messages to. Currently {@link System#out}.
+     */
+    private PrintStream getOutput() {
+        return System.out;
+    }
+
+    /**
+     * The error output stream to print log messages to. This is {@link System#err} by default.
+     */
+    private PrintStream getErrorOutput() {
+        return errorOutputStream;
+    }
+
     void setDebugFlags(int debugFlags) {
-        checkOpen();
-        nativeSetDebugFlags(handle, debugFlags);
+        nativeSetDebugFlags(getNativeStore(), debugFlags);
     }
 
     long panicModeRemoveAllObjects(int entityId) {
-        checkOpen();
-        return nativePanicModeRemoveAllObjects(handle, entityId);
+        return nativePanicModeRemoveAllObjects(getNativeStore(), entityId);
     }
 
     /**
-     * If you want to use the same ObjectBox store using the C API, e.g. via JNI, this gives the required pointer,
-     * which you have to pass on to obx_store_wrap().
+     * Gets the reference to the native store. Can be used with the C API to use the same store, e.g. via JNI, by
+     * passing it on to {@code obx_store_wrap()}.
+     * <p>
+     * Throws if the store is closed.
+     * <p>
      * The procedure is like this:<br>
      * 1) you create a BoxStore on the Java side<br>
      * 2) you call this method to get the native store pointer<br>
@@ -1258,6 +1475,34 @@ public long getNativeStore() {
         return handle;
     }
 
+    /**
+     * For internal use only. This API might change or be removed with a future release.
+     * <p>
+     * Returns {@code true} once the native Store is about to be destroyed.
+     * <p>
+     * This is {@code true} shortly after {@link #close()} was called and {@link #isClosed()} returns {@code true}.
+     *
+     * @see #isNativeStoreDestroyed()
+     */
+    @Internal
+    public boolean isNativeStoreClosed() {
+        return handle == 0;
+    }
+
+    /**
+     * For internal use only. This API might change or be removed with a future release.
+     * <p>
+     * Returns {@code true} once the native Store was destroyed.
+     * <p>
+     * This is {@code true} shortly after {@link #isNativeStoreClosed()} returns {@code true}.
+     *
+     * @see #isNativeStoreClosed()
+     */
+    @Internal
+    public boolean isNativeStoreDestroyed() {
+        return nativeStoreDestroyed;
+    }
+
     /**
      * Returns the {@link SyncClient} associated with this store. To create one see {@link io.objectbox.sync.Sync Sync}.
      */
diff --git a/objectbox-java/src/main/java/io/objectbox/BoxStoreBuilder.java b/objectbox-java/src/main/java/io/objectbox/BoxStoreBuilder.java
index 1497f1f6..0dc5e4f8 100644
--- a/objectbox-java/src/main/java/io/objectbox/BoxStoreBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/BoxStoreBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,8 +16,6 @@
 
 package io.objectbox;
 
-import io.objectbox.flatbuffers.FlatBufferBuilder;
-
 import org.greenrobot.essentials.io.IoUtils;
 
 import java.io.BufferedInputStream;
@@ -27,6 +25,7 @@
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.io.PrintStream;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -37,10 +36,16 @@
 
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.config.DebugFlags;
+import io.objectbox.config.FlatStoreOptions;
+import io.objectbox.config.ValidateOnOpenModeKv;
+import io.objectbox.config.ValidateOnOpenModePages;
 import io.objectbox.exception.DbException;
+import io.objectbox.exception.DbFullException;
+import io.objectbox.exception.DbMaxDataSizeExceededException;
+import io.objectbox.exception.DbMaxReadersExceededException;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
 import io.objectbox.ideasonly.ModelUpdate;
-import io.objectbox.model.FlatStoreOptions;
-import io.objectbox.model.ValidateOnOpenMode;
 
 /**
  * Configures and builds a {@link BoxStore} with reasonable defaults. To get an instance use {@code MyObjectBox.builder()}.
@@ -63,6 +68,12 @@ public class BoxStoreBuilder {
     /** The default maximum size the DB can grow to, which can be overwritten using {@link #maxSizeInKByte}. */
     public static final int DEFAULT_MAX_DB_SIZE_KBYTE = 1024 * 1024;
 
+    /**
+     * The error output stream {@link BoxStore} uses for logging. Defaults to {@link System#err}, but can be customized
+     * for tests.
+     */
+    PrintStream errorOutputStream = System.err;
+
     final byte[] model;
 
     /** BoxStore uses this (not baseDirectory/name) */
@@ -74,19 +85,24 @@ public class BoxStoreBuilder {
     /** Ignored by BoxStore */
     private String name;
 
+    /** If non-null, using an in-memory database with this identifier. */
+    private String inMemory;
+
     /** Defaults to {@link #DEFAULT_MAX_DB_SIZE_KBYTE}. */
     long maxSizeInKByte = DEFAULT_MAX_DB_SIZE_KBYTE;
 
+    long maxDataSizeInKByte;
+
     /** On Android used for native library loading. */
-    @Nullable Object context;
-    @Nullable Object relinker;
+    @Nullable
+    Object context;
+    @Nullable
+    Object relinker;
 
     ModelUpdate modelUpdate;
 
     int debugFlags;
 
-    private boolean android;
-
     boolean debugRelations;
 
     int fileMode;
@@ -102,9 +118,11 @@ public class BoxStoreBuilder {
     boolean readOnly;
     boolean usePreviousCommit;
 
-    short validateOnOpenMode;
+    short validateOnOpenModePages;
     long validateOnOpenPageLimit;
 
+    short validateOnOpenModeKv;
+
     TxCallback<?> failedReadTxAttemptCallback;
 
     final List<EntityInfo<?>> entityInfoList = new ArrayList<>();
@@ -125,6 +143,8 @@ private BoxStoreBuilder() {
     /** Called internally from the generated class "MyObjectBox". Check MyObjectBox.builder() to get an instance. */
     @Internal
     public BoxStoreBuilder(byte[] model) {
+        // Note: annotations do not guarantee parameter is non-null.
+        //noinspection ConstantValue
         if (model == null) {
             throw new IllegalArgumentException("Model may not be null");
         }
@@ -133,16 +153,24 @@ public BoxStoreBuilder(byte[] model) {
     }
 
     /**
-     * Name of the database, which will be used as a directory for DB files.
+     * For testing: set a custom error output stream {@link BoxStore} uses for logging. Defaults to {@link System#err}.
+     */
+    @Internal
+    BoxStoreBuilder setErrorOutput(PrintStream err) {
+        errorOutputStream = err;
+        return this;
+    }
+
+    /**
+     * Name of the database, which will be used as a directory for database files.
      * You can also specify a base directory for this one using {@link #baseDirectory(File)}.
-     * Cannot be used in combination with {@link #directory(File)}.
+     * Cannot be used in combination with {@link #directory(File)} and {@link #inMemory(String)}.
      * <p>
      * Default: "objectbox", {@link #DEFAULT_NAME} (unless {@link #directory(File)} is used)
      */
     public BoxStoreBuilder name(String name) {
-        if (directory != null) {
-            throw new IllegalArgumentException("Already has directory, cannot assign name");
-        }
+        checkIsNull(directory, "Already has directory, cannot assign name");
+        checkIsNull(inMemory, "Already set to in-memory database, cannot assign name");
         if (name.contains("/") || name.contains("\\")) {
             throw new IllegalArgumentException("Name may not contain (back) slashes. " +
                     "Use baseDirectory() or directory() to configure alternative directories");
@@ -152,16 +180,28 @@ public BoxStoreBuilder name(String name) {
     }
 
     /**
-     * The directory where all DB files should be placed in.
-     * Cannot be used in combination with {@link #name(String)}/{@link #baseDirectory(File)}.
+     * The directory where all database files should be placed in.
+     * <p>
+     * If the directory does not exist, it will be created. Make sure the process has permissions to write to this
+     * directory.
+     * <p>
+     * To switch to an in-memory database, use a file path with {@link BoxStore#IN_MEMORY_PREFIX} and an identifier
+     * instead:
+     * <p>
+     * <pre>{@code
+     * BoxStore inMemoryStore = MyObjectBox.builder()
+     *     .directory(BoxStore.IN_MEMORY_PREFIX + "notes-db")
+     *     .build();
+     * }</pre>
+     * Alternatively, use {@link #inMemory(String)}.
+     * <p>
+     * Can not be used in combination with {@link #name(String)}, {@link #baseDirectory(File)}
+     * or {@link #inMemory(String)}.
      */
     public BoxStoreBuilder directory(File directory) {
-        if (name != null) {
-            throw new IllegalArgumentException("Already has name, cannot assign directory");
-        }
-        if (!android && baseDirectory != null) {
-            throw new IllegalArgumentException("Already has base directory, cannot assign directory");
-        }
+        checkIsNull(name, "Already has name, cannot assign directory");
+        checkIsNull(inMemory, "Already set to in-memory database, cannot assign directory");
+        checkIsNull(baseDirectory, "Already has base directory, cannot assign directory");
         this.directory = directory;
         return this;
     }
@@ -169,28 +209,53 @@ public BoxStoreBuilder directory(File directory) {
     /**
      * In combination with {@link #name(String)}, this lets you specify the location of where the DB files should be
      * stored.
-     * Cannot be used in combination with {@link #directory(File)}.
+     * Cannot be used in combination with {@link #directory(File)} or {@link #inMemory(String)}.
      */
     public BoxStoreBuilder baseDirectory(File baseDirectory) {
-        if (directory != null) {
-            throw new IllegalArgumentException("Already has directory, cannot assign base directory");
-        }
+        checkIsNull(directory, "Already has directory, cannot assign base directory");
+        checkIsNull(inMemory, "Already set to in-memory database, cannot assign base directory");
         this.baseDirectory = baseDirectory;
         return this;
     }
 
     /**
-     * On Android, you can pass a Context to set the base directory using this method.
-     * This will conveniently configure the storage location to be in the files directory of your app.
+     * Switches to an in-memory database using the given name as its identifier.
      * <p>
-     * In more detail, this assigns the base directory (see {@link #baseDirectory}) to
+     * Can not be used in combination with {@link #name(String)}, {@link #directory(File)}
+     * or {@link #baseDirectory(File)}.
+     */
+    public BoxStoreBuilder inMemory(String identifier) {
+        checkIsNull(name, "Already has name, cannot switch to in-memory database");
+        checkIsNull(directory, "Already has directory, cannot switch to in-memory database");
+        checkIsNull(baseDirectory, "Already has base directory, cannot switch to in-memory database");
+        inMemory = identifier;
+        return this;
+    }
+
+    /**
+     * Use to check conflicting properties are not set.
+     * If not null, throws {@link IllegalStateException} with the given message.
+     */
+    private static void checkIsNull(@Nullable Object value, String errorMessage) {
+        if (value != null) {
+            throw new IllegalStateException(errorMessage);
+        }
+    }
+
+    /**
+     * Use on Android to pass a <a href="https://developer.android.com/reference/android/content/Context">Context</a>
+     * for loading the native library and, if not an {@link #inMemory(String)} database, for creating the base
+     * directory for database files in the
+     * <a href="https://developer.android.com/reference/android/content/Context#getFilesDir()">files directory of the app</a>.
+     * <p>
+     * In more detail, upon {@link #build()} assigns the base directory (see {@link #baseDirectory}) to
      * {@code context.getFilesDir() + "/objectbox/"}.
-     * Thus, when using the default name (also "objectbox" unless overwritten using {@link #name(String)}), the default
-     * location of DB files will be "objectbox/objectbox/" inside the app files directory.
-     * If you specify a custom name, for example with {@code name("foobar")}, it would become
-     * "objectbox/foobar/".
+     * Thus, when using the default name (also "objectbox", unless overwritten using {@link #name(String)}), the default
+     * location of database files will be "objectbox/objectbox/" inside the app's files directory.
+     * If a custom name is specified, for example with {@code name("foobar")}, it would become "objectbox/foobar/".
      * <p>
-     * Alternatively, you can also use {@link #baseDirectory} or {@link #directory(File)} instead.
+     * Use {@link #baseDirectory(File)} or {@link #directory(File)} to specify a different directory for the database
+     * files.
      */
     public BoxStoreBuilder androidContext(Object context) {
         //noinspection ConstantConditions Annotation does not enforce non-null.
@@ -198,19 +263,6 @@ public BoxStoreBuilder androidContext(Object context) {
             throw new NullPointerException("Context may not be null");
         }
         this.context = getApplicationContext(context);
-
-        File baseDir = getAndroidBaseDir(context);
-        if (!baseDir.exists()) {
-            baseDir.mkdir();
-            if (!baseDir.exists()) { // check baseDir.exists() because of potential concurrent processes
-                throw new RuntimeException("Could not init Android base dir at " + baseDir.getAbsolutePath());
-            }
-        }
-        if (!baseDir.isDirectory()) {
-            throw new RuntimeException("Android base dir is not a dir: " + baseDir.getAbsolutePath());
-        }
-        baseDirectory = baseDir;
-        android = true;
         return this;
     }
 
@@ -289,18 +341,18 @@ public BoxStoreBuilder fileMode(int mode) {
     }
 
     /**
-     * Sets the maximum number of concurrent readers. For most applications, the default is fine (~ 126 readers).
+     * Sets the maximum number of concurrent readers. For most applications, the default is fine (about 126 readers).
      * <p>
-     * A "reader" is short for a thread involved in a read transaction.
+     * A "reader" is short for a thread involved in a read transaction. If the maximum is exceeded the store throws
+     * {@link DbMaxReadersExceededException}. In this case check that your code only uses a reasonable amount of
+     * threads.
      * <p>
-     * If you hit {@link io.objectbox.exception.DbMaxReadersExceededException}, you should first worry about the
-     * amount of threads you are using.
      * For highly concurrent setups (e.g. you are using ObjectBox on the server side) it may make sense to increase the
      * number.
-     *
+     * <p>
      * Note: Each thread that performed a read transaction and is still alive holds on to a reader slot.
      * These slots only get vacated when the thread ends. Thus, be mindful with the number of active threads.
-     * Alternatively, you can opt to try the experimental noReaderThreadLocals option flag.
+     * Alternatively, you can try the experimental {@link #noReaderThreadLocals()} option flag.
      */
     public BoxStoreBuilder maxReaders(int maxReaders) {
         this.maxReaders = maxReaders;
@@ -310,9 +362,9 @@ public BoxStoreBuilder maxReaders(int maxReaders) {
     /**
      * Disables the usage of thread locals for "readers" related to read transactions.
      * This can make sense if you are using a lot of threads that are kept alive.
-     *
+     * <p>
      * Note: This is still experimental, as it comes with subtle behavior changes at a low level and may affect
-     *       corner cases with e.g. transactions, which may not be fully tested at the moment.
+     * corner cases with e.g. transactions, which may not be fully tested at the moment.
      */
     public BoxStoreBuilder noReaderThreadLocals() {
         this.noReaderThreadLocals = true;
@@ -333,16 +385,44 @@ BoxStoreBuilder modelUpdate(ModelUpdate modelUpdate) {
 
     /**
      * Sets the maximum size the database file can grow to.
-     * By default this is 1 GB, which should be sufficient for most applications.
      * <p>
-     * In general, a maximum size prevents the DB from growing indefinitely when something goes wrong
-     * (for example you insert data in an infinite loop).
+     * The Store will throw when the file size is about to be exceeded, see {@link DbFullException} for details.
+     * <p>
+     * By default, this is 1 GB, which should be sufficient for most applications. In general, a maximum size prevents
+     * the database from growing indefinitely when something goes wrong (for example data is put in an infinite loop).
+     * <p>
+     * This can be set to a value different, so higher or also lower, from when last building the Store.
      */
     public BoxStoreBuilder maxSizeInKByte(long maxSizeInKByte) {
+        if (maxSizeInKByte <= maxDataSizeInKByte) {
+            throw new IllegalArgumentException("maxSizeInKByte must be larger than maxDataSizeInKByte.");
+        }
         this.maxSizeInKByte = maxSizeInKByte;
         return this;
     }
 
+    /**
+     * Sets the maximum size the data stored in the database can grow to.
+     * When applying a transaction (e.g. putting an object) would exceed it a {@link DbMaxDataSizeExceededException}
+     * is thrown.
+     * <p>
+     * Must be below {@link #maxSizeInKByte(long)}.
+     * <p>
+     * Different from {@link #maxSizeInKByte(long)} this only counts bytes stored in objects, excluding system and
+     * metadata. However, it is more involved than database size tracking, e.g. it stores an internal counter.
+     * Only use this if a stricter, more accurate limit is required.
+     * <p>
+     * When the data limit is reached, data can be removed to get below the limit again (assuming the database size limit
+     * is not also reached).
+     */
+    public BoxStoreBuilder maxDataSizeInKByte(long maxDataSizeInKByte) {
+        if (maxDataSizeInKByte >= maxSizeInKByte) {
+            throw new IllegalArgumentException("maxDataSizeInKByte must be smaller than maxSizeInKByte.");
+        }
+        this.maxDataSizeInKByte = maxDataSizeInKByte;
+        return this;
+    }
+
     /**
      * Open the store in read-only mode: no schema update, no write transactions are allowed (would throw).
      */
@@ -370,14 +450,18 @@ public BoxStoreBuilder usePreviousCommit() {
      * OSes, file systems, or hardware.
      * <p>
      * Note: ObjectBox builds upon ACID storage, which already has strong consistency mechanisms in place.
+     * <p>
+     * See also {@link #validateOnOpenPageLimit(long)} to fine-tune this check and {@link #validateOnOpenKv(short)} for
+     * additional checks.
      *
-     * @param validateOnOpenMode One of {@link ValidateOnOpenMode}.
+     * @param validateOnOpenModePages One of {@link ValidateOnOpenModePages}.
      */
-    public BoxStoreBuilder validateOnOpen(short validateOnOpenMode) {
-        if (validateOnOpenMode < ValidateOnOpenMode.None || validateOnOpenMode > ValidateOnOpenMode.Full) {
-            throw new IllegalArgumentException("Must be one of ValidateOnOpenMode");
+    public BoxStoreBuilder validateOnOpen(short validateOnOpenModePages) {
+        if (validateOnOpenModePages < ValidateOnOpenModePages.None
+                || validateOnOpenModePages > ValidateOnOpenModePages.Full) {
+            throw new IllegalArgumentException("Must be one of ValidateOnOpenModePages");
         }
-        this.validateOnOpenMode = validateOnOpenMode;
+        this.validateOnOpenModePages = validateOnOpenModePages;
         return this;
     }
 
@@ -386,10 +470,12 @@ public BoxStoreBuilder validateOnOpen(short validateOnOpenMode) {
      * This is measured in "pages" with a page typically holding 4000.
      * Usually a low number (e.g. 1-20) is sufficient and does not impact startup performance significantly.
      * <p>
-     * This can only be used with {@link ValidateOnOpenMode#Regular} and {@link ValidateOnOpenMode#WithLeaves}.
+     * This can only be used with {@link ValidateOnOpenModePages#Regular} and
+     * {@link ValidateOnOpenModePages#WithLeaves}.
      */
     public BoxStoreBuilder validateOnOpenPageLimit(long limit) {
-        if (validateOnOpenMode != ValidateOnOpenMode.Regular && validateOnOpenMode != ValidateOnOpenMode.WithLeaves) {
+        if (validateOnOpenModePages != ValidateOnOpenModePages.Regular &&
+                validateOnOpenModePages != ValidateOnOpenModePages.WithLeaves) {
             throw new IllegalStateException("Must call validateOnOpen(mode) with mode Regular or WithLeaves first");
         }
         if (limit < 1) {
@@ -400,11 +486,29 @@ public BoxStoreBuilder validateOnOpenPageLimit(long limit) {
     }
 
     /**
-     * @deprecated Use {@link #debugFlags} instead.
+     * When a database is opened, ObjectBox can perform additional consistency checks on its database structure.
+     * This enables validation checks on a key/value level.
+     * <p>
+     * This is a shortcut for {@link #validateOnOpenKv(short) validateOnOpenKv(ValidateOnOpenModeKv.Regular)}.
      */
-    @Deprecated
-    public BoxStoreBuilder debugTransactions() {
-        this.debugFlags |= DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE;
+    public BoxStoreBuilder validateOnOpenKv() {
+        this.validateOnOpenModeKv = ValidateOnOpenModeKv.Regular;
+        return this;
+    }
+
+    /**
+     * When a database is opened, ObjectBox can perform additional consistency checks on its database structure.
+     * This enables validation checks on a key/value level.
+     * <p>
+     * See also {@link #validateOnOpen(short)} for additional consistency checks.
+     *
+     * @param mode One of {@link ValidateOnOpenModeKv}.
+     */
+    public BoxStoreBuilder validateOnOpenKv(short mode) {
+        if (mode < ValidateOnOpenModeKv.Regular || mode > ValidateOnOpenModeKv.Regular) {
+            throw new IllegalArgumentException("Must be one of ValidateOnOpenModeKv");
+        }
+        this.validateOnOpenModeKv = mode;
         return this;
     }
 
@@ -427,11 +531,11 @@ public BoxStoreBuilder debugRelations() {
     /**
      * For massive concurrent setups (app is using a lot of threads), you can enable automatic retries for queries.
      * This can resolve situations in which resources are getting sparse (e.g.
-     * {@link io.objectbox.exception.DbMaxReadersExceededException} or other variations of
-     * {@link io.objectbox.exception.DbException} are thrown during query execution).
+     * {@link DbMaxReadersExceededException} or other variations of
+     * {@link DbException} are thrown during query execution).
      *
      * @param queryAttempts number of attempts a query find operation will be executed before failing.
-     *                      Recommended values are in the range of 2 to 5, e.g. a value of 3 as a starting point.
+     * Recommended values are in the range of 2 to 5, e.g. a value of 3 as a starting point.
      */
     @Experimental
     public BoxStoreBuilder queryAttempts(int queryAttempts) {
@@ -472,7 +576,7 @@ public BoxStoreBuilder initialDbFile(Factory<InputStream> initialDbFileFactory)
 
     byte[] buildFlatStoreOptions(String canonicalPath) {
         FlatBufferBuilder fbb = new FlatBufferBuilder();
-        // FlatBuffer default values are set in generated code, e.g. may be different from here, so always store value.
+        // Always put values, even if they match the default values (defined in the generated classes)
         fbb.forceDefaults(true);
 
         // Add non-integer values first...
@@ -482,37 +586,61 @@ byte[] buildFlatStoreOptions(String canonicalPath) {
 
         // ...then build options.
         FlatStoreOptions.addDirectoryPath(fbb, directoryPathOffset);
-        FlatStoreOptions.addMaxDbSizeInKByte(fbb, maxSizeInKByte);
+        FlatStoreOptions.addMaxDbSizeInKbyte(fbb, maxSizeInKByte);
         FlatStoreOptions.addFileMode(fbb, fileMode);
         FlatStoreOptions.addMaxReaders(fbb, maxReaders);
-        if (validateOnOpenMode != 0) {
-            FlatStoreOptions.addValidateOnOpen(fbb, validateOnOpenMode);
+        if (validateOnOpenModePages != 0) {
+            FlatStoreOptions.addValidateOnOpenPages(fbb, validateOnOpenModePages);
             if (validateOnOpenPageLimit != 0) {
                 FlatStoreOptions.addValidateOnOpenPageLimit(fbb, validateOnOpenPageLimit);
             }
         }
-        if(skipReadSchema) FlatStoreOptions.addSkipReadSchema(fbb, skipReadSchema);
-        if(usePreviousCommit) FlatStoreOptions.addUsePreviousCommit(fbb, usePreviousCommit);
-        if(readOnly) FlatStoreOptions.addReadOnly(fbb, readOnly);
-        if(noReaderThreadLocals) FlatStoreOptions.addNoReaderThreadLocals(fbb, noReaderThreadLocals);
-        if (debugFlags != 0) {
-            FlatStoreOptions.addDebugFlags(fbb, debugFlags);
+        if (validateOnOpenModeKv != 0) {
+            FlatStoreOptions.addValidateOnOpenKv(fbb, validateOnOpenModeKv);
         }
+        if (skipReadSchema) FlatStoreOptions.addSkipReadSchema(fbb, true);
+        if (usePreviousCommit) FlatStoreOptions.addUsePreviousCommit(fbb, true);
+        if (readOnly) FlatStoreOptions.addReadOnly(fbb, true);
+        if (noReaderThreadLocals) FlatStoreOptions.addNoReaderThreadLocals(fbb, true);
+        if (debugFlags != 0) FlatStoreOptions.addDebugFlags(fbb, debugFlags);
+        if (maxDataSizeInKByte > 0) FlatStoreOptions.addMaxDataSizeInKbyte(fbb, maxDataSizeInKByte);
 
         int offset = FlatStoreOptions.endFlatStoreOptions(fbb);
         fbb.finish(offset);
         return fbb.sizedByteArray();
-    }    
+    }
 
     /**
-     * Builds a {@link BoxStore} using any given configuration.
+     * Builds a {@link BoxStore} using the current configuration of this builder.
+     *
+     * <p>If {@link #androidContext(Object)} was called and no {@link #directory(File)} or {@link #baseDirectory(File)}
+     * is configured, creates and sets {@link #baseDirectory(File)} as explained in {@link #androidContext(Object)}.
      */
     public BoxStore build() {
+        // If in-memory, use a special directory (it will never be created)
+        if (inMemory != null) {
+            directory = new File(BoxStore.IN_MEMORY_PREFIX + inMemory);
+        }
+        // On Android, create and set base directory if no directory is explicitly configured
+        if (directory == null && baseDirectory == null && context != null) {
+            File baseDir = getAndroidBaseDir(context);
+            if (!baseDir.exists()) {
+                baseDir.mkdir();
+                if (!baseDir.exists()) { // check baseDir.exists() because of potential concurrent processes
+                    throw new RuntimeException("Could not init Android base dir at " + baseDir.getAbsolutePath());
+                }
+            }
+            if (!baseDir.isDirectory()) {
+                throw new RuntimeException("Android base dir is not a dir: " + baseDir.getAbsolutePath());
+            }
+            baseDirectory = baseDir;
+        }
         if (directory == null) {
-            name = dbName(name);
             directory = getDbDir(baseDirectory, name);
         }
-        checkProvisionInitialDbFile();
+        if (inMemory == null) {
+            checkProvisionInitialDbFile();
+        }
         return new BoxStore(this);
     }
 
@@ -558,7 +686,52 @@ static File getDbDir(@Nullable File baseDirectoryOrNull, @Nullable String nameOr
      */
     public BoxStore buildDefault() {
         BoxStore store = build();
-        BoxStore.setDefault(store);
+        try {
+            BoxStore.setDefault(store);
+        } catch (IllegalStateException e) {
+            // Clean up the new store if it can't be set as default
+            store.close();
+            throw e;
+        }
         return store;
     }
-}
+
+
+    @Internal
+    BoxStoreBuilder createClone(String namePostfix) {
+        if (model == null) {
+            throw new IllegalStateException("BoxStoreBuilder must have a model");
+        }
+        if (initialDbFileFactory != null) {
+            throw new IllegalStateException("Initial DB files factories are not supported for sync-enabled DBs");
+        }
+
+        BoxStoreBuilder clone = new BoxStoreBuilder(model);
+        // Note: don't use absolute path for directories; it messes with in-memory paths ("memory:")
+        clone.directory = this.directory != null ? new File(this.directory.getPath() + namePostfix) : null;
+        clone.baseDirectory = this.baseDirectory != null ? new File(this.baseDirectory.getPath()) : null;
+        clone.name = this.name != null ? name + namePostfix : null;
+        clone.inMemory = this.inMemory;
+        clone.maxSizeInKByte = this.maxSizeInKByte;
+        clone.maxDataSizeInKByte = this.maxDataSizeInKByte;
+        clone.context = this.context;
+        clone.relinker = this.relinker;
+        clone.debugFlags = this.debugFlags;
+        clone.debugRelations = this.debugRelations;
+        clone.fileMode = this.fileMode;
+        clone.maxReaders = this.maxReaders;
+        clone.noReaderThreadLocals = this.noReaderThreadLocals;
+        clone.queryAttempts = this.queryAttempts;
+        clone.skipReadSchema = this.skipReadSchema;
+        clone.readOnly = this.readOnly;
+        clone.usePreviousCommit = this.usePreviousCommit;
+        clone.validateOnOpenModePages = this.validateOnOpenModePages;
+        clone.validateOnOpenPageLimit = this.validateOnOpenPageLimit;
+        clone.validateOnOpenModeKv = this.validateOnOpenModeKv;
+
+        clone.initialDbFileFactory = this.initialDbFileFactory;
+        clone.entityInfoList.addAll(this.entityInfoList); // Entity info is stateless & immutable; shallow clone is OK
+
+        return clone;
+    }
+}
\ No newline at end of file
diff --git a/objectbox-java/src/main/java/io/objectbox/Cursor.java b/objectbox-java/src/main/java/io/objectbox/Cursor.java
index 68a639a4..82954c05 100644
--- a/objectbox-java/src/main/java/io/objectbox/Cursor.java
+++ b/objectbox-java/src/main/java/io/objectbox/Cursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,16 +16,17 @@
 
 package io.objectbox;
 
+import java.io.Closeable;
+import java.util.List;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
 import io.objectbox.annotation.apihint.Beta;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.internal.CursorFactory;
 import io.objectbox.relation.ToMany;
 
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.NotThreadSafe;
-import java.io.Closeable;
-import java.util.List;
-
 @SuppressWarnings({"unchecked", "SameParameterValue", "unused", "WeakerAccess", "UnusedReturnValue"})
 @Beta
 @Internal
@@ -105,6 +106,7 @@ protected static native long collect004000(long cursor, long keyIfComplete, int
                                                int idLong3, long valueLong3, int idLong4, long valueLong4
     );
 
+    // STRING ARRAYS
     protected static native long collectStringArray(long cursor, long keyIfComplete, int flags,
                                                     int idStringArray, @Nullable String[] stringArray
     );
@@ -113,6 +115,29 @@ protected static native long collectStringList(long cursor, long keyIfComplete,
                                                    int idStringList, @Nullable List<String> stringList
     );
 
+    // INTEGER ARRAYS
+    protected static native long collectBooleanArray(long cursor, long keyIfComplete, int flags,
+                                                   int propertyId, @Nullable boolean[] value);
+
+    protected static native long collectShortArray(long cursor, long keyIfComplete, int flags,
+                                                   int propertyId, @Nullable short[] value);
+
+    protected static native long collectCharArray(long cursor, long keyIfComplete, int flags,
+                                                  int propertyId, @Nullable char[] value);
+
+    protected static native long collectIntArray(long cursor, long keyIfComplete, int flags,
+                                                 int propertyId, @Nullable int[] value);
+
+    protected static native long collectLongArray(long cursor, long keyIfComplete, int flags,
+                                                  int propertyId, @Nullable long[] value);
+
+    // FLOATING POINT ARRAYS
+    protected static native long collectFloatArray(long cursor, long keyIfComplete, int flags,
+                                                   int propertyId, @Nullable float[] value);
+
+    protected static native long collectDoubleArray(long cursor, long keyIfComplete, int flags,
+                                                    int propertyId, @Nullable double[] value);
+
     native int nativePropertyId(long cursor, String propertyValue);
 
     native List<T> nativeGetBacklinkEntities(long cursor, int entityId, int propertyId, long key);
@@ -327,9 +352,9 @@ public void modifyRelationsSingle(int relationId, long key, long targetKey, bool
         nativeModifyRelationsSingle(cursor, relationId, key, targetKey, remove);
     }
 
-    protected <TARGET> void checkApplyToManyToDb(List<TARGET> orders, Class<TARGET> targetClass) {
-        if (orders instanceof ToMany) {
-            ToMany<TARGET> toMany = (ToMany<TARGET>) orders;
+    protected <TARGET> void checkApplyToManyToDb(List<TARGET> relationField, Class<TARGET> targetClass) {
+        if (relationField instanceof ToMany) {
+            ToMany<TARGET> toMany = (ToMany<TARGET>) relationField;
             if (toMany.internalCheckApplyToDbRequired()) {
                 try (Cursor<TARGET> targetCursor = getRelationTargetCursor(targetClass)) {
                     toMany.internalApplyToDb(this, targetCursor);
diff --git a/objectbox-java/src/main/java/io/objectbox/EntityInfo.java b/objectbox-java/src/main/java/io/objectbox/EntityInfo.java
index 3b561fdd..5493c9df 100644
--- a/objectbox-java/src/main/java/io/objectbox/EntityInfo.java
+++ b/objectbox-java/src/main/java/io/objectbox/EntityInfo.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/Factory.java b/objectbox-java/src/main/java/io/objectbox/Factory.java
index 78020b23..95f2f7c5 100644
--- a/objectbox-java/src/main/java/io/objectbox/Factory.java
+++ b/objectbox-java/src/main/java/io/objectbox/Factory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/InternalAccess.java b/objectbox-java/src/main/java/io/objectbox/InternalAccess.java
index 5f1a9637..2f203749 100644
--- a/objectbox-java/src/main/java/io/objectbox/InternalAccess.java
+++ b/objectbox-java/src/main/java/io/objectbox/InternalAccess.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,16 +21,13 @@
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.sync.SyncClient;
 
+/**
+ * Exposes internal APIs to tests and code in other packages.
+ */
 @Internal
 public class InternalAccess {
-    public static <T> Cursor<T> getReader(Box<T> box) {
-        return box.getReader();
-    }
-
-    public static long getHandle(BoxStore boxStore) {
-        return boxStore.internalHandle();
-    }
 
+    @Internal
     public static Transaction getActiveTx(BoxStore boxStore) {
         Transaction tx = boxStore.activeTx.get();
         if (tx == null) {
@@ -40,45 +37,50 @@ public static Transaction getActiveTx(BoxStore boxStore) {
         return tx;
     }
 
-    public static long getHandle(Cursor reader) {
-        return reader.internalHandle();
-    }
-
+    @Internal
     public static long getHandle(Transaction tx) {
         return tx.internalHandle();
     }
 
+    @Internal
     public static void setSyncClient(BoxStore boxStore, @Nullable SyncClient syncClient) {
         boxStore.setSyncClient(syncClient);
     }
 
-    public static <T> void releaseReader(Box<T> box, Cursor<T> reader) {
-        box.releaseReader(reader);
-    }
-
+    @Internal
     public static <T> Cursor<T> getWriter(Box<T> box) {
         return box.getWriter();
     }
 
+    @Internal
     public static <T> Cursor<T> getActiveTxCursor(Box<T> box) {
         return box.getActiveTxCursor();
     }
 
+    @Internal
     public static <T> long getActiveTxCursorHandle(Box<T> box) {
         return box.getActiveTxCursor().internalHandle();
     }
 
-    public static <T> void releaseWriter(Box<T> box, Cursor<T> writer) {
-        box.releaseWriter(writer);
-    }
-
+    @Internal
     public static <T> void commitWriter(Box<T> box, Cursor<T> writer) {
         box.commitWriter(writer);
     }
 
-    /** Makes creation more expensive, but lets Finalizers show the creation stack for dangling resources. */
+    /**
+     * Makes creation more expensive, but lets Finalizers show the creation stack for dangling resources.
+     * <p>
+     * Currently used by integration tests.
+     */
+    @SuppressWarnings("unused")
+    @Internal
     public static void enableCreationStackTracking() {
         Transaction.TRACK_CREATION_STACK = true;
         Cursor.TRACK_CREATION_STACK = true;
     }
+
+    @Internal
+    public static BoxStoreBuilder clone(BoxStoreBuilder original, String namePostfix) {
+        return original.createClone(namePostfix);
+    }
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/KeyValueCursor.java b/objectbox-java/src/main/java/io/objectbox/KeyValueCursor.java
index fec5b72a..b9945c8a 100644
--- a/objectbox-java/src/main/java/io/objectbox/KeyValueCursor.java
+++ b/objectbox-java/src/main/java/io/objectbox/KeyValueCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/ModelBuilder.java b/objectbox-java/src/main/java/io/objectbox/ModelBuilder.java
index 9784b972..460e9178 100644
--- a/objectbox-java/src/main/java/io/objectbox/ModelBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/ModelBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,60 +16,136 @@
 
 package io.objectbox;
 
-import io.objectbox.flatbuffers.FlatBufferBuilder;
-
 import java.util.ArrayList;
 import java.util.List;
 
 import javax.annotation.Nullable;
 
+import io.objectbox.annotation.ExternalName;
+import io.objectbox.annotation.ExternalType;
+import io.objectbox.annotation.HnswIndex;
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.model.ExternalPropertyType;
+import io.objectbox.model.HnswDistanceType;
+import io.objectbox.model.HnswFlags;
+import io.objectbox.model.HnswParams;
 import io.objectbox.model.IdUid;
 import io.objectbox.model.Model;
 import io.objectbox.model.ModelEntity;
 import io.objectbox.model.ModelProperty;
 import io.objectbox.model.ModelRelation;
 
-// Remember: IdUid is a struct, not a table, and thus must be inlined
-@SuppressWarnings("WeakerAccess,UnusedReturnValue, unused")
+// To learn how to use the FlatBuffers API see https://flatbuffers.dev/tutorial/
+// Note: IdUid is a struct, not a table, and thus must be inlined
+
+/**
+ * Builds a flatbuffer representation of the database model to be passed to {@link BoxStoreBuilder}.
+ * <p>
+ * This is an internal API that should only be called by the generated MyObjectBox code.
+ */
 @Internal
 public class ModelBuilder {
+
+    /**
+     * The version of the model (structure). The database verifies it supports this version of a model.
+     * <p>
+     * Note this is different from the "modelVersion" in the model JSON file, which only refers to the JSON schema.
+     */
     private static final int MODEL_VERSION = 2;
+    private static final String DEFAULT_NAME = "default";
+    private static final int DEFAULT_VERSION = 1;
 
-    final FlatBufferBuilder fbb = new FlatBufferBuilder();
-    final List<Integer> entityOffsets = new ArrayList<>();
+    private final FlatBufferBuilder fbb = new FlatBufferBuilder();
+    private final List<Integer> entityOffsets = new ArrayList<>();
 
-    long version = 1;
+    private long version = DEFAULT_VERSION;
 
-    Integer lastEntityId;
-    Long lastEntityUid;
+    private Integer lastEntityId;
+    private Long lastEntityUid;
 
-    Integer lastIndexId;
-    Long lastIndexUid;
+    private Integer lastIndexId;
+    private Long lastIndexUid;
 
-    Integer lastRelationId;
-    Long lastRelationUid;
+    private Integer lastRelationId;
+    private Long lastRelationUid;
+
+    /**
+     * Base class for builders.
+     * <p>
+     * Methods adding properties to be used by {@link #createFlatBufferTable(FlatBufferBuilder)} should call
+     * {@link #checkNotFinished()}.
+     * <p>
+     * The last call should be {@link #finish()}.
+     */
+    abstract static class PartBuilder {
+
+        private final FlatBufferBuilder fbb;
+        private boolean finished;
+
+        PartBuilder(FlatBufferBuilder fbb) {
+            this.fbb = fbb;
+        }
+
+        FlatBufferBuilder getFbb() {
+            return fbb;
+        }
+
+        void checkNotFinished() {
+            if (finished) {
+                throw new IllegalStateException("Already finished");
+            }
+        }
+
+        /**
+         * Marks this as finished and returns {@link #createFlatBufferTable(FlatBufferBuilder)}.
+         */
+        public final int finish() {
+            checkNotFinished();
+            finished = true;
+            return createFlatBufferTable(getFbb());
+        }
+
+        /**
+         * Creates a flatbuffer table using the given builder and returns its offset.
+         */
+        public abstract int createFlatBufferTable(FlatBufferBuilder fbb);
+    }
+
+    public static class PropertyBuilder extends PartBuilder {
 
-    public class PropertyBuilder {
-        private final int type;
-        private final int virtualTargetOffset;
         private final int propertyNameOffset;
         private final int targetEntityOffset;
+        private final int virtualTargetOffset;
+        private final int type;
 
         private int secondaryNameOffset;
-        boolean finished;
-        private int flags;
         private int id;
         private long uid;
         private int indexId;
         private long indexUid;
         private int indexMaxValueLength;
+        private int externalNameOffset;
+        private int externalType;
+        private int hnswParamsOffset;
+        private int flags;
 
-        PropertyBuilder(String name, @Nullable String targetEntityName, @Nullable String virtualTarget, int type) {
-            this.type = type;
+        private PropertyBuilder(FlatBufferBuilder fbb, String name, @Nullable String targetEntityName,
+                                @Nullable String virtualTarget, int type) {
+            super(fbb);
             propertyNameOffset = fbb.createString(name);
             targetEntityOffset = targetEntityName != null ? fbb.createString(targetEntityName) : 0;
             virtualTargetOffset = virtualTarget != null ? fbb.createString(virtualTarget) : 0;
+            this.type = type;
+        }
+
+        /**
+         * Sets the Java name of a renamed property when using {@link io.objectbox.annotation.NameInDb}.
+         */
+        public PropertyBuilder secondaryName(String secondaryName) {
+            checkNotFinished();
+            secondaryNameOffset = getFbb().createString(secondaryName);
+            return this;
         }
 
         public PropertyBuilder id(int id, long uid) {
@@ -92,38 +168,86 @@ public PropertyBuilder indexMaxValueLength(int indexMaxValueLength) {
             return this;
         }
 
-        public PropertyBuilder flags(int flags) {
+        /**
+         * Sets the {@link ExternalName} of this property.
+         */
+        public PropertyBuilder externalName(String externalName) {
             checkNotFinished();
-            this.flags = flags;
+            externalNameOffset = getFbb().createString(externalName);
             return this;
         }
 
-        public PropertyBuilder secondaryName(String secondaryName) {
+        /**
+         * Sets the {@link ExternalType} of this property. Should be one of {@link ExternalPropertyType}.
+         */
+        public PropertyBuilder externalType(int externalType) {
             checkNotFinished();
-            secondaryNameOffset = fbb.createString(secondaryName);
+            this.externalType = externalType;
             return this;
         }
 
-        private void checkNotFinished() {
-            if (finished) {
-                throw new IllegalStateException("Already finished");
+        /**
+         * Set parameters for {@link HnswIndex}.
+         *
+         * @param dimensions see {@link HnswIndex#dimensions()}.
+         * @param neighborsPerNode see {@link HnswIndex#neighborsPerNode()}.
+         * @param indexingSearchCount see {@link HnswIndex#indexingSearchCount()}.
+         * @param flags see {@link HnswIndex#flags()}, mapped to {@link HnswFlags}.
+         * @param distanceType see {@link HnswIndex#distanceType()}, mapped to {@link HnswDistanceType}.
+         * @param reparationBacklinkProbability see {@link HnswIndex#reparationBacklinkProbability()}.
+         * @param vectorCacheHintSizeKb see {@link HnswIndex#vectorCacheHintSizeKB()}.
+         * @return this builder.
+         */
+        public PropertyBuilder hnswParams(long dimensions,
+                                          @Nullable Long neighborsPerNode,
+                                          @Nullable Long indexingSearchCount,
+                                          @Nullable Integer flags,
+                                          @Nullable Short distanceType,
+                                          @Nullable Float reparationBacklinkProbability,
+                                          @Nullable Long vectorCacheHintSizeKb) {
+            checkNotFinished();
+            FlatBufferBuilder fbb = getFbb();
+            HnswParams.startHnswParams(fbb);
+            HnswParams.addDimensions(fbb, dimensions);
+            if (neighborsPerNode != null) {
+                HnswParams.addNeighborsPerNode(fbb, neighborsPerNode);
+            }
+            if (indexingSearchCount != null) {
+                HnswParams.addIndexingSearchCount(fbb, indexingSearchCount);
             }
+            if (flags != null) {
+                HnswParams.addFlags(fbb, flags);
+            }
+            if (distanceType != null) {
+                HnswParams.addDistanceType(fbb, distanceType);
+            }
+            if (reparationBacklinkProbability != null) {
+                HnswParams.addReparationBacklinkProbability(fbb, reparationBacklinkProbability);
+            }
+            if (vectorCacheHintSizeKb != null) {
+                HnswParams.addVectorCacheHintSizeKb(fbb, vectorCacheHintSizeKb);
+            }
+            hnswParamsOffset = HnswParams.endHnswParams(fbb);
+            return this;
         }
 
-        public int finish() {
+        /**
+         * One or more of {@link io.objectbox.model.PropertyFlags}.
+         */
+        public PropertyBuilder flags(int flags) {
             checkNotFinished();
-            finished = true;
+            this.flags = flags;
+            return this;
+        }
+
+        @Override
+        public int createFlatBufferTable(FlatBufferBuilder fbb) {
             ModelProperty.startModelProperty(fbb);
             ModelProperty.addName(fbb, propertyNameOffset);
-            if (targetEntityOffset != 0) {
-                ModelProperty.addTargetEntity(fbb, targetEntityOffset);
-            }
-            if (virtualTargetOffset != 0) {
-                ModelProperty.addVirtualTarget(fbb, virtualTargetOffset);
-            }
-            if (secondaryNameOffset != 0) {
-                ModelProperty.addNameSecondary(fbb, secondaryNameOffset);
-            }
+            if (targetEntityOffset != 0) ModelProperty.addTargetEntity(fbb, targetEntityOffset);
+            if (virtualTargetOffset != 0) ModelProperty.addVirtualTarget(fbb, virtualTargetOffset);
+            ModelProperty.addType(fbb, type);
+            if (secondaryNameOffset != 0) ModelProperty.addNameSecondary(fbb, secondaryNameOffset);
             if (id != 0) {
                 int idOffset = IdUid.createIdUid(fbb, id, uid);
                 ModelProperty.addId(fbb, idOffset);
@@ -132,31 +256,89 @@ public int finish() {
                 int indexIdOffset = IdUid.createIdUid(fbb, indexId, indexUid);
                 ModelProperty.addIndexId(fbb, indexIdOffset);
             }
-            if (indexMaxValueLength > 0) {
-                ModelProperty.addMaxIndexValueLength(fbb, indexMaxValueLength);
-            }
-            ModelProperty.addType(fbb, type);
-            if (flags != 0) {
-                ModelProperty.addFlags(fbb, flags);
-            }
+            if (indexMaxValueLength > 0) ModelProperty.addMaxIndexValueLength(fbb, indexMaxValueLength);
+            if (externalNameOffset != 0) ModelProperty.addExternalName(fbb, externalNameOffset);
+            if (externalType != 0) ModelProperty.addExternalType(fbb, externalType);
+            if (hnswParamsOffset != 0) ModelProperty.addHnswParams(fbb, hnswParamsOffset);
+            if (flags != 0) ModelProperty.addFlags(fbb, flags);
             return ModelProperty.endModelProperty(fbb);
         }
     }
 
-    public class EntityBuilder {
-        final String name;
-        final List<Integer> propertyOffsets = new ArrayList<>();
-        final List<Integer> relationOffsets = new ArrayList<>();
+    public static class RelationBuilder extends PartBuilder {
+
+        private final String name;
+        private final int relationId;
+        private final long relationUid;
+        private final int targetEntityId;
+        private final long targetEntityUid;
 
-        Integer id;
-        Long uid;
-        Integer flags;
-        Integer lastPropertyId;
-        Long lastPropertyUid;
-        PropertyBuilder propertyBuilder;
-        boolean finished;
+        private int externalNameOffset;
+        private int externalType;
 
-        EntityBuilder(String name) {
+        private RelationBuilder(FlatBufferBuilder fbb, String name, int relationId, long relationUid,
+                                int targetEntityId, long targetEntityUid) {
+            super(fbb);
+            this.name = name;
+            this.relationId = relationId;
+            this.relationUid = relationUid;
+            this.targetEntityId = targetEntityId;
+            this.targetEntityUid = targetEntityUid;
+        }
+
+        /**
+         * Sets the {@link ExternalName} of this relation.
+         */
+        public RelationBuilder externalName(String externalName) {
+            checkNotFinished();
+            externalNameOffset = getFbb().createString(externalName);
+            return this;
+        }
+
+        /**
+         * Sets the {@link ExternalType} of this relation. Should be one of {@link ExternalPropertyType}.
+         */
+        public RelationBuilder externalType(int externalType) {
+            checkNotFinished();
+            this.externalType = externalType;
+            return this;
+        }
+
+        @Override
+        public int createFlatBufferTable(FlatBufferBuilder fbb) {
+            int nameOffset = fbb.createString(name);
+
+            ModelRelation.startModelRelation(fbb);
+            ModelRelation.addName(fbb, nameOffset);
+            int relationIdOffset = IdUid.createIdUid(fbb, relationId, relationUid);
+            ModelRelation.addId(fbb, relationIdOffset);
+            int targetEntityIdOffset = IdUid.createIdUid(fbb, targetEntityId, targetEntityUid);
+            ModelRelation.addTargetEntityId(fbb, targetEntityIdOffset);
+            if (externalNameOffset != 0) ModelRelation.addExternalName(fbb, externalNameOffset);
+            if (externalType != 0) ModelRelation.addExternalType(fbb, externalType);
+            return ModelRelation.endModelRelation(fbb);
+        }
+    }
+
+    public static class EntityBuilder extends PartBuilder {
+
+        private final ModelBuilder model;
+        private final String name;
+        private final List<Integer> propertyOffsets = new ArrayList<>();
+        private final List<Integer> relationOffsets = new ArrayList<>();
+
+        private Integer id;
+        private Long uid;
+        private Integer lastPropertyId;
+        private Long lastPropertyUid;
+        @Nullable private String externalName;
+        private Integer flags;
+        @Nullable private PropertyBuilder propertyBuilder;
+        @Nullable private RelationBuilder relationBuilder;
+
+        private EntityBuilder(ModelBuilder model, FlatBufferBuilder fbb, String name) {
+            super(fbb);
+            this.model = model;
             this.name = name;
         }
 
@@ -174,15 +356,21 @@ public EntityBuilder lastPropertyId(int lastPropertyId, long lastPropertyUid) {
             return this;
         }
 
-        public EntityBuilder flags(int flags) {
-            this.flags = flags;
+        /**
+         * Sets the {@link ExternalName} of this entity.
+         */
+        public EntityBuilder externalName(String externalName) {
+            checkNotFinished();
+            this.externalName = externalName;
             return this;
         }
 
-        private void checkNotFinished() {
-            if (finished) {
-                throw new IllegalStateException("Already finished");
-            }
+        /**
+         * One or more of {@link io.objectbox.model.EntityFlags}.
+         */
+        public EntityBuilder flags(int flags) {
+            this.flags = flags;
+            return this;
         }
 
         public PropertyBuilder property(String name, int type) {
@@ -193,49 +381,63 @@ public PropertyBuilder property(String name, @Nullable String targetEntityName,
             return property(name, targetEntityName, null, type);
         }
 
+        /**
+         * @param name The name of this property in the database.
+         * @param targetEntityName For {@link io.objectbox.model.PropertyType#Relation}, the name of the target entity.
+         * @param virtualTarget For {@link io.objectbox.model.PropertyType#Relation}, if this property does not really
+         * exist in the source code and is a virtual one, the name of the field this is based on that actually exists.
+         * Currently used for ToOne fields that create virtual target ID properties.
+         * @param type The {@link io.objectbox.model.PropertyType}.
+         */
         public PropertyBuilder property(String name, @Nullable String targetEntityName, @Nullable String virtualTarget,
                                         int type) {
             checkNotFinished();
-            checkFinishProperty();
-            propertyBuilder = new PropertyBuilder(name, targetEntityName, virtualTarget, type);
+            finishPropertyOrRelation();
+            propertyBuilder = new PropertyBuilder(getFbb(), name, targetEntityName, virtualTarget, type);
             return propertyBuilder;
         }
 
-        void checkFinishProperty() {
+        public RelationBuilder relation(String name, int relationId, long relationUid, int targetEntityId,
+                                        long targetEntityUid) {
+            checkNotFinished();
+            finishPropertyOrRelation();
+
+            RelationBuilder relationBuilder = new RelationBuilder(getFbb(), name, relationId, relationUid, targetEntityId, targetEntityUid);
+            this.relationBuilder = relationBuilder;
+            return relationBuilder;
+        }
+
+        private void finishPropertyOrRelation() {
+            if (propertyBuilder != null && relationBuilder != null) {
+                throw new IllegalStateException("Must not build property and relation at the same time.");
+            }
             if (propertyBuilder != null) {
                 propertyOffsets.add(propertyBuilder.finish());
                 propertyBuilder = null;
             }
+            if (relationBuilder != null) {
+                relationOffsets.add(relationBuilder.finish());
+                relationBuilder = null;
+            }
         }
 
-        public EntityBuilder relation(String name, int relationId, long relationUid, int targetEntityId,
-                                      long targetEntityUid) {
+        public ModelBuilder entityDone() {
+            // Make sure any pending property or relation is finished first
             checkNotFinished();
-            checkFinishProperty();
-
-            int propertyNameOffset = fbb.createString(name);
-
-            ModelRelation.startModelRelation(fbb);
-            ModelRelation.addName(fbb, propertyNameOffset);
-            int relationIdOffset = IdUid.createIdUid(fbb, relationId, relationUid);
-            ModelRelation.addId(fbb, relationIdOffset);
-            int targetEntityIdOffset = IdUid.createIdUid(fbb, targetEntityId, targetEntityUid);
-            ModelRelation.addTargetEntityId(fbb, targetEntityIdOffset);
-            relationOffsets.add(ModelRelation.endModelRelation(fbb));
-
-            return this;
+            finishPropertyOrRelation();
+            model.entityOffsets.add(finish());
+            return model;
         }
 
-        public ModelBuilder entityDone() {
-            checkNotFinished();
-            checkFinishProperty();
-            finished = true;
-            int testEntityNameOffset = fbb.createString(name);
-            int propertiesOffset = createVector(propertyOffsets);
-            int relationsOffset = relationOffsets.isEmpty() ? 0 : createVector(relationOffsets);
+        @Override
+        public int createFlatBufferTable(FlatBufferBuilder fbb) {
+            int nameOffset = fbb.createString(name);
+            int externalNameOffset = externalName != null ? fbb.createString(externalName) : 0;
+            int propertiesOffset = model.createVector(propertyOffsets);
+            int relationsOffset = relationOffsets.isEmpty() ? 0 : model.createVector(relationOffsets);
 
             ModelEntity.startModelEntity(fbb);
-            ModelEntity.addName(fbb, testEntityNameOffset);
+            ModelEntity.addName(fbb, nameOffset);
             ModelEntity.addProperties(fbb, propertiesOffset);
             if (relationsOffset != 0) ModelEntity.addRelations(fbb, relationsOffset);
             if (id != null && uid != null) {
@@ -246,15 +448,14 @@ public ModelBuilder entityDone() {
                 int idOffset = IdUid.createIdUid(fbb, lastPropertyId, lastPropertyUid);
                 ModelEntity.addLastPropertyId(fbb, idOffset);
             }
-            if (flags != null) {
-                ModelEntity.addFlags(fbb, flags);
-            }
-            entityOffsets.add(ModelEntity.endModelEntity(fbb));
-            return ModelBuilder.this;
+            if (externalNameOffset != 0) ModelEntity.addExternalName(fbb, externalNameOffset);
+            if (flags != null) ModelEntity.addFlags(fbb, flags);
+            return ModelEntity.endModelEntity(fbb);
         }
+
     }
 
-    int createVector(List<Integer> offsets) {
+    private int createVector(List<Integer> offsets) {
         int[] offsetArray = new int[offsets.size()];
         for (int i = 0; i < offsets.size(); i++) {
             offsetArray[i] = offsets.get(i);
@@ -262,13 +463,18 @@ int createVector(List<Integer> offsets) {
         return fbb.createVectorOfTables(offsetArray);
     }
 
+    /**
+     * Sets the user-defined version of the schema this represents. Defaults to 1.
+     * <p>
+     * Currently unused.
+     */
     public ModelBuilder version(long version) {
         this.version = version;
         return this;
     }
 
     public EntityBuilder entity(String name) {
-        return new EntityBuilder(name);
+        return new EntityBuilder(this, fbb, name);
     }
 
     public ModelBuilder lastEntityId(int lastEntityId, long lastEntityUid) {
@@ -290,12 +496,12 @@ public ModelBuilder lastRelationId(int lastRelationId, long lastRelationUid) {
     }
 
     public byte[] build() {
-        int nameOffset = fbb.createString("default");
+        int nameOffset = fbb.createString(DEFAULT_NAME);
         int entityVectorOffset = createVector(entityOffsets);
         Model.startModel(fbb);
         Model.addName(fbb, nameOffset);
         Model.addModelVersion(fbb, MODEL_VERSION);
-        Model.addVersion(fbb, 1);
+        Model.addVersion(fbb, version);
         Model.addEntities(fbb, entityVectorOffset);
         if (lastEntityId != null) {
             int idOffset = IdUid.createIdUid(fbb, lastEntityId, lastEntityUid);
diff --git a/objectbox-java/src/main/java/io/objectbox/ObjectBoxThreadPoolExecutor.java b/objectbox-java/src/main/java/io/objectbox/ObjectBoxThreadPoolExecutor.java
new file mode 100644
index 00000000..52eeb881
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/ObjectBoxThreadPoolExecutor.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A {@link ThreadPoolExecutor} that automatically releases thread-local ObjectBox resources after each task execution
+ * by calling {@link BoxStore#closeThreadResources()}.
+ * <p>
+ * This is useful when using a thread pool with ObjectBox to ensure that thread-local resources (currently readers only)
+ * are properly cleaned up after each task completes.
+ * <p>
+ * <b>Recommended:</b> Use the factory methods {@link BoxStore#newFixedThreadPoolExecutor(int)} or
+ * {@link BoxStore#newCachedThreadPoolExecutor()} to create instances of this executor.
+ * <p>
+ * Example usage:
+ * <pre>
+ * BoxStore boxStore = MyObjectBox.builder().build();
+ *
+ * // Recommended: Use BoxStore factory methods
+ * ObjectBoxThreadPoolExecutor executor = boxStore.newFixedThreadPoolExecutor(4);
+ *
+ * // Or for a cached thread pool
+ * ObjectBoxThreadPoolExecutor cachedExecutor = boxStore.newCachedThreadPoolExecutor();
+ *
+ * // Advanced: Direct construction for custom configuration
+ * ObjectBoxThreadPoolExecutor customExecutor = new ObjectBoxThreadPoolExecutor(
+ *     boxStore,
+ *     4, // core pool size
+ *     8, // maximum pool size
+ *     60L, TimeUnit.SECONDS, // keep-alive time
+ *     new LinkedBlockingQueue&lt;&gt;()
+ * );
+ * </pre>
+ */
+public class ObjectBoxThreadPoolExecutor extends ThreadPoolExecutor {
+
+    private final BoxStore boxStore;
+
+    /**
+     * Creates a new ObjectBoxThreadPoolExecutor with the given parameters.
+     * <p>
+     * See {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue)} for parameter
+     * details.
+     *
+     * @param boxStore the BoxStore instance for which to close thread resources
+     */
+    public ObjectBoxThreadPoolExecutor(BoxStore boxStore, int corePoolSize, int maximumPoolSize,
+                                       long keepAliveTime, TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * Creates a new ObjectBoxThreadPoolExecutor with the given parameters.
+     * <p>
+     * See {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory)} for
+     * parameter details.
+     *
+     * @param boxStore the BoxStore instance for which to close thread resources
+     */
+    public ObjectBoxThreadPoolExecutor(BoxStore boxStore, int corePoolSize, int maximumPoolSize,
+                                       long keepAliveTime, TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue,
+                                       ThreadFactory threadFactory) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * Creates a new ObjectBoxThreadPoolExecutor with the given parameters.
+     * <p>
+     * See
+     * {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, RejectedExecutionHandler)}
+     * for parameter details.
+     *
+     * @param boxStore the BoxStore instance for which to close thread resources
+     */
+    public ObjectBoxThreadPoolExecutor(BoxStore boxStore, int corePoolSize, int maximumPoolSize,
+                                       long keepAliveTime, TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue,
+                                       RejectedExecutionHandler handler) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * Creates a new ObjectBoxThreadPoolExecutor with the given parameters.
+     * <p>
+     * See
+     * {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory,
+     * RejectedExecutionHandler)} for parameter details.
+     *
+     * @param boxStore the BoxStore instance for which to close thread resources
+     */
+    public ObjectBoxThreadPoolExecutor(BoxStore boxStore, int corePoolSize, int maximumPoolSize,
+                                       long keepAliveTime, TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue,
+                                       ThreadFactory threadFactory,
+                                       RejectedExecutionHandler handler) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * Releases thread-local ObjectBox resources after each task execution.
+     */
+    @Override
+    protected void afterExecute(Runnable runnable, Throwable throwable) {
+        super.afterExecute(runnable, throwable);
+        boxStore.closeThreadResources();
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/ObjectClassPublisher.java b/objectbox-java/src/main/java/io/objectbox/ObjectClassPublisher.java
index cf6e9127..6001e293 100644
--- a/objectbox-java/src/main/java/io/objectbox/ObjectClassPublisher.java
+++ b/objectbox-java/src/main/java/io/objectbox/ObjectClassPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,9 +16,6 @@
 
 package io.objectbox;
 
-import org.greenrobot.essentials.collections.MultimapSet;
-import org.greenrobot.essentials.collections.MultimapSet.SetType;
-
 import java.util.ArrayDeque;
 import java.util.Collection;
 import java.util.Collections;
@@ -32,6 +29,8 @@
 import io.objectbox.reactive.DataPublisher;
 import io.objectbox.reactive.DataPublisherUtils;
 import io.objectbox.reactive.SubscriptionBuilder;
+import org.greenrobot.essentials.collections.MultimapSet;
+import org.greenrobot.essentials.collections.MultimapSet.SetType;
 
 /**
  * A {@link DataPublisher} that notifies {@link DataObserver}s about changes in an entity box.
@@ -45,14 +44,17 @@ class ObjectClassPublisher implements DataPublisher<Class>, Runnable {
     final BoxStore boxStore;
     final MultimapSet<Integer, DataObserver<Class>> observersByEntityTypeId = MultimapSet.create(SetType.THREAD_SAFE);
     private final Deque<PublishRequest> changesQueue = new ArrayDeque<>();
+
     private static class PublishRequest {
         @Nullable private final DataObserver<Class> observer;
         private final int[] entityTypeIds;
+
         PublishRequest(@Nullable DataObserver<Class> observer, int[] entityTypeIds) {
             this.observer = observer;
             this.entityTypeIds = entityTypeIds;
         }
     }
+
     volatile boolean changePublisherRunning;
 
     ObjectClassPublisher(BoxStore boxStore) {
diff --git a/objectbox-java/src/main/java/io/objectbox/Property.java b/objectbox-java/src/main/java/io/objectbox/Property.java
index d151f4f6..13a4ccae 100644
--- a/objectbox-java/src/main/java/io/objectbox/Property.java
+++ b/objectbox-java/src/main/java/io/objectbox/Property.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,12 @@
 
 package io.objectbox;
 
+import java.io.Serializable;
+import java.util.Date;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.HnswIndex;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.converter.PropertyConverter;
 import io.objectbox.exception.DbException;
@@ -27,21 +33,20 @@
 import io.objectbox.query.PropertyQueryConditionImpl.LongArrayCondition;
 import io.objectbox.query.PropertyQueryConditionImpl.LongCondition;
 import io.objectbox.query.PropertyQueryConditionImpl.LongLongCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.NearestNeighborCondition;
 import io.objectbox.query.PropertyQueryConditionImpl.NullCondition;
 import io.objectbox.query.PropertyQueryConditionImpl.StringArrayCondition;
 import io.objectbox.query.PropertyQueryConditionImpl.StringCondition;
 import io.objectbox.query.PropertyQueryConditionImpl.StringCondition.Operation;
+import io.objectbox.query.PropertyQueryConditionImpl.StringDoubleCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.StringLongCondition;
 import io.objectbox.query.PropertyQueryConditionImpl.StringStringCondition;
+import io.objectbox.query.Query;
 import io.objectbox.query.QueryBuilder.StringOrder;
 
-import javax.annotation.Nullable;
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.Date;
-
 /**
  * Meta data describing a Property of an ObjectBox Entity.
- * Properties are typically used when defining {@link io.objectbox.query.Query Query} conditions
+ * Properties are typically used when defining {@link Query Query} conditions
  * using {@link io.objectbox.query.QueryBuilder QueryBuilder}.
  * Access properties using the generated underscore class of an entity (e.g. {@code Example_.id}).
  */
@@ -60,7 +65,8 @@ public class Property<ENTITY> implements Serializable {
     public final boolean isId;
     public final boolean isVirtual;
     public final String dbName;
-    @SuppressWarnings("rawtypes") // Use raw type of PropertyConverter to allow users to supply a generic implementation.
+    @SuppressWarnings("rawtypes")
+    // Use raw type of PropertyConverter to allow users to supply a generic implementation.
     public final Class<? extends PropertyConverter> converterClass;
 
     /** Type, which is converted to a type supported by the DB. */
@@ -83,14 +89,16 @@ public Property(EntityInfo<ENTITY> entity, int ordinal, int id, Class<?> type, S
         this(entity, ordinal, id, type, name, isId, dbName, null, null);
     }
 
-    @SuppressWarnings("rawtypes") // Use raw type of PropertyConverter to allow users to supply a generic implementation.
+    @SuppressWarnings("rawtypes")
+    // Use raw type of PropertyConverter to allow users to supply a generic implementation.
     public Property(EntityInfo<ENTITY> entity, int ordinal, int id, Class<?> type, String name, boolean isId,
                     @Nullable String dbName, @Nullable Class<? extends PropertyConverter> converterClass,
                     @Nullable Class<?> customType) {
         this(entity, ordinal, id, type, name, isId, false, dbName, converterClass, customType);
     }
 
-    @SuppressWarnings("rawtypes") // Use raw type of PropertyConverter to allow users to supply a generic implementation.
+    @SuppressWarnings("rawtypes")
+    // Use raw type of PropertyConverter to allow users to supply a generic implementation.
     public Property(EntityInfo<ENTITY> entity, int ordinal, int id, Class<?> type, String name, boolean isId,
                     boolean isVirtual, @Nullable String dbName,
                     @Nullable Class<? extends PropertyConverter> converterClass, @Nullable Class<?> customType) {
@@ -298,6 +306,25 @@ public PropertyQueryCondition<ENTITY> between(double lowerBoundary, double upper
                 lowerBoundary, upperBoundary);
     }
 
+    /**
+     * Performs an approximate nearest neighbor (ANN) search to find objects near to the given {@code queryVector}.
+     * <p>
+     * This requires the vector property to have an {@link HnswIndex}.
+     * <p>
+     * The dimensions of the query vector should be at least the dimensions of this vector property.
+     * <p>
+     * Use {@code maxResultCount} to set the maximum number of objects to return by the ANN condition. Hint: it can also
+     * be used as the "ef" HNSW parameter to increase the search quality in combination with a query limit. For example,
+     * use maxResultCount of 100 with a Query limit of 10 to have 10 results that are of potentially better quality than
+     * just passing in 10 for maxResultCount (quality/performance tradeoff).
+     * <p>
+     * To change the given parameters after building the query, use {@link Query#setParameter(Property, float[])} and
+     * {@link Query#setParameter(Property, long)} or their alias equivalent.
+     */
+    public PropertyQueryCondition<ENTITY> nearestNeighbors(float[] queryVector, int maxResultCount) {
+        return new NearestNeighborCondition<>(this, queryVector, maxResultCount);
+    }
+
     /** Creates an "equal ('=')" condition for this property. */
     public PropertyQueryCondition<ENTITY> equal(Date value) {
         return new LongCondition<>(this, LongCondition.Operation.EQUAL, value);
@@ -328,6 +355,16 @@ public PropertyQueryCondition<ENTITY> lessOrEqual(Date value) {
         return new LongCondition<>(this, LongCondition.Operation.LESS_OR_EQUAL, value);
     }
 
+    /** Creates an "IN (..., ..., ...)" condition for this property. */
+    public PropertyQueryCondition<ENTITY> oneOf(Date[] value) {
+        return new LongArrayCondition<>(this, LongArrayCondition.Operation.IN, value);
+    }
+
+    /** Creates a "NOT IN (..., ..., ...)" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notOneOf(Date[] value) {
+        return new LongArrayCondition<>(this, LongArrayCondition.Operation.NOT_IN, value);
+    }
+
     /**
      * Creates a "BETWEEN ... AND ..." condition for this property.
      * Finds objects with property value between and including the first and second value.
@@ -460,21 +497,161 @@ public PropertyQueryCondition<ENTITY> containsElement(String value, StringOrder
      * For a String-key map property, matches if at least one key and value combination equals the given values
      * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
      *
+     * @deprecated Use the {@link #equalKeyValue(String, String, StringOrder)} condition instead.
+     *
      * @see #containsKeyValue(String, String, StringOrder)
      */
+    @Deprecated
     public PropertyQueryCondition<ENTITY> containsKeyValue(String key, String value) {
-        return new StringStringCondition<>(this, StringStringCondition.Operation.CONTAINS_KEY_VALUE,
+        return new StringStringCondition<>(this, StringStringCondition.Operation.EQUAL_KEY_VALUE,
                 key, value, StringOrder.CASE_SENSITIVE);
     }
 
     /**
+     * @deprecated Use the {@link #equalKeyValue(String, String, StringOrder)} condition instead.
      * @see #containsKeyValue(String, String)
      */
+    @Deprecated
     public PropertyQueryCondition<ENTITY> containsKeyValue(String key, String value, StringOrder order) {
-        return new StringStringCondition<>(this, StringStringCondition.Operation.CONTAINS_KEY_VALUE,
+        return new StringStringCondition<>(this, StringStringCondition.Operation.EQUAL_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is equal
+     * to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> equalKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.EQUAL_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.GREATER_KEY_VALUE,
                 key, value, order);
     }
 
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterOrEqualKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.GREATER_EQUALS_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.LESS_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessOrEqualKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.LESS_EQUALS_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is equal
+     * to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> equalKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.EQUAL_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.GREATER_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterOrEqualKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.GREATER_EQUALS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.LESS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessOrEqualKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.LESS_EQUALS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is equal
+     * to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> equalKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.EQUAL_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.GREATER_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterOrEqualKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.GREATER_EQUALS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.LESS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessOrEqualKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.LESS_EQUALS_KEY_VALUE,
+                key, value);
+    }
+
     /**
      * Creates a starts with condition using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
      *
@@ -543,133 +720,6 @@ public PropertyQueryCondition<ENTITY> lessOrEqual(byte[] value) {
         return new ByteArrayCondition<>(this, ByteArrayCondition.Operation.LESS_OR_EQUAL, value);
     }
 
-    //////
-    // Note: The following are deprecated conditions used with DAOcompat only.
-    // They exist so library users need not update their code where new conditions are named differently.
-    //////
-
-    /**
-     * Creates an "equal ('=')" condition for this property.
-     *
-     * @deprecated Use {@link #equal} instead.
-     */
-    @Deprecated
-    public PropertyQueryCondition<ENTITY> eq(Object value) {
-        if (value instanceof Long) {
-            return equal((Long) value);
-        } else if (value instanceof Integer) {
-            return equal((Integer) value);
-        } else if (value instanceof String) {
-            return equal((String) value);
-        } else {
-            throw new IllegalArgumentException("Only LONG, INTEGER or STRING values are supported.");
-        }
-    }
-
-    /**
-     * Creates an "not equal ('&lt;&gt;')" condition for this property.
-     *
-     * @deprecated Use {@link #notEqual} instead.
-     */
-    @Deprecated
-    public PropertyQueryCondition<ENTITY> notEq(Object value) {
-        if (value instanceof Long) {
-            return notEqual((Long) value);
-        } else if (value instanceof Integer) {
-            return notEqual((Integer) value);
-        } else if (value instanceof String) {
-            return notEqual((String) value);
-        } else {
-            throw new IllegalArgumentException("Only LONG, INTEGER or STRING values are supported.");
-        }
-    }
-
-    /**
-     * Creates an "IN (..., ..., ...)" condition for this property.
-     *
-     * @deprecated Use {@link #oneOf} instead.
-     */
-    @Deprecated
-    public PropertyQueryCondition<ENTITY> in(Object... values) {
-        // just check the first value and assume all others are of the same type
-        // maybe this is too naive and we should properly check values earlier
-        if (values[0] instanceof Long) {
-            long[] inValues = new long[values.length];
-            for (int i = 0; i < values.length; i++) {
-                inValues[i] = (long) values[i];
-            }
-            return oneOf(inValues);
-        } else if (values[0] instanceof Integer) {
-            int[] inValues = new int[values.length];
-            for (int i = 0; i < values.length; i++) {
-                inValues[i] = (int) values[i];
-            }
-            return oneOf(inValues);
-        } else {
-            throw new IllegalArgumentException("The IN condition only supports LONG or INTEGER values.");
-        }
-    }
-
-    /**
-     * Creates an "IN (..., ..., ...)" condition for this property.
-     *
-     * @deprecated Use {@link #oneOf} instead.
-     */
-    @Deprecated
-    public PropertyQueryCondition<ENTITY> in(Collection<?> inValues) {
-        return in(inValues.toArray());
-    }
-
-    /**
-     * Creates an "greater than ('&gt;')" condition for this property.
-     *
-     * @deprecated Use {@link #greater} instead.
-     */
-    @Deprecated
-    public PropertyQueryCondition<ENTITY> gt(Object value) {
-        if (value instanceof Long) {
-            return greater((Long) value);
-        } else if (value instanceof Integer) {
-            return greater((Integer) value);
-        } else if (value instanceof Double) {
-            return greater((Double) value);
-        } else if (value instanceof Float) {
-            return greater((Float) value);
-        } else {
-            throw new IllegalArgumentException("Only LONG, INTEGER, DOUBLE or FLOAT values are supported.");
-        }
-    }
-
-    /**
-     * Creates an "less than ('&lt;')" condition for this property.
-     *
-     * @deprecated Use {@link #less} instead.
-     */
-    @Deprecated
-    public PropertyQueryCondition<ENTITY> lt(Object value) {
-        if (value instanceof Long) {
-            return less((Long) value);
-        } else if (value instanceof Integer) {
-            return less((Integer) value);
-        } else if (value instanceof Double) {
-            return less((Double) value);
-        } else if (value instanceof Float) {
-            return less((Float) value);
-        } else {
-            throw new IllegalArgumentException("Only LONG, INTEGER, DOUBLE or FLOAT values are supported.");
-        }
-    }
-
-    /**
-     * Creates an "IS NOT NULL" condition for this property.
-     *
-     * @deprecated Use {@link #notNull()} instead.
-     */
-    @Deprecated
-    public PropertyQueryCondition<ENTITY> isNotNull() {
-        return notNull();
-    }
-
     @Internal
     public int getEntityId() {
         return entity.getEntityId();
diff --git a/objectbox-java/src/main/java/io/objectbox/Transaction.java b/objectbox-java/src/main/java/io/objectbox/Transaction.java
index b3ba8906..323cd2c2 100644
--- a/objectbox-java/src/main/java/io/objectbox/Transaction.java
+++ b/objectbox-java/src/main/java/io/objectbox/Transaction.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -101,7 +101,9 @@ public synchronized void close() {
             closed = true;
             store.unregisterTransaction(this);
 
-            if (!nativeIsOwnerThread(transaction)) {
+            boolean isOwnerThread = nativeIsOwnerThread(transaction);
+            if (!isOwnerThread) {
+                // Note: don't use isActive(), it returns false here because closed == true already
                 boolean isActive = nativeIsActive(transaction);
                 boolean isRecycled = nativeIsRecycled(transaction);
                 if (isActive || isRecycled) {
@@ -124,12 +126,51 @@ public synchronized void close() {
 
             // If store is already closed natively, destroying the tx would cause EXCEPTION_ACCESS_VIOLATION
             // TODO not destroying is probably only a small leak on rare occasions, but still could be fixed
-            if (!store.isClosed()) {
+            if (!store.isNativeStoreClosed()) {
                 nativeDestroy(transaction);
+            } else {
+                // Note: don't use isActive(), it returns false here because closed == true already
+                boolean isActive = nativeIsActive(transaction);
+                if (readOnly) {
+                    // Minor leak if TX is active, but still log so the ObjectBox team can check that it only happens
+                    // occasionally.
+                    // Note this cannot assume the store isn't destroyed, yet. The native and Java stores may at best
+                    // briefly wait for read transactions.
+                    System.out.printf(
+                            "Info: closing read transaction after store was closed (isActive=%s, isOwnerThread=%s), this should be avoided.%n",
+                            isActive, isOwnerThread);
+                    System.out.flush();
+
+                    // Note: get fresh active state
+                    if (!nativeIsActive(transaction)) {
+                        nativeDestroy(transaction);
+                    }
+                } else {
+                    // write transaction
+                    System.out.printf(
+                            "WARN: closing write transaction after store was closed (isActive=%s, isOwnerThread=%s), this must be avoided.%n",
+                            isActive, isOwnerThread);
+                    System.out.flush();
+
+                    // Note: get fresh active state
+                    if (nativeIsActive(transaction) && store.isNativeStoreDestroyed()) {
+                        // This is an internal validation: if this is an active write-TX,
+                        // the (native) store will always wait for it, so it must not be destroyed yet.
+                        // If this ever happens, the above assumption is wrong, and throwing likely prevents a SIGSEGV.
+                        throw new IllegalStateException(
+                                "Internal error: cannot close active write transaction for an already destroyed store");
+                    }
+                    // Note: inactive transactions are always safe to destroy, regardless of store state and thread.
+                    // Note: the current native impl panics if the transaction is active AND created in another thread.
+                    nativeDestroy(transaction);
+                }
             }
         }
     }
 
+    /**
+     * For a write transaction commits the changes. For a read transaction throws.
+     */
     public void commit() {
         checkOpen();
         int[] entityTypeIdsAffected = nativeCommit(transaction);
@@ -141,6 +182,9 @@ public void commitAndClose() {
         close();
     }
 
+    /**
+     * For a read or write transaction, aborts it.
+     */
     public void abort() {
         checkOpen();
         nativeAbort(transaction);
@@ -184,7 +228,7 @@ public <T> Cursor<T> createCursor(Class<T> entityClass) {
         EntityInfo<T> entityInfo = store.getEntityInfo(entityClass);
         CursorFactory<T> factory = entityInfo.getCursorFactory();
         long cursorHandle = nativeCreateCursor(transaction, entityInfo.getDbName(), entityClass);
-        if(cursorHandle == 0) throw new DbException("Could not create native cursor");
+        if (cursorHandle == 0) throw new DbException("Could not create native cursor");
         return factory.createCursor(this, cursorHandle, store);
     }
 
@@ -192,9 +236,14 @@ public BoxStore getStore() {
         return store;
     }
 
+    /**
+     * A transaction is active after it was created until {@link #close()}, {@link #abort()}, or, for write
+     * transactions only, {@link #commit()} is called.
+     *
+     * @return If this transaction is active.
+     */
     public boolean isActive() {
-        checkOpen();
-        return nativeIsActive(transaction);
+        return !closed && nativeIsActive(transaction);
     }
 
     public boolean isRecycled() {
diff --git a/objectbox-java/src/main/java/io/objectbox/TxCallback.java b/objectbox-java/src/main/java/io/objectbox/TxCallback.java
index 9e9b216a..281c7c2f 100644
--- a/objectbox-java/src/main/java/io/objectbox/TxCallback.java
+++ b/objectbox-java/src/main/java/io/objectbox/TxCallback.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/DebugFlags.java b/objectbox-java/src/main/java/io/objectbox/config/DebugFlags.java
similarity index 91%
rename from objectbox-java/src/main/java/io/objectbox/DebugFlags.java
rename to objectbox-java/src/main/java/io/objectbox/config/DebugFlags.java
index 78049e72..68e9de10 100644
--- a/objectbox-java/src/main/java/io/objectbox/DebugFlags.java
+++ b/objectbox-java/src/main/java/io/objectbox/config/DebugFlags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
 
 // automatically generated by the FlatBuffers compiler, do not modify
 
-package io.objectbox;
+package io.objectbox.config;
 
 /**
  * Debug flags typically enable additional "debug logging" that can be helpful to better understand what is going on
@@ -43,5 +43,9 @@ private DebugFlags() { }
    * Run a quick self-test to verify basic threading; somewhat paranoia to check the platform and the library setup.
    */
   public static final int RUN_THREADING_SELF_TEST = 512;
+  /**
+   * Enables debug logs for write-ahead logging
+   */
+  public static final int LOG_WAL = 1024;
 }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/model/FlatStoreOptions.java b/objectbox-java/src/main/java/io/objectbox/config/FlatStoreOptions.java
similarity index 70%
rename from objectbox-java/src/main/java/io/objectbox/model/FlatStoreOptions.java
rename to objectbox-java/src/main/java/io/objectbox/config/FlatStoreOptions.java
index 2443561a..94187b2d 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/FlatStoreOptions.java
+++ b/objectbox-java/src/main/java/io/objectbox/config/FlatStoreOptions.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,12 +16,24 @@
 
 // automatically generated by the FlatBuffers compiler, do not modify
 
-package io.objectbox.model;
+package io.objectbox.config;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import io.objectbox.flatbuffers.*;
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
 /**
  * Options to open a store with. Set only the values you want; defaults are used otherwise.
@@ -31,7 +43,7 @@
  */
 @SuppressWarnings("unused")
 public final class FlatStoreOptions extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_2_0_8(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static FlatStoreOptions getRootAsFlatStoreOptions(ByteBuffer _bb) { return getRootAsFlatStoreOptions(_bb, new FlatStoreOptions()); }
   public static FlatStoreOptions getRootAsFlatStoreOptions(ByteBuffer _bb, FlatStoreOptions obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -57,7 +69,7 @@ public final class FlatStoreOptions extends Table {
    * e.g. caused by programming error.
    * If your app runs into errors like "db full", you may consider to raise the limit.
    */
-  public long maxDbSizeInKByte() { int o = __offset(8); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  public long maxDbSizeInKbyte() { int o = __offset(8); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
   /**
    * File permissions given in Unix style octal bit flags (e.g. 0644). Ignored on Windows.
    * Note: directories become searchable if the "read" or "write" permission is set (e.g. 0640 becomes 0750).
@@ -85,7 +97,7 @@ public final class FlatStoreOptions extends Table {
    * OSes, file systems, or hardware.
    * Note: ObjectBox builds upon ACID storage, which already has strong consistency mechanisms in place.
    */
-  public int validateOnOpen() { int o = __offset(14); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  public int validateOnOpenPages() { int o = __offset(14); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
   /**
    * To fine-tune database validation, you can specify a limit on how much data is looked at.
    * This is measured in "pages" with a page typically holding 4K.
@@ -135,14 +147,52 @@ public final class FlatStoreOptions extends Table {
    *       corner cases with e.g. transactions, which may not be fully tested at the moment.
    */
   public boolean noReaderThreadLocals() { int o = __offset(30); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+  /**
+   * Data size tracking is more involved than DB size tracking, e.g. it stores an internal counter.
+   * Thus only use it if a stricter, more accurate limit is required.
+   * It tracks the size of actual data bytes of objects (system and metadata is not considered).
+   * On the upside, reaching the data limit still allows data to be removed (assuming DB limit is not reached).
+   * Max data and DB sizes can be combined; data size must be below the DB size.
+   */
+  public long maxDataSizeInKbyte() { int o = __offset(32); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * When a database is opened, ObjectBox can perform additional consistency checks on its database structure.
+   * This enum is used to enable validation checks on a key/value level.
+   */
+  public int validateOnOpenKv() { int o = __offset(34); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * Restores the database content from the given backup file (note: backup is a server-only feature).
+   * By default, actually restoring the backup is only performed if no database already exists
+   * (database does not contain data).
+   * This behavior can be adjusted with backupRestoreFlags, e.g., to overwrite all existing data in the database.
+   *
+   * \note Backup files are created from an existing database using ObjectBox API.
+   *
+   * \note The following error types can occur for different error scenarios:
+   *       * IO error: the backup file doesn't exist, couldn't be read or has an unexpected size,
+   *       * format error: the backup-file is malformed
+   *       * integrity error: the backup file failed integrity checks
+   */
+  public String backupFile() { int o = __offset(36); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer backupFileAsByteBuffer() { return __vector_as_bytebuffer(36, 1); }
+  public ByteBuffer backupFileInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 36, 1); }
+  /**
+   * Flags to change the default behavior for restoring backups, e.g. what should happen to existing data.
+   */
+  public long backupRestoreFlags() { int o = __offset(38); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Options for write-ahead logging (WAL)
+   */
+  public WalOptions walOptions() { return walOptions(new WalOptions()); }
+  public WalOptions walOptions(WalOptions obj) { int o = __offset(40); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
 
   public static int createFlatStoreOptions(FlatBufferBuilder builder,
       int directoryPathOffset,
       int modelBytesOffset,
-      long maxDbSizeInKByte,
+      long maxDbSizeInKbyte,
       long fileMode,
       long maxReaders,
-      int validateOnOpen,
+      int validateOnOpenPages,
       long validateOnOpenPageLimit,
       int putPaddingMode,
       boolean skipReadSchema,
@@ -150,17 +200,27 @@ public static int createFlatStoreOptions(FlatBufferBuilder builder,
       boolean usePreviousCommitOnValidationFailure,
       boolean readOnly,
       long debugFlags,
-      boolean noReaderThreadLocals) {
-    builder.startTable(14);
+      boolean noReaderThreadLocals,
+      long maxDataSizeInKbyte,
+      int validateOnOpenKv,
+      int backupFileOffset,
+      long backupRestoreFlags,
+      int walOptionsOffset) {
+    builder.startTable(19);
+    FlatStoreOptions.addMaxDataSizeInKbyte(builder, maxDataSizeInKbyte);
     FlatStoreOptions.addValidateOnOpenPageLimit(builder, validateOnOpenPageLimit);
-    FlatStoreOptions.addMaxDbSizeInKByte(builder, maxDbSizeInKByte);
+    FlatStoreOptions.addMaxDbSizeInKbyte(builder, maxDbSizeInKbyte);
+    FlatStoreOptions.addWalOptions(builder, walOptionsOffset);
+    FlatStoreOptions.addBackupRestoreFlags(builder, backupRestoreFlags);
+    FlatStoreOptions.addBackupFile(builder, backupFileOffset);
     FlatStoreOptions.addDebugFlags(builder, debugFlags);
     FlatStoreOptions.addMaxReaders(builder, maxReaders);
     FlatStoreOptions.addFileMode(builder, fileMode);
     FlatStoreOptions.addModelBytes(builder, modelBytesOffset);
     FlatStoreOptions.addDirectoryPath(builder, directoryPathOffset);
+    FlatStoreOptions.addValidateOnOpenKv(builder, validateOnOpenKv);
     FlatStoreOptions.addPutPaddingMode(builder, putPaddingMode);
-    FlatStoreOptions.addValidateOnOpen(builder, validateOnOpen);
+    FlatStoreOptions.addValidateOnOpenPages(builder, validateOnOpenPages);
     FlatStoreOptions.addNoReaderThreadLocals(builder, noReaderThreadLocals);
     FlatStoreOptions.addReadOnly(builder, readOnly);
     FlatStoreOptions.addUsePreviousCommitOnValidationFailure(builder, usePreviousCommitOnValidationFailure);
@@ -169,16 +229,16 @@ public static int createFlatStoreOptions(FlatBufferBuilder builder,
     return FlatStoreOptions.endFlatStoreOptions(builder);
   }
 
-  public static void startFlatStoreOptions(FlatBufferBuilder builder) { builder.startTable(14); }
+  public static void startFlatStoreOptions(FlatBufferBuilder builder) { builder.startTable(19); }
   public static void addDirectoryPath(FlatBufferBuilder builder, int directoryPathOffset) { builder.addOffset(0, directoryPathOffset, 0); }
   public static void addModelBytes(FlatBufferBuilder builder, int modelBytesOffset) { builder.addOffset(1, modelBytesOffset, 0); }
   public static int createModelBytesVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
   public static int createModelBytesVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
   public static void startModelBytesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
-  public static void addMaxDbSizeInKByte(FlatBufferBuilder builder, long maxDbSizeInKByte) { builder.addLong(2, maxDbSizeInKByte, 0L); }
+  public static void addMaxDbSizeInKbyte(FlatBufferBuilder builder, long maxDbSizeInKbyte) { builder.addLong(2, maxDbSizeInKbyte, 0L); }
   public static void addFileMode(FlatBufferBuilder builder, long fileMode) { builder.addInt(3, (int) fileMode, (int) 0L); }
   public static void addMaxReaders(FlatBufferBuilder builder, long maxReaders) { builder.addInt(4, (int) maxReaders, (int) 0L); }
-  public static void addValidateOnOpen(FlatBufferBuilder builder, int validateOnOpen) { builder.addShort(5, (short) validateOnOpen, (short) 0); }
+  public static void addValidateOnOpenPages(FlatBufferBuilder builder, int validateOnOpenPages) { builder.addShort(5, (short) validateOnOpenPages, (short) 0); }
   public static void addValidateOnOpenPageLimit(FlatBufferBuilder builder, long validateOnOpenPageLimit) { builder.addLong(6, validateOnOpenPageLimit, 0L); }
   public static void addPutPaddingMode(FlatBufferBuilder builder, int putPaddingMode) { builder.addShort(7, (short) putPaddingMode, (short) 0); }
   public static void addSkipReadSchema(FlatBufferBuilder builder, boolean skipReadSchema) { builder.addBoolean(8, skipReadSchema, false); }
@@ -187,6 +247,11 @@ public static int createFlatStoreOptions(FlatBufferBuilder builder,
   public static void addReadOnly(FlatBufferBuilder builder, boolean readOnly) { builder.addBoolean(11, readOnly, false); }
   public static void addDebugFlags(FlatBufferBuilder builder, long debugFlags) { builder.addInt(12, (int) debugFlags, (int) 0L); }
   public static void addNoReaderThreadLocals(FlatBufferBuilder builder, boolean noReaderThreadLocals) { builder.addBoolean(13, noReaderThreadLocals, false); }
+  public static void addMaxDataSizeInKbyte(FlatBufferBuilder builder, long maxDataSizeInKbyte) { builder.addLong(14, maxDataSizeInKbyte, 0L); }
+  public static void addValidateOnOpenKv(FlatBufferBuilder builder, int validateOnOpenKv) { builder.addShort(15, (short) validateOnOpenKv, (short) 0); }
+  public static void addBackupFile(FlatBufferBuilder builder, int backupFileOffset) { builder.addOffset(16, backupFileOffset, 0); }
+  public static void addBackupRestoreFlags(FlatBufferBuilder builder, long backupRestoreFlags) { builder.addInt(17, (int) backupRestoreFlags, (int) 0L); }
+  public static void addWalOptions(FlatBufferBuilder builder, int walOptionsOffset) { builder.addOffset(18, walOptionsOffset, 0); }
   public static int endFlatStoreOptions(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
diff --git a/objectbox-java/src/main/java/io/objectbox/config/TreeOptionFlags.java b/objectbox-java/src/main/java/io/objectbox/config/TreeOptionFlags.java
new file mode 100644
index 00000000..5b2bee91
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/TreeOptionFlags.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+/**
+ * Options flags for trees.
+ */
+@SuppressWarnings("unused")
+public final class TreeOptionFlags {
+  private TreeOptionFlags() { }
+  /**
+   * If true, debug logs are always disabled for this tree regardless of the store's debug flags.
+   */
+  public static final int DebugLogsDisable = 1;
+  /**
+   * If true, debug logs are always enabled for this tree regardless of the store's debug flags.
+   */
+  public static final int DebugLogsEnable = 2;
+  /**
+   * By default, a path such as "a/b/c" can address a branch and a leaf at the same time.
+   * E.g. under the common parent path "a/b", a branch "c" and a "c" leaf may exist.
+   * To disable this, set this flag to true.
+   * This will enable an additional check when inserting new leafs and new branches for the existence of the other.
+   */
+  public static final int EnforceUniquePath = 4;
+  /**
+   * In some scenarios, e.g. when using Sync, multiple node objects of the same type (e.g. branch or leaf) at the
+   * same path may exist temporarily. By enabling this flag, this is not considered an error situation. Instead, the
+   * first node is picked.
+   */
+  public static final int AllowNonUniqueNodes = 8;
+  /**
+   * Nodes described in AllowNonUniqueNodes will be automatically detected to consolidate them (manually).
+   */
+  public static final int DetectNonUniqueNodes = 16;
+  /**
+   * Nodes described in AllowNonUniqueNodes will be automatically consolidated to make them unique.
+   * This consolidation happens e.g. on put/remove operations.
+   * Using this value implies DetectNonUniqueNodes.
+   */
+  public static final int AutoConsolidateNonUniqueNodes = 32;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModeKv.java b/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModeKv.java
new file mode 100644
index 00000000..9ff9a989
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModeKv.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+/**
+ * Defines if and how the database is checked for valid key/value (KV) entries when opening it.
+ */
+@SuppressWarnings("unused")
+public final class ValidateOnOpenModeKv {
+  private ValidateOnOpenModeKv() { }
+  /**
+   * Not a real type, just best practice (e.g. forward compatibility).
+   */
+  public static final short Unknown = 0;
+  /**
+   * Performs standard checks.
+   */
+  public static final short Regular = 1;
+
+  public static final String[] names = { "Unknown", "Regular", };
+
+  public static String name(int e) { return names[e]; }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/model/ValidateOnOpenMode.java b/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModePages.java
similarity index 90%
rename from objectbox-java/src/main/java/io/objectbox/model/ValidateOnOpenMode.java
rename to objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModePages.java
index c55594cd..6f191104 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/ValidateOnOpenMode.java
+++ b/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModePages.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,14 +16,14 @@
 
 // automatically generated by the FlatBuffers compiler, do not modify
 
-package io.objectbox.model;
+package io.objectbox.config;
 
 /**
- * Defines if and how the database is checked for structural consistency when opening it.
+ * Defines if and how the database is checked for structural consistency (pages) when opening it.
  */
 @SuppressWarnings("unused")
-public final class ValidateOnOpenMode {
-  private ValidateOnOpenMode() { }
+public final class ValidateOnOpenModePages {
+  private ValidateOnOpenModePages() { }
   /**
    * Not a real type, just best practice (e.g. forward compatibility)
    */
diff --git a/objectbox-java/src/main/java/io/objectbox/config/WalFlags.java b/objectbox-java/src/main/java/io/objectbox/config/WalFlags.java
new file mode 100644
index 00000000..c867a299
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/WalFlags.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+/**
+ * WAL flags control how the store handles WAL files.
+ */
+@SuppressWarnings("unused")
+public final class WalFlags {
+  private WalFlags() { }
+  /**
+   * Enable WAL
+   */
+  public static final int EnableWal = 1;
+  /**
+   * Does not wait for the disk to acknowledge
+   */
+  public static final int NoFileSync = 2;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/config/WalOptions.java b/objectbox-java/src/main/java/io/objectbox/config/WalOptions.java
new file mode 100644
index 00000000..ce637943
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/WalOptions.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.Table;
+
+/**
+ * Options to enable and configure WAL.
+ */
+@SuppressWarnings("unused")
+public final class WalOptions extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static WalOptions getRootAsWalOptions(ByteBuffer _bb) { return getRootAsWalOptions(_bb, new WalOptions()); }
+  public static WalOptions getRootAsWalOptions(ByteBuffer _bb, WalOptions obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public WalOptions __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /**
+   * Flags to enable and change default WAL behavior, e.g. no sync to disk option.
+   */
+  public long walFlags() { int o = __offset(4); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * The WAL file gets consolidated when it reached this size limit when opening the database.
+   * This setting is meant for applications that prefer to consolidate on startup,
+   * which may avoid consolidations on commits while the application is running.
+   * The default is 4096 (4 MB).
+   */
+  public long maxWalFileSizeOnOpenInKbyte() { int o = __offset(6); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * The WAL file gets consolidated when it reaches this size limit after a commit.
+   * As consolidation takes some time, it is a trade-off between accumulating enough data
+   * and the time the consolidation takes (longer with more data).
+   * The default is 16384 (16 MB).
+   */
+  public long maxWalFileSizeInKbyte() { int o = __offset(8); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+
+  public static int createWalOptions(FlatBufferBuilder builder,
+      long walFlags,
+      long maxWalFileSizeOnOpenInKbyte,
+      long maxWalFileSizeInKbyte) {
+    builder.startTable(3);
+    WalOptions.addMaxWalFileSizeInKbyte(builder, maxWalFileSizeInKbyte);
+    WalOptions.addMaxWalFileSizeOnOpenInKbyte(builder, maxWalFileSizeOnOpenInKbyte);
+    WalOptions.addWalFlags(builder, walFlags);
+    return WalOptions.endWalOptions(builder);
+  }
+
+  public static void startWalOptions(FlatBufferBuilder builder) { builder.startTable(3); }
+  public static void addWalFlags(FlatBufferBuilder builder, long walFlags) { builder.addInt(0, (int) walFlags, (int) 0L); }
+  public static void addMaxWalFileSizeOnOpenInKbyte(FlatBufferBuilder builder, long maxWalFileSizeOnOpenInKbyte) { builder.addLong(1, maxWalFileSizeOnOpenInKbyte, 0L); }
+  public static void addMaxWalFileSizeInKbyte(FlatBufferBuilder builder, long maxWalFileSizeInKbyte) { builder.addLong(2, maxWalFileSizeInKbyte, 0L); }
+  public static int endWalOptions(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public WalOptions get(int j) { return get(new WalOptions(), j); }
+    public WalOptions get(WalOptions obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/FlexObjectConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/FlexObjectConverter.java
index 9fc8d97d..45c3f363 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/FlexObjectConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/FlexObjectConverter.java
@@ -1,8 +1,20 @@
-package io.objectbox.converter;
+/*
+ * Copyright 2021-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-import io.objectbox.flatbuffers.ArrayReadWriteBuf;
-import io.objectbox.flatbuffers.FlexBuffers;
-import io.objectbox.flatbuffers.FlexBuffersBuilder;
+package io.objectbox.converter;
 
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
@@ -12,6 +24,10 @@
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
 
+import io.objectbox.flatbuffers.ArrayReadWriteBuf;
+import io.objectbox.flatbuffers.FlexBuffers;
+import io.objectbox.flatbuffers.FlexBuffersBuilder;
+
 /**
  * Converts between {@link Object} properties and byte arrays using FlexBuffers.
  * <p>
@@ -110,12 +126,14 @@ private void addMap(FlexBuffersBuilder builder, String mapKey, Map<Object, Objec
         for (Map.Entry<Object, Object> entry : map.entrySet()) {
             Object rawKey = entry.getKey();
             Object value = entry.getValue();
-            if (rawKey == null || value == null) {
-                throw new IllegalArgumentException("Map keys or values must not be null");
+            if (rawKey == null) {
+                throw new IllegalArgumentException("Map keys must not be null");
             }
             checkMapKeyType(rawKey);
             String key = rawKey.toString();
-            if (value instanceof Map) {
+            if (value == null) {
+                builder.putNull(key);
+            } else if (value instanceof Map) {
                 //noinspection unchecked
                 addMap(builder, key, (Map<Object, Object>) value);
             } else if (value instanceof List) {
@@ -155,9 +173,8 @@ private void addVector(FlexBuffersBuilder builder, String vectorKey, List<Object
 
         for (Object item : list) {
             if (item == null) {
-                throw new IllegalArgumentException("List elements must not be null");
-            }
-            if (item instanceof Map) {
+                builder.putNull();
+            } else if (item instanceof Map) {
                 //noinspection unchecked
                 addMap(builder, null, (Map<Object, Object>) item);
             } else if (item instanceof List) {
@@ -197,7 +214,9 @@ public Object convertToEntityProperty(byte[] databaseValue) {
         if (databaseValue == null) return null;
 
         FlexBuffers.Reference value = FlexBuffers.getRoot(new ArrayReadWriteBuf(databaseValue, databaseValue.length));
-        if (value.isMap()) {
+        if (value.isNull()) {
+            return null;
+        } else if (value.isMap()) {
             return buildMap(value.asMap());
         } else if (value.isVector()) {
             return buildList(value.asVector());
@@ -261,7 +280,9 @@ private Map<Object, Object> buildMap(FlexBuffers.Map map) {
             String rawKey = keys.get(i).toString();
             Object key = convertToKey(rawKey);
             FlexBuffers.Reference value = values.get(i);
-            if (value.isMap()) {
+            if (value.isNull()) {
+                resultMap.put(key, null);
+            } else if (value.isMap()) {
                 resultMap.put(key, buildMap(value.asMap()));
             } else if (value.isVector()) {
                 resultMap.put(key, buildList(value.asVector()));
@@ -298,7 +319,9 @@ private List<Object> buildList(FlexBuffers.Vector vector) {
 
         for (int i = 0; i < itemCount; i++) {
             FlexBuffers.Reference item = vector.get(i);
-            if (item.isMap()) {
+            if (item.isNull()) {
+                list.add(null);
+            } else if (item.isMap()) {
                 list.add(buildMap(item.asMap()));
             } else if (item.isVector()) {
                 list.add(buildList(item.asVector()));
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/IntegerFlexMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/IntegerFlexMapConverter.java
index 8a605fad..04707ffd 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/IntegerFlexMapConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/IntegerFlexMapConverter.java
@@ -1,7 +1,25 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 /**
- * Used to automatically convert {@code Map&lt;Integer, V&gt;}.
+ * A {@link FlexObjectConverter} that uses {@link Integer} as map keys.
+ * <p>
+ * Used by default to convert {@code Map<Integer, V>}.
  */
 public class IntegerFlexMapConverter extends FlexObjectConverter {
 
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/IntegerLongMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/IntegerLongMapConverter.java
index eb447576..17b40518 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/IntegerLongMapConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/IntegerLongMapConverter.java
@@ -1,11 +1,27 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 import io.objectbox.flatbuffers.FlexBuffers;
 
 /**
- * Used to automatically convert {@code Map&lt;Integer, Long&gt;}.
+ * Like {@link IntegerFlexMapConverter}, but always restores integer map values as {@link Long}.
  * <p>
- * Unlike {@link FlexObjectConverter} always restores integer map values as {@link Long}.
+ * Used by default to convert {@code Map<Integer, Long>}.
  */
 public class IntegerLongMapConverter extends IntegerFlexMapConverter {
     @Override
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/LongFlexMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/LongFlexMapConverter.java
index 053045d1..d897ecce 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/LongFlexMapConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/LongFlexMapConverter.java
@@ -1,7 +1,25 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 /**
- * Used to automatically convert {@code Map<Long, V>}.
+ * A {@link FlexObjectConverter} that uses {@link Long} as map keys.
+ * <p>
+ * Used by default to convert {@code Map<Long, V>}.
  */
 public class LongFlexMapConverter extends FlexObjectConverter {
 
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/LongLongMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/LongLongMapConverter.java
index fe042787..e11f8dba 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/LongLongMapConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/LongLongMapConverter.java
@@ -1,11 +1,27 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 import io.objectbox.flatbuffers.FlexBuffers;
 
 /**
- * Used to automatically convert {@code Map&lt;Long, Long&gt;}.
+ * Like {@link LongFlexMapConverter}, but always restores integer map values as {@link Long}.
  * <p>
- * Unlike {@link FlexObjectConverter} always restores integer map values as {@link Long}.
+ * Used by default to convert {@code Map<Long, Long>}.
  */
 public class LongLongMapConverter extends LongFlexMapConverter {
     @Override
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/NullToEmptyStringConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/NullToEmptyStringConverter.java
index 1f8873fd..df0bcbff 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/NullToEmptyStringConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/NullToEmptyStringConverter.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 import javax.annotation.Nullable;
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/StringFlexMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/StringFlexMapConverter.java
index 7db9893a..01229760 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/StringFlexMapConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/StringFlexMapConverter.java
@@ -1,7 +1,25 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 /**
- * Used to automatically convert {@code Map&lt;String, V&gt;}.
+ * A {@link FlexObjectConverter}.
+ * <p>
+ * Used by default to convert {@code Map<String, V>}.
  */
 public class StringFlexMapConverter extends FlexObjectConverter {
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/StringLongMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/StringLongMapConverter.java
index 2c38708c..c1347071 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/StringLongMapConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/StringLongMapConverter.java
@@ -1,9 +1,27 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 import io.objectbox.flatbuffers.FlexBuffers;
 
 /**
- * Used to automatically convert {@code Map&lt;String, Long&gt;}.
+ * Like {@link StringFlexMapConverter}, but always restores integer map values as {@link Long}.
+ * <p>
+ * Used by default to convert {@code Map<String, Long>}.
  */
 public class StringLongMapConverter extends StringFlexMapConverter {
     @Override
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/StringMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/StringMapConverter.java
index d5397a53..0fab3d26 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/StringMapConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/StringMapConverter.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020-2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 import io.objectbox.flatbuffers.ArrayReadWriteBuf;
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/ConstraintViolationException.java b/objectbox-java/src/main/java/io/objectbox/exception/ConstraintViolationException.java
index 29088db7..3fe5b2c7 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/ConstraintViolationException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/ConstraintViolationException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbDetachedException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbDetachedException.java
index 65b47dba..066ab5e7 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbDetachedException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbDetachedException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,11 +16,23 @@
 
 package io.objectbox.exception;
 
+/**
+ * This exception occurs while working with a {@link io.objectbox.relation.ToMany ToMany} or
+ * {@link io.objectbox.relation.ToOne ToOne} of an object and the object is not attached to a
+ * {@link io.objectbox.Box Box} (technically a {@link io.objectbox.BoxStore BoxStore}).
+ * <p>
+ * If your code uses <a href="https://docs.objectbox.io/advanced/object-ids#self-assigned-object-ids">manually assigned
+ * IDs</a> make sure it takes care of some things that ObjectBox would normally do by itself. This includes
+ * {@link io.objectbox.Box#attach(Object) attaching} the Box to an object before modifying a ToMany.
+ * <p>
+ * Also see the documentation about <a href="https://docs.objectbox.io/relations#updating-relations">Updating
+ * Relations</a> and <a href="https://docs.objectbox.io/advanced/object-ids#self-assigned-object-ids">manually assigned
+ * IDs</a> for details.
+ */
 public class DbDetachedException extends DbException {
 
     public DbDetachedException() {
-        this("Cannot perform this action on a detached entity. " +
-                "Ensure it was loaded by ObjectBox, or attach it manually.");
+        this("Entity must be attached to a Box.");
     }
 
     public DbDetachedException(String message) {
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbException.java
index f1cd7967..7ec46060 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbExceptionListener.java b/objectbox-java/src/main/java/io/objectbox/exception/DbExceptionListener.java
index 1a77c5fb..0c72d6b1 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbExceptionListener.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbExceptionListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018-2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2018-2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbFullException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbFullException.java
index 5b0da063..8aa7c2c3 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbFullException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbFullException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,13 @@
 
 package io.objectbox.exception;
 
+/**
+ * Thrown when applying a database operation would exceed the (default)
+ * {@link io.objectbox.BoxStoreBuilder#maxSizeInKByte(long) maxSizeInKByte} configured for the Store.
+ * <p>
+ * This can occur for operations like when an Object is {@link io.objectbox.Box#put(Object) put}, at the point when the
+ * (internal) transaction is committed. Or when the Store is opened with a max size too small for the existing database.
+ */
 public class DbFullException extends DbException {
     public DbFullException(String message) {
         super(message);
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbMaxDataSizeExceededException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbMaxDataSizeExceededException.java
new file mode 100644
index 00000000..a0f5ac16
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbMaxDataSizeExceededException.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.exception;
+
+/**
+ * Thrown when applying a transaction would exceed the {@link io.objectbox.BoxStoreBuilder#maxDataSizeInKByte(long) maxDataSizeInKByte}
+ * configured for the store.
+ */
+public class DbMaxDataSizeExceededException extends DbException {
+    public DbMaxDataSizeExceededException(String message) {
+        super(message);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbMaxReadersExceededException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbMaxReadersExceededException.java
index d3587778..98bcc062 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbMaxReadersExceededException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbMaxReadersExceededException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,9 +21,9 @@
 
 /**
  * Thrown when the maximum of readers (read transactions) was exceeded.
- * Verify that you run a reasonable amount of threads only.
+ * Verify that your code only uses a reasonable amount of threads.
  * <p>
- * If you intend to work with a very high number of threads (&gt;100), consider increasing the number of maximum readers
+ * If a very high number of threads (&gt;100) needs to be used, consider increasing the number of maximum readers
  * using {@link BoxStoreBuilder#maxReaders(int)} and enabling query retries using
  * {@link BoxStoreBuilder#queryAttempts(int)}.
  * <p>
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbSchemaException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbSchemaException.java
index a337915e..0b8778c0 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbSchemaException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbSchemaException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,15 @@
 
 package io.objectbox.exception;
 
+/**
+ * Thrown when there is an error with the data schema (data model).
+ * <p>
+ * Typically, there is a conflict between the data model defined in your code (using {@link io.objectbox.annotation.Entity @Entity}
+ * classes) and the data model of the existing database file.
+ * <p>
+ * Read the <a href="https://docs.objectbox.io/advanced/meta-model-ids-and-uids#resolving-meta-model-conflicts">meta model docs</a>
+ * on why this can happen and how to resolve such conflicts.
+ */
 public class DbSchemaException extends DbException {
     public DbSchemaException(String message) {
         super(message);
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbShutdownException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbShutdownException.java
index 3cf4b69e..6b06895c 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbShutdownException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbShutdownException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,10 +17,10 @@
 package io.objectbox.exception;
 
 /**
- * Thrown when an error occurred that requires the DB to shutdown.
- * This may be an I/O error for example.
- * Regular operations won't be possible anymore.
- * To handle that situation you could exit the app or try to reopen the store.
+ * Thrown when an error occurred that requires the store to be closed.
+ * <p>
+ * This may be an I/O error. Regular operations won't be possible.
+ * To handle this exit the app or try to reopen the store.
  */
 public class DbShutdownException extends DbException {
     public DbShutdownException(String message) {
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/FeatureNotAvailableException.java b/objectbox-java/src/main/java/io/objectbox/exception/FeatureNotAvailableException.java
new file mode 100644
index 00000000..cb87a23a
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/exception/FeatureNotAvailableException.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.exception;
+
+/**
+ * Thrown when a special feature was used, which is not part of the native library.
+ * <p>
+ * This typically indicates a developer error. Check that the correct dependencies for the native ObjectBox library are
+ * included.
+ */
+public class FeatureNotAvailableException extends DbException {
+
+    // Note: this constructor is called by JNI, check before modifying/removing it.
+    public FeatureNotAvailableException(String message) {
+        super(message);
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/FileCorruptException.java b/objectbox-java/src/main/java/io/objectbox/exception/FileCorruptException.java
index 14c018e5..076e1117 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/FileCorruptException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/FileCorruptException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,14 @@
  */
 package io.objectbox.exception;
 
-/** Errors were detected in a file, e.g. illegal values or structural inconsistencies. */
+import io.objectbox.BoxStoreBuilder;
+
+/**
+ * Errors were detected in a database file, e.g. illegal values or structural inconsistencies.
+ * <p>
+ * It may be possible to re-open the store with {@link BoxStoreBuilder#usePreviousCommit()} to restore
+ * to a working state.
+ */
 public class FileCorruptException extends DbException {
     public FileCorruptException(String message) {
         super(message);
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/NonUniqueResultException.java b/objectbox-java/src/main/java/io/objectbox/exception/NonUniqueResultException.java
index 4eb4dbdf..c2f4f49c 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/NonUniqueResultException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/NonUniqueResultException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2018 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,11 @@
 
 package io.objectbox.exception;
 
-/** Throw if {@link io.objectbox.query.Query#findUnique()} returns more than one result. */
+/**
+ * Thrown if {@link io.objectbox.query.Query#findUnique() Query.findUnique()} or
+ * {@link io.objectbox.query.Query#findUniqueId() Query.findUniqueId()} is called,
+ * but the query matches more than one object.
+ */
 public class NonUniqueResultException extends DbException {
     public NonUniqueResultException(String message) {
         super(message);
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/NumericOverflowException.java b/objectbox-java/src/main/java/io/objectbox/exception/NumericOverflowException.java
index 8ab0c395..7a283dcc 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/NumericOverflowException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/NumericOverflowException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/PagesCorruptException.java b/objectbox-java/src/main/java/io/objectbox/exception/PagesCorruptException.java
index dae73f35..bcc2474f 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/PagesCorruptException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/PagesCorruptException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,9 @@
  */
 package io.objectbox.exception;
 
-/** Errors were detected in a file related to pages, e.g. illegal values or structural inconsistencies. */
+/**
+ * Errors related to pages were detected in a database file, e.g. bad page refs outside of the file.
+ */
 public class PagesCorruptException extends FileCorruptException {
     public PagesCorruptException(String message) {
         super(message);
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/UniqueViolationException.java b/objectbox-java/src/main/java/io/objectbox/exception/UniqueViolationException.java
index 023bbbac..ec0f2b37 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/UniqueViolationException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/UniqueViolationException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2018 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/package-info.java b/objectbox-java/src/main/java/io/objectbox/exception/package-info.java
index c389e4c5..ed0d08d0 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/Constants.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Constants.java
index 7112d110..dc2949a5 100644
--- a/objectbox-java/src/main/java/io/objectbox/flatbuffers/Constants.java
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Constants.java
@@ -46,7 +46,7 @@ public class Constants {
     Changes to the Java implementation need to be sure to change
     the version here and in the code generator on every possible
     incompatible change */
-    public static void FLATBUFFERS_2_0_8() {}
+    public static void FLATBUFFERS_23_5_26() {}
 }
 
 /// @endcond
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffersBuilder.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffersBuilder.java
index 63e1d245..010afccc 100644
--- a/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffersBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffersBuilder.java
@@ -173,6 +173,21 @@ public ReadWriteBuf getBuffer() {
         return bb;
     }
 
+    /**
+     * Insert a null value into the buffer
+     */
+    public void putNull() {
+        putNull(null);
+    }
+
+    /**
+     * Insert a null value into the buffer
+     * @param key key used to store element in map
+     */
+    public void putNull(String key) {
+        stack.add(Value.nullValue(putKey(key)));
+    }
+
     /**
      * Insert a single boolean into the buffer
      * @param val true or false
@@ -502,7 +517,9 @@ public ByteBuffer finish() {
      * @return Value representing the created vector
      */
     private Value createVector(int key, int start, int length, boolean typed, boolean fixed, Value keys) {
-        assert (!fixed || typed); // typed=false, fixed=true combination is not supported.
+        if (fixed & !typed)
+            throw new UnsupportedOperationException("Untyped fixed vector is not supported");
+
         // Figure out smallest bit width we can store this vector with.
         int bitWidth = Math.max(WIDTH_8, widthUInBits(length));
         int prefixElems = 1;
@@ -673,6 +690,10 @@ private static class Value {
             this.iValue = Long.MIN_VALUE;
         }
 
+        static Value nullValue(int key) {
+            return new Value(key, FBT_NULL, WIDTH_8, 0);
+        }
+
         static Value bool(int key, boolean b) {
             return new Value(key, FBT_BOOL, WIDTH_8, b ? 1 : 0);
         }
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/README.md b/objectbox-java/src/main/java/io/objectbox/flatbuffers/README.md
index 91ee6107..90455638 100644
--- a/objectbox-java/src/main/java/io/objectbox/flatbuffers/README.md
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/README.md
@@ -3,7 +3,7 @@
 This is a copy of the [FlatBuffers](https://github.com/google/flatbuffers) for Java source code in a custom package
 to avoid conflicts with FlatBuffers generated Java code from users of this library.
 
-Current version: `2.0.8` (Note: version in `Constants.java` may be lower).
+Current version: `23.5.26` (Note: version in `Constants.java` may be lower).
 
 Copy a different version using the script in `scripts\update-flatbuffers.sh`.
 It expects FlatBuffers source files in the `../flatbuffers` directory (e.g. check out
diff --git a/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelModifier.java b/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelModifier.java
index b25ab938..239195ce 100644
--- a/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelModifier.java
+++ b/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelModifier.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,7 +35,7 @@ public void remove() {
         }
 
         public PropertyModifier property(String name) {
-            return  new PropertyModifier(this, name);
+            return new PropertyModifier(this, name);
         }
     }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelUpdate.java b/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelUpdate.java
index 6a1d3213..3ff925c8 100644
--- a/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelUpdate.java
+++ b/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelUpdate.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/CallWithHandle.java b/objectbox-java/src/main/java/io/objectbox/internal/CallWithHandle.java
index 9069dd8a..ee8edbbd 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/CallWithHandle.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/CallWithHandle.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/CursorFactory.java b/objectbox-java/src/main/java/io/objectbox/internal/CursorFactory.java
index e1f094e5..a564af5e 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/CursorFactory.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/CursorFactory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/DebugCursor.java b/objectbox-java/src/main/java/io/objectbox/internal/DebugCursor.java
index dd53dbd0..df0fd3db 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/DebugCursor.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/DebugCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42,7 +42,7 @@ public class DebugCursor implements Closeable {
     public static DebugCursor create(Transaction tx) {
         long txHandle = InternalAccess.getHandle(tx);
         long handle = nativeCreate(txHandle);
-        if(handle == 0) throw new DbException("Could not create native debug cursor");
+        if (handle == 0) throw new DbException("Could not create native debug cursor");
         return new DebugCursor(tx, handle);
     }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/Feature.java b/objectbox-java/src/main/java/io/objectbox/internal/Feature.java
index 99ca6f67..48fd3544 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/Feature.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/Feature.java
@@ -11,7 +11,7 @@ public enum Feature {
     /** TimeSeries support (date/date-nano companion ID and other time-series functionality). */
     TIME_SERIES(2),
 
-     /** Sync client availability. Visit <a href="https://objectbox.io/sync">the ObjectBox Sync website</a> for more details. */
+    /** Sync client availability. Visit <a href="https://objectbox.io/sync">the ObjectBox Sync website</a> for more details. */
     SYNC(3),
 
     /** Check whether debug log can be enabled during runtime. */
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/IdGetter.java b/objectbox-java/src/main/java/io/objectbox/internal/IdGetter.java
index 36c0e5eb..a2bb6568 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/IdGetter.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/IdGetter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/JniTest.java b/objectbox-java/src/main/java/io/objectbox/internal/JniTest.java
index af6df829..6da9649a 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/JniTest.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/JniTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryLoader.java b/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryLoader.java
index b7373ced..8288a1d4 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryLoader.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryLoader.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,11 +16,6 @@
 
 package io.objectbox.internal;
 
-import io.objectbox.BoxStore;
-import org.greenrobot.essentials.io.IoUtils;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
@@ -35,8 +30,15 @@
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLConnection;
+import java.nio.charset.Charset;
 import java.util.Arrays;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import io.objectbox.BoxStore;
+import org.greenrobot.essentials.io.IoUtils;
+
 /**
  * Separate class, so we can mock BoxStore.
  */
@@ -162,7 +164,7 @@ private static String getCpuArch() {
                         String cpuArchOS = cpuArchOSOrNull.toLowerCase();
                         if (cpuArchOS.startsWith("armv7")) {
                             cpuArch = "armv7";
-                        } else if (cpuArchOS.startsWith("armv6")){
+                        } else if (cpuArchOS.startsWith("armv6")) {
                             cpuArch = "armv6";
                         } // else use fall back below.
                     } // else use fall back below.
@@ -202,7 +204,8 @@ private static String getCpuArchOSOrNull() {
         try {
             // Linux
             Process exec = Runtime.getRuntime().exec("uname -m");
-            BufferedReader reader = new BufferedReader(new InputStreamReader(exec.getInputStream()));
+            BufferedReader reader = new BufferedReader(
+                    new InputStreamReader(exec.getInputStream(), Charset.defaultCharset()));
             archOrNull = reader.readLine();
             reader.close();
         } catch (Exception ignored) {
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryUtils.java b/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryUtils.java
new file mode 100644
index 00000000..0dcc5145
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryUtils.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.internal;
+
+
+import io.objectbox.BoxStore;
+import io.objectbox.exception.FeatureNotAvailableException;
+
+/**
+ * Provides utility methods related to the platform-specific database library.
+ */
+public class NativeLibraryUtils {
+
+    private static final String FEATURE_NOT_AVAIL_TEMPLATE =
+            "The included ObjectBox database library does not include the %s feature." +
+                    " Please visit %s for options.";
+    private static final String URL_SYNC_LANDING_PAGE = "https://objectbox.io/sync/";
+
+    private NativeLibraryUtils() {
+    }
+
+    /**
+     * If {@link BoxStore#hasFeature(Feature)} returns false, throws a
+     * {@link FeatureNotAvailableException} with a unified, helpful message.
+     *
+     * @param feature the feature to check for
+     * @param featureName a user-friendly name for the feature to use in the message
+     * @param infoUrl the URL where the user can learn about options to get that feature
+     */
+    private static void checkHasFeature(Feature feature, String featureName, String infoUrl)
+            throws FeatureNotAvailableException {
+        if (!BoxStore.hasFeature(feature)) {
+            throw new FeatureNotAvailableException(
+                    String.format(FEATURE_NOT_AVAIL_TEMPLATE, featureName, infoUrl));
+        }
+    }
+
+    /**
+     * Calls {@link #checkHasFeature} with {@link Feature#SYNC}.
+     */
+    public static void checkHasFeature() {
+        checkHasFeature(Feature.SYNC, "Sync", URL_SYNC_LANDING_PAGE);
+    }
+
+    /**
+     * Calls {@link #checkHasFeature} with {@link Feature#SYNC_SERVER}.
+     */
+    public static void checkHasSyncServerFeature() {
+        checkHasFeature(Feature.SYNC_SERVER, "Sync Server", URL_SYNC_LANDING_PAGE);
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/ObjectBoxThreadPool.java b/objectbox-java/src/main/java/io/objectbox/internal/ObjectBoxThreadPool.java
index 41b2ccdd..29bafec2 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/ObjectBoxThreadPool.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/ObjectBoxThreadPool.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,10 +33,11 @@
  *     <li>Reduce keep-alive time for threads to 20 seconds</li>
  *     <li>Uses a ThreadFactory to name threads like "ObjectBox-1-Thread-1"</li>
  * </ul>
- *
  */
 @Internal
 public class ObjectBoxThreadPool extends ThreadPoolExecutor {
+
+    public static final String THREAD_NAME_PREFIX = "ObjectBox-";
     private final BoxStore boxStore;
 
     public ObjectBoxThreadPool(BoxStore boxStore) {
@@ -55,7 +56,7 @@ static class ObjectBoxThreadFactory implements ThreadFactory {
         private static final AtomicInteger POOL_COUNT = new AtomicInteger();
 
         private final ThreadGroup group;
-        private final String namePrefix = "ObjectBox-" + POOL_COUNT.incrementAndGet() + "-Thread-";
+        private final String namePrefix = THREAD_NAME_PREFIX + POOL_COUNT.incrementAndGet() + "-Thread-";
         private final AtomicInteger threadCount = new AtomicInteger();
 
         ObjectBoxThreadFactory() {
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/ReflectionCache.java b/objectbox-java/src/main/java/io/objectbox/internal/ReflectionCache.java
index 3176431c..36ad79b2 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/ReflectionCache.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/ReflectionCache.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/ToManyGetter.java b/objectbox-java/src/main/java/io/objectbox/internal/ToManyGetter.java
index 8eb29102..8038f741 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/ToManyGetter.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/ToManyGetter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,6 @@
 import io.objectbox.annotation.apihint.Internal;
 
 @Internal
-public interface ToManyGetter<SOURCE> extends Serializable {
-    <TARGET> List<TARGET> getToMany(SOURCE object);
+public interface ToManyGetter<SOURCE, TARGET> extends Serializable {
+    List<TARGET> getToMany(SOURCE object);
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/ToOneGetter.java b/objectbox-java/src/main/java/io/objectbox/internal/ToOneGetter.java
index 51c70e5c..e435171e 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/ToOneGetter.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/ToOneGetter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,6 @@
 import io.objectbox.relation.ToOne;
 
 @Internal
-public interface ToOneGetter<SOURCE> extends Serializable {
-    <TARGET> ToOne<TARGET> getToOne(SOURCE object);
+public interface ToOneGetter<SOURCE, TARGET> extends Serializable {
+    ToOne<TARGET> getToOne(SOURCE object);
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/package-info.java b/objectbox-java/src/main/java/io/objectbox/internal/package-info.java
index b77731f3..4ac0203a 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/model/EntityFlags.java b/objectbox-java/src/main/java/io/objectbox/model/EntityFlags.java
index f6e9883f..3c0b3201 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/EntityFlags.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/EntityFlags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/model/ExternalPropertyType.java b/objectbox-java/src/main/java/io/objectbox/model/ExternalPropertyType.java
new file mode 100644
index 00000000..583b58ef
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/model/ExternalPropertyType.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.model;
+
+/**
+ * A property type of an external system (e.g. another database) that has no default mapping to an ObjectBox type.
+ * External property types numeric values start at 100 to avoid overlaps with ObjectBox's PropertyType.
+ * (And if we ever support one of these as a primary type, we could share the numeric value?)
+ */
+@SuppressWarnings("unused")
+public final class ExternalPropertyType {
+  private ExternalPropertyType() { }
+  /**
+   * Not a real type: represents uninitialized state and can be used for forward compatibility.
+   */
+  public static final short Unknown = 0;
+  /**
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation, little endian (16 bytes)
+   */
+  public static final short Int128 = 100;
+  public static final short Reserved1 = 101;
+  /**
+   * A UUID (Universally Unique Identifier) as defined by RFC 9562.
+   * ObjectBox uses the UUIDv7 scheme (timestamp + random) to create new UUIDs.
+   * UUIDv7 is a good choice for database keys as it's mostly sequential and encodes a timestamp.
+   * However, if keys are used externally, consider UuidV4 for better privacy by not exposing any time information.
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation (16 bytes)
+   */
+  public static final short Uuid = 102;
+  /**
+   * IEEE 754 decimal128 type, e.g. supported by MongoDB
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation (16 bytes)
+   */
+  public static final short Decimal128 = 103;
+  /**
+   * UUID represented as a string of 36 characters, e.g. "019571b4-80e3-7516-a5c1-5f1053d23fff".
+   * For efficient storage, consider the Uuid type instead, which occupies only 16 bytes (20 bytes less).
+   * This type may still be a convenient alternative as the string type is widely supported and more human-readable.
+   * In accordance to standards, new UUIDs generated by ObjectBox use lowercase hexadecimal digits.
+   * Representing type: String
+   */
+  public static final short UuidString = 104;
+  /**
+   * A UUID (Universally Unique Identifier) as defined by RFC 9562.
+   * ObjectBox uses the UUIDv4 scheme (completely random) to create new UUIDs.
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation (16 bytes)
+   */
+  public static final short UuidV4 = 105;
+  /**
+   * Like UuidString, but using the UUIDv4 scheme (completely random) to create new UUID.
+   * Representing type: String
+   */
+  public static final short UuidV4String = 106;
+  /**
+   * A key/value map; e.g. corresponds to a JSON object or a MongoDB document (although not keeping the key order).
+   * Unlike the Flex type, this must contain a map value (e.g. not a vector or a scalar).
+   * Representing type: Flex
+   * Encoding: Flex
+   */
+  public static final short FlexMap = 107;
+  /**
+   * A vector (aka list or array) of flexible elements; e.g. corresponds to a JSON array or a MongoDB array.
+   * Unlike the Flex type, this must contain a vector value (e.g. not a map or a scalar).
+   * Representing type: Flex
+   * Encoding: Flex
+   */
+  public static final short FlexVector = 108;
+  /**
+   * Placeholder (not yet used) for a JSON document.
+   * Representing type: String
+   */
+  public static final short Json = 109;
+  /**
+   * Placeholder (not yet used) for a BSON document.
+   * Representing type: ByteVector
+   */
+  public static final short Bson = 110;
+  /**
+   * JavaScript source code
+   * Representing type: String
+   */
+  public static final short JavaScript = 111;
+  /**
+   * A JSON string that is converted to a native "complex" representation in the external system.
+   * For example in MongoDB, embedded/nested documents are converted to a JSON string in ObjectBox and vice versa.
+   * This allows a quick and simple way to work with non-normalized data from MongoDB in ObjectBox.
+   * Alternatively, you can use FlexMap and FlexVector to map to language primitives (e.g. maps with string keys;
+   * not supported by all ObjectBox languages yet).
+   * For MongoDB, (nested) documents and arrays are supported.
+   * Note that this is very close to the internal representation, e.g. the key order is preserved (unlike Flex).
+   * Representing type: String
+   */
+  public static final short JsonToNative = 112;
+  public static final short Reserved6 = 113;
+  public static final short Reserved7 = 114;
+  public static final short Reserved8 = 115;
+  /**
+   * A vector (array) of Int128 values
+   */
+  public static final short Int128Vector = 116;
+  public static final short Reserved9 = 117;
+  /**
+   * A vector (array) of UUID values
+   */
+  public static final short UuidVector = 118;
+  public static final short Reserved10 = 119;
+  public static final short Reserved11 = 120;
+  public static final short Reserved12 = 121;
+  public static final short Reserved13 = 122;
+  /**
+   * The 12-byte ObjectId type in MongoDB
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation (12 bytes)
+   */
+  public static final short MongoId = 123;
+  /**
+   * A vector (array) of MongoId values
+   */
+  public static final short MongoIdVector = 124;
+  /**
+   * Representing type: Long
+   * Encoding: Two unsigned 32-bit integers merged into a 64-bit integer.
+   */
+  public static final short MongoTimestamp = 125;
+  /**
+   * Representing type: ByteVector
+   * Encoding: 3 zero bytes (reserved, functions as padding), fourth byte is the sub-type,
+   * followed by the binary data.
+   */
+  public static final short MongoBinary = 126;
+  /**
+   * Representing type: string vector with 2 elements (index 0: pattern, index 1: options)
+   * Encoding: 1:1 string representation
+   */
+  public static final short MongoRegex = 127;
+
+  public static final String[] names = { "Unknown", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "Int128", "Reserved1", "Uuid", "Decimal128", "UuidString", "UuidV4", "UuidV4String", "FlexMap", "FlexVector", "Json", "Bson", "JavaScript", "JsonToNative", "Reserved6", "Reserved7", "Reserved8", "Int128Vector", "Reserved9", "UuidVector", "Reserved10", "Reserved11", "Reserved12", "Reserved13", "MongoId", "MongoIdVector", "MongoTimestamp", "MongoBinary", "MongoRegex", };
+
+  public static String name(int e) { return names[e]; }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/model/HnswDistanceType.java b/objectbox-java/src/main/java/io/objectbox/model/HnswDistanceType.java
new file mode 100644
index 00000000..7d48ca98
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/model/HnswDistanceType.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.model;
+
+/**
+ * The distance algorithm used by an HNSW index (vector search).
+ */
+@SuppressWarnings("unused")
+public final class HnswDistanceType {
+  private HnswDistanceType() { }
+  /**
+   * Not a real type, just best practice (e.g. forward compatibility)
+   */
+  public static final short Unknown = 0;
+  /**
+   * The default; typically "Euclidean squared" internally.
+   */
+  public static final short Euclidean = 1;
+  /**
+   * Cosine similarity compares two vectors irrespective of their magnitude (compares the angle of two vectors).
+   * Often used for document or semantic similarity.
+   * Value range: 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)
+   */
+  public static final short Cosine = 2;
+  /**
+   * For normalized vectors (vector length == 1.0), the dot product is equivalent to the cosine similarity.
+   * Because of this, the dot product is often preferred as it performs better.
+   * Value range (normalized vectors): 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)
+   */
+  public static final short DotProduct = 3;
+  /**
+   * For geospatial coordinates aka latitude/longitude pairs.
+   * Note, that the vector dimension must be 2, with the latitude being the first element and longitude the second.
+   * Internally, this uses haversine distance.
+   */
+  public static final short Geo = 6;
+  /**
+   * A custom dot product similarity measure that does not require the vectors to be normalized.
+   * Note: this is no replacement for cosine similarity (like DotProduct for normalized vectors is).
+   * The non-linear conversion provides a high precision over the entire float range (for the raw dot product).
+   * The higher the dot product, the lower the distance is (the nearer the vectors are).
+   * The more negative the dot product, the higher the distance is (the farther the vectors are).
+   * Value range: 0.0 - 2.0 (nonlinear; 0.0: nearest, 1.0: orthogonal, 2.0: farthest)
+   */
+  public static final short DotProductNonNormalized = 10;
+
+  public static final String[] names = { "Unknown", "Euclidean", "Cosine", "DotProduct", "", "", "Geo", "", "", "", "DotProductNonNormalized", };
+
+  public static String name(int e) { return names[e]; }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/model/HnswFlags.java b/objectbox-java/src/main/java/io/objectbox/model/HnswFlags.java
new file mode 100644
index 00000000..39f7c6e2
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/model/HnswFlags.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.model;
+
+/**
+ * Flags as a part of the HNSW configuration.
+ */
+@SuppressWarnings("unused")
+public final class HnswFlags {
+  private HnswFlags() { }
+  /**
+   * Enables debug logs.
+   */
+  public static final int DebugLogs = 1;
+  /**
+   * Enables "high volume" debug logs, e.g. individual gets/puts.
+   */
+  public static final int DebugLogsDetailed = 2;
+  /**
+   * Padding for SIMD is enabled by default, which uses more memory but may be faster. This flag turns it off.
+   */
+  public static final int VectorCacheSimdPaddingOff = 4;
+  /**
+   * If the speed of removing nodes becomes a concern in your use case, you can speed it up by setting this flag.
+   * By default, repairing the graph after node removals creates more connections to improve the graph's quality.
+   * The extra costs for this are relatively low (e.g. vs. regular indexing), and thus the default is recommended.
+   */
+  public static final int ReparationLimitCandidates = 8;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/model/HnswParams.java b/objectbox-java/src/main/java/io/objectbox/model/HnswParams.java
new file mode 100644
index 00000000..582a770e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/model/HnswParams.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.model;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Parameters to configure HNSW-based approximate nearest neighbor (ANN) search.
+ * Some of the parameters can influence index construction and searching.
+ * Changing these values causes re-indexing, which can take a while due to the complex nature of HNSW.
+ */
+@SuppressWarnings("unused")
+public final class HnswParams extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static HnswParams getRootAsHnswParams(ByteBuffer _bb) { return getRootAsHnswParams(_bb, new HnswParams()); }
+  public static HnswParams getRootAsHnswParams(ByteBuffer _bb, HnswParams obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public HnswParams __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /**
+   * Dimensions of vectors; vector data with less dimensions are ignored.
+   * Vectors with more dimensions than specified here are only evaluated up to the given dimension value.
+   * Changing this value causes re-indexing.
+   */
+  public long dimensions() { int o = __offset(4); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Aka "M": the max number of connections per node (default: 30).
+   * Higher numbers increase the graph connectivity, which can lead to more accurate search results.
+   * However, higher numbers also increase the indexing time and resource usage.
+   * Try e.g. 16 for faster but less accurate results, or 64 for more accurate results.
+   * Changing this value causes re-indexing.
+   */
+  public long neighborsPerNode() { int o = __offset(6); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Aka "efConstruction": the number of neighbor searched for while indexing (default: 100).
+   * The higher the value, the more accurate the search, but the longer the indexing.
+   * If indexing time is not a major concern, a value of at least 200 is recommended to improve search quality.
+   * Changing this value causes re-indexing.
+   */
+  public long indexingSearchCount() { int o = __offset(8); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  public long flags() { int o = __offset(10); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * The distance type used for the HNSW index; if none is given, the default Euclidean is used.
+   * Changing this value causes re-indexing.
+   */
+  public int distanceType() { int o = __offset(12); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * When repairing the graph after a node was removed, this gives the probability of adding backlinks to the
+   * repaired neighbors.
+   * The default is 1.0 (aka "always") as this should be worth a bit of extra costs as it improves the graph's
+   * quality.
+   */
+  public float reparationBacklinkProbability() { int o = __offset(14); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
+  /**
+   * A non-binding hint at the maximum size of the vector cache in KB (default: 2097152 or 2 GB/GiB).
+   * The actual size max cache size may be altered according to device and/or runtime settings.
+   * The vector cache is used to store vectors in memory to speed up search and indexing.
+   * Note 1: cache chunks are allocated only on demand, when they are actually used.
+   *         Thus, smaller datasets will use less memory.
+   * Note 2: the cache is for one specific HNSW index; e.g. each index has its own cache.
+   * Note 3: the memory consumption can temporarily exceed the cache size,
+   *         e.g. for large changes, it can double due to multi-version transactions.
+   */
+  public long vectorCacheHintSizeKb() { int o = __offset(16); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+
+  public static int createHnswParams(FlatBufferBuilder builder,
+      long dimensions,
+      long neighborsPerNode,
+      long indexingSearchCount,
+      long flags,
+      int distanceType,
+      float reparationBacklinkProbability,
+      long vectorCacheHintSizeKb) {
+    builder.startTable(7);
+    HnswParams.addVectorCacheHintSizeKb(builder, vectorCacheHintSizeKb);
+    HnswParams.addReparationBacklinkProbability(builder, reparationBacklinkProbability);
+    HnswParams.addFlags(builder, flags);
+    HnswParams.addIndexingSearchCount(builder, indexingSearchCount);
+    HnswParams.addNeighborsPerNode(builder, neighborsPerNode);
+    HnswParams.addDimensions(builder, dimensions);
+    HnswParams.addDistanceType(builder, distanceType);
+    return HnswParams.endHnswParams(builder);
+  }
+
+  public static void startHnswParams(FlatBufferBuilder builder) { builder.startTable(7); }
+  public static void addDimensions(FlatBufferBuilder builder, long dimensions) { builder.addInt(0, (int) dimensions, (int) 0L); }
+  public static void addNeighborsPerNode(FlatBufferBuilder builder, long neighborsPerNode) { builder.addInt(1, (int) neighborsPerNode, (int) 0L); }
+  public static void addIndexingSearchCount(FlatBufferBuilder builder, long indexingSearchCount) { builder.addInt(2, (int) indexingSearchCount, (int) 0L); }
+  public static void addFlags(FlatBufferBuilder builder, long flags) { builder.addInt(3, (int) flags, (int) 0L); }
+  public static void addDistanceType(FlatBufferBuilder builder, int distanceType) { builder.addShort(4, (short) distanceType, (short) 0); }
+  public static void addReparationBacklinkProbability(FlatBufferBuilder builder, float reparationBacklinkProbability) { builder.addFloat(5, reparationBacklinkProbability, 0.0f); }
+  public static void addVectorCacheHintSizeKb(FlatBufferBuilder builder, long vectorCacheHintSizeKb) { builder.addLong(6, vectorCacheHintSizeKb, 0L); }
+  public static int endHnswParams(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public HnswParams get(int j) { return get(new HnswParams(), j); }
+    public HnswParams get(HnswParams obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/model/IdUid.java b/objectbox-java/src/main/java/io/objectbox/model/IdUid.java
index 7ab5eb2d..278a551e 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/IdUid.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/IdUid.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,10 +18,22 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import io.objectbox.flatbuffers.*;
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
 /**
  * ID tuple: besides the main ID there is also a UID for verification
diff --git a/objectbox-java/src/main/java/io/objectbox/model/Model.java b/objectbox-java/src/main/java/io/objectbox/model/Model.java
index 10632d28..9d16d67a 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/Model.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/Model.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,10 +18,22 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import io.objectbox.flatbuffers.*;
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
 /**
  * A model describes all entities and other meta data.
@@ -31,7 +43,7 @@
  */
 @SuppressWarnings("unused")
 public final class Model extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_2_0_8(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static Model getRootAsModel(ByteBuffer _bb) { return getRootAsModel(_bb, new Model()); }
   public static Model getRootAsModel(ByteBuffer _bb, Model obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
diff --git a/objectbox-java/src/main/java/io/objectbox/model/ModelEntity.java b/objectbox-java/src/main/java/io/objectbox/model/ModelEntity.java
index a57f2212..94418193 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/ModelEntity.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/ModelEntity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,14 +18,29 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import io.objectbox.flatbuffers.*;
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
+/**
+ * The type/class of an entity object.
+ */
 @SuppressWarnings("unused")
 public final class ModelEntity extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_2_0_8(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static ModelEntity getRootAsModelEntity(ByteBuffer _bb) { return getRootAsModelEntity(_bb, new ModelEntity()); }
   public static ModelEntity getRootAsModelEntity(ByteBuffer _bb, ModelEntity obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -58,8 +73,14 @@ public final class ModelEntity extends Table {
   public String nameSecondary() { int o = __offset(16); return o != 0 ? __string(o + bb_pos) : null; }
   public ByteBuffer nameSecondaryAsByteBuffer() { return __vector_as_bytebuffer(16, 1); }
   public ByteBuffer nameSecondaryInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 16, 1); }
+  /**
+   * Optional name used in an external system, e.g. another database that ObjectBox syncs with.
+   */
+  public String externalName() { int o = __offset(18); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer externalNameAsByteBuffer() { return __vector_as_bytebuffer(18, 1); }
+  public ByteBuffer externalNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 18, 1); }
 
-  public static void startModelEntity(FlatBufferBuilder builder) { builder.startTable(7); }
+  public static void startModelEntity(FlatBufferBuilder builder) { builder.startTable(8); }
   public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addStruct(0, idOffset, 0); }
   public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(1, nameOffset, 0); }
   public static void addProperties(FlatBufferBuilder builder, int propertiesOffset) { builder.addOffset(2, propertiesOffset, 0); }
@@ -71,6 +92,7 @@ public final class ModelEntity extends Table {
   public static void startRelationsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
   public static void addFlags(FlatBufferBuilder builder, long flags) { builder.addInt(5, (int) flags, (int) 0L); }
   public static void addNameSecondary(FlatBufferBuilder builder, int nameSecondaryOffset) { builder.addOffset(6, nameSecondaryOffset, 0); }
+  public static void addExternalName(FlatBufferBuilder builder, int externalNameOffset) { builder.addOffset(7, externalNameOffset, 0); }
   public static int endModelEntity(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
diff --git a/objectbox-java/src/main/java/io/objectbox/model/ModelProperty.java b/objectbox-java/src/main/java/io/objectbox/model/ModelProperty.java
index eb2ca2f2..1a3baf56 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/ModelProperty.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/ModelProperty.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,14 +18,26 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import io.objectbox.flatbuffers.*;
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class ModelProperty extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_2_0_8(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static ModelProperty getRootAsModelProperty(ByteBuffer _bb) { return getRootAsModelProperty(_bb, new ModelProperty()); }
   public static ModelProperty getRootAsModelProperty(ByteBuffer _bb, ModelProperty obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -72,8 +84,25 @@ public final class ModelProperty extends Table {
    * For value-based indexes, this defines the maximum length of the value stored for indexing
    */
   public long maxIndexValueLength() { int o = __offset(20); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * For float vectors properties and nearest neighbor search, you can index the property with HNSW.
+   * This is the configuration for the HNSW index, e.g. dimensions and parameters affecting quality/speed tradeoff.
+   */
+  public io.objectbox.model.HnswParams hnswParams() { return hnswParams(new io.objectbox.model.HnswParams()); }
+  public io.objectbox.model.HnswParams hnswParams(io.objectbox.model.HnswParams obj) { int o = __offset(22); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
+  /**
+   * Optional type used in an external system, e.g. another database that ObjectBox syncs with.
+   * Note that the supported mappings from ObjectBox types to external types are limited.
+   */
+  public int externalType() { int o = __offset(24); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * Optional name used in an external system, e.g. another database that ObjectBox syncs with.
+   */
+  public String externalName() { int o = __offset(26); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer externalNameAsByteBuffer() { return __vector_as_bytebuffer(26, 1); }
+  public ByteBuffer externalNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 26, 1); }
 
-  public static void startModelProperty(FlatBufferBuilder builder) { builder.startTable(9); }
+  public static void startModelProperty(FlatBufferBuilder builder) { builder.startTable(12); }
   public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addStruct(0, idOffset, 0); }
   public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(1, nameOffset, 0); }
   public static void addType(FlatBufferBuilder builder, int type) { builder.addShort(2, (short) type, (short) 0); }
@@ -83,6 +112,9 @@ public final class ModelProperty extends Table {
   public static void addVirtualTarget(FlatBufferBuilder builder, int virtualTargetOffset) { builder.addOffset(6, virtualTargetOffset, 0); }
   public static void addNameSecondary(FlatBufferBuilder builder, int nameSecondaryOffset) { builder.addOffset(7, nameSecondaryOffset, 0); }
   public static void addMaxIndexValueLength(FlatBufferBuilder builder, long maxIndexValueLength) { builder.addInt(8, (int) maxIndexValueLength, (int) 0L); }
+  public static void addHnswParams(FlatBufferBuilder builder, int hnswParamsOffset) { builder.addOffset(9, hnswParamsOffset, 0); }
+  public static void addExternalType(FlatBufferBuilder builder, int externalType) { builder.addShort(10, (short) externalType, (short) 0); }
+  public static void addExternalName(FlatBufferBuilder builder, int externalNameOffset) { builder.addOffset(11, externalNameOffset, 0); }
   public static int endModelProperty(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
diff --git a/objectbox-java/src/main/java/io/objectbox/model/ModelRelation.java b/objectbox-java/src/main/java/io/objectbox/model/ModelRelation.java
index 184eac76..581457b8 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/ModelRelation.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/ModelRelation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,14 +18,20 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import io.objectbox.flatbuffers.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.Table;
+
+/**
+ * A many-to-many relation between two entity types.
+ */
 @SuppressWarnings("unused")
 public final class ModelRelation extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_2_0_8(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static ModelRelation getRootAsModelRelation(ByteBuffer _bb) { return getRootAsModelRelation(_bb, new ModelRelation()); }
   public static ModelRelation getRootAsModelRelation(ByteBuffer _bb, ModelRelation obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -38,11 +44,25 @@ public final class ModelRelation extends Table {
   public ByteBuffer nameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); }
   public io.objectbox.model.IdUid targetEntityId() { return targetEntityId(new io.objectbox.model.IdUid()); }
   public io.objectbox.model.IdUid targetEntityId(io.objectbox.model.IdUid obj) { int o = __offset(8); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; }
+  /**
+   * Optional type used in an external system, e.g. another database that ObjectBox syncs with.
+   * Note that the supported mappings from ObjectBox types to external types are limited.
+   * Here, external relation types must be vectors, i.e. a list of IDs.
+   */
+  public int externalType() { int o = __offset(10); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * Optional name used in an external system, e.g. another database that ObjectBox syncs with.
+   */
+  public String externalName() { int o = __offset(12); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer externalNameAsByteBuffer() { return __vector_as_bytebuffer(12, 1); }
+  public ByteBuffer externalNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 12, 1); }
 
-  public static void startModelRelation(FlatBufferBuilder builder) { builder.startTable(3); }
+  public static void startModelRelation(FlatBufferBuilder builder) { builder.startTable(5); }
   public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addStruct(0, idOffset, 0); }
   public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(1, nameOffset, 0); }
   public static void addTargetEntityId(FlatBufferBuilder builder, int targetEntityIdOffset) { builder.addStruct(2, targetEntityIdOffset, 0); }
+  public static void addExternalType(FlatBufferBuilder builder, int externalType) { builder.addShort(3, (short) externalType, (short) 0); }
+  public static void addExternalName(FlatBufferBuilder builder, int externalNameOffset) { builder.addOffset(4, externalNameOffset, 0); }
   public static int endModelRelation(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
diff --git a/objectbox-java/src/main/java/io/objectbox/model/PropertyFlags.java b/objectbox-java/src/main/java/io/objectbox/model/PropertyFlags.java
index fbe82680..17ee468e 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/PropertyFlags.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/PropertyFlags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -103,5 +103,29 @@ private PropertyFlags() { }
    * However, the deletion process can be triggered by an API call.
    */
   public static final int EXPIRATION_TIME = 65536;
+  /**
+   * Marks a Long (64-bit integer) property as a the sync clock, a "hybrid logical clock" to resolve Sync conflicts.
+   * These clock values allow "last write wins" conflict resolution.
+   * There can be only one sync clock per sync entity type; which is also recommended for basic conflict resolution.
+   * For new objects, initialize a property value to 0 to reserve "a slot" in the object data.
+   * ObjectBox Sync will update this property automatically on put operations.
+   * As a hybrid clock, it combines a wall clock with a logical counter to compensate for some clock skew effects.
+   */
+  public static final int SYNC_CLOCK = 131072;
+  /**
+   * Marks a Long (64-bit integer) property as a the "sync precedence" to customize Sync conflict resolution.
+   * Developer-assigned precedence values are then used to resolve conflicts via "higher precedence wins".
+   * Defining and assigning precedence values are completely in the hands of the developer (the ObjectBox user).
+   * There can be only one sync precedence per sync entity type.
+   * Typically, it is combined with a sync clock, with the latter being the tie-breaker for equal precedence values.
+   * This can be used to model some business logic use cases, for example:
+   *   - Setting an object a special state, e.g. a final/closed state, which may not be overwritten by a lesser state
+   *   - Multiple workflow states that occur linearly (i.e. using an increasing precedence value)
+   *   - Role based, e.g. only admins set or increment the precedence..
+   *   - “Checkpoint timestamps:” e.g. when some changes are “checked” as in approved/applied,
+   *     the precedence is updated to the current timestamp.
+   *     “Non-checked” or previously checkpointed changes are disregarded.
+   */
+  public static final int SYNC_PRECEDENCE = 262144;
 }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/model/PropertyType.java b/objectbox-java/src/main/java/io/objectbox/model/PropertyType.java
index ee0a67e8..4fb0db94 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/PropertyType.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/PropertyType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,17 +28,44 @@ private PropertyType() { }
    * Not a real type, just best practice (e.g. forward compatibility)
    */
   public static final short Unknown = 0;
+  /**
+   * A boolean (flag)
+   */
   public static final short Bool = 1;
+  /**
+   * 8-bit integer
+   */
   public static final short Byte = 2;
+  /**
+   * 16-bit integer
+   */
   public static final short Short = 3;
+  /**
+   * 16-bit character
+   */
   public static final short Char = 4;
+  /**
+   * 32-bit integer
+   */
   public static final short Int = 5;
+  /**
+   * 64-bit integer
+   */
   public static final short Long = 6;
+  /**
+   * 32-bit floating point number
+   */
   public static final short Float = 7;
+  /**
+   * 64-bit floating point number
+   */
   public static final short Double = 8;
+  /**
+   * UTF-8 encoded string (variable length)
+   */
   public static final short String = 9;
   /**
-   * Date/time stored as a 64 bit long representing milliseconds since 1970-01-01 (unix epoch)
+   * Date/time stored as a 64-bit (integer) timestamp representing milliseconds since 1970-01-01 (unix epoch)
    */
   public static final short Date = 10;
   /**
@@ -46,7 +73,7 @@ private PropertyType() { }
    */
   public static final short Relation = 11;
   /**
-   * High precision date/time stored as a 64 bit long representing nanoseconds since 1970-01-01 (unix epoch)
+   * High precision date/time stored as a 64-bit timestamp representing nanoseconds since 1970-01-01 (unix epoch)
    */
   public static final short DateNano = 12;
   /**
@@ -62,16 +89,49 @@ private PropertyType() { }
   public static final short Reserved8 = 19;
   public static final short Reserved9 = 20;
   public static final short Reserved10 = 21;
+  /**
+   * Variable sized vector of Bool values (boolean; note: each value is represented as one byte)
+   */
   public static final short BoolVector = 22;
+  /**
+   * Variable sized vector of Byte values (8-bit integers)
+   */
   public static final short ByteVector = 23;
+  /**
+   * Variable sized vector of Short values (16-bit integers)
+   */
   public static final short ShortVector = 24;
+  /**
+   * Variable sized vector of Char values (16-bit characters)
+   */
   public static final short CharVector = 25;
+  /**
+   * Variable sized vector of Int values (32-bit integers)
+   */
   public static final short IntVector = 26;
+  /**
+   * Variable sized vector of Long values (64-bit integers)
+   */
   public static final short LongVector = 27;
+  /**
+   * Variable sized vector of Float values (32-bit floating point numbers)
+   */
   public static final short FloatVector = 28;
+  /**
+   * Variable sized vector of Double values (64-bit floating point numbers)
+   */
   public static final short DoubleVector = 29;
+  /**
+   * Variable sized vector of String values (UTF-8 encoded strings).
+   */
   public static final short StringVector = 30;
+  /**
+   * Variable sized vector of Date values (64-bit timestamp).
+   */
   public static final short DateVector = 31;
+  /**
+   * Variable sized vector of Date values (high precision 64-bit timestamp).
+   */
   public static final short DateNanoVector = 32;
 
   public static final String[] names = { "Unknown", "Bool", "Byte", "Short", "Char", "Int", "Long", "Float", "Double", "String", "Date", "Relation", "DateNano", "Flex", "Reserved3", "Reserved4", "Reserved5", "Reserved6", "Reserved7", "Reserved8", "Reserved9", "Reserved10", "BoolVector", "ByteVector", "ShortVector", "CharVector", "IntVector", "LongVector", "FloatVector", "DoubleVector", "StringVector", "DateVector", "DateNanoVector", };
diff --git a/objectbox-java/src/main/java/io/objectbox/package-info.java b/objectbox-java/src/main/java/io/objectbox/package-info.java
index 7010abb0..2db20b8b 100644
--- a/objectbox-java/src/main/java/io/objectbox/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/BreakForEach.java b/objectbox-java/src/main/java/io/objectbox/query/BreakForEach.java
index 343bc795..271a4c98 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/BreakForEach.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/BreakForEach.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/EagerRelation.java b/objectbox-java/src/main/java/io/objectbox/query/EagerRelation.java
index 63ad47ba..32d0667e 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/EagerRelation.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/EagerRelation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/IdWithScore.java b/objectbox-java/src/main/java/io/objectbox/query/IdWithScore.java
new file mode 100644
index 00000000..d26f2f01
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/IdWithScore.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+/**
+ * Wraps the ID of a matching object and a score when using {@link Query#findIdsWithScores}.
+ */
+public class IdWithScore {
+
+    private final long id;
+    private final double score;
+
+    // Note: this constructor is called by JNI, check before modifying/removing it.
+    public IdWithScore(long id, double score) {
+        this.id = id;
+        this.score = score;
+    }
+
+    /**
+     * Returns the object ID.
+     */
+    public long getId() {
+        return id;
+    }
+
+    /**
+     * Returns the query score for the {@link #getId() id}.
+     * <p>
+     * The query score indicates some quality measurement. E.g. for vector nearest neighbor searches, the score is the
+     * distance to the given vector.
+     */
+    public double getScore() {
+        return score;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/InternalAccess.java b/objectbox-java/src/main/java/io/objectbox/query/InternalAccess.java
new file mode 100644
index 00000000..3546144b
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/InternalAccess.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+import io.objectbox.annotation.apihint.Internal;
+
+/**
+ * Exposes internal APIs to tests and code in other packages.
+ */
+@Internal
+public class InternalAccess {
+
+    @Internal
+    public static <T> void nativeFindFirst(Query<T> query, long cursorHandle) {
+        query.nativeFindFirst(query.handle, cursorHandle);
+    }
+
+    /**
+     * See {@link QueryPublisher#LOG_STATES}.
+     */
+    @Internal
+    public static void queryPublisherLogStates() {
+        QueryPublisher.LOG_STATES = true;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/LazyList.java b/objectbox-java/src/main/java/io/objectbox/query/LazyList.java
index 27a360ba..8c3a18b2 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/LazyList.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/LazyList.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -278,6 +278,9 @@ public ListIterator<E> listIterator() {
 
     @Override
     public ListIterator<E> listIterator(int location) {
+        if (location < 0 || location > size) {
+            throw new IndexOutOfBoundsException("Index: " + location + ", Size: " + size);
+        }
         return new LazyIterator(location);
     }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/query/LogicQueryCondition.java b/objectbox-java/src/main/java/io/objectbox/query/LogicQueryCondition.java
index c3aa8363..c62b0c9d 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/LogicQueryCondition.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/LogicQueryCondition.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.query;
 
 /**
diff --git a/objectbox-java/src/main/java/io/objectbox/query/ObjectWithScore.java b/objectbox-java/src/main/java/io/objectbox/query/ObjectWithScore.java
new file mode 100644
index 00000000..38e3f75f
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/ObjectWithScore.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+/**
+ * Wraps a matching object and a score when using {@link Query#findWithScores}.
+ */
+public class ObjectWithScore<T> {
+
+    private final T object;
+    private final double score;
+
+    // Note: this constructor is called by JNI, check before modifying/removing it.
+    public ObjectWithScore(T object, double score) {
+        this.object = object;
+        this.score = score;
+    }
+
+    // Do not use getObject() to avoid having to escape the name in Kotlin
+    /**
+     * Returns the matching object.
+     */
+    public T get() {
+        return object;
+    }
+
+    /**
+     * Returns the query score for the {@link #get() object}.
+     * <p>
+     * The query score indicates some quality measurement. E.g. for vector nearest neighbor searches, the score is the
+     * distance to the given vector.
+     */
+    public double getScore() {
+        return score;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/OrderFlags.java b/objectbox-java/src/main/java/io/objectbox/query/OrderFlags.java
index 24197f7f..96b451cf 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/OrderFlags.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/OrderFlags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/PropertyQuery.java b/objectbox-java/src/main/java/io/objectbox/query/PropertyQuery.java
index 9ddc5100..c54e879d 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/PropertyQuery.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/PropertyQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -347,10 +347,10 @@ public Double findDouble() {
 
     /**
      * Sums up all values for the given property over all Objects matching the query.
-     *
+     * <p>
      * Note: this method is not recommended for properties of type long unless you know the contents of the DB not to
-     *       overflow. Use {@link #sumDouble()} instead if you cannot guarantee the sum to be in the long value range.
-     * 
+     * overflow. Use {@link #sumDouble()} instead if you cannot guarantee the sum to be in the long value range.
+     *
      * @return 0 in case no elements matched the query
      * @throws io.objectbox.exception.NumericOverflowException if the sum exceeds the numbers {@link Long} can
      * represent.
@@ -362,11 +362,11 @@ public long sum() {
         );
     }
 
-    /** 
+    /**
      * Sums up all values for the given property over all Objects matching the query.
-     * 
+     * <p>
      * Note: for integer types int and smaller, {@link #sum()} is usually preferred for sums.
-     *       
+     *
      * @return 0 in case no elements matched the query
      */
     public double sumDouble() {
@@ -386,9 +386,9 @@ public long max() {
         );
     }
 
-    /** 
+    /**
      * Finds the maximum value for the given property over all Objects matching the query.
-     * 
+     *
      * @return NaN in case no elements matched the query
      */
     public double maxDouble() {
diff --git a/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryCondition.java b/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryCondition.java
index a8d55387..b1f7cbb9 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryCondition.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryCondition.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.query;
 
 import io.objectbox.Property;
diff --git a/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryConditionImpl.java b/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryConditionImpl.java
index 444fb290..0bf40400 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryConditionImpl.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryConditionImpl.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.query;
 
 import java.util.Date;
@@ -196,6 +212,15 @@ public LongArrayCondition(Property<T> property, Operation op, long[] value) {
             this.value = value;
         }
 
+        public LongArrayCondition(Property<T> property, Operation op, Date[] value) {
+            super(property);
+            this.op = op;
+            this.value = new long[value.length];
+            for (int i = 0; i < value.length; i++) {
+                this.value[i] = value[i].getTime();
+            }
+        }
+
         @Override
         void applyCondition(QueryBuilder<T> builder) {
             switch (op) {
@@ -350,7 +375,11 @@ public static class StringStringCondition<T> extends PropertyQueryConditionImpl<
         private final StringOrder order;
 
         public enum Operation {
-            CONTAINS_KEY_VALUE
+            EQUAL_KEY_VALUE,
+            GREATER_KEY_VALUE,
+            GREATER_EQUALS_KEY_VALUE,
+            LESS_KEY_VALUE,
+            LESS_EQUALS_KEY_VALUE
         }
 
         public StringStringCondition(Property<T> property, Operation op, String leftValue, String rightValue, StringOrder order) {
@@ -363,8 +392,92 @@ public StringStringCondition(Property<T> property, Operation op, String leftValu
 
         @Override
         void applyCondition(QueryBuilder<T> builder) {
-            if (op == Operation.CONTAINS_KEY_VALUE) {
-                builder.containsKeyValue(property, leftValue, rightValue, order);
+            if (op == Operation.EQUAL_KEY_VALUE) {
+                builder.equalKeyValue(property, leftValue, rightValue, order);
+            } else if (op == Operation.GREATER_KEY_VALUE) {
+                builder.greaterKeyValue(property, leftValue, rightValue, order);
+            } else if (op == Operation.GREATER_EQUALS_KEY_VALUE) {
+                builder.greaterOrEqualKeyValue(property, leftValue, rightValue, order);
+            } else if (op == Operation.LESS_KEY_VALUE) {
+                builder.lessKeyValue(property, leftValue, rightValue, order);
+            } else if (op == Operation.LESS_EQUALS_KEY_VALUE) {
+                builder.lessOrEqualKeyValue(property, leftValue, rightValue, order);
+            } else {
+                throw new UnsupportedOperationException(op + " is not supported with two String values");
+            }
+        }
+    }
+
+    public static class StringLongCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final String leftValue;
+        private final long rightValue;
+
+        public enum Operation {
+            EQUAL_KEY_VALUE,
+            GREATER_KEY_VALUE,
+            GREATER_EQUALS_KEY_VALUE,
+            LESS_KEY_VALUE,
+            LESS_EQUALS_KEY_VALUE
+        }
+
+        public StringLongCondition(Property<T> property, Operation op, String leftValue, long rightValue) {
+            super(property);
+            this.op = op;
+            this.leftValue = leftValue;
+            this.rightValue = rightValue;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            if (op == Operation.EQUAL_KEY_VALUE) {
+                builder.equalKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.GREATER_KEY_VALUE) {
+                builder.greaterKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.GREATER_EQUALS_KEY_VALUE) {
+                builder.greaterOrEqualKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.LESS_KEY_VALUE) {
+                builder.lessKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.LESS_EQUALS_KEY_VALUE) {
+                builder.lessOrEqualKeyValue(property, leftValue, rightValue);
+            } else {
+                throw new UnsupportedOperationException(op + " is not supported with two String values");
+            }
+        }
+    }
+
+    public static class StringDoubleCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final String leftValue;
+        private final double rightValue;
+
+        public enum Operation {
+            EQUAL_KEY_VALUE,
+            GREATER_KEY_VALUE,
+            GREATER_EQUALS_KEY_VALUE,
+            LESS_KEY_VALUE,
+            LESS_EQUALS_KEY_VALUE
+        }
+
+        public StringDoubleCondition(Property<T> property, Operation op, String leftValue, double rightValue) {
+            super(property);
+            this.op = op;
+            this.leftValue = leftValue;
+            this.rightValue = rightValue;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            if (op == Operation.EQUAL_KEY_VALUE) {
+                builder.equalKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.GREATER_KEY_VALUE) {
+                builder.greaterKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.GREATER_EQUALS_KEY_VALUE) {
+                builder.greaterOrEqualKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.LESS_KEY_VALUE) {
+                builder.lessKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.LESS_EQUALS_KEY_VALUE) {
+                builder.lessOrEqualKeyValue(property, leftValue, rightValue);
             } else {
                 throw new UnsupportedOperationException(op + " is not supported with two String values");
             }
@@ -442,4 +555,24 @@ void applyCondition(QueryBuilder<T> builder) {
             }
         }
     }
+
+    /**
+     * Conditions for properties with an {@link io.objectbox.annotation.HnswIndex}.
+     */
+    public static class NearestNeighborCondition<T> extends PropertyQueryConditionImpl<T> {
+
+        private final float[] queryVector;
+        private final int maxResultCount;
+
+        public NearestNeighborCondition(Property<T> property, float[] queryVector, int maxResultCount) {
+            super(property);
+            this.queryVector = queryVector;
+            this.maxResultCount = maxResultCount;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            builder.nearestNeighbors(property, queryVector, maxResultCount);
+        }
+    }
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/query/Query.java b/objectbox-java/src/main/java/io/objectbox/query/Query.java
index 317ef310..4c4f5c07 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/Query.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/Query.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,6 +31,9 @@
 import io.objectbox.BoxStore;
 import io.objectbox.InternalAccess;
 import io.objectbox.Property;
+import io.objectbox.annotation.Entity;
+import io.objectbox.annotation.HnswIndex;
+import io.objectbox.exception.NonUniqueResultException;
 import io.objectbox.reactive.DataObserver;
 import io.objectbox.reactive.DataSubscriptionList;
 import io.objectbox.reactive.SubscriptionBuilder;
@@ -38,9 +41,9 @@
 import io.objectbox.relation.ToOne;
 
 /**
- * A repeatable Query returning the latest matching Objects.
+ * A repeatable Query returning the latest matching objects.
  * <p>
- * Use {@link #find()} or related methods to fetch the latest results from the BoxStore.
+ * Use {@link #find()} or related methods to fetch the latest results from the {@link BoxStore}.
  * <p>
  * Use {@link #property(Property)} to only return values or an aggregate of a single Property.
  * <p>
@@ -55,14 +58,25 @@ public class Query<T> implements Closeable {
 
     native void nativeDestroy(long handle);
 
+    /** Clones the native query, incl. conditions and parameters, and returns a handle to the clone. */
+    native long nativeClone(long handle);
+
     native Object nativeFindFirst(long handle, long cursorHandle);
 
     native Object nativeFindUnique(long handle, long cursorHandle);
 
     native List<T> nativeFind(long handle, long cursorHandle, long offset, long limit) throws Exception;
 
+    native long nativeFindFirstId(long handle, long cursorHandle);
+
+    native long nativeFindUniqueId(long handle, long cursorHandle);
+
     native long[] nativeFindIds(long handle, long cursorHandle, long offset, long limit);
 
+    native List<ObjectWithScore<T>> nativeFindWithScores(long handle, long cursorHandle, long offset, long limit);
+
+    native List<IdWithScore> nativeFindIdsWithScores(long handle, long cursorHandle, long offset, long limit);
+
     native long nativeCount(long handle, long cursorHandle);
 
     native long nativeRemove(long handle, long cursorHandle);
@@ -101,6 +115,9 @@ native void nativeSetParameters(long handle, int entityId, int propertyId, @Null
     native void nativeSetParameter(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
                                    byte[] value);
 
+    native void nativeSetParameter(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
+                                    float[] values);
+
     final Box<T> box;
     private final BoxStore store;
     private final QueryPublisher<T> publisher;
@@ -113,7 +130,7 @@ native void nativeSetParameter(long handle, int entityId, int propertyId, @Nulla
     // volatile so checkOpen() is more up-to-date (no need for synchronized; it's a race anyway)
     volatile long handle;
 
-    Query(Box<T> box, long queryHandle, @Nullable List<EagerRelation<T, ?>> eagerRelations, @Nullable  QueryFilter<T> filter,
+    Query(Box<T> box, long queryHandle, @Nullable List<EagerRelation<T, ?>> eagerRelations, @Nullable QueryFilter<T> filter,
           @Nullable Comparator<T> comparator) {
         this.box = box;
         store = box.getStore();
@@ -125,6 +142,20 @@ native void nativeSetParameter(long handle, int entityId, int propertyId, @Nulla
         this.comparator = comparator;
     }
 
+    /**
+     * Creates a copy of the {@code originalQuery}, but pointing to a different native query using {@code handle}.
+     */
+    // Note: not using recommended copy constructor (just passing this) as handle needs to change.
+    private Query(Query<T> originalQuery, long handle) {
+        this(
+                originalQuery.box,
+                handle,
+                originalQuery.eagerRelations,
+                originalQuery.filter,
+                originalQuery.comparator
+        );
+    }
+
     /**
      * Explicitly call {@link #close()} instead to avoid expensive finalization.
      */
@@ -144,6 +175,7 @@ protected void finalize() throws Throwable {
      * Calling any other methods of this afterwards will throw an {@link IllegalStateException}.
      */
     public synchronized void close() {
+        publisher.stopAndAwait();  // Ensure it is done so that the query is not used anymore
         if (handle != 0) {
             // Closeable recommendation: mark as "closed" before nativeDestroy could throw.
             long handleCopy = handle;
@@ -152,13 +184,34 @@ public synchronized void close() {
         }
     }
 
+    /**
+     * Creates a copy of this for use in another thread.
+     * <p>
+     * Clones the native query, keeping any previously set parameters.
+     * <p>
+     * Closing the original query does not close the copy. {@link #close()} the copy once finished using it.
+     * <p>
+     * Note: a set {@link QueryBuilder#filter(QueryFilter) filter} or {@link QueryBuilder#sort(Comparator) sort}
+     * order <b>must be thread safe</b>.
+     */
+    // Note: not overriding clone() to avoid confusion with Java's cloning mechanism.
+    public Query<T> copy() {
+        long cloneHandle = nativeClone(handle);
+        return new Query<>(this, cloneHandle);
+    }
+
     /** To be called inside a read TX */
     long cursorHandle() {
         return InternalAccess.getActiveTxCursorHandle(box);
     }
 
     /**
-     * Find the first Object matching the query.
+     * Finds the first object matching this query.
+     * <p>
+     * Note: if no {@link QueryBuilder#order} conditions are present, which object is the first one might be arbitrary
+     * (sometimes the one with the lowest ID, but never guaranteed to be).
+     *
+     * @return The first object if there are matches. {@code null} if no object matches.
      */
     @Nullable
     public T findFirst() {
@@ -191,9 +244,10 @@ private void ensureNoComparator() {
     }
 
     /**
-     * Find the unique Object matching the query.
+     * Finds the only object matching this query.
      *
-     * @throws io.objectbox.exception.NonUniqueResultException if result was not unique
+     * @return The object if a single object matches. {@code null} if no object matches. Throws
+     * {@link NonUniqueResultException} if there are multiple objects matching the query.
      */
     @Nullable
     public T findUnique() {
@@ -207,7 +261,12 @@ public T findUnique() {
     }
 
     /**
-     * Find all Objects matching the query.
+     * Finds objects matching the query.
+     * <p>
+     * Note: if no {@link QueryBuilder#order} conditions are present, the order is arbitrary (sometimes ordered by ID,
+     * but never guaranteed to).
+     *
+     * @return A list of matching objects. An empty list if no object matches.
      */
     @Nonnull
     public List<T> find() {
@@ -231,8 +290,12 @@ public List<T> find() {
     }
 
     /**
-     * Find all Objects matching the query, skipping the first offset results and returning at most limit results.
-     * Use this for pagination.
+     * Like {@link #find()}, but can skip and limit results.
+     * <p>
+     * Use to get a slice of the whole result, e.g. for "result paging".
+     *
+     * @param offset If greater than 0, skips this many results.
+     * @param limit If greater than 0, returns at most this many results.
      */
     @Nonnull
     public List<T> find(final long offset, final long limit) {
@@ -245,20 +308,59 @@ public List<T> find(final long offset, final long limit) {
     }
 
     /**
-     * Very efficient way to get just the IDs without creating any objects. IDs can later be used to lookup objects
-     * (lookups by ID are also very efficient in ObjectBox).
+     * Like {@link #findFirst()}, but returns just the ID of the object.
+     * <p>
+     * This is more efficient as no object is created.
+     * <p>
+     * Ignores any {@link QueryBuilder#filter(QueryFilter) query filter}.
+     *
+     * @return The ID of the first matching object. {@code 0} if no object matches.
+     */
+    public long findFirstId() {
+        checkOpen();
+        return box.internalCallWithReaderHandle(cursorHandle -> nativeFindFirstId(handle, cursorHandle));
+    }
+
+    /**
+     * Like {@link #findUnique()}, but returns just the ID of the object.
+     * <p>
+     * This is more efficient as no object is created.
+     * <p>
+     * Ignores any {@link QueryBuilder#filter(QueryFilter) query filter}.
+     *
+     * @return The ID of the object, if a single object matches. {@code 0} if no object matches. Throws
+     * {@link NonUniqueResultException} if there are multiple objects matching the query.
+     */
+    public long findUniqueId() {
+        checkOpen();
+        return box.internalCallWithReaderHandle(cursorHandle -> nativeFindUniqueId(handle, cursorHandle));
+    }
+
+    /**
+     * Like {@link #find()}, but returns just the IDs of the objects.
+     * <p>
+     * IDs can later be used to {@link Box#get} objects.
+     * <p>
+     * This is very efficient as no objects are created.
      * <p>
      * Note: a filter set with {@link QueryBuilder#filter(QueryFilter)} will be silently ignored!
+     *
+     * @return An array of IDs of matching objects. An empty array if no objects match.
      */
     @Nonnull
     public long[] findIds() {
-        return findIds(0,0);
+        return findIds(0, 0);
     }
 
     /**
-     * Like {@link #findIds()} but with a offset/limit param, e.g. for pagination.
+     * Like {@link #findIds()}, but can skip and limit results.
+     * <p>
+     * Use to get a slice of the whole result, e.g. for "result paging".
      * <p>
      * Note: a filter set with {@link QueryBuilder#filter(QueryFilter)} will be silently ignored!
+     *
+     * @param offset If greater than 0, skips this many results.
+     * @param limit If greater than 0, returns at most this many results.
      */
     @Nonnull
     public long[] findIds(final long offset, final long limit) {
@@ -288,6 +390,68 @@ public LazyList<T> findLazyCached() {
         return new LazyList<>(box, findIds(), true);
     }
 
+    /**
+     * Like {@link #findIdsWithScores()}, but can skip and limit results.
+     * <p>
+     * Use to get a slice of the whole result, e.g. for "result paging".
+     *
+     * @param offset If greater than 0, skips this many results.
+     * @param limit If greater than 0, returns at most this many results.
+     */
+    @Nonnull
+    public List<IdWithScore> findIdsWithScores(final long offset, final long limit) {
+        checkOpen();
+        return box.internalCallWithReaderHandle(cursorHandle -> nativeFindIdsWithScores(handle, cursorHandle, offset, limit));
+    }
+
+    /**
+     * Finds IDs of objects matching the query associated to their query score (e.g. distance in NN search).
+     * <p>
+     * This only works on objects with a property with an {@link HnswIndex}.
+     *
+     * @return A list of {@link IdWithScore} that wraps IDs of matching objects and their score, sorted by score in
+     * ascending order.
+     */
+    @Nonnull
+    public List<IdWithScore> findIdsWithScores() {
+        return findIdsWithScores(0, 0);
+    }
+
+    /**
+     * Like {@link #findWithScores()}, but can skip and limit results.
+     * <p>
+     * Use to get a slice of the whole result, e.g. for "result paging".
+     *
+     * @param offset If greater than 0, skips this many results.
+     * @param limit If greater than 0, returns at most this many results.
+     */
+    @Nonnull
+    public List<ObjectWithScore<T>> findWithScores(final long offset, final long limit) {
+        ensureNoFilterNoComparator();
+        return callInReadTx(() -> {
+            List<ObjectWithScore<T>> results = nativeFindWithScores(handle, cursorHandle(), offset, limit);
+            if (eagerRelations != null) {
+                for (int i = 0; i < results.size(); i++) {
+                    resolveEagerRelationForNonNullEagerRelations(results.get(i).get(), i);
+                }
+            }
+            return results;
+        });
+    }
+
+    /**
+     * Finds objects matching the query associated to their query score (e.g. distance in NN search).
+     * <p>
+     * This only works on objects with a property with an {@link HnswIndex}.
+     *
+     * @return A list of {@link ObjectWithScore} that wraps matching objects and their score, sorted by score in
+     * ascending order.
+     */
+    @Nonnull
+    public List<ObjectWithScore<T>> findWithScores() {
+        return findWithScores(0, 0);
+    }
+
     /**
      * Creates a {@link PropertyQuery} for the given property.
      * <p>
@@ -408,9 +572,10 @@ public Query<T> setParameter(Property<?> property, String value) {
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, String value) {
         checkOpen();
@@ -428,9 +593,10 @@ public Query<T> setParameter(Property<?> property, long value) {
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, long value) {
         checkOpen();
@@ -448,9 +614,10 @@ public Query<T> setParameter(Property<?> property, double value) {
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, double value) {
         checkOpen();
@@ -468,9 +635,10 @@ public Query<T> setParameter(Property<?> property, Date value) {
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      * @throws NullPointerException if given date is null
      */
     public Query<T> setParameter(String alias, Date value) {
@@ -485,89 +653,128 @@ public Query<T> setParameter(Property<?> property, boolean value) {
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, boolean value) {
         return setParameter(alias, value ? 1 : 0);
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition for {@code property} to a new {@code value}.
+     *
+     * @param property Property reference from generated entity underscore class, like {@code Example_.example}.
+     * @param value The new {@code int[]} value to use for the query condition.
      */
-    public Query<T> setParameters(Property<?> property, long value1, long value2) {
+    public Query<T> setParameter(Property<?> property, int[] value) {
         checkOpen();
-        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value1, value2);
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new {@code int[]} value to use for the query condition.
      */
-    public Query<T> setParameters(String alias, long value1, long value2) {
+    public Query<T> setParameter(String alias, int[] value) {
         checkOpen();
-        nativeSetParameters(handle, 0, 0, alias, value1, value2);
+        nativeSetParameters(handle, 0, 0, alias, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition for {@code property} to a new {@code value}.
+     *
+     * @param property Property reference from generated entity underscore class, like {@code Example_.example}.
+     * @param value The new {@code long[]} value to use for the query condition.
      */
-    public Query<T> setParameters(Property<?> property, int[] values) {
+    public Query<T> setParameter(Property<?> property, long[] value) {
         checkOpen();
-        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, values);
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new {@code long[]} value to use for the query condition.
      */
-    public Query<T> setParameters(String alias, int[] values) {
+    public Query<T> setParameter(String alias, long[] value) {
         checkOpen();
-        nativeSetParameters(handle, 0, 0, alias, values);
+        nativeSetParameters(handle, 0, 0, alias, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition for {@code property} to a new {@code value}.
+     *
+     * @param property Property reference from generated entity underscore class, like {@code Example_.example}.
+     * @param value The new {@code float[]} value to use for the query condition.
      */
-    public Query<T> setParameters(Property<?> property, long[] values) {
+    public Query<T> setParameter(Property<?> property, float[] value) {
         checkOpen();
-        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, values);
+        nativeSetParameter(handle, property.getEntityId(), property.getId(), null, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
+     *
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new {@code float[]} value to use for the query condition.
+     */
+    public Query<T> setParameter(String alias, float[] value) {
+        checkOpen();
+        nativeSetParameter(handle, 0, 0, alias, value);
+        return this;
+    }
+
+    /**
+     * Changes the parameter of the query condition for {@code property} to a new {@code value}.
+     *
+     * @param property Property reference from generated entity underscore class, like {@code Example_.example}.
+     * @param value The new {@code String[]} value to use for the query condition.
+     */
+    public Query<T> setParameter(Property<?> property, String[] value) {
+        checkOpen();
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value);
+        return this;
+    }
+
+    /**
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new {@code String[]} value to use for the query condition.
      */
-    public Query<T> setParameters(String alias, long[] values) {
+    public Query<T> setParameter(String alias, String[] value) {
         checkOpen();
-        nativeSetParameters(handle, 0, 0, alias, values);
+        nativeSetParameters(handle, 0, 0, alias, value);
         return this;
     }
 
     /**
      * Sets a parameter previously given to the {@link QueryBuilder} to new values.
      */
-    public Query<T> setParameters(Property<?> property, double value1, double value2) {
+    public Query<T> setParameters(Property<?> property, long value1, long value2) {
         checkOpen();
         nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value1, value2);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameters of the query condition with the matching {@code alias} to the new values.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value1 The first value to use for the query condition.
+     * @param value2 The second value to use for the query condition.
      */
-    public Query<T> setParameters(String alias, double value1, double value2) {
+    public Query<T> setParameters(String alias, long value1, long value2) {
         checkOpen();
         nativeSetParameters(handle, 0, 0, alias, value1, value2);
         return this;
@@ -576,20 +783,22 @@ public Query<T> setParameters(String alias, double value1, double value2) {
     /**
      * Sets a parameter previously given to the {@link QueryBuilder} to new values.
      */
-    public Query<T> setParameters(Property<?> property, String[] values) {
+    public Query<T> setParameters(Property<?> property, double value1, double value2) {
         checkOpen();
-        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, values);
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value1, value2);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameters of the query condition with the matching {@code alias} to the new values.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value1 The first value to use for the query condition.
+     * @param value2 The second value to use for the query condition.
      */
-    public Query<T> setParameters(String alias, String[] values) {
+    public Query<T> setParameters(String alias, double value1, double value2) {
         checkOpen();
-        nativeSetParameters(handle, 0, 0, alias, values);
+        nativeSetParameters(handle, 0, 0, alias, value1, value2);
         return this;
     }
 
@@ -603,9 +812,11 @@ public Query<T> setParameters(Property<?> property, String key, String value) {
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameters of the query condition with the matching {@code alias} to the new values.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param key The first value to use for the query condition.
+     * @param value The second value to use for the query condition.
      */
     public Query<T> setParameters(String alias, String key, String value) {
         checkOpen();
@@ -623,9 +834,10 @@ public Query<T> setParameter(Property<?> property, byte[] value) {
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, byte[] value) {
         checkOpen();
@@ -645,22 +857,27 @@ public long remove() {
     }
 
     /**
-     * A {@link io.objectbox.reactive.DataObserver} can be subscribed to data changes using the returned builder.
-     * The observer is supplied via {@link SubscriptionBuilder#observer(DataObserver)} and will be notified once
-     * the query results have (potentially) changed.
+     * Returns a {@link SubscriptionBuilder} to build a subscription to observe changes to the results of this query.
      * <p>
-     * With subscribing, the observer will immediately get current query results.
-     * The query is run for the subscribing observer.
+     * Typical usage:
+     * <pre>
+     * DataSubscription subscription = query.subscribe()
+     *         .observer((List&lt;T&gt; data) -> {
+     *               // Do something with the returned results
+     *         });
+     * // Once the observer should no longer be notified
+     * subscription.cancel();
+     * </pre>
+     * Note that the observer will receive new results on any changes to the {@link Box} of the {@link Entity @Entity}
+     * this queries, regardless of the conditions of this query. This is because the {@link QueryPublisher} used for the
+     * subscription observes changes by using {@link BoxStore#subscribe(Class)} on the Box this queries.
      * <p>
-     * Threading notes:
-     * Query observers are notified from a thread pooled. Observers may be notified in parallel.
-     * The notification order is the same as the subscription order, although this may not always be guaranteed in
-     * the future.
+     * To customize this or for advanced use cases, consider using {@link BoxStore#subscribe(Class)} directly.
      * <p>
-     * Stale observers: you must hold on to the Query or {@link io.objectbox.reactive.DataSubscription} objects to keep
-     * your {@link DataObserver}s active. If this Query is not referenced anymore
-     * (along with its {@link io.objectbox.reactive.DataSubscription}s, which hold a reference to the Query internally),
-     * it may be GCed and observers may become stale (won't receive anymore data).
+     * See {@link SubscriptionBuilder#observer(DataObserver)} for additional details.
+     *
+     * @return A {@link SubscriptionBuilder} to build a subscription.
+     * @see #publish()
      */
     public SubscriptionBuilder<List<T>> subscribe() {
         checkOpen();
@@ -680,11 +897,15 @@ public SubscriptionBuilder<List<T>> subscribe(DataSubscriptionList dataSubscript
     }
 
     /**
-     * Publishes the current data to all subscribed @{@link DataObserver}s.
-     * This is useful triggering observers when new parameters have been set.
-     * Note, that setParameter methods will NOT be propagated to observers.
+     * Manually schedules publishing the current results of this query to all {@link #subscribe() subscribed}
+     * {@link DataObserver observers}, even if the underlying Boxes have not changed.
+     * <p>
+     * This is useful to publish new results after changing parameters of this query which would otherwise not trigger
+     * publishing of new results.
      */
     public void publish() {
+        // Do open check to not silently fail (publisher runnable would just not get scheduled if query is closed)
+        checkOpen();
         publisher.publish();
     }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java b/objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java
index bf3a01cf..0f61c45d 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,20 +16,20 @@
 
 package io.objectbox.query;
 
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
 import io.objectbox.Box;
 import io.objectbox.EntityInfo;
 import io.objectbox.Property;
-import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.exception.DbException;
 import io.objectbox.relation.RelationInfo;
 
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.Date;
-import java.util.List;
-
 /**
  * Builds a {@link Query Query} using conditions which can then be used to return a list of matching Objects.
  * <p>
@@ -151,6 +151,9 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native void nativeSetParameterAlias(long conditionHandle, String alias);
 
+    private native long nativeRelationCount(long handle, long storeHandle, int relationOwnerEntityId, int propertyId,
+                                            int relationCount);
+
     // ------------------------------ (Not)Null------------------------------
 
     private native long nativeNull(long handle, int propertyId);
@@ -173,6 +176,16 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native long nativeIn(long handle, int propertyId, long[] values, boolean negate);
 
+    private native long nativeEqualKeyValue(long handle, int propertyId, String key, long value);
+
+    private native long nativeGreaterKeyValue(long handle, int propertyId, String key, long value);
+
+    private native long nativeGreaterEqualsKeyValue(long handle, int propertyId, String key, long value);
+
+    private native long nativeLessKeyValue(long handle, int propertyId, String key, long value);
+
+    private native long nativeLessEqualsKeyValue(long handle, int propertyId, String key, long value);
+
     // ------------------------------ Strings ------------------------------
 
     private native long nativeEqual(long handle, int propertyId, String value, boolean caseSensitive);
@@ -183,7 +196,15 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native long nativeContainsElement(long handle, int propertyId, String value, boolean caseSensitive);
 
-    private native long nativeContainsKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+    private native long nativeEqualKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
+    private native long nativeGreaterKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
+    private native long nativeGreaterEqualsKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
+    private native long nativeLessKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
+    private native long nativeLessEqualsKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
 
     private native long nativeStartsWith(long handle, int propertyId, String value, boolean caseSensitive);
 
@@ -203,6 +224,18 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native long nativeBetween(long handle, int propertyId, double value1, double value2);
 
+    private native long nativeNearestNeighborsF32(long handle, int propertyId, float[] queryVector, int maxResultCount);
+
+    private native long nativeEqualKeyValue(long handle, int propertyId, String key, double value);
+
+    private native long nativeGreaterKeyValue(long handle, int propertyId, String key, double value);
+
+    private native long nativeGreaterEqualsKeyValue(long handle, int propertyId, String key, double value);
+
+    private native long nativeLessKeyValue(long handle, int propertyId, String key, double value);
+
+    private native long nativeLessEqualsKeyValue(long handle, int propertyId, String key, double value);
+
     // ------------------------------ Bytes ------------------------------
 
     private native long nativeEqual(long handle, int propertyId, byte[] value);
@@ -216,7 +249,7 @@ public QueryBuilder(Box<T> box, long storeHandle, String entityName) {
         this.box = box;
         this.storeHandle = storeHandle;
         handle = nativeCreate(storeHandle, entityName);
-        if(handle == 0) throw new DbException("Could not create native query builder");
+        if (handle == 0) throw new DbException("Could not create native query builder");
         isSubQuery = false;
     }
 
@@ -266,7 +299,7 @@ public Query<T> build() {
             throw new IllegalStateException("Incomplete logic condition. Use or()/and() between two conditions only.");
         }
         long queryHandle = nativeBuild(handle);
-        if(queryHandle == 0) throw new DbException("Could not create native query");
+        if (queryHandle == 0) throw new DbException("Could not create native query");
         Query<T> query = new Query<>(box, queryHandle, eagerRelations, filter, comparator);
         close();
         return query;
@@ -285,8 +318,6 @@ private void verifyHandle() {
     }
 
     /**
-     * Experimental. This API might change or be removed in the future based on user feedback.
-     * <p>
      * Applies the given query conditions and returns the builder for further customization, such as result order.
      * Build the condition using the properties from your entity underscore classes.
      * <p>
@@ -304,7 +335,6 @@ private void verifyHandle() {
      * </pre>
      * Use {@link Box#query(QueryCondition)} as a shortcut for this method.
      */
-    @Experimental
     public QueryBuilder<T> apply(QueryCondition<T> queryCondition) {
         ((QueryConditionImpl<T>) queryCondition).apply(this);
         return this;
@@ -366,6 +396,9 @@ public QueryBuilder<T> sort(Comparator<T> comparator) {
 
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
      * Assigns the given alias to the previous condition.
      *
      * @param alias The string alias for use with setParameter(s) methods.
@@ -425,8 +458,7 @@ public <TARGET> QueryBuilder<TARGET> backlink(RelationInfo<TARGET, ?> relationIn
 
     /**
      * Specifies relations that should be resolved eagerly.
-     * This prepares the given relation objects to be preloaded (cached) avoiding further get operations from the db.
-     * A common use case is prealoading all
+     * This prepares the given relation objects to be preloaded (cached) avoiding further get operations from the database.
      *
      * @param relationInfo The relation as found in the generated meta info class ("EntityName_") of class T.
      * @param more         Supply further relations to be eagerly loaded.
@@ -569,52 +601,95 @@ void internalOr(long leftCondition, long rightCondition) {
         lastCondition = nativeCombine(handle, leftCondition, rightCondition, true);
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> isNull(Property<T> property) {
         verifyHandle();
         checkCombineCondition(nativeNull(handle, property.getId()));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> notNull(Property<T> property) {
         verifyHandle();
         checkCombineCondition(nativeNotNull(handle, property.getId()));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> relationCount(RelationInfo<T, ?> relationInfo, int relationCount) {
+        verifyHandle();
+        checkCombineCondition(nativeRelationCount(handle, storeHandle, relationInfo.targetInfo.getEntityId(),
+                relationInfo.targetIdProperty.id, relationCount));
+        return this;
+    }
+
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                              Integers
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> equal(Property<T> property, long value) {
         verifyHandle();
         checkCombineCondition(nativeEqual(handle, property.getId(), value));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> notEqual(Property<T> property, long value) {
         verifyHandle();
         checkCombineCondition(nativeNotEqual(handle, property.getId(), value));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> less(Property<T> property, long value) {
         verifyHandle();
         checkCombineCondition(nativeLess(handle, property.getId(), value, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> lessOrEqual(Property<T> property, long value) {
         verifyHandle();
         checkCombineCondition(nativeLess(handle, property.getId(), value, true));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greater(Property<T> property, long value) {
         verifyHandle();
         checkCombineCondition(nativeGreater(handle, property.getId(), value, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greaterOrEqual(Property<T> property, long value) {
         verifyHandle();
         checkCombineCondition(nativeGreater(handle, property.getId(), value, true));
@@ -622,6 +697,9 @@ public QueryBuilder<T> greaterOrEqual(Property<T> property, long value) {
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
      * Finds objects with property value between and including the first and second value.
      */
     public QueryBuilder<T> between(Property<T> property, long value1, long value2) {
@@ -631,12 +709,21 @@ public QueryBuilder<T> between(Property<T> property, long value1, long value2) {
     }
 
     // FIXME DbException: invalid unordered_map<K, T> key
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> in(Property<T> property, long[] values) {
         verifyHandle();
         checkCombineCondition(nativeIn(handle, property.getId(), values, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> notIn(Property<T> property, long[] values) {
         verifyHandle();
         checkCombineCondition(nativeIn(handle, property.getId(), values, true));
@@ -647,12 +734,20 @@ public QueryBuilder<T> notIn(Property<T> property, long[] values) {
     // Integers -> int[]
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> in(Property<T> property, int[] values) {
         verifyHandle();
         checkCombineCondition(nativeIn(handle, property.getId(), values, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> notIn(Property<T> property, int[] values) {
         verifyHandle();
         checkCombineCondition(nativeIn(handle, property.getId(), values, true));
@@ -663,12 +758,20 @@ public QueryBuilder<T> notIn(Property<T> property, int[] values) {
     // Integers -> boolean
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> equal(Property<T> property, boolean value) {
         verifyHandle();
         checkCombineCondition(nativeEqual(handle, property.getId(), value ? 1 : 0));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> notEqual(Property<T> property, boolean value) {
         verifyHandle();
         checkCombineCondition(nativeNotEqual(handle, property.getId(), value ? 1 : 0));
@@ -680,6 +783,9 @@ public QueryBuilder<T> notEqual(Property<T> property, boolean value) {
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
      * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
      */
     public QueryBuilder<T> equal(Property<T> property, Date value) {
@@ -689,6 +795,9 @@ public QueryBuilder<T> equal(Property<T> property, Date value) {
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
      * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
      */
     public QueryBuilder<T> notEqual(Property<T> property, Date value) {
@@ -698,6 +807,9 @@ public QueryBuilder<T> notEqual(Property<T> property, Date value) {
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
      * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
      */
     public QueryBuilder<T> less(Property<T> property, Date value) {
@@ -707,6 +819,9 @@ public QueryBuilder<T> less(Property<T> property, Date value) {
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
      * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
      */
     public QueryBuilder<T> lessOrEqual(Property<T> property, Date value) {
@@ -716,6 +831,9 @@ public QueryBuilder<T> lessOrEqual(Property<T> property, Date value) {
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
      * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
      */
     public QueryBuilder<T> greater(Property<T> property, Date value) {
@@ -725,6 +843,9 @@ public QueryBuilder<T> greater(Property<T> property, Date value) {
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
      * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
      */
     public QueryBuilder<T> greaterOrEqual(Property<T> property, Date value) {
@@ -734,6 +855,9 @@ public QueryBuilder<T> greaterOrEqual(Property<T> property, Date value) {
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
      * Finds objects with property value between and including the first and second value.
      *
      * @throws NullPointerException if one of the given values is null.
@@ -749,6 +873,9 @@ public QueryBuilder<T> between(Property<T> property, Date value1, Date value2) {
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
      * Creates an "equal ('=')" condition for this property.
      */
     public QueryBuilder<T> equal(Property<T> property, String value, StringOrder order) {
@@ -758,6 +885,9 @@ public QueryBuilder<T> equal(Property<T> property, String value, StringOrder ord
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
      * Creates a "not equal ('&lt;&gt;')" condition for this property.
      */
     public QueryBuilder<T> notEqual(Property<T> property, String value, StringOrder order) {
@@ -767,7 +897,10 @@ public QueryBuilder<T> notEqual(Property<T> property, String value, StringOrder
     }
 
     /**
-     * Creates an contains condition.
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
+     * Creates a contains condition.
      * <p>
      * Note: for a String array property, use {@link #containsElement} instead.
      */
@@ -781,6 +914,9 @@ public QueryBuilder<T> contains(Property<T> property, String value, StringOrder
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
      * For a String array, list or String-key map property, matches if at least one element equals the given value.
      */
     public QueryBuilder<T> containsElement(Property<T> property, String value, StringOrder order) {
@@ -790,50 +926,230 @@ public QueryBuilder<T> containsElement(Property<T> property, String value, Strin
     }
 
     /**
-     * For a String-key map property, matches if at least one key and value combination equals the given values.
+     * @deprecated Use {@link Property#equalKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
      */
+    @Deprecated
     public QueryBuilder<T> containsKeyValue(Property<T> property, String key, String value, StringOrder order) {
         verifyHandle();
-        checkCombineCondition(nativeContainsKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        checkCombineCondition(nativeEqualKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#equalKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> equalKeyValue(Property<T> property, String key, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeEqualKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessKeyValue(Property<T> property, String key, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeLessKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessOrEqualKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessOrEqualKeyValue(Property<T> property, String key, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeLessEqualsKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterKeyValue(Property<T> property, String key, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterOrEqualKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterOrEqualKeyValue(Property<T> property, String key, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterEqualsKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#equalKeyValue(String, long)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> equalKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeEqualKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessKeyValue(String, long)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeLessKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessOrEqualKeyValue(String, long)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessOrEqualKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeLessEqualsKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterOrEqualKeyValue(String, long)} (String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterOrEqualKeyValue(String, long)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterOrEqualKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterEqualsKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#equalKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> equalKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeEqualKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeLessKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessOrEqualKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessOrEqualKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeLessEqualsKeyValue(handle, property.getId(), key, value));
         return this;
     }
 
+    /**
+     * Note: Use {@link Property#greaterKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterOrEqualKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterOrEqualKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterEqualsKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> startsWith(Property<T> property, String value, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeStartsWith(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> endsWith(Property<T> property, String value, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeEndsWith(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> less(Property<T> property, String value, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeLess(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> lessOrEqual(Property<T> property, String value, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeLess(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE, true));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greater(Property<T> property, String value, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeGreater(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greaterOrEqual(Property<T> property, String value, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeGreater(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE, true));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> in(Property<T> property, String[] values, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeIn(handle, property.getId(), values, order == StringOrder.CASE_SENSITIVE));
@@ -848,6 +1164,9 @@ public QueryBuilder<T> in(Property<T> property, String[] values, StringOrder ord
     // Help people with floating point equality...
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
      * Floating point equality is non-trivial; this is just a convenience for
      * {@link #between(Property, double, double)} with parameters(property, value - tolerance, value + tolerance).
      * When using {@link Query#setParameters(Property, double, double)},
@@ -857,24 +1176,40 @@ public QueryBuilder<T> equal(Property<T> property, double value, double toleranc
         return between(property, value - tolerance, value + tolerance);
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> less(Property<T> property, double value) {
         verifyHandle();
         checkCombineCondition(nativeLess(handle, property.getId(), value, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> lessOrEqual(Property<T> property, double value) {
         verifyHandle();
         checkCombineCondition(nativeLess(handle, property.getId(), value, true));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greater(Property<T> property, double value) {
         verifyHandle();
         checkCombineCondition(nativeGreater(handle, property.getId(), value, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greaterOrEqual(Property<T> property, double value) {
         verifyHandle();
         checkCombineCondition(nativeGreater(handle, property.getId(), value, true));
@@ -882,6 +1217,9 @@ public QueryBuilder<T> greaterOrEqual(Property<T> property, double value) {
     }
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
      * Finds objects with property value between and including the first and second value.
      */
     public QueryBuilder<T> between(Property<T> property, double value1, double value2) {
@@ -890,34 +1228,64 @@ public QueryBuilder<T> between(Property<T> property, double value1, double value
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> nearestNeighbors(Property<T> property, float[] queryVector, int maxResultCount) {
+        verifyHandle();
+        checkCombineCondition(nativeNearestNeighborsF32(handle, property.getId(), queryVector, maxResultCount));
+        return this;
+    }
+
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                                 Bytes
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> equal(Property<T> property, byte[] value) {
         verifyHandle();
         checkCombineCondition(nativeEqual(handle, property.getId(), value));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> less(Property<T> property, byte[] value) {
         verifyHandle();
         checkCombineCondition(nativeLess(handle, property.getId(), value, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> lessOrEqual(Property<T> property, byte[] value) {
         verifyHandle();
         checkCombineCondition(nativeLess(handle, property.getId(), value, true));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greater(Property<T> property, byte[] value) {
         verifyHandle();
         checkCombineCondition(nativeGreater(handle, property.getId(), value, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greaterOrEqual(Property<T> property, byte[] value) {
         verifyHandle();
         checkCombineCondition(nativeGreater(handle, property.getId(), value, true));
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryCondition.java b/objectbox-java/src/main/java/io/objectbox/query/QueryCondition.java
index 6553c6a7..b4b5a6dc 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryCondition.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryCondition.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2016-2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.query;
 
 import io.objectbox.Property;
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryConditionImpl.java b/objectbox-java/src/main/java/io/objectbox/query/QueryConditionImpl.java
index 5fe8bc61..2d7ded81 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryConditionImpl.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryConditionImpl.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.query;
 
 import io.objectbox.query.LogicQueryCondition.AndCondition;
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryConsumer.java b/objectbox-java/src/main/java/io/objectbox/query/QueryConsumer.java
index 255d0a66..24fd53de 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryConsumer.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryConsumer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryFilter.java b/objectbox-java/src/main/java/io/objectbox/query/QueryFilter.java
index b60349b2..86213a34 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryFilter.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryFilter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryPublisher.java b/objectbox-java/src/main/java/io/objectbox/query/QueryPublisher.java
index a3d2196e..7f1eb75f 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryPublisher.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,26 +35,39 @@
 import io.objectbox.reactive.SubscriptionBuilder;
 
 /**
- * A {@link DataPublisher} that subscribes to an ObjectClassPublisher if there is at least one observer.
- * Publishing is requested if the ObjectClassPublisher reports changes, a subscription is
- * {@link SubscriptionBuilder#observer(DataObserver) observed} or {@link Query#publish()} is called.
- * For publishing the query is re-run and the result delivered to the current observers.
- * Results are published on a single thread, one at a time, in the order publishing was requested.
+ * A {@link DataPublisher} that {@link BoxStore#subscribe(Class) subscribes to the Box} of its associated {@link Query}
+ * while there is at least one observer (see {@link #subscribe(DataObserver, Object)} and
+ * {@link #unsubscribe(DataObserver, Object)}).
+ * <p>
+ * Publishing is requested if the Box reports changes, a subscription is
+ * {@link SubscriptionBuilder#observer(DataObserver) observed} (if {@link #publishSingle(DataObserver, Object)} is
+ * called) or {@link Query#publish()} (calls {@link #publish()}) is called.
+ * <p>
+ * For publishing the query is re-run and the result data is delivered to the current observers.
+ * <p>
+ * Data is passed to observers on a single thread ({@link BoxStore#internalScheduleThread(Runnable)}), one at a time, in
+ * the order observers were added.
  */
 @Internal
 class QueryPublisher<T> implements DataPublisher<List<T>>, Runnable {
 
+    /**
+     * If enabled, logs states of the publisher runnable. Useful to debug a query subscription.
+     */
+    public static boolean LOG_STATES = false;
     private final Query<T> query;
     private final Box<T> box;
     private final Set<DataObserver<List<T>>> observers = new CopyOnWriteArraySet<>();
     private final Deque<DataObserver<List<T>>> publishQueue = new ArrayDeque<>();
     private volatile boolean publisherRunning = false;
+    private volatile boolean publisherStopped = false;
 
     private static class SubscribedObservers<T> implements DataObserver<List<T>> {
         @Override
         public void onData(List<T> data) {
         }
     }
+
     /** Placeholder observer to use if all subscribed observers should be notified. */
     private final SubscribedObservers<T> SUBSCRIBED_OBSERVERS = new SubscribedObservers<>();
 
@@ -105,6 +118,10 @@ void publish() {
      */
     private void queueObserverAndScheduleRun(DataObserver<List<T>> observer) {
         synchronized (publishQueue) {
+            // Check after obtaining the lock as the publisher may have been stopped while waiting on the lock
+            if (publisherStopped) {
+                return;
+            }
             publishQueue.add(observer);
             if (!publisherRunning) {
                 publisherRunning = true;
@@ -113,6 +130,31 @@ private void queueObserverAndScheduleRun(DataObserver<List<T>> observer) {
         }
     }
 
+    /**
+     * Marks this publisher as stopped and if it is currently running waits on it to complete.
+     * <p>
+     * After calling this, this publisher will no longer run, even if observers subscribe or publishing is requested.
+     */
+    void stopAndAwait() {
+        publisherStopped = true;
+        // Doing wait/notify waiting here; could also use the Future from BoxStore.internalScheduleThread() instead.
+        // The latter would require another member though, which seems redundant.
+        synchronized (this) {
+            while (publisherRunning) {
+                try {
+                    this.wait();
+                } catch (InterruptedException e) {
+                    if (publisherRunning) {
+                        // When called by Query.close() throwing here will leak the query. But not throwing would allow
+                        // close() to proceed in destroying the native query while it may still be active (run() of this
+                        // is at the query.find() call), which would trigger a VM crash.
+                        throw new RuntimeException("Interrupted while waiting for publisher to finish", e);
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Processes publish requests for this query on a single thread to prevent
      * older query results getting delivered after newer query results.
@@ -121,9 +163,11 @@ private void queueObserverAndScheduleRun(DataObserver<List<T>> observer) {
      */
     @Override
     public void run() {
+        log("started");
         try {
-            while (true) {
+            while (!publisherStopped) {
                 // Get all queued observer(s), stop processing if none.
+                log("checking for observers");
                 List<DataObserver<List<T>>> singlePublishObservers = new ArrayList<>();
                 boolean notifySubscribedObservers = false;
                 synchronized (publishQueue) {
@@ -142,9 +186,12 @@ public void run() {
                 }
 
                 // Query.
+                log("running query");
+                if (publisherStopped) break;  // Check again to avoid running the query if possible
                 List<T> result = query.find();
 
                 // Notify observer(s).
+                log("notifying observers");
                 for (DataObserver<List<T>> observer : singlePublishObservers) {
                     observer.onData(result);
                 }
@@ -157,8 +204,12 @@ public void run() {
                 }
             }
         } finally {
+            log("stopped");
             // Re-set if wrapped code throws, otherwise this publisher can no longer publish.
             publisherRunning = false;
+            synchronized (this) {
+                this.notifyAll();
+            }
         }
     }
 
@@ -171,4 +222,8 @@ public synchronized void unsubscribe(DataObserver<List<T>> observer, @Nullable O
         }
     }
 
+    private static void log(String message) {
+        if (LOG_STATES) System.out.println("QueryPublisher: " + message);
+    }
+
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryThreadLocal.java b/objectbox-java/src/main/java/io/objectbox/query/QueryThreadLocal.java
new file mode 100644
index 00000000..9bef4ec5
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryThreadLocal.java
@@ -0,0 +1,22 @@
+package io.objectbox.query;
+
+/**
+ * A {@link ThreadLocal} that, given an original {@link Query} object,
+ * returns a {@link Query#copy() copy}, for each thread.
+ */
+public class QueryThreadLocal<T> extends ThreadLocal<Query<T>> {
+
+    private final Query<T> original;
+
+    /**
+     * See {@link QueryThreadLocal}.
+     */
+    public QueryThreadLocal(Query<T> original) {
+        this.original = original;
+    }
+
+    @Override
+    protected Query<T> initialValue() {
+        return original.copy();
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/RelationCountCondition.java b/objectbox-java/src/main/java/io/objectbox/query/RelationCountCondition.java
new file mode 100644
index 00000000..86d5e38c
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/RelationCountCondition.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+import io.objectbox.relation.RelationInfo;
+
+public class RelationCountCondition<T> extends QueryConditionImpl<T> {
+
+    private final RelationInfo<T, ?> relationInfo;
+    private final int relationCount;
+
+
+    public RelationCountCondition(RelationInfo<T, ?> relationInfo, int relationCount) {
+        this.relationInfo = relationInfo;
+        this.relationCount = relationCount;
+    }
+
+    @Override
+    void apply(QueryBuilder<T> builder) {
+        builder.relationCount(relationInfo, relationCount);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/package-info.java b/objectbox-java/src/main/java/io/objectbox/query/package-info.java
index 7530a37c..86a3bf23 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataObserver.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataObserver.java
index 3c5dac41..2ab7f534 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataObserver.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataObserver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisher.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisher.java
index f57950ce..001753fe 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisher.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisherUtils.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisherUtils.java
index 496b172a..a6f08298 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisherUtils.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisherUtils.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscription.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscription.java
index 26b12fe8..54b2dedf 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscription.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscription.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionImpl.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionImpl.java
index fc7a15fe..5b854cf1 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionImpl.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionList.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionList.java
index 40d19e24..59e63dde 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionList.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionList.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataTransformer.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataTransformer.java
index d34f1cea..4d65d9b9 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataTransformer.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataTransformer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,6 +33,7 @@
 public interface DataTransformer<FROM, TO> {
     /**
      * Transforms/processes the given data.
+     *
      * @param source data to be transformed
      * @return transformed data
      * @throws Exception Transformers may throw any exceptions, which can be reacted on via
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DelegatingObserver.java b/objectbox-java/src/main/java/io/objectbox/reactive/DelegatingObserver.java
index b771a5a7..3263d86a 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DelegatingObserver.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DelegatingObserver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/ErrorObserver.java b/objectbox-java/src/main/java/io/objectbox/reactive/ErrorObserver.java
index 2b1b245d..8d1de9c8 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/ErrorObserver.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/ErrorObserver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/RunWithParam.java b/objectbox-java/src/main/java/io/objectbox/reactive/RunWithParam.java
index 90059cf9..03cdd43e 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/RunWithParam.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/RunWithParam.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/Scheduler.java b/objectbox-java/src/main/java/io/objectbox/reactive/Scheduler.java
index 4172ea67..7f478a1d 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/Scheduler.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/Scheduler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/Schedulers.java b/objectbox-java/src/main/java/io/objectbox/reactive/Schedulers.java
index 8461acce..e095f462 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/Schedulers.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/Schedulers.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/SubscriptionBuilder.java b/objectbox-java/src/main/java/io/objectbox/reactive/SubscriptionBuilder.java
index 12b9373e..9760128d 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/SubscriptionBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/SubscriptionBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -148,13 +148,20 @@ public SubscriptionBuilder<T> on(Scheduler scheduler) {
     }
 
     /**
-     * Sets the observer for this subscription and requests the latest data to be delivered immediately.
-     * Subscribes to receive data updates. This can be changed by using {@link #single()} or {@link #onlyChanges()}.
+     * Completes building the subscription by setting a {@link DataObserver} that receives the data.
      * <p>
-     * Results are delivered on a background thread owned by the internal data publisher,
-     * unless a scheduler was set using {@link #on(Scheduler)}.
+     * By default, requests the latest data to be delivered immediately and on any future updates. To change this call
+     * {@link #single()} or {@link #onlyChanges()} before.
      * <p>
-     * The returned {@link DataSubscription} must be canceled once the observer should no longer receive data.
+     * By default, {@link DataObserver#onData(Object)} is called from an internal background thread. Change this by
+     * setting a custom scheduler using {@link #on(Scheduler)}. It may also get called for multiple observers at the
+     * same time. The order in which observers are called is the same as the subscription order, although this may
+     * change in the future.
+     * <p>
+     * Typically, keep a reference to the returned {@link DataSubscription} to avoid it getting garbage collected, to
+     * keep receiving new data.
+     * <p>
+     * Call {@link DataSubscription#cancel()} once the observer should no longer receive data.
      */
     public DataSubscription observer(DataObserver<T> observer) {
         WeakDataObserver<T> weakObserver = null;
@@ -167,7 +174,7 @@ public DataSubscription observer(DataObserver<T> observer) {
             weakObserver.setSubscription(subscription);
         }
 
-        if(dataSubscriptionList != null) {
+        if (dataSubscriptionList != null) {
             dataSubscriptionList.add(subscription);
         }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/WeakDataObserver.java b/objectbox-java/src/main/java/io/objectbox/reactive/WeakDataObserver.java
index cdffbed2..a11f57af 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/WeakDataObserver.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/WeakDataObserver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/package-info.java b/objectbox-java/src/main/java/io/objectbox/reactive/package-info.java
index b70449b6..57a0bb94 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/ListFactory.java b/objectbox-java/src/main/java/io/objectbox/relation/ListFactory.java
index b7a12a98..b6666e4c 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/ListFactory.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/ListFactory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/RelationInfo.java b/objectbox-java/src/main/java/io/objectbox/relation/RelationInfo.java
index 09386908..8c47ffe3 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/RelationInfo.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/RelationInfo.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,6 +25,8 @@
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.internal.ToManyGetter;
 import io.objectbox.internal.ToOneGetter;
+import io.objectbox.query.QueryCondition;
+import io.objectbox.query.RelationCountCondition;
 
 /**
  * Meta info describing a relation including source and target entity.
@@ -44,16 +46,16 @@ public class RelationInfo<SOURCE, TARGET> implements Serializable {
     public final int targetRelationId;
 
     /** Only set for ToOne relations */
-    public final ToOneGetter<SOURCE> toOneGetter;
+    public final ToOneGetter<SOURCE, TARGET> toOneGetter;
 
     /** Only set for ToMany relations */
-    public final ToManyGetter<SOURCE> toManyGetter;
+    public final ToManyGetter<SOURCE, TARGET> toManyGetter;
 
     /** For ToMany relations based on ToOne backlinks (null otherwise). */
-    public final ToOneGetter<TARGET> backlinkToOneGetter;
+    public final ToOneGetter<TARGET, SOURCE> backlinkToOneGetter;
 
     /** For ToMany relations based on ToMany backlinks (null otherwise). */
-    public final ToManyGetter<TARGET> backlinkToManyGetter;
+    public final ToManyGetter<TARGET, SOURCE> backlinkToManyGetter;
 
     /** For stand-alone to-many relations (0 otherwise). */
     public final int relationId;
@@ -62,7 +64,7 @@ public class RelationInfo<SOURCE, TARGET> implements Serializable {
      * ToOne
      */
     public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, Property<SOURCE> targetIdProperty,
-                        ToOneGetter<SOURCE> toOneGetter) {
+                        ToOneGetter<SOURCE, TARGET> toOneGetter) {
         this.sourceInfo = sourceInfo;
         this.targetInfo = targetInfo;
         this.targetIdProperty = targetIdProperty;
@@ -77,8 +79,8 @@ public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo
     /**
      * ToMany as a ToOne backlink
      */
-    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE> toManyGetter,
-                        Property<TARGET> targetIdProperty, ToOneGetter<TARGET> backlinkToOneGetter) {
+    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE, TARGET> toManyGetter,
+                        Property<TARGET> targetIdProperty, ToOneGetter<TARGET, SOURCE> backlinkToOneGetter) {
         this.sourceInfo = sourceInfo;
         this.targetInfo = targetInfo;
         this.targetIdProperty = targetIdProperty;
@@ -93,8 +95,8 @@ public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo
     /**
      * ToMany as a ToMany backlink
      */
-    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE> toManyGetter,
-            ToManyGetter<TARGET> backlinkToManyGetter, int targetRelationId) {
+    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE, TARGET> toManyGetter,
+                        ToManyGetter<TARGET, SOURCE> backlinkToManyGetter, int targetRelationId) {
         this.sourceInfo = sourceInfo;
         this.targetInfo = targetInfo;
         this.toManyGetter = toManyGetter;
@@ -109,7 +111,7 @@ public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo
     /**
      * Stand-alone ToMany.
      */
-    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE> toManyGetter,
+    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE, TARGET> toManyGetter,
                         int relationId) {
         this.sourceInfo = sourceInfo;
         this.targetInfo = targetInfo;
@@ -130,5 +132,31 @@ public boolean isBacklink() {
     public String toString() {
         return "RelationInfo from " + sourceInfo.getEntityClass() + " to " + targetInfo.getEntityClass();
     }
+
+    /**
+     * Creates a condition to match objects that have {@code relationCount} related objects pointing to them.
+     * <pre>
+     * try (Query&lt;Customer&gt; query = customerBox
+     *         .query(Customer_.orders.relationCount(2))
+     *         .build()) {
+     *     List&lt;Customer&gt; customersWithTwoOrders = query.find();
+     * }
+     * </pre>
+     * {@code relationCount} may be 0 to match objects that do not have related objects.
+     * It typically should be a low number.
+     * <p>
+     * This condition has some limitations:
+     * <ul>
+     *     <li>only 1:N (ToMany using @Backlink) relations are supported,</li>
+     *     <li>the complexity is {@code O(n * (relationCount + 1))} and cannot be improved via indexes,</li>
+     *     <li>the relation count cannot be changed with setParameter once the query is built.</li>
+     * </ul>
+     */
+    public QueryCondition<SOURCE> relationCount(int relationCount) {
+        if (targetIdProperty == null) {
+            throw new IllegalStateException("The relation count condition is only supported for 1:N (ToMany using @Backlink) relations.");
+        }
+        return new RelationCountCondition<>(this, relationCount);
+    }
 }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/ToMany.java b/objectbox-java/src/main/java/io/objectbox/relation/ToMany.java
index 79b4e19f..508490e3 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/ToMany.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/ToMany.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,6 @@
  */
 package io.objectbox.relation;
 
-import io.objectbox.internal.ToManyGetter;
 import java.io.Serializable;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
@@ -36,30 +35,76 @@
 import io.objectbox.BoxStore;
 import io.objectbox.Cursor;
 import io.objectbox.InternalAccess;
+import io.objectbox.annotation.Backlink;
+import io.objectbox.annotation.Entity;
 import io.objectbox.annotation.apihint.Beta;
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.exception.DbDetachedException;
 import io.objectbox.internal.IdGetter;
 import io.objectbox.internal.ReflectionCache;
+import io.objectbox.internal.ToManyGetter;
 import io.objectbox.internal.ToOneGetter;
+import io.objectbox.query.QueryBuilder;
 import io.objectbox.query.QueryFilter;
 import io.objectbox.relation.ListFactory.CopyOnWriteArrayListFactory;
 
 import static java.lang.Boolean.TRUE;
 
 /**
- * A List representing a to-many relation.
- * It tracks changes (adds and removes) that can be later applied (persisted) to the database.
- * This happens either on {@link Box#put(Object)} of the source entity of this relation or using
- * {@link #applyChangesToDb()}.
+ * A to-many relation of an entity that references multiple objects of a {@link TARGET} entity.
+ * <p>
+ * Example:
+ * <pre>{@code
+ * // Java
+ * @Entity
+ * public class Student {
+ *     private ToMany<Teacher> teachers;
+ * }
+ *
+ * // Kotlin
+ * @Entity
+ * data class Student() {
+ *     lateinit var teachers: ToMany<Teacher>
+ * }
+ * }</pre>
+ * <p>
+ * Implements the {@link List} interface and uses lazy initialization. The target objects are only read from the
+ * database when the list is first accessed.
+ * <p>
+ * The required database query runs on the calling thread, so avoid accessing ToMany from a UI or main thread. To get the
+ * latest data {@link Box#get} the object with the ToMany again or use {@link #reset()} before accessing the list again.
+ * It is possible to preload the list when running a query using {@link QueryBuilder#eager}.
+ * <p>
+ * Tracks when target objects are added and removed. Common usage:
+ * <ul>
+ * <li>{@link #add(Object)} to add target objects to the relation.
+ * <li>{@link #remove(Object)} to remove target objects from the relation.
+ * <li>{@link #remove(int)} to remove target objects at a specific index.
+ * </ul>
  * <p>
- * If this relation is a backlink from a {@link ToOne} relation, a DB sync will also update ToOne objects
- * (but not vice versa).
+ * To apply (persist) the changes to the database, call {@link #applyChangesToDb()} or put the object with the ToMany.
+ * For important details, see the notes about relations of {@link Box#put(Object)}.
+ * <pre>{@code
+ * // Example 1: add target objects to a relation
+ * student.getTeachers().add(teacher1);
+ * student.getTeachers().add(teacher2);
+ * store.boxFor(Student.class).put(student);
+ *
+ * // Example 2: remove a target object from the relation
+ * student.getTeachers().remove(index);
+ * student.getTeachers().applyChangesToDb();
+ * // or store.boxFor(Student.class).put(student);
+ * }</pre>
+ * <p>
+ * In the database, the target objects are referenced by their IDs, which are persisted as part of the relation of the
+ * object with the ToMany.
  * <p>
- * ToMany is thread-safe by default (only if the default {@link java.util.concurrent.CopyOnWriteArrayList} is used).
+ * ToMany is thread-safe by default (may not be the case if {@link #setListFactory(ListFactory)} is used).
+ * <p>
+ * To get all objects with a ToMany that reference a target object, see {@link Backlink}.
  *
- * @param <TARGET> Object type (entity).
+ * @param <TARGET> target object type ({@link Entity @Entity} class).
  */
 public class ToMany<TARGET> implements List<TARGET>, Serializable {
     private static final long serialVersionUID = 2367317778240689006L;
@@ -147,8 +192,8 @@ private void ensureBoxes() {
             try {
                 boxStore = (BoxStore) boxStoreField.get(entity);
                 if (boxStore == null) {
-                    throw new DbDetachedException("Cannot resolve relation for detached entities, " +
-                            "call box.attach(entity) beforehand.");
+                    throw new DbDetachedException("Cannot resolve relation for detached objects, " +
+                            "call box.attach(object) beforehand.");
                 }
             } catch (IllegalAccessException e) {
                 throw new RuntimeException(e);
@@ -218,9 +263,10 @@ private void ensureEntities() {
     }
 
     /**
-     * Adds the given entity to the list and tracks the addition so it can be later applied to the database
-     * (e.g. via {@link Box#put(Object)} of the entity owning the ToMany, or via {@link #applyChangesToDb()}).
-     * Note that the given entity will remain unchanged at this point (e.g. to-ones are not updated).
+     * Prepares to add the given target object to this relation.
+     * <p>
+     * To apply changes, call {@link #applyChangesToDb()} or put the object with the ToMany. For important details, see
+     * the notes about relations of {@link Box#put(Object)}.
      */
     @Override
     public synchronized boolean add(TARGET object) {
@@ -321,8 +367,9 @@ public boolean containsAll(Collection<?> collection) {
     }
 
     /**
-     * @return An object for the given ID, or null if the object was already removed from its box
-     * (and was not cached before).
+     * Gets the target object at the given index.
+     * <p>
+     * {@link ToMany} uses lazy initialization, so on first access this will read the target objects from the database.
      */
     @Override
     public TARGET get(int location) {
@@ -373,6 +420,9 @@ public ListIterator<TARGET> listIterator(int location) {
         return entities.listIterator(location);
     }
 
+    /**
+     * Like {@link #remove(Object)}, but using the location of the target object.
+     */
     @Override
     public synchronized TARGET remove(int location) {
         ensureEntitiesWithTrackingLists();
@@ -381,6 +431,12 @@ public synchronized TARGET remove(int location) {
         return removed;
     }
 
+    /**
+     * Prepares to remove the target object from this relation.
+     * <p>
+     * To apply changes, call {@link #applyChangesToDb()} or put the object with the ToMany. For important details, see
+     * the notes about relations of {@link Box#put(Object)}.
+     */
     @SuppressWarnings("unchecked") // Cast to TARGET: If removed, must be of type TARGET.
     @Override
     public synchronized boolean remove(Object object) {
@@ -392,7 +448,9 @@ public synchronized boolean remove(Object object) {
         return removed;
     }
 
-    /** Removes an object by its entity ID. */
+    /**
+     * Like {@link #remove(Object)}, but using just the ID of the target object.
+     */
     public synchronized TARGET removeById(long id) {
         ensureEntities();
         int size = entities.size();
@@ -482,8 +540,10 @@ public <T> T[] toArray(T[] array) {
     }
 
     /**
-     * Resets the already loaded entities so they will be re-loaded on their next access.
-     * This allows to sync with non-tracked changes (outside of this ToMany object).
+     * Resets the already loaded (cached) objects of this list, so they will be re-loaded when accessing this list
+     * again.
+     * <p>
+     * Use this to sync with changes to this relation or target objects made outside of this ToMany.
      */
     public synchronized void reset() {
         entities = null;
@@ -509,9 +569,9 @@ public int getRemoveCount() {
     }
 
     /**
-     * Sorts the list by the "natural" ObjectBox order for to-many list (by entity ID).
-     * This will be the order when you get the entities fresh (e.g. initially or after calling {@link #reset()}).
-     * Note that non persisted entities (ID is zero) will be put to the end as they are still to get an ID.
+     * Sorts the list by the "natural" ObjectBox order for to-many list (by object ID).
+     * This will be the order when you get the objects fresh (e.g. initially or after calling {@link #reset()}).
+     * Note that non persisted objects (ID is zero) will be put to the end as they are still to get an ID.
      */
     public void sortById() {
         ensureEntities();
@@ -540,23 +600,25 @@ else if (delta > 0)
     }
 
     /**
-     * Applies (persists) tracked changes (added and removed entities) to the target box
-     * and/or updates standalone relations.
-     * Note that this is done automatically when you put the source entity of this to-many relation.
-     * However, if only this to-many relation has changed, it is more efficient to call this method.
+     * Saves changes (added and removed objects) made to this relation to the database. For some important details, see
+     * the notes about relations of {@link Box#put(Object)}.
+     * <p>
+     * Note that this is called already when the object that contains this ToMany is put. However, if only this ToMany
+     * has changed, it is more efficient to just use this method.
      *
-     * @throws IllegalStateException If the source entity of this to-many relation was not previously persisted
+     * @throws IllegalStateException If the object that contains this ToMany has no ID assigned (it must have been put
+     * before).
      */
     public void applyChangesToDb() {
         long id = relationInfo.sourceInfo.getIdGetter().getId(entity);
         if (id == 0) {
             throw new IllegalStateException(
-                    "The source entity was not yet persisted (no ID), use box.put() on it instead");
+                    "The object with the ToMany was not yet persisted (no ID), use box.put() on it instead");
         }
         try {
             ensureBoxes();
         } catch (DbDetachedException e) {
-            throw new IllegalStateException("The source entity was not yet persisted, use box.put() on it instead");
+            throw new IllegalStateException("The object with the ToMany was not yet persisted, use box.put() on it instead");
         }
         if (internalCheckApplyToDbRequired()) {
             // We need a TX because we use two writers and both must use same TX (without: unchecked, SIGSEGV)
@@ -569,10 +631,10 @@ public void applyChangesToDb() {
     }
 
     /**
-     * Returns true if at least one of the entities matches the given filter.
+     * Returns true if at least one of the target objects matches the given filter.
      * <p>
-     * For use with {@link io.objectbox.query.QueryBuilder#filter(QueryFilter)} inside a {@link QueryFilter} to check
-     * to-many relation entities.
+     * For use with {@link QueryBuilder#filter(QueryFilter)} inside a {@link QueryFilter} to check
+     * to-many relation objects.
      */
     @Beta
     public boolean hasA(QueryFilter<TARGET> filter) {
@@ -587,10 +649,10 @@ public boolean hasA(QueryFilter<TARGET> filter) {
     }
 
     /**
-     * Returns true if all of the entities match the given filter. Returns false if the list is empty.
+     * Returns true if all of the target objects match the given filter. Returns false if the list is empty.
      * <p>
-     * For use with {@link io.objectbox.query.QueryBuilder#filter(QueryFilter)} inside a {@link QueryFilter} to check
-     * to-many relation entities.
+     * For use with {@link QueryBuilder#filter(QueryFilter)} inside a {@link QueryFilter} to check
+     * to-many relation objects.
      */
     @Beta
     public boolean hasAll(QueryFilter<TARGET> filter) {
@@ -607,7 +669,7 @@ public boolean hasAll(QueryFilter<TARGET> filter) {
         return true;
     }
 
-    /** Gets an object by its entity ID. */
+    /** Gets an object by its ID. */
     @Beta
     public TARGET getById(long id) {
         ensureEntities();
@@ -622,7 +684,7 @@ public TARGET getById(long id) {
         return null;
     }
 
-    /** Gets the index of the object with the given entity ID. */
+    /** Gets the index of the object with the given ID. */
     @Beta
     public int indexOfId(long id) {
         ensureEntities();
@@ -641,7 +703,7 @@ public int indexOfId(long id) {
 
     /**
      * Returns true if there are pending changes for the DB.
-     * Changes will be automatically persisted once the owning entity is put, or an explicit call to
+     * Changes will be automatically persisted once the object with the ToMany is put, or an explicit call to
      * {@link #applyChangesToDb()} is made.
      */
     public boolean hasPendingDbChanges() {
@@ -656,7 +718,7 @@ public boolean hasPendingDbChanges() {
 
     /**
      * For internal use only; do not use in your app.
-     * Called after relation source entity is put (so we have its ID).
+     * Called after relation source object is put (so we have its ID).
      * Prepares data for {@link #internalApplyToDb(Cursor, Cursor)}
      */
     @Internal
@@ -680,7 +742,7 @@ public boolean internalCheckApplyToDbRequired() {
             // Relation based on Backlink
             long entityId = relationInfo.sourceInfo.getIdGetter().getId(entity);
             if (entityId == 0) {
-                throw new IllegalStateException("Source entity has no ID (should have been put before)");
+                throw new IllegalStateException("Object with the ToMany has no ID (should have been put before)");
             }
             IdGetter<TARGET> idGetter = relationInfo.targetInfo.getIdGetter();
             Map<TARGET, Boolean> setAdded = this.entitiesAdded;
@@ -694,9 +756,20 @@ public boolean internalCheckApplyToDbRequired() {
         }
     }
 
+    /**
+     * Modifies the {@link Backlink linked} ToMany relation of added or removed target objects and schedules put by
+     * {@link #internalApplyToDb} for them.
+     * <p>
+     * If {@link #setRemoveFromTargetBox} is true, removed target objects are scheduled for removal instead of just
+     * updating their ToMany relation.
+     * <p>
+     * If target objects are new, schedules a put if they were added, but never if they were removed from this relation.
+     *
+     * @return Whether there are any target objects to put or remove.
+     */
     private boolean prepareToManyBacklinkEntitiesForDb(long entityId, IdGetter<TARGET> idGetter,
-            @Nullable Map<TARGET, Boolean> setAdded, @Nullable Map<TARGET, Boolean> setRemoved) {
-        ToManyGetter<TARGET> backlinkToManyGetter = relationInfo.backlinkToManyGetter;
+                                                       @Nullable Map<TARGET, Boolean> setAdded, @Nullable Map<TARGET, Boolean> setRemoved) {
+        ToManyGetter<TARGET, Object> backlinkToManyGetter = relationInfo.backlinkToManyGetter;
 
         synchronized (this) {
             if (setAdded != null && !setAdded.isEmpty()) {
@@ -738,9 +811,12 @@ private boolean prepareToManyBacklinkEntitiesForDb(long entityId, IdGetter<TARGE
         }
     }
 
+    /**
+     * Like {@link #prepareToManyBacklinkEntitiesForDb} but for the linked ToOne relation.
+     */
     private boolean prepareToOneBacklinkEntitiesForDb(long entityId, IdGetter<TARGET> idGetter,
-            @Nullable Map<TARGET, Boolean> setAdded, @Nullable Map<TARGET, Boolean> setRemoved) {
-        ToOneGetter<TARGET> backlinkToOneGetter = relationInfo.backlinkToOneGetter;
+                                                      @Nullable Map<TARGET, Boolean> setAdded, @Nullable Map<TARGET, Boolean> setRemoved) {
+        ToOneGetter<TARGET, Object> backlinkToOneGetter = relationInfo.backlinkToOneGetter;
 
         synchronized (this) {
             if (setAdded != null && !setAdded.isEmpty()) {
@@ -840,7 +916,7 @@ public void internalApplyToDb(Cursor<?> sourceCursor, Cursor<TARGET> targetCurso
         if (isStandaloneRelation) {
             long entityId = relationInfo.sourceInfo.getIdGetter().getId(entity);
             if (entityId == 0) {
-                throw new IllegalStateException("Source entity has no ID (should have been put before)");
+                throw new IllegalStateException("Object with the ToMany has no ID (should have been put before)");
             }
 
             if (removedStandalone != null) {
@@ -883,7 +959,7 @@ private void addStandaloneRelations(Cursor<?> cursor, long sourceEntityId, TARGE
             long targetId = targetIdGetter.getId(added[i]);
             if (targetId == 0) {
                 // Paranoia
-                throw new IllegalStateException("Target entity has no ID (should have been put before)");
+                throw new IllegalStateException("Target object has no ID (should have been put before)");
             }
             targetIds[i] = targetId;
         }
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/ToOne.java b/objectbox-java/src/main/java/io/objectbox/relation/ToOne.java
index 44b13c6f..254c4537 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/ToOne.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/ToOne.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,22 +24,64 @@
 import io.objectbox.Box;
 import io.objectbox.BoxStore;
 import io.objectbox.Cursor;
+import io.objectbox.annotation.Backlink;
+import io.objectbox.annotation.Entity;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.exception.DbDetachedException;
 import io.objectbox.internal.ReflectionCache;
 
 /**
- * Manages a to-one relation: resolves the target object, keeps the target Id in sync, etc.
- * A to-relation is unidirectional: it points from the source entity to the target entity.
- * The target is referenced by its ID, which is persisted in the source entity.
+ * A to-one relation of an entity that references one object of a {@link TARGET} entity.
  * <p>
- * If there is a {@link ToMany} relation linking back to this to-one relation (@Backlink),
- * the ToMany object will not be notified/updated about persisted changes here.
- * Call {@link ToMany#reset()} so it will update when next accessed.
+ * Example:
+ * <pre>{@code
+ * // Java
+ * @Entity
+ * public class Order {
+ *     private ToOne<Customer> customer;
+ * }
+ *
+ * // Kotlin
+ * @Entity
+ * data class Order() {
+ *     lateinit var customer: ToOne<Customer>
+ * }
+ * }</pre>
+ * <p>
+ * Uses lazy initialization. The target object ({@link #getTarget()}) is only read from the database when it is first
+ * accessed.
+ * <p>
+ * Common usage:
+ * <ul>
+ * <li>Set the target object with {@link #setTarget} to create a relation.
+ *     When the object with the ToOne is put, if the target object is new (its ID is 0), it will be put as well.
+ *     Otherwise, only the target ID in the database is updated.
+ * <li>{@link #setTargetId} of the target object to create a relation.
+ * <li>{@link #setTarget} with {@code null} or {@link #setTargetId} to {@code 0} to remove the relation.
+ * </ul>
+ * <p>
+ * Then, to persist the changes {@link Box#put} the object with the ToOne.
+ * <pre>{@code
+ * // Example 1: create a relation
+ * order.getCustomer().setTarget(customer);
+ * // or order.getCustomer().setTargetId(customerId);
+ * store.boxFor(Order.class).put(order);
+ *
+ * // Example 2: remove the relation
+ * order.getCustomer().setTarget(null);
+ * // or order.getCustomer().setTargetId(0);
+ * store.boxFor(Order.class).put(order);
+ * }</pre>
+ * <p>
+ * The target object is referenced by its ID.
+ * This target ID ({@link #getTargetId()}) is persisted as part of the object with the ToOne in a special
+ * property created for each ToOne (named like "customerId").
+ * <p>
+ * To get all objects with a ToOne that reference a target object, see {@link Backlink}.
+ *
+ * @param <TARGET> target object type ({@link Entity @Entity} class).
  */
-// TODO add more tests
 // TODO not exactly thread safe
-// TODO enforce not-null (not zero) checks on the target setters once we use some not-null annotation
 public class ToOne<TARGET> implements Serializable {
     private static final long serialVersionUID = 5092547044335989281L;
 
@@ -85,7 +127,9 @@ public ToOne(Object sourceEntity, RelationInfo<?, TARGET> relationInfo) {
     }
 
     /**
-     * @return The target entity of the to-one relation.
+      * Returns the target object or {@code null} if there is none.
+     * <p>
+     * {@link ToOne} uses lazy initialization, so on first access this will read the target object from the database.
      */
     public TARGET getTarget() {
         return getTarget(getTargetId());
@@ -150,10 +194,11 @@ public boolean isNull() {
     }
 
     /**
-     * Sets or clears the target ID in the source entity. Pass 0 to clear.
+     * Prepares to set the target of this relation to the object with the given ID. Pass {@code 0} to remove an existing
+     * one.
      * <p>
-     * Put the source entity to persist changes.
-     * If the ID is not 0 creates a relation to the target entity with this ID, otherwise dissolves it.
+     * To apply changes, put the object with the ToOne. For important details, see the notes about relations of
+     * {@link Box#put(Object)}.
      *
      * @see #setTarget
      */
@@ -181,10 +226,10 @@ void setAndUpdateTargetId(long targetId) {
     }
 
     /**
-     * Sets or clears the target entity and ID in the source entity. Pass null to clear.
+     * Prepares to set the target object of this relation. Pass {@code null} to remove an existing one.
      * <p>
-     * Put the source entity to persist changes.
-     * If the target entity was not put yet (its ID is 0), it will be stored when the source entity is put.
+     * To apply changes, put the object with the ToOne. For important details, see the notes about relations of
+     * {@link Box#put(Object)}.
      *
      * @see #setTargetId
      */
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/package-info.java b/objectbox-java/src/main/java/io/objectbox/relation/package-info.java
index 20e254bb..fa27060c 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/ConnectivityMonitor.java b/objectbox-java/src/main/java/io/objectbox/sync/ConnectivityMonitor.java
index 3e0b1cdd..11270a73 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/ConnectivityMonitor.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/ConnectivityMonitor.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
 import javax.annotation.Nullable;
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/Credentials.java b/objectbox-java/src/main/java/io/objectbox/sync/Credentials.java
new file mode 100644
index 00000000..b06c6460
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/Credentials.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Credentials consist of a type and the credentials data to perform authentication checks.
+ * The data is either provided as plain-bytes, or as a list of strings.
+ * Credentials can be used from the client and server side.
+ * This depends on the type however:
+ * for example, shared secrets are configured at both sides, but username/password is only provided at the client.
+ */
+@SuppressWarnings("unused")
+public final class Credentials extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static Credentials getRootAsCredentials(ByteBuffer _bb) { return getRootAsCredentials(_bb, new Credentials()); }
+  public static Credentials getRootAsCredentials(ByteBuffer _bb, Credentials obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public Credentials __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long type() { int o = __offset(4); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Credentials provided by plain bytes.
+   * This is used for shared secrets (client & server).
+   */
+  public int bytes(int j) { int o = __offset(6); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
+  public int bytesLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; }
+  public ByteVector bytesVector() { return bytesVector(new ByteVector()); }
+  public ByteVector bytesVector(ByteVector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
+  public ByteBuffer bytesAsByteBuffer() { return __vector_as_bytebuffer(6, 1); }
+  public ByteBuffer bytesInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); }
+  /**
+   * Credentials provided by a string array.
+   * For username/password (client-only), provide the username in strings[0] and the password in strings[1].
+   * For GoogleAuth, you can provide a list of accepted IDs (server-only).
+   */
+  public String strings(int j) { int o = __offset(8); return o != 0 ? __string(__vector(o) + j * 4) : null; }
+  public int stringsLength() { int o = __offset(8); return o != 0 ? __vector_len(o) : 0; }
+  public StringVector stringsVector() { return stringsVector(new StringVector()); }
+  public StringVector stringsVector(StringVector obj) { int o = __offset(8); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
+
+  public static int createCredentials(FlatBufferBuilder builder,
+      long type,
+      int bytesOffset,
+      int stringsOffset) {
+    builder.startTable(3);
+    Credentials.addStrings(builder, stringsOffset);
+    Credentials.addBytes(builder, bytesOffset);
+    Credentials.addType(builder, type);
+    return Credentials.endCredentials(builder);
+  }
+
+  public static void startCredentials(FlatBufferBuilder builder) { builder.startTable(3); }
+  public static void addType(FlatBufferBuilder builder, long type) { builder.addInt(0, (int) type, (int) 0L); }
+  public static void addBytes(FlatBufferBuilder builder, int bytesOffset) { builder.addOffset(1, bytesOffset, 0); }
+  public static int createBytesVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+  public static int createBytesVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
+  public static void startBytesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
+  public static void addStrings(FlatBufferBuilder builder, int stringsOffset) { builder.addOffset(2, stringsOffset, 0); }
+  public static int createStringsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startStringsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static int endCredentials(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public Credentials get(int j) { return get(new Credentials(), j); }
+    public Credentials get(Credentials obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/CredentialsType.java b/objectbox-java/src/main/java/io/objectbox/sync/CredentialsType.java
new file mode 100644
index 00000000..0b4cce7e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/CredentialsType.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync;
+
+/**
+ * Credentials types for login at a sync server.
+ */
+@SuppressWarnings("unused")
+public final class CredentialsType {
+  private CredentialsType() { }
+  /**
+   * Used to indicate an uninitialized variable. Should never be sent/received in a message.
+   */
+  public static final int Invalid = 0;
+  /**
+   * No credentials required; do not use for public/production servers.
+   * This is useful for testing and during development.
+   */
+  public static final int None = 1;
+  /**
+   * Deprecated, replaced by SHARED_SECRET_SIPPED
+   */
+  public static final int SharedSecret = 2;
+  /**
+   * Google Auth ID token
+   */
+  public static final int GoogleAuth = 3;
+  /**
+   * Use shared secret to create a SipHash and make attacks harder than just copy&paste.
+   * (At some point we may want to switch to crypto & challenge/response.)
+   */
+  public static final int SharedSecretSipped = 4;
+  /**
+   * Use ObjectBox Admin users for Sync authentication.
+   */
+  public static final int ObxAdminUser = 5;
+  /**
+   * Generic credential type suitable for ObjectBox admin (and possibly others in the future)
+   */
+  public static final int UserPassword = 6;
+  /**
+   * JSON Web Token (JWT): an ID token that typically provides identity information about the authenticated user.
+   */
+  public static final int JwtId = 7;
+  /**
+   * JSON Web Token (JWT): an access token that is used to access resources.
+   */
+  public static final int JwtAccess = 8;
+  /**
+   * JSON Web Token (JWT): a refresh token that is used to obtain a new access token.
+   */
+  public static final int JwtRefresh = 9;
+  /**
+   * JSON Web Token (JWT): a token that is neither an ID, access, nor refresh token.
+   */
+  public static final int JwtCustom = 10;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/InternalSyncAccess.java b/objectbox-java/src/main/java/io/objectbox/sync/InternalSyncAccess.java
new file mode 100644
index 00000000..e58f7f8e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/InternalSyncAccess.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Internal;
+
+/**
+ * Internal sync access for ObjectBox platform integrations, e.g. platform-specific mesh networks.
+ * This class is not part of the public API and may change without notice.
+ */
+@Internal
+public final class InternalSyncAccess {
+
+    /**
+     * Creates a mesh sync configuration. See the {@link MeshConfig} setters for details on each
+     * option.
+     *
+     * @param meshId The mesh network identifier (required); nodes with different IDs ignore each
+     * other.
+     */
+    public static MeshConfig createMeshConfig(String meshId) {
+        return new MeshConfig(meshId);
+    }
+
+    /**
+     * Adds a platform-specific native network (transport) to a mesh config.
+     *
+     * @param networkInternalHandle an internal handle to a native mesh network created by a
+     * platform library.
+     */
+    public static void addNetworkInternalHandle(MeshConfig config, long networkInternalHandle) {
+        config.networkInternalHandles.add(networkInternalHandle);
+    }
+
+    private InternalSyncAccess() {
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/MeshConfig.java b/objectbox-java/src/main/java/io/objectbox/sync/MeshConfig.java
new file mode 100644
index 00000000..59795c51
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/MeshConfig.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * Configuration of a peer-to-peer mesh sync.
+ * <p>
+ * A mesh sync enables peer-to-peer (P2P) synchronization between sync clients without a central
+ * server. Pass an instance to {@link SyncBuilder#mesh(MeshConfig)} to attach a mesh sync to the
+ * client; it starts and stops together with the client. Query the running mesh via
+ * {@link SyncClient#getMesh()}.
+ * <p>
+ * A mesh requires at least one platform-specific network (transport); networks are registered by
+ * ObjectBox platform libraries (e.g. for Android), which also create this configuration. Thus, this
+ * class can not be created directly; see the documentation of the platform library for how to
+ * obtain a mesh configuration.
+ * <p>
+ * Only the mesh ID is required; all other values are optional and fall back to the defaults of the
+ * ObjectBox native library when not set. The values are read once when the sync client is created,
+ * which is also when the native library validates them.
+ */
+@Experimental
+public final class MeshConfig {
+
+    final String meshId;
+    @Nullable Integer maxConnectionCount;
+    @Nullable Integer backoffMillis;
+    @Nullable Integer evictionBackoffMillis;
+    @Nullable Integer requestTimeoutMillis;
+    @Nullable Integer advertisingDelayMillis;
+    @Nullable Integer advertisingRetryMillis;
+    @Nullable Integer advertisingRetryMaxMillis;
+    @Nullable Integer connectDelayMillis;
+    @Nullable Integer initialDiscoveryDurationSeconds;
+    @Nullable Integer discoveryDurationSeconds;
+    @Nullable Integer discoveryPauseSeconds;
+    @Nullable Integer discoveryPauseJitterSeconds;
+    @Nullable Integer txLogBatchSizeKb;
+    @Nullable Integer txLogBatchMaxCount;
+
+    /**
+     * Handles to platform-specific native networks (transports) to register with the mesh sync,
+     * added via {@link InternalSyncAccess#addNetworkInternalHandle(MeshConfig, long)}.
+     */
+    final List<Long> networkInternalHandles = new ArrayList<>();
+
+    /**
+     * Use {@link InternalSyncAccess#createMeshConfig(String)} instead.
+     *
+     * @param meshId The mesh network identifier (required); nodes with different IDs ignore each
+     * other.
+     */
+    MeshConfig(String meshId) {
+        if (meshId == null || meshId.isEmpty()) {
+            throw new IllegalArgumentException("meshId must not be null or empty.");
+        }
+        this.meshId = meshId;
+    }
+
+    /**
+     * Maximum number of simultaneous connections a peer can have to other peers (default: 3).
+     * <p>
+     * The default of 3 already provides mesh resilience through alternative paths. 4 may give
+     * better fault tolerance, but at the cost of more radio activity. Values above 4 are not
+     * recommended. 2 is typically not recommended unless you run into severe radio limitations. 1
+     * would be a rare special case if you only want to create pairs, not a mesh.
+     */
+    public MeshConfig maxConnectionCount(int maxConnectionCount) {
+        this.maxConnectionCount = maxConnectionCount;
+        return this;
+    }
+
+    /**
+     * Backoff time in milliseconds before retrying a failed connection (default: 10000).
+     */
+    public MeshConfig backoffMillis(int backoffMillis) {
+        this.backoffMillis = backoffMillis;
+        return this;
+    }
+
+    /**
+     * Backoff time in milliseconds between peer evictions (default: 30000).
+     * <p>
+     * When an incoming peer has 0 connections, but this peer is at
+     * {@link #maxConnectionCount(int)}, this peer ends a connection to an existing peer, it
+     * "evicts" that peer, to make room. This backoff prevents frequent evictions.
+     */
+    public MeshConfig evictionBackoffMillis(int evictionBackoffMillis) {
+        this.evictionBackoffMillis = evictionBackoffMillis;
+        return this;
+    }
+
+    /**
+     * Timeout in milliseconds for a TX request from a peer before retrying from another (default:
+     * 5000).
+     */
+    public MeshConfig requestTimeoutMillis(int requestTimeoutMillis) {
+        this.requestTimeoutMillis = requestTimeoutMillis;
+        return this;
+    }
+
+    /**
+     * Delay in milliseconds before advertising starts after the mesh sync starts (default: 2000).
+     * <p>
+     * Discovery always starts immediately; advertising is delayed to "stretch out" radio activity.
+     */
+    public MeshConfig advertisingDelayMillis(int advertisingDelayMillis) {
+        this.advertisingDelayMillis = advertisingDelayMillis;
+        return this;
+    }
+
+    /**
+     * Base delay in milliseconds before retrying advertising after a network failed to start it
+     * (default: 5000).
+     * <p>
+     * A network may fail to start advertising (e.g. missing permissions); advertising is then
+     * retried with exponential backoff (doubling up to {@link #advertisingRetryMaxMillis(int)}),
+     * because the required permissions may be granted later at runtime. Must be positive.
+     */
+    public MeshConfig advertisingRetryMillis(int advertisingRetryMillis) {
+        this.advertisingRetryMillis = advertisingRetryMillis;
+        return this;
+    }
+
+    /**
+     * Upper bound in milliseconds for the advertising retry backoff (default: 60000).
+     * <p>
+     * Must be greater than or equal to {@link #advertisingRetryMillis(int)}.
+     */
+    public MeshConfig advertisingRetryMaxMillis(int advertisingRetryMaxMillis) {
+        this.advertisingRetryMaxMillis = advertisingRetryMaxMillis;
+        return this;
+    }
+
+    /**
+     * Minimum delay in milliseconds between two outgoing connection attempts (default: 1000).
+     */
+    public MeshConfig connectDelayMillis(int connectDelayMillis) {
+        this.connectDelayMillis = connectDelayMillis;
+        return this;
+    }
+
+    /**
+     * Duration in seconds of the initial discovery phase (default: 30; 0 means never stop by
+     * time).
+     *
+     * @see #discoveryDurationSeconds(int)
+     */
+    public MeshConfig initialDiscoveryDurationSeconds(int initialDiscoveryDurationSeconds) {
+        this.initialDiscoveryDurationSeconds = initialDiscoveryDurationSeconds;
+        return this;
+    }
+
+    /**
+     * Duration in seconds of a standard (non-initial) discovery phase (default: 15; 0 means never
+     * stop by time).
+     *
+     * @see #initialDiscoveryDurationSeconds(int)
+     */
+    public MeshConfig discoveryDurationSeconds(int discoveryDurationSeconds) {
+        this.discoveryDurationSeconds = discoveryDurationSeconds;
+        return this;
+    }
+
+    /**
+     * Pause in seconds between two discovery phases (default: 45).
+     */
+    public MeshConfig discoveryPauseSeconds(int discoveryPauseSeconds) {
+        this.discoveryPauseSeconds = discoveryPauseSeconds;
+        return this;
+    }
+
+    /**
+     * Random +/- jitter in seconds applied to the discovery pause (default: 15; must be &lt;=
+     * pause). 0 disables jitter.
+     */
+    public MeshConfig discoveryPauseJitterSeconds(int discoveryPauseJitterSeconds) {
+        this.discoveryPauseJitterSeconds = discoveryPauseJitterSeconds;
+        return this;
+    }
+
+    /**
+     * Soft cap in KB for the total TX log payload batched into a single TxLogData message (default:
+     * 100).
+     */
+    public MeshConfig txLogBatchSizeKb(int txLogBatchSizeKb) {
+        this.txLogBatchSizeKb = txLogBatchSizeKb;
+        return this;
+    }
+
+    /**
+     * Maximum number of TX logs to batch into a single TxLogData message (default: 1000). Must be
+     * in the range (0, 100000].
+     */
+    public MeshConfig txLogBatchMaxCount(int txLogBatchMaxCount) {
+        this.txLogBatchMaxCount = txLogBatchMaxCount;
+        return this;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/MeshState.java b/objectbox-java/src/main/java/io/objectbox/sync/MeshState.java
new file mode 100644
index 00000000..9f1e16e6
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/MeshState.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * State of a {@link MeshSync} as returned by {@link MeshSync#getState()}.
+ */
+@Experimental
+public enum MeshState {
+
+    /**
+     * State is unknown, e.g. the native API reported a state that's not recognized yet.
+     */
+    UNKNOWN(0),
+
+    /**
+     * Created, but not started yet.
+     */
+    CREATED(1),
+
+    /**
+     * Discovery is active (not enough peers connected yet).
+     */
+    DISCOVERING(2),
+
+    /**
+     * Fully connected: the maximum number of peers (see {@link MeshConfig#maxConnectionCount(int)})
+     * is connected.
+     */
+    FULLY_CONNECTED(3),
+
+    /**
+     * Stopped.
+     */
+    STOPPED(4),
+
+    /**
+     * Stopped and native resources have been released.
+     * <p>
+     * Note that checks in the Java API should prevent this state from ever getting returned.
+     */
+    DEAD(5);
+
+    public final int id;
+
+    MeshState(int id) {
+        this.id = id;
+    }
+
+    public static MeshState fromId(int id) {
+        for (MeshState value : values()) {
+            if (value.id == id) return value;
+        }
+        return UNKNOWN;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/MeshStats.java b/objectbox-java/src/main/java/io/objectbox/sync/MeshStats.java
new file mode 100644
index 00000000..013cc45f
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/MeshStats.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * Mesh sync statistics counters, useful for testing and diagnostics.
+ * <p>
+ * Read a counter value with {@link MeshSync#getStats(MeshStats)}.
+ */
+@Experimental
+public enum MeshStats {
+
+    /**
+     * Number of peers discovered.
+     */
+    PEERS_DISCOVERED(1),
+
+    /**
+     * Number of peers connected.
+     */
+    PEERS_CONNECTED(2),
+
+    /**
+     * Number of peers disconnected.
+     */
+    PEERS_DISCONNECTED(3),
+
+    /**
+     * Number of peer connection attempts that failed.
+     */
+    PEER_CONNECTIONS_FAILED(4),
+
+    /**
+     * Number of peers lost (no longer available after discovery).
+     */
+    PEERS_LOST(5),
+
+    /**
+     * Number of messages received.
+     */
+    MESSAGES_RECEIVED(6),
+
+    /**
+     * Number of messages sent.
+     */
+    MESSAGES_SENT(7),
+
+    /**
+     * Number of TX IDs announced.
+     */
+    TX_IDS_ANNOUNCED(8),
+
+    /**
+     * Number of TX IDs requested (sent in TxLogRequest messages).
+     */
+    TX_IDS_REQUESTED(9),
+
+    /**
+     * Number of TX IDs received.
+     */
+    TX_IDS_RECEIVED(10),
+
+    /**
+     * Number of TX logs sent (in TxLogData messages).
+     */
+    TX_LOGS_SENT(11),
+
+    /**
+     * Number of TX logs received and stored (from TxLogData messages).
+     */
+    TX_LOGS_RECEIVED(12),
+
+    /**
+     * Number of TX logs applied to the local database.
+     */
+    TX_LOGS_APPLIED(13),
+
+    /**
+     * Number of protocol errors.
+     */
+    PROTOCOL_ERRORS(14),
+
+    /**
+     * Number of general errors.
+     */
+    GENERAL_ERRORS(15),
+
+    /**
+     * Number of peers evicted to make room for newcomers.
+     */
+    PEERS_EVICTED(16),
+
+    /**
+     * Number of discoveries of our own peer ID prefix that were ignored.
+     */
+    SELF_DISCOVERIES_IGNORED(17);
+
+    /**
+     * The counter type ID passed to the native API.
+     */
+    final int id;
+
+    MeshStats(int id) {
+        this.id = id;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/MeshSync.java b/objectbox-java/src/main/java/io/objectbox/sync/MeshSync.java
new file mode 100644
index 00000000..1e84e424
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/MeshSync.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * A running peer-to-peer mesh sync, obtained via {@link SyncClient#getMesh()}.
+ * <p>
+ * Configure a mesh via a {@link MeshConfig} passed to {@link SyncBuilder#mesh(MeshConfig)}. The mesh is owned by the
+ * sync client and starts and stops together with it. Once the owning sync client is closed, this object is no longer
+ * valid and any access throws an {@link IllegalStateException}.
+ */
+@Experimental
+public final class MeshSync {
+
+    /**
+     * The native mesh is owned by the sync client; this handle is reset by {@link SyncClientImpl#close()} so later
+     * access throws instead of using a dangling pointer.
+     */
+    private volatile long handle;
+
+    MeshSync(long handle) {
+        this.handle = handle;
+    }
+
+    private long getHandle() {
+        long handle = this.handle;
+        if (handle == 0) {
+            throw new IllegalStateException("MeshSync is no longer valid (the owning SyncClient was closed)");
+        }
+        return handle;
+    }
+
+    /**
+     * Invalidates this mesh; called by the owning sync client when it is closed.
+     */
+    void invalidate() {
+        handle = 0;
+    }
+
+    /**
+     * Gets the current state of this mesh sync.
+     */
+    public MeshState getState() {
+        return MeshState.fromId(nativeGetState(getHandle()));
+    }
+
+    /**
+     * Gets a human-readable string for the current mesh sync state (e.g. "Discovering").
+     */
+    public String getStateString() {
+        return nativeGetStateString(getHandle());
+    }
+
+    /**
+     * Returns the number of currently connected peers.
+     */
+    public long getConnectedPeerCount() {
+        return nativeGetConnectedPeerCount(getHandle());
+    }
+
+    /**
+     * Gets a mesh sync statistics counter value, see {@link MeshStats}.
+     */
+    public long getStats(MeshStats counter) {
+        return nativeGetStats(getHandle(), counter.id);
+    }
+
+    /**
+     * Requests an immediate retry of the network radios: advertising (bypassing the current retry
+     * backoff) and discovery (restarting the current phase).
+     * <p>
+     * Call this when conditions that may have prevented the radios from starting have changed, e.g.
+     * the user just granted the required permissions. Thread-safe; the actual retry happens on the
+     * mesh sync thread shortly after.
+     */
+    public void retryNetworks() {
+        nativeRetryNetworks(getHandle());
+    }
+
+    /**
+     * Returns the current {@link MeshState} value.
+     */
+    private static native int nativeGetState(long handle);
+
+    private static native String nativeGetStateString(long handle);
+
+    private static native long nativeGetConnectedPeerCount(long handle);
+
+    private static native void nativeRetryNetworks(long handle);
+
+    /**
+     * @param counterType One of the {@link MeshStats} IDs.
+     */
+    private static native long nativeGetStats(long handle, int counterType);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/ObjectsMessageBuilder.java b/objectbox-java/src/main/java/io/objectbox/sync/ObjectsMessageBuilder.java
index 60f9d7f5..96dbba31 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/ObjectsMessageBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/ObjectsMessageBuilder.java
@@ -1,10 +1,26 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
 /**
- * @see SyncClient#startObjectsMessage 
+ * @see SyncClient#startObjectsMessage
  */
 public interface ObjectsMessageBuilder {
-    
+
     ObjectsMessageBuilder addString(long optionalId, String value);
 
     ObjectsMessageBuilder addBytes(long optionalId, byte[] value, boolean isFlatBuffers);
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/Sync.java b/objectbox-java/src/main/java/io/objectbox/sync/Sync.java
index 8d839c97..aaf421a2 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/Sync.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/Sync.java
@@ -1,13 +1,32 @@
+/*
+ * Copyright 2019-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
+import java.util.Arrays;
+
 import io.objectbox.BoxStore;
-import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.BoxStoreBuilder;
+import io.objectbox.sync.server.SyncServer;
 import io.objectbox.sync.server.SyncServerBuilder;
 
 /**
  * <a href="https://objectbox.io/sync/">ObjectBox Sync</a> makes data available on other devices.
- * Start building a sync client using Sync.{@link #client(BoxStore, String, SyncCredentials)}
- * or an embedded server using Sync.{@link #server(BoxStore, String, SyncCredentials)}.
+ * <p>
+ * Use the static methods to build a Sync client or embedded server.
  */
 @SuppressWarnings({"unused", "WeakerAccess"})
 public final class Sync {
@@ -27,22 +46,114 @@ public static boolean isServerAvailable() {
     }
 
     /**
-     * Start building a sync client. Requires the BoxStore that should be synced with the server,
-     * the URL and port of the server to connect to and credentials to authenticate against the server.
+     * Returns true if the included native (JNI) ObjectBox library supports Sync hybrids (server and client).
+     */
+    public static boolean isHybridAvailable() {
+        return isAvailable() && isServerAvailable();
+    }
+
+    /**
+     * Starts building a {@link SyncClient} for the given {@link BoxStore}.
+     * <p>
+     * This does not initiate any connection attempts yet: call {@link SyncBuilder#buildAndStart()} to do so. Before,
+     * you must configure the server URL via {@link SyncBuilder#url(String)} and add credentials via
+     * {@link SyncBuilder#credentials(SyncCredentials)}.
+     * <p>
+     * By default, a Sync client automatically receives updates from the server once login succeeded. To configure this
+     * differently, call {@link SyncBuilder#requestUpdatesMode(SyncBuilder.RequestUpdatesMode)} with the wanted mode.
+     *
+     * @param boxStore The {@link BoxStore} the client should use.
+     * @return a builder to configure the Sync client
+     */
+    public static SyncBuilder client(BoxStore boxStore) {
+        return new SyncBuilder(boxStore);
+    }
+
+    /**
+     * Starts building a {@link SyncClient}. Once done, complete with {@link SyncBuilder#build() build()}.
+     *
+     * @param boxStore The {@link BoxStore} the client should use.
+     * @param url The URL of the Sync server on which the Sync protocol is exposed. This is typically a WebSockets URL
+     * starting with {@code ws://} or {@code wss://} (for encrypted connections), for example
+     * {@code ws://127.0.0.1:9999}.
+     * @param credentials {@link SyncCredentials} to authenticate with the server.
+     * @deprecated Use {@link #client(BoxStore)}, {@link SyncBuilder#url(String)} and
+     * {@link SyncBuilder#credentials(SyncCredentials)} instead.
      */
+    @Deprecated
     public static SyncBuilder client(BoxStore boxStore, String url, SyncCredentials credentials) {
-        return new SyncBuilder(boxStore, url, credentials);
+        return client(boxStore)
+                .url(url)
+                .credentials(credentials);
     }
 
     /**
-     * Start building a sync server. Requires the BoxStore the server should use,
-     * the URL and port the server should bind to and authenticator credentials to authenticate clients.
-     * Additional authenticator credentials can be supplied using the builder.
+     * Like {@link #client(BoxStore, String, SyncCredentials)}, but supports passing a set of authentication methods.
+     *
+     * @param multipleCredentials An array of {@link SyncCredentials} to be used to authenticate with the server.
+     * @deprecated Use {@link #client(BoxStore)}, {@link SyncBuilder#url(String)} and
+     * {@link SyncBuilder#credentials(SyncCredentials)} instead.
+     */
+    @Deprecated
+    public static SyncBuilder client(BoxStore boxStore, String url, SyncCredentials[] multipleCredentials) {
+        SyncBuilder builder = client(boxStore).url(url);
+        //noinspection ConstantValue
+        if (multipleCredentials != null) {
+            builder.credentials(Arrays.asList(multipleCredentials));
+        }
+        return builder;
+    }
+
+    /**
+     * Starts building a {@link SyncServer}. Once done, complete with {@link SyncServerBuilder#build() build()}.
+     * <p>
+     * Note: when also using Admin, make sure it is started before the server.
+     *
+     * @param boxStore The {@link BoxStore} the server should use.
+     * @param url The URL of the Sync server on which the Sync protocol is exposed. This is typically a WebSockets URL
+     * starting with {@code ws://} or {@code wss://} (for encrypted connections), for example
+     * {@code ws://0.0.0.0:9999}.
+     * @param authenticatorCredentials An authentication method available to Sync clients and peers. Additional
+     * authenticator credentials can be supplied using the returned builder. For the embedded server, currently only
+     * {@link SyncCredentials#sharedSecret}, any JWT method like {@link SyncCredentials#jwtIdTokenServer()} as well as
+     * {@link SyncCredentials#none} are supported.
      */
     public static SyncServerBuilder server(BoxStore boxStore, String url, SyncCredentials authenticatorCredentials) {
         return new SyncServerBuilder(boxStore, url, authenticatorCredentials);
     }
 
+    /**
+     * Like {@link #server(BoxStore, String, SyncCredentials)}, but supports passing a set of authentication methods
+     * for clients and peers.
+     */
+    public static SyncServerBuilder server(BoxStore boxStore, String url, SyncCredentials[] multipleAuthenticatorCredentials) {
+        return new SyncServerBuilder(boxStore, url, multipleAuthenticatorCredentials);
+    }
+
+    /**
+     * Starts building a {@link SyncHybrid}, a client/server hybrid typically used for embedded cluster setups.
+     * <p>
+     * Unlike {@link #client(BoxStore, String, SyncCredentials)} and {@link #server(BoxStore, String, SyncCredentials)},
+     * the client Store is not built before. Instead, a Store builder must be passed. The client and server Store will
+     * be built internally when calling this method.
+     * <p>
+     * To configure client and server use the methods on {@link SyncHybridBuilder}.
+     *
+     * @param storeBuilder The {@link BoxStoreBuilder} to use for building the client store.
+     * @param url The URL of the Sync server on which the Sync protocol is exposed. This is typically a WebSockets URL
+     * starting with {@code ws://} or {@code wss://} (for encrypted connections), for example
+     * {@code ws://0.0.0.0:9999}.
+     * @param authenticatorCredentials An authentication method available to Sync clients and peers. The client of the
+     * hybrid is pre-configured with them. Additional credentials can be supplied using the client and server builder of
+     * the returned builder. For the embedded server, currently only {@link SyncCredentials#sharedSecret}, any JWT
+     * method like {@link SyncCredentials#jwtIdTokenServer()} as well as {@link SyncCredentials#none} are supported.
+     * @return An instance of {@link SyncHybridBuilder}.
+     */
+    public static SyncHybridBuilder hybrid(BoxStoreBuilder storeBuilder, String url,
+                                           SyncCredentials authenticatorCredentials) {
+        return new SyncHybridBuilder(storeBuilder, url, authenticatorCredentials);
+    }
+
     private Sync() {
     }
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncBuilder.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncBuilder.java
index 9875819c..107af027 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/SyncBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncBuilder.java
@@ -1,11 +1,32 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
 
 import javax.annotation.Nullable;
 
 import io.objectbox.BoxStore;
 import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.internal.NativeLibraryUtils;
 import io.objectbox.sync.internal.Platform;
 import io.objectbox.sync.listener.SyncChangeListener;
 import io.objectbox.sync.listener.SyncCompletedListener;
@@ -15,17 +36,15 @@
 import io.objectbox.sync.listener.SyncTimeListener;
 
 /**
- * A builder to create a {@link SyncClient}; the builder itself should be created via
- * {@link Sync#client(BoxStore, String, SyncCredentials)}.
+ * A builder to create a {@link SyncClient}; the builder itself should be created via {@link Sync#client(BoxStore)}.
  */
-@Experimental
 @SuppressWarnings({"unused", "WeakerAccess"})
-public class SyncBuilder {
+public final class SyncBuilder {
 
     final Platform platform;
     final BoxStore boxStore;
-    final String url;
-    final SyncCredentials credentials;
+    final List<String> urls = new ArrayList<>();
+    final List<SyncCredentials> credentials = new ArrayList<>();
 
     @Nullable SyncLoginListener loginListener;
     @Nullable SyncCompletedListener completedListener;
@@ -36,9 +55,13 @@ public class SyncBuilder {
 
     @Nullable
     String[] trustedCertPaths;
+    int flags;
+    @Nullable MeshConfig meshConfig;
     boolean uncommittedAcks;
 
     RequestUpdatesMode requestUpdatesMode = RequestUpdatesMode.AUTO;
+    // To be helpful when debugging, use a TreeMap so variables are eventually passed ordered by name to the native API
+    final Map<String, String> filterVariables = new TreeMap<>();
 
     public enum RequestUpdatesMode {
         /**
@@ -68,19 +91,96 @@ public enum RequestUpdatesMode {
         AUTO_NO_PUSHES
     }
 
-    public SyncBuilder(BoxStore boxStore, String url, SyncCredentials credentials) {
-        checkNotNull(boxStore, "BoxStore is required.");
-        checkNotNull(url, "Sync server URL is required.");
-        checkNotNull(credentials, "Sync credentials are required.");
-        if (!BoxStore.isSyncAvailable()) {
-            throw new IllegalStateException(
-                    "This library does not include ObjectBox Sync. " +
-                            "Please visit https://objectbox.io/sync/ for options.");
-        }
-        this.platform = Platform.findPlatform();
+    /**
+     * Creates a builder for a {@link SyncClient}.
+     * <p>
+     * Don't use this directly, use the {@link Sync#client} method instead.
+     */
+    SyncBuilder(BoxStore boxStore) {
+        checkNotNull(boxStore, "boxStore");
         this.boxStore = boxStore;
-        this.url = url;
-        this.credentials = credentials;
+        NativeLibraryUtils.checkHasFeature();
+        this.platform = Platform.findPlatform(); // Requires APIs only present in Android Sync library
+    }
+
+    /**
+     * Adds a Sync server URL the client should connect to.
+     * <p>
+     * This is typically a WebSockets URL starting with {@code ws://} or {@code wss://} (for encrypted connections), for
+     * example if the server is running on localhost {@code ws://127.0.0.1:9999}.
+     * <p>
+     * Can be called multiple times to add multiple URLs for high availability and load balancing (like when using an
+     * ObjectBox Sync Server Cluster). A random URL is selected for each connection attempt.
+     *
+     * @param url The URL of the Sync server on which the Sync protocol is exposed.
+     * @return this builder for chaining
+     * @see #urls(List)
+     */
+    public SyncBuilder url(String url) {
+        checkNotNull(url, "url");
+        this.urls.add(url);
+        return this;
+    }
+
+    /**
+     * Like {@link #url(String)}, but accepts a list of URLs.
+     *
+     * @param urls A list of URLs of Sync servers on which the Sync protocol is exposed.
+     * @return this builder for chaining
+     * @see #url(String)
+     */
+    public SyncBuilder urls(List<String> urls) {
+        checkNotNull(urls, "urls");
+        for (String url : urls) {
+            url(url);
+        }
+        return this;
+    }
+
+    /**
+     * Adds {@link SyncCredentials} to authenticate the client with the server.
+     * <p>
+     * The accepted credentials types depend on your Sync server configuration.
+     *
+     * @param credentials credentials created using a {@link SyncCredentials} factory method, for example
+     * {@code SyncCredentials.jwtIdToken(idToken)}.
+     * @see #credentials(List)
+     */
+    public SyncBuilder credentials(SyncCredentials credentials) {
+        checkNotNull(credentials, "credentials");
+        this.credentials.add(credentials);
+        return this;
+    }
+
+    /**
+     * Like {@link #credentials(SyncCredentials)}, but accepts a list of credentials.
+     *
+     * @param credentials a list of credentials where each element is created using a {@link SyncCredentials} factory
+     * method, for example {@code SyncCredentials.jwtIdToken(idToken)}.
+     * @return this builder for chaining
+     */
+    public SyncBuilder credentials(List<SyncCredentials> credentials) {
+        checkNotNull(credentials, "credentials");
+        for (SyncCredentials credential : credentials) {
+            credentials(credential);
+        }
+        return this;
+    }
+
+    /**
+     * Adds or replaces a <a href="https://sync.objectbox.io/sync-server/sync-filters">Sync filter</a> variable value
+     * for the given name.
+     * <p>
+     * Sync client filter variables can be used in server-side Sync filters to filter out objects that do not match the
+     * filter.
+     *
+     * @see SyncClient#putFilterVariable
+     */
+    public SyncBuilder filterVariable(String name, String value) {
+        checkNotNull(name, "name");
+        checkNotNull(value, "value");
+        filterVariables.put(name, value);
+        return this;
     }
 
     /**
@@ -96,6 +196,16 @@ public SyncBuilder trustedCertificates(String[] paths) {
         return this;
     }
 
+    /**
+     * Sets bit flags to adjust Sync behavior, like additional logging.
+     *
+     * @param flags One or multiple {@link SyncFlags}, combined with bitwise or.
+     */
+    public SyncBuilder flags(int flags) {
+        this.flags = flags;
+        return this;
+    }
+
     /**
      * Configure automatic sync updates from the server.
      * If automatic sync updates are turned off, they will need to be requested using the sync client.
@@ -108,6 +218,21 @@ public SyncBuilder requestUpdatesMode(RequestUpdatesMode requestUpdatesMode) {
         return this;
     }
 
+    /**
+     * Attaches a peer-to-peer mesh sync configuration to the client.
+     * <p>
+     * A mesh sync is then created together with the client; it starts and stops together with the client.
+     * Query the running mesh via {@link SyncClient#getMesh()}.
+     * <p>
+     * See {@link MeshConfig} for how to obtain a configuration.
+     */
+    @Experimental
+    public SyncBuilder mesh(MeshConfig meshConfig) {
+        checkNotNull(meshConfig, "meshConfig");
+        this.meshConfig = meshConfig;
+        return this;
+    }
+
     /**
      * Turns on sending of uncommitted acks.
      */
@@ -195,7 +320,7 @@ public SyncClient build() {
     }
 
     /**
-     * Builds, {@link SyncClient#start() starts} and returns a Sync client.
+     * {@link #build() Builds}, {@link SyncClient#start() starts} and returns a Sync client.
      */
     public SyncClient buildAndStart() {
         SyncClient syncClient = build();
@@ -203,10 +328,13 @@ public SyncClient buildAndStart() {
         return syncClient;
     }
 
-    private void checkNotNull(Object object, String message) {
-        //noinspection ConstantConditions Non-null annotation does not enforce, so check for null.
+    /**
+     * Nullness annotations are only a hint in Java, so explicitly check nonnull annotated parameters
+     * (see package-info.java for package settings).
+     */
+    private void checkNotNull(@Nullable Object object, String name) {
         if (object == null) {
-            throw new IllegalArgumentException(message);
+            throw new IllegalArgumentException(name + " must not be null.");
         }
     }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncChange.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncChange.java
index 13f95b6f..ad6d8c66 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/SyncChange.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncChange.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2019-2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
 import io.objectbox.annotation.apihint.Beta;
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncClient.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncClient.java
index 04c9bccb..41b3acbe 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/SyncClient.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncClient.java
@@ -1,5 +1,26 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
+import java.io.Closeable;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.sync.SyncBuilder.RequestUpdatesMode;
 import io.objectbox.sync.listener.SyncChangeListener;
@@ -9,26 +30,43 @@
 import io.objectbox.sync.listener.SyncLoginListener;
 import io.objectbox.sync.listener.SyncTimeListener;
 
-import javax.annotation.Nullable;
-import java.io.Closeable;
-
 /**
  * ObjectBox sync client. Build a client with {@link Sync#client}.
- *
+ * <p>
  * Keep the instance around (avoid garbage collection) while you want to have sync ongoing.
  * For a clean shutdown, call {@link #close()}.
  * <p>
  * SyncClient is thread-safe.
  */
 @SuppressWarnings("unused")
-@Experimental
 public interface SyncClient extends Closeable {
 
     /**
      * Gets the sync server URL this client is connected to.
+     *
+     * @deprecated Use {@link #getUrls()}
      */
+    @Deprecated
     String getServerUrl();
 
+    /**
+     * Gets the sync server URLs this client may connect to.
+     * <p>
+     * See {@link SyncBuilder#url(String)} for notes on multiple URLs.
+     */
+    List<String> getUrls();
+
+    /**
+     * Returns the running peer-to-peer mesh sync attached to this client, or {@code null} if no {@link MeshConfig}
+     * was passed via {@link SyncBuilder#mesh(MeshConfig)}.
+     * <p>
+     * The mesh starts and stops together with this client. The returned object is owned by this client and valid
+     * until the client is closed.
+     */
+    @Experimental
+    @Nullable
+    MeshSync getMesh();
+
     /**
      * Flag indicating if the sync client was started.
      * Started clients try to connect, login, and sync with the sync destination.
@@ -48,8 +86,9 @@ public interface SyncClient extends Closeable {
 
     /**
      * Estimates the current server timestamp in nanoseconds based on the last known server time.
+     *
      * @return unix timestamp in nanoseconds (since epoch);
-     *         or 0 if there has not been a server contact yet and thus the server's time is unknown
+     * or 0 if there has not been a server contact yet and thus the server's time is unknown
      */
     long getServerTimeNanos();
 
@@ -60,7 +99,7 @@ public interface SyncClient extends Closeable {
      * except for when the server time is unknown, then the result is zero.
      *
      * @return time difference in nanoseconds; e.g. positive if server time is ahead of local time;
-     *         or 0 if there has not been a server contact yet and thus the server's time is unknown
+     * or 0 if there has not been a server contact yet and thus the server's time is unknown
      */
     long getServerTimeDiffNanos();
 
@@ -69,7 +108,7 @@ public interface SyncClient extends Closeable {
      * This is measured during login.
      *
      * @return roundtrip time in nanoseconds;
-     *         or 0 if there has not been a server contact yet and thus the roundtrip time could not be estimated
+     * or 0 if there has not been a server contact yet and thus the roundtrip time could not be estimated
      */
     long getRoundtripTimeNanos();
 
@@ -111,11 +150,91 @@ public interface SyncClient extends Closeable {
     void setSyncTimeListener(@Nullable SyncTimeListener timeListener);
 
     /**
-     * Updates the login credentials. This should not be required during regular use.
-     * The original credentials were passed when building sync client.
+     * Adds or replaces a <a href="https://sync.objectbox.io/sync-server/sync-filters">Sync filter</a> variable value
+     * for the given name.
+     * <p>
+     * Note: If the client is already logged in, this change is not applied until {@link #applyFilterVariables()} is
+     * called. This allows to put or remove multiple variables before applying all changes. Filter variables set before
+     * login (before calling {@link #start()}) are automatically applied.
+     * <p>
+     * Eventually, existing values for the same name are replaced.
+     * <p>
+     * Sync client filter variables can be used in server-side Sync filters to filter out objects that do not match the
+     * filter.
+     *
+     * @see #removeFilterVariable
+     * @see #removeAllFilterVariables
+     * @see #applyFilterVariables
+     */
+    void putFilterVariable(String name, String value);
+
+    /**
+     * Removes a previously added Sync filter variable value.
+     * <p>
+     * Note: If the client is already logged in, this change is not applied until {@link #applyFilterVariables()} is
+     * called. See {@link #putFilterVariable} for details.
+     *
+     * @see #putFilterVariable
+     * @see #removeAllFilterVariables
+     */
+    void removeFilterVariable(String name);
+
+    /**
+     * Removes all previously added Sync filter variable values.
+     * <p>
+     * Note: If the client is already logged in, this change is not applied until {@link #applyFilterVariables()} is
+     * called. See {@link #putFilterVariable} for details.
+     *
+     * @see #putFilterVariable
+     * @see #removeFilterVariable
+     */
+    void removeAllFilterVariables();
+
+    /**
+     * Applies all pending Sync filter variable updates (from {@link #putFilterVariable} and
+     * {@link #removeFilterVariable} calls).
+     * <p>
+     * If the client is connected, sends the updated variables to the server. If the client is not connected,
+     * the updated variables will be included in the next login message.
+     *
+     * @see #putFilterVariable
+     * @see #removeFilterVariable
+     * @see #removeAllFilterVariables
+     */
+    void applyFilterVariables();
+
+    /**
+     * Sets credentials to authenticate the client with the server.
+     * <p>
+     * Any credentials that were set before are replaced.
+     * <p>
+     * Usually, credentials are passed via {@link SyncBuilder#credentials(SyncCredentials)}, but this can be used to
+     * update them later, such as when a token expires.
+     * <p>
+     * The accepted credentials type depends on your Sync server configuration.
+     *
+     * @param credentials credentials created using a {@link SyncCredentials} factory method, for example
+     * {@code SyncCredentials.jwtIdToken(idToken)}.
+     * @see #setLoginCredentials(List)
      */
     void setLoginCredentials(SyncCredentials credentials);
 
+    /**
+     * Like {@link #setLoginCredentials(SyncCredentials)}, but accepts a list of credentials.
+     *
+     * @param credentials a list of credentials where each element is created using a {@link SyncCredentials} factory
+     * method, for example {@code SyncCredentials.jwtIdToken(idToken)}.
+     */
+    void setLoginCredentials(List<SyncCredentials> credentials);
+
+    /**
+     * Like {@link #setLoginCredentials(SyncCredentials)}, but accepts an array of credentials.
+     *
+     * @param multipleCredentials an array of credentials where each element is created using a {@link SyncCredentials}
+     * factory method, for example {@code SyncCredentials.jwtIdToken(idToken)}.
+     */
+    void setLoginCredentials(SyncCredentials[] multipleCredentials);
+
     /**
      * Waits until the sync client receives a response to its first (connection and) login attempt
      * or until the given time has expired.
@@ -148,9 +267,9 @@ public interface SyncClient extends Closeable {
      * This is useful if sync updates were turned off with
      * {@link SyncBuilder#requestUpdatesMode(RequestUpdatesMode) requestUpdatesMode(MANUAL)}.
      *
-     * @see #cancelUpdates()
      * @return 'true' if the request was likely sent (e.g. the sync client is in "logged in" state)
      * or 'false' if the request was not sent (and will not be sent in the future)
+     * @see #cancelUpdates()
      */
     boolean requestUpdates();
 
@@ -158,6 +277,7 @@ public interface SyncClient extends Closeable {
      * Asks the server to send sync updates until this sync client is up-to-date, then pauses sync updates again.
      * This is useful if sync updates were turned off with
      * {@link SyncBuilder#requestUpdatesMode(RequestUpdatesMode) requestUpdatesMode(MANUAL)}.
+     *
      * @return 'true' if the request was likely sent (e.g. the sync client is in "logged in" state)
      * or 'false' if the request was not sent (and will not be sent in the future)
      */
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncClientImpl.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncClientImpl.java
index b98f86dd..2fb7e357 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/SyncClientImpl.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncClientImpl.java
@@ -1,5 +1,28 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import javax.annotation.Nullable;
+
 import io.objectbox.BoxStore;
 import io.objectbox.InternalAccess;
 import io.objectbox.annotation.apihint.Experimental;
@@ -12,20 +35,16 @@
 import io.objectbox.sync.listener.SyncLoginListener;
 import io.objectbox.sync.listener.SyncTimeListener;
 
-import javax.annotation.Nullable;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
 /**
  * Internal sync client implementation. Use {@link SyncClient} to access functionality,
  * this class may change without notice.
  */
 @Internal
-public class SyncClientImpl implements SyncClient {
+public final class SyncClientImpl implements SyncClient {
 
     @Nullable
     private BoxStore boxStore;
-    private final String serverUrl;
+    private final List<String> urls;
     private final InternalSyncClientListener internalListener;
     @Nullable
     private final ConnectivityMonitor connectivityMonitor;
@@ -41,19 +60,58 @@ public class SyncClientImpl implements SyncClient {
     private volatile SyncTimeListener timeListener;
     private volatile long lastLoginCode;
     private volatile boolean started;
+    @Nullable
+    private volatile MeshSync mesh;
 
     SyncClientImpl(SyncBuilder builder) {
         this.boxStore = builder.boxStore;
-        this.serverUrl = builder.url;
+        this.urls = builder.urls;
         this.connectivityMonitor = builder.platform.getConnectivityMonitor();
 
-        long boxStoreHandle = InternalAccess.getHandle(builder.boxStore);
-        long handle = nativeCreate(boxStoreHandle, serverUrl, builder.trustedCertPaths);
+        // Build the options
+        long optHandle = nativeSyncOptCreate(builder.boxStore.getNativeStore());
+        if (optHandle == 0) {
+            throw new RuntimeException("Failed to create Sync client options: handle is zero.");
+        }
+        try {
+            // Add all server URLs
+            for (String url : urls) {
+                nativeSyncOptAddUrl(optHandle, url);
+            }
+
+            // Add trusted certificate paths if provided
+            if (builder.trustedCertPaths != null) {
+                for (String certPath : builder.trustedCertPaths) {
+                    nativeSyncOptAddCertPath(optHandle, certPath);
+                }
+            }
+
+            // Add Sync flags if set
+            if (builder.flags != 0) {
+                nativeSyncOptFlags(optHandle, builder.flags);
+            }
+
+            // Attach a mesh sync configuration if set
+            if (builder.meshConfig != null) {
+                applyMeshConfig(optHandle, builder.meshConfig);
+            }
+        } catch (Exception e) {
+            // Free the options if any option method call failed (like due to invalid arguments)
+            nativeSyncOptFree(optHandle);
+            throw e;
+        }
+
+        // Create the sync client (this frees the options in any case)
+        long handle = nativeSyncOptCreateClient(optHandle);
         if (handle == 0) {
-            throw new RuntimeException("Failed to create sync client: handle is zero.");
+            throw new RuntimeException("Failed to create Sync client: handle is zero.");
         }
         this.handle = handle;
 
+        for (Map.Entry<String, String> entry : builder.filterVariables.entrySet()) {
+            putFilterVariable(entry.getKey(), entry.getValue());
+        }
+
         // Only change setting if not default (automatic sync updates and push subscription enabled).
         if (builder.requestUpdatesMode != RequestUpdatesMode.AUTO) {
             boolean autoRequestUpdates = builder.requestUpdatesMode != RequestUpdatesMode.MANUAL;
@@ -85,6 +143,72 @@ public class SyncClientImpl implements SyncClient {
         InternalAccess.setSyncClient(builder.boxStore, this);
     }
 
+    /**
+     * Builds native mesh options from the given config and attaches them to the sync options.
+     * <p>
+     * Only options with a value are passed to the native API, so the native defaults stay authoritative.
+     * The native library validates the configuration when the sync client is created.
+     */
+    private static void applyMeshConfig(long syncOptHandle, MeshConfig config) {
+        long meshOptHandle = nativeMeshOptCreate(config.meshId);
+        if (meshOptHandle == 0) {
+            throw new RuntimeException("Failed to create mesh options: handle is zero.");
+        }
+        try {
+            if (config.maxConnectionCount != null) {
+                nativeMeshOptMaxConnectionCount(meshOptHandle, config.maxConnectionCount);
+            }
+            if (config.backoffMillis != null) {
+                nativeMeshOptBackoffMillis(meshOptHandle, config.backoffMillis);
+            }
+            if (config.evictionBackoffMillis != null) {
+                nativeMeshOptEvictionBackoffMillis(meshOptHandle, config.evictionBackoffMillis);
+            }
+            if (config.requestTimeoutMillis != null) {
+                nativeMeshOptRequestTimeoutMillis(meshOptHandle, config.requestTimeoutMillis);
+            }
+            if (config.advertisingDelayMillis != null) {
+                nativeMeshOptAdvertisingDelayMillis(meshOptHandle, config.advertisingDelayMillis);
+            }
+            if (config.advertisingRetryMillis != null) {
+                nativeMeshOptAdvertisingRetryMillis(meshOptHandle, config.advertisingRetryMillis);
+            }
+            if (config.advertisingRetryMaxMillis != null) {
+                nativeMeshOptAdvertisingRetryMaxMillis(meshOptHandle, config.advertisingRetryMaxMillis);
+            }
+            if (config.connectDelayMillis != null) {
+                nativeMeshOptConnectDelayMillis(meshOptHandle, config.connectDelayMillis);
+            }
+            if (config.initialDiscoveryDurationSeconds != null) {
+                nativeMeshOptInitialDiscoveryDurationSeconds(meshOptHandle, config.initialDiscoveryDurationSeconds);
+            }
+            if (config.discoveryDurationSeconds != null) {
+                nativeMeshOptDiscoveryDurationSeconds(meshOptHandle, config.discoveryDurationSeconds);
+            }
+            if (config.discoveryPauseSeconds != null) {
+                nativeMeshOptDiscoveryPauseSeconds(meshOptHandle, config.discoveryPauseSeconds);
+            }
+            if (config.discoveryPauseJitterSeconds != null) {
+                nativeMeshOptDiscoveryPauseJitterSeconds(meshOptHandle, config.discoveryPauseJitterSeconds);
+            }
+            if (config.txLogBatchSizeKb != null) {
+                nativeMeshOptTxLogBatchSizeKb(meshOptHandle, config.txLogBatchSizeKb);
+            }
+            if (config.txLogBatchMaxCount != null) {
+                nativeMeshOptTxLogBatchMaxCount(meshOptHandle, config.txLogBatchMaxCount);
+            }
+            for (long networkInternalHandle : config.networkInternalHandles) {
+                nativeMeshOptNetworkInternal(meshOptHandle, networkInternalHandle);
+            }
+        } catch (Exception e) {
+            // Free the mesh options if any option method call failed (like due to invalid arguments)
+            nativeMeshOptFree(meshOptHandle);
+            throw e;
+        }
+        // Attaches and consumes the mesh options (they are freed in any case, also on error)
+        nativeSyncOptMesh(syncOptHandle, meshOptHandle);
+    }
+
     private long getHandle() {
         long handle = this.handle;
         if (handle == 0) {
@@ -93,9 +217,30 @@ private long getHandle() {
         return handle;
     }
 
+    @Override
+    @Nullable
+    public synchronized MeshSync getMesh() {
+        MeshSync existingMesh = this.mesh;
+        if (existingMesh != null) {
+            return existingMesh;
+        }
+
+        long meshHandle = nativeGetMesh(getHandle());
+        if (meshHandle == 0) return null;
+        MeshSync mesh = new MeshSync(meshHandle);
+        this.mesh = mesh;
+        return mesh;
+    }
+
     @Override
     public String getServerUrl() {
-        return serverUrl;
+        // nativeSyncOptCreateClient guarantees there is at least one URL
+        return getUrls().get(0);
+    }
+
+    @Override
+    public List<String> getUrls() {
+        return urls;
     }
 
     @Override
@@ -164,13 +309,74 @@ public void setSyncListener(@Nullable SyncListener listener) {
         setSyncChangeListener(listener);
     }
 
+    public void putFilterVariable(String name, String value) {
+        nativePutFilterVariable(getHandle(), name, value);
+    }
+
+    public void removeFilterVariable(String name) {
+        nativeRemoveFilterVariable(getHandle(), name);
+    }
+
+    public void removeAllFilterVariables() {
+        nativeRemoveAllFilterVariables(getHandle());
+    }
+
+    public void applyFilterVariables() {
+        nativeApplyFilterVariables(getHandle());
+    }
+
+    @Override
+    public void setLoginCredentials(List<SyncCredentials> credentials) {
+        if (credentials.size() == 1) {
+            setLoginCredentials(credentials.get(0));
+        } else if (credentials.size() > 1) {
+            setLoginCredentials(credentials.toArray(new SyncCredentials[0]));
+        } else {
+            throw new IllegalArgumentException("Credentials must be provided");
+        }
+    }
+
     @Override
     public void setLoginCredentials(SyncCredentials credentials) {
-        SyncCredentialsToken credentialsInternal = (SyncCredentialsToken) credentials;
-        nativeSetLoginInfo(getHandle(), credentialsInternal.getTypeId(), credentialsInternal.getTokenBytes());
-        credentialsInternal.clear(); // Clear immediately, not needed anymore.
+        if (credentials == null) {
+            throw new IllegalArgumentException("credentials must not be null");
+        }
+        if (credentials instanceof SyncCredentialsToken) {
+            SyncCredentialsToken credToken = (SyncCredentialsToken) credentials;
+            nativeSetLoginInfo(getHandle(), credToken.getTypeId(), credToken.getTokenBytes());
+            credToken.clear(); // Clear immediately, not needed anymore.
+        } else if (credentials instanceof SyncCredentialsUserPassword) {
+            SyncCredentialsUserPassword credUserPassword = (SyncCredentialsUserPassword) credentials;
+            nativeSetLoginInfoUserPassword(getHandle(), credUserPassword.getTypeId(), credUserPassword.getUsername(),
+                    credUserPassword.getPassword());
+        } else {
+            throw new IllegalArgumentException("credentials is not a supported type");
+        }
     }
 
+    @Override
+    public void setLoginCredentials(SyncCredentials[] multipleCredentials) {
+        if (multipleCredentials == null) {
+            throw new IllegalArgumentException("credentials must not be null");
+        }
+        for (int i = 0; i < multipleCredentials.length; i++) {
+            SyncCredentials credentials = multipleCredentials[i];
+            boolean isLast = i == (multipleCredentials.length - 1);
+            if (credentials instanceof SyncCredentialsToken) {
+                SyncCredentialsToken credToken = (SyncCredentialsToken) credentials;
+                nativeAddLoginCredentials(getHandle(), credToken.getTypeId(), credToken.getTokenBytes(), isLast);
+                credToken.clear(); // Clear immediately, not needed anymore.
+            } else if (credentials instanceof SyncCredentialsUserPassword) {
+                SyncCredentialsUserPassword credUserPassword = (SyncCredentialsUserPassword) credentials;
+                nativeAddLoginCredentialsUserPassword(getHandle(), credUserPassword.getTypeId(), credUserPassword.getUsername(),
+                        credUserPassword.getPassword(), isLast);
+            } else {
+                throw new IllegalArgumentException("credentials is not a supported type");
+            }
+        }
+    }
+
+
     @Override
     public boolean awaitFirstLogin(long millisToWait) {
         if (!started) {
@@ -220,6 +426,14 @@ public void close() {
                 this.boxStore = null;
             }
 
+            // The native mesh is owned by the client and freed with it; invalidate any MeshSync wrapper so later
+            // access throws instead of using a dangling pointer.
+            MeshSync mesh = this.mesh;
+            if (mesh != null) {
+                mesh.invalidate();
+                this.mesh = null;
+            }
+
             handleToDelete = this.handle;
             handle = 0;
         }
@@ -282,10 +496,134 @@ public ObjectsMessageBuilder startObjectsMessage(long flags, @Nullable String to
     }
 
     /**
-     * Creates a native sync client for the given store handle ready to connect to the server at the given URI.
-     * Uses certificate authorities trusted by the host if no trusted certificate paths are passed.
+     * Creates a sync client options object for the given store.
+     * <p>
+     * The options must be configured (at least one URL) and then used with {@link #nativeSyncOptCreateClient}.
+     *
+     * @return handle to the options object, or 0 on error
+     */
+    private static native long nativeSyncOptCreate(long storeHandle);
+
+    /**
+     * Adds a server URL to the sync options; at least one URL must be added before creating the sync client.
+     * <p>
+     * Passing multiple URLs allows high availability and load balancing (i.e. using an ObjectBox Sync Server Cluster).
+     * <p>
+     * A random URL is selected for each connection attempt.
+     */
+    private static native void nativeSyncOptAddUrl(long optHandle, String url);
+
+    /**
+     * Adds a certificate path to the sync options.
+     * <p>
+     * This allows to pass certificate paths referring to the local file system.
+     * <p>
+     * Example use cases are using self-signed certificates in a local development environment and custom certificate
+     * authorities.
+     */
+    private static native void nativeSyncOptAddCertPath(long optHandle, String certPath);
+
+    /**
+     * Sets sync flags to adjust sync behavior; see SyncFlags for available flags.
+     * <p>
+     * Combine multiple flags using bitwise OR.
+     */
+    private static native void nativeSyncOptFlags(long optHandle, int flags);
+
+    /**
+     * Creates a sync client with the given options.
+     * <p>
+     * This does not initiate any connection attempts yet: call {@link #nativeStart} to do so. Before nativeStart(), you
+     * must configure credentials via {@link #nativeSetLoginInfo} or {@link #nativeAddLoginCredentials}.
+     * <p>
+     * By default, a sync client automatically receives updates from the server once login succeeded. To configure this
+     * differently, call {@link #nativeSetRequestUpdatesMode} with the wanted mode.
+     * <p>
+     * Note: the given options are always freed by this function, including when an error occurs.
+     *
+     * @return handle to the sync client, or 0 on error
      */
-    private static native long nativeCreate(long storeHandle, String uri, @Nullable String[] certificateDirsOrPaths);
+    private static native long nativeSyncOptCreateClient(long optHandle);
+
+    /**
+     * Frees the sync options object.
+     * <p>
+     * Note: Only free *unused* options; {@link #nativeSyncOptCreateClient} frees the options internally.
+     */
+    private static native void nativeSyncOptFree(long optHandle);
+
+    /**
+     * Creates a mesh options object used to configure a peer-to-peer mesh sync.
+     * <p>
+     * Pass it to {@link #nativeSyncOptMesh} to attach it to the sync options; that call frees the mesh options.
+     *
+     * @param meshId the mesh network identifier (required); nodes with different IDs ignore each other.
+     * @return handle to the mesh options object, or 0 on error
+     */
+    private static native long nativeMeshOptCreate(String meshId);
+
+    /**
+     * Frees the mesh options object.
+     * <p>
+     * Note: Only free *unused* options; {@link #nativeSyncOptMesh} frees the mesh options internally.
+     */
+    private static native void nativeMeshOptFree(long meshOptHandle);
+
+    private static native void nativeMeshOptMaxConnectionCount(long meshOptHandle, int count);
+
+    private static native void nativeMeshOptBackoffMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptEvictionBackoffMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptRequestTimeoutMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptAdvertisingDelayMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptAdvertisingRetryMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptAdvertisingRetryMaxMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptConnectDelayMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptInitialDiscoveryDurationSeconds(long meshOptHandle, int seconds);
+
+    private static native void nativeMeshOptDiscoveryDurationSeconds(long meshOptHandle, int seconds);
+
+    private static native void nativeMeshOptDiscoveryPauseSeconds(long meshOptHandle, int seconds);
+
+    private static native void nativeMeshOptDiscoveryPauseJitterSeconds(long meshOptHandle, int seconds);
+
+    private static native void nativeMeshOptTxLogBatchSizeKb(long meshOptHandle, int sizeKb);
+
+    private static native void nativeMeshOptTxLogBatchMaxCount(long meshOptHandle, int count);
+
+    /**
+     * Registers an internal mesh network (transport) implementation with the mesh options.
+     * <p>
+     * Networks are platform-specific (e.g. Android Nearby) and are created by ObjectBox platform libraries.
+     *
+     * @param networkInternalHandle an internal handle to a native mesh network.
+     */
+    private static native void nativeMeshOptNetworkInternal(long meshOptHandle, long networkInternalHandle);
+
+    /**
+     * Attaches a mesh sync configuration to the sync options.
+     * <p>
+     * When the sync client is created ({@link #nativeSyncOptCreateClient}), a mesh sync is created from this
+     * configuration and attached to the client; it starts and stops together with the client. Use
+     * {@link #nativeGetMesh} to query the running mesh.
+     * <p>
+     * Note: the given mesh options are always freed by this function, including when an error occurs.
+     */
+    private static native void nativeSyncOptMesh(long optHandle, long meshOptHandle);
+
+    /**
+     * Returns a handle to the mesh sync attached to the sync client (configured via {@link #nativeSyncOptMesh}),
+     * or 0 if no mesh sync is attached.
+     * <p>
+     * The mesh sync is owned by the sync client; the handle is valid as long as the sync client is not closed.
+     */
+    private native long nativeGetMesh(long handle);
 
     private native void nativeDelete(long handle);
 
@@ -293,8 +631,26 @@ public ObjectsMessageBuilder startObjectsMessage(long flags, @Nullable String to
 
     private native void nativeStop(long handle);
 
+    // extern "C" JNIEXPORT void JNICALL Java_io_objectbox_sync_SyncClientImpl_nativePutFilterVariable(JNIEnv* env, jobject, jlong handle, jstring name, jstring value)
+    private native void nativePutFilterVariable(long handle, String name, String value);
+
+    // extern "C" JNIEXPORT void JNICALL Java_io_objectbox_sync_SyncClientImpl_nativeRemoveFilterVariable(JNIEnv* env, jobject, jlong handle, jstring name)
+    private native void nativeRemoveFilterVariable(long handle, String name);
+
+    // extern "C" JNIEXPORT void JNICALL Java_io_objectbox_sync_SyncClientImpl_nativeRemoveAllFilterVariables(JNIEnv* env, jobject, jlong handle)
+    private native void nativeRemoveAllFilterVariables(long handle);
+
+    // extern "C" JNIEXPORT void JNICALL Java_io_objectbox_sync_SyncClientImpl_nativeApplyFilterVariables(JNIEnv* env, jobject, jlong handle)
+    private native void nativeApplyFilterVariables(long handle);
+
     private native void nativeSetLoginInfo(long handle, long credentialsType, @Nullable byte[] credentials);
 
+    private native void nativeSetLoginInfoUserPassword(long handle, long credentialsType, String username, String password);
+
+    private native void nativeAddLoginCredentials(long handle, long credentialsType, @Nullable byte[] credentials, boolean complete);
+
+    private native void nativeAddLoginCredentialsUserPassword(long handle, long credentialsType, String username, String password, boolean complete);
+
     private native void nativeSetListener(long handle, @Nullable InternalSyncClientListener listener);
 
     private native void nativeSetSyncChangesListener(long handle, @Nullable SyncChangeListener advancedListener);
@@ -322,8 +678,8 @@ public ObjectsMessageBuilder startObjectsMessage(long flags, @Nullable String to
     private native boolean nativeCancelUpdates(long handle);
 
     /**
-     *  Hints to the native client that an active network connection is available.
-     *  Returns true if the native client was disconnected (and will try to re-connect).
+     * Hints to the native client that an active network connection is available.
+     * Returns true if the native client was disconnected (and will try to re-connect).
      */
     private native boolean nativeTriggerReconnect(long handle);
 
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentials.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentials.java
index 2f230e93..77e1120e 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentials.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentials.java
@@ -1,28 +1,43 @@
-package io.objectbox.sync;
+/*
+ * Copyright 2019-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-import io.objectbox.annotation.apihint.Experimental;
+package io.objectbox.sync;
 
 /**
  * Use the static helper methods to build Sync credentials,
  * for example {@link #sharedSecret(String) SyncCredentials.sharedSecret("secret")}.
  */
 @SuppressWarnings("unused")
-@Experimental
-public class SyncCredentials {
+public abstract class SyncCredentials {
+
+    private final CredentialsType type;
 
     /**
      * Authenticate with a shared secret. This could be a passphrase, big number or randomly chosen bytes.
      * The string is expected to use UTF-8 characters.
      */
     public static SyncCredentials sharedSecret(String secret) {
-        return new SyncCredentialsToken(CredentialsType.SHARED_SECRET, secret);
+        return new SyncCredentialsToken(CredentialsType.SHARED_SECRET_SIPPED, secret);
     }
 
     /**
      * Authenticate with a shared secret. This could be a passphrase, big number or randomly chosen bytes.
      */
     public static SyncCredentials sharedSecret(byte[] secret) {
-        return new SyncCredentialsToken(CredentialsType.SHARED_SECRET, secret);
+        return new SyncCredentialsToken(CredentialsType.SHARED_SECRET_SIPPED, secret);
     }
 
     /**
@@ -33,6 +48,112 @@ public static SyncCredentials google(String idToken) {
         return new SyncCredentialsToken(CredentialsType.GOOGLE, idToken);
     }
 
+    /**
+     * ObjectBox Admin user (username and password).
+     */
+    public static SyncCredentials obxAdminUser(String user, String password) {
+        return new SyncCredentialsUserPassword(CredentialsType.OBX_ADMIN_USER, user, password);
+    }
+
+    /**
+     * Generic credentials type suitable for ObjectBox Admin (and possibly others in the future).
+     */
+    public static SyncCredentials userAndPassword(String user, String password) {
+        return new SyncCredentialsUserPassword(CredentialsType.USER_PASSWORD, user, password);
+    }
+
+    /**
+     * Authenticate with a JSON Web Token (JWT) that is an ID token.
+     * <p>
+     * An ID token typically provides identity information about the authenticated user.
+     * <p>
+     * Use this and the other JWT methods that accept a token to configure JWT auth for a Sync client or server peer.
+     * To configure Sync server auth options, use the server variants, like {@link #jwtIdTokenServer()}, instead.
+     * <p>
+     * See the <a href="https://sync.objectbox.io/sync-server-configuration/jwt-authentication">JWT authentication documentation</a>
+     * for details.
+     */
+    public static SyncCredentials jwtIdToken(String jwtIdToken) {
+        return new SyncCredentialsToken(CredentialsType.JWT_ID_TOKEN, jwtIdToken);
+    }
+
+    /**
+     * Authenticate with a JSON Web Token (JWT) that is an access token.
+     * <p>
+     * An access token is used to access resources.
+     * <p>
+     * See {@link #jwtIdToken(String)} for some common remarks.
+     */
+    public static SyncCredentials jwtAccessToken(String jwtAccessToken) {
+        return new SyncCredentialsToken(CredentialsType.JWT_ACCESS_TOKEN, jwtAccessToken);
+    }
+
+    /**
+     * Authenticate with a JSON Web Token (JWT) that is a refresh token.
+     * <p>
+     * A refresh token is used to obtain a new access token.
+     * <p>
+     * See {@link #jwtIdToken(String)} for some common remarks.
+     */
+    public static SyncCredentials jwtRefreshToken(String jwtRefreshToken) {
+        return new SyncCredentialsToken(CredentialsType.JWT_REFRESH_TOKEN, jwtRefreshToken);
+    }
+
+    /**
+     * Authenticate with a JSON Web Token (JWT) that is neither an ID, access, nor refresh token.
+     * <p>
+     * See {@link #jwtIdToken(String)} for some common remarks.
+     */
+    public static SyncCredentials jwtCustomToken(String jwtCustomToken) {
+        return new SyncCredentialsToken(CredentialsType.JWT_CUSTOM_TOKEN, jwtCustomToken);
+    }
+
+    /**
+     * Enable authentication using a JSON Web Token (JWT) that is an ID token.
+     * <p>
+     * An ID token typically provides identity information about the authenticated user.
+     * <p>
+     * Use this and the other JWT server credentials types to configure a Sync server.
+     * For Sync clients, use the ones that accept a token, like {@link #jwtIdToken(String)}, instead.
+     * <p>
+     * See the <a href="https://sync.objectbox.io/sync-server-configuration/jwt-authentication">JWT authentication documentation</a>
+     * for details.
+     */
+    public static SyncCredentials jwtIdTokenServer() {
+        return new SyncCredentialsToken(CredentialsType.JWT_ID_TOKEN);
+    }
+
+    /**
+     * Enable authentication using a JSON Web Token (JWT) that is an access token.
+     * <p>
+     * An access token is used to access resources.
+     * <p>
+     * See {@link #jwtIdTokenServer()} for some common remarks.
+     */
+    public static SyncCredentials jwtAccessTokenServer() {
+        return new SyncCredentialsToken(CredentialsType.JWT_ACCESS_TOKEN);
+    }
+
+    /**
+     * Enable authentication using a JSON Web Token (JWT) that is a refresh token.
+     * <p>
+     * A refresh token is used to obtain a new access token.
+     * <p>
+     * See {@link #jwtIdTokenServer()} for some common remarks.
+     */
+    public static SyncCredentials jwtRefreshTokenServer() {
+        return new SyncCredentialsToken(CredentialsType.JWT_REFRESH_TOKEN);
+    }
+
+    /**
+     * Enable authentication using a JSON Web Token (JWT) that is neither an ID, access, nor refresh token.
+     * <p>
+     * See {@link #jwtIdTokenServer()} for some common remarks.
+     */
+    public static SyncCredentials jwtCustomTokenServer() {
+        return new SyncCredentialsToken(CredentialsType.JWT_CUSTOM_TOKEN);
+    }
+
     /**
      * No authentication, unsecured. Use only for development and testing purposes.
      */
@@ -41,13 +162,16 @@ public static SyncCredentials none() {
     }
 
     public enum CredentialsType {
-        // Note: this needs to match with CredentialsType in Core.
 
-        NONE(1),
-
-        SHARED_SECRET(2),
-
-        GOOGLE(3);
+        NONE(io.objectbox.sync.CredentialsType.None),
+        GOOGLE(io.objectbox.sync.CredentialsType.GoogleAuth),
+        SHARED_SECRET_SIPPED(io.objectbox.sync.CredentialsType.SharedSecretSipped),
+        OBX_ADMIN_USER(io.objectbox.sync.CredentialsType.ObxAdminUser),
+        USER_PASSWORD(io.objectbox.sync.CredentialsType.UserPassword),
+        JWT_ID_TOKEN(io.objectbox.sync.CredentialsType.JwtId),
+        JWT_ACCESS_TOKEN(io.objectbox.sync.CredentialsType.JwtAccess),
+        JWT_REFRESH_TOKEN(io.objectbox.sync.CredentialsType.JwtRefresh),
+        JWT_CUSTOM_TOKEN(io.objectbox.sync.CredentialsType.JwtCustom);
 
         public final long id;
 
@@ -56,7 +180,24 @@ public enum CredentialsType {
         }
     }
 
-    SyncCredentials() {
+    SyncCredentials(CredentialsType type) {
+        this.type = type;
     }
 
+    public CredentialsType getType() {
+        return type;
+    }
+
+    public long getTypeId() {
+        return type.id;
+    }
+
+    /**
+     * Creates a copy of these credentials.
+     * <p>
+     * This can be useful to use the same credentials when creating multiple clients or a server in combination with a
+     * client as some credentials may get cleared when building a client or server.
+     */
+    abstract SyncCredentials createClone();
+
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsToken.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsToken.java
index 7cff538b..55ceff13 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsToken.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsToken.java
@@ -1,28 +1,46 @@
+/*
+ * Copyright 2019-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
-import io.objectbox.annotation.apihint.Internal;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
 
 import javax.annotation.Nullable;
-import java.io.UnsupportedEncodingException;
-import java.util.Arrays;
+
+import io.objectbox.annotation.apihint.Internal;
 
 /**
  * Internal credentials implementation. Use {@link SyncCredentials} to build credentials.
  */
 @Internal
-public class SyncCredentialsToken extends SyncCredentials {
+public final class SyncCredentialsToken extends SyncCredentials {
 
-    private final CredentialsType type;
     @Nullable private byte[] token;
     private volatile boolean cleared;
 
     SyncCredentialsToken(CredentialsType type) {
-        this.type = type;
+        super(type);
         this.token = null;
     }
 
-    SyncCredentialsToken(CredentialsType type, @SuppressWarnings("NullableProblems") byte[] token) {
+    SyncCredentialsToken(CredentialsType type, byte[] token) {
         this(type);
+        // Annotations do not guarantee non-null values
+        //noinspection ConstantValue
         if (token == null || token.length == 0) {
             throw new IllegalArgumentException("Token must not be empty");
         }
@@ -30,11 +48,11 @@ public class SyncCredentialsToken extends SyncCredentials {
     }
 
     SyncCredentialsToken(CredentialsType type, String token) {
-        this(type, asUtf8Bytes(token));
+        this(type, token.getBytes(StandardCharsets.UTF_8));
     }
 
-    public long getTypeId() {
-        return type.id;
+    public boolean hasToken() {
+        return token != null;
     }
 
     @Nullable
@@ -47,9 +65,12 @@ public byte[] getTokenBytes() {
 
     /**
      * Clear after usage.
-     *
-     * Note that actual data is not removed from memory until the next garbage collector run.
-     * Anyhow, the credentials are still kept in memory by the native component.
+     * <p>
+     * Note that when the token is passed as a String, that String is removed from memory at the earliest with the next
+     * garbage collector run.
+     * <p>
+     * Also note that while the token is removed from the Java heap, it is present on the native heap of the Sync
+     * component using it.
      */
     public void clear() {
         cleared = true;
@@ -60,12 +81,15 @@ public void clear() {
         this.token = null;
     }
 
-    private static byte[] asUtf8Bytes(String token) {
-        try {
-            //noinspection CharsetObjectCanBeUsed On Android not available until SDK 19.
-            return token.getBytes("UTF-8");
-        } catch (UnsupportedEncodingException e) {
-            throw new RuntimeException(e);
+    @Override
+    SyncCredentialsToken createClone() {
+        if (cleared) {
+            throw new IllegalStateException("Cannot clone: credentials already have been cleared");
+        }
+        if (token == null) {
+            return new SyncCredentialsToken(getType());
+        } else {
+            return new SyncCredentialsToken(getType(), Arrays.copyOf(token, token.length));
         }
     }
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsUserPassword.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsUserPassword.java
new file mode 100644
index 00000000..62d9e53f
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsUserPassword.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Internal;
+
+/**
+ * Internal credentials implementation for user and password authentication.
+ * Use {@link SyncCredentials} to build credentials.
+ */
+@Internal
+public final class SyncCredentialsUserPassword extends SyncCredentials {
+
+    private final String username;
+    private final String password;
+
+    SyncCredentialsUserPassword(CredentialsType type, String username, String password) {
+        super(type);
+        this.username = username;
+        this.password = password;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    @Override
+    SyncCredentials createClone() {
+        return new SyncCredentialsUserPassword(getType(), this.username, this.password);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/model/SyncFlags.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncFlags.java
similarity index 57%
rename from objectbox-java/src/main/java/io/objectbox/model/SyncFlags.java
rename to objectbox-java/src/main/java/io/objectbox/sync/SyncFlags.java
index f26c6457..08051585 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/SyncFlags.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncFlags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ * Copyright 2026 ObjectBox Ltd. https://objectbox.io
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
 
 // automatically generated by the FlatBuffers compiler, do not modify
 
-package io.objectbox.model;
+package io.objectbox.sync;
 
 /**
  * Flags to adjust sync behavior like additional logging.
@@ -25,7 +25,7 @@
 public final class SyncFlags {
   private SyncFlags() { }
   /**
-   * Enable (rather extensive) logging on how IDs are mapped (local <-> global)
+   * Enable (rather extensive) logging on how IDs are mapped (local &lt;-&gt; global)
    */
   public static final int DebugLogIdMapping = 1;
   /**
@@ -37,5 +37,26 @@ private SyncFlags() { }
    * Client-only: setting this flag for Sync server has no effect.
    */
   public static final int ClientKeepDataOnSyncError = 2;
+  /**
+   * Logs sync filter variables used for each client, e.g. values provided by JWT or the client's login message.
+   * Server-only: setting this flag for Sync client has no effect.
+   */
+  public static final int DebugLogFilterVariables = 4;
+  /**
+   * When set, remove operations will include the full object data in the TX log (REMOVE_OBJECT command).
+   * This allows sync filters to filter out remove operations based on the object content.
+   * Without this flag, remove operations only contain the object ID and cannot be filtered.
+   * Note: this increases the size of TX logs for remove operations.
+   */
+  public static final int RemoveWithObjectData = 8;
+  /**
+   * Enables debug logging of TX log processing.
+   * For now, this only has an effect on SyncClients (Sync Server has extensive debug logs already).
+   */
+  public static final int DebugLogTxLogs = 16;
+  /**
+   * Skips invalid (put object) operations in the TX log instead of failing.
+   */
+  public static final int SkipInvalidTxOps = 32;
 }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncHybrid.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncHybrid.java
new file mode 100644
index 00000000..cb2b19d2
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncHybrid.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import java.io.Closeable;
+
+import io.objectbox.BoxStore;
+import io.objectbox.sync.server.SyncServer;
+
+/**
+ * Combines the functionality of a Sync client and a Sync server.
+ * <p>
+ * It is typically used in local cluster setups, in which a "hybrid" functions as a client and cluster peer (server).
+ * <p>
+ * Call {@link #getStore()} to retrieve the store. To set sync listeners use the {@link SyncClient} that is available
+ * from {@link #getClient()}.
+ * <p>
+ * This class implements the {@link Closeable} interface, ensuring that resources are cleaned up properly.
+ */
+public final class SyncHybrid implements Closeable {
+    private BoxStore store;
+    private final SyncClient client;
+    private BoxStore storeServer;
+    private final SyncServer server;
+
+    SyncHybrid(BoxStore store, SyncClient client, BoxStore storeServer, SyncServer server) {
+        this.store = store;
+        this.client = client;
+        this.storeServer = storeServer;
+        this.server = server;
+    }
+
+    public BoxStore getStore() {
+        return store;
+    }
+
+    /**
+     * Returns the {@link SyncClient} of this hybrid, typically only to set Sync listeners.
+     * <p>
+     * Note: do not stop or close the client directly. Instead, use the {@link #stop()} and {@link #close()} methods of
+     * this hybrid.
+     */
+    public SyncClient getClient() {
+        return client;
+    }
+
+    /**
+     * Returns the {@link SyncServer} of this hybrid.
+     * <p>
+     * Typically, the server should not be touched. Yet, it is still exposed for advanced use cases.
+     * <p>
+     * Note: do not stop or close the server directly. Instead, use the {@link #stop()} and {@link #close()} methods of
+     * this hybrid.
+     */
+    public SyncServer getServer() {
+        return server;
+    }
+
+    /**
+     * Stops the client and server.
+     */
+    public void stop() {
+        client.stop();
+        server.stop();
+    }
+
+    /**
+     * Closes and cleans up all resources used by this Sync hybrid.
+     * <p>
+     * It can no longer be used afterward, build a new one instead.
+     * <p>
+     * Does nothing if this has already been closed.
+     */
+    @Override
+    public void close() {
+        // Clear reference to boxStore but do not close it (same behavior as SyncClient and SyncServer)
+        store = null;
+        client.close();
+        server.close();
+        if (storeServer != null) {
+            storeServer.close(); // The server store is "internal", so can safely close it
+            storeServer = null;
+        }
+    }
+
+    /**
+     * Users of this class should explicitly call {@link #close()} instead to avoid expensive finalization.
+     */
+    @SuppressWarnings("deprecation") // finalize()
+    @Override
+    protected void finalize() throws Throwable {
+        close();
+        super.finalize();
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncHybridBuilder.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncHybridBuilder.java
new file mode 100644
index 00000000..1cade53b
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncHybridBuilder.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.BoxStore;
+import io.objectbox.BoxStoreBuilder;
+import io.objectbox.InternalAccess;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.sync.server.SyncServer;
+import io.objectbox.sync.server.SyncServerBuilder;
+
+/**
+ * Builder for a Sync client and server hybrid setup, a {@link SyncHybrid}.
+ * <p>
+ * To change the server/cluster configuration, call {@link #serverBuilder()}, and for the client configuration
+ * {@link #clientBuilder()}.
+ */
+@SuppressWarnings({"unused", "UnusedReturnValue"})
+public final class SyncHybridBuilder {
+
+    private final BoxStore boxStore;
+    private final BoxStore boxStoreServer;
+    private final SyncBuilder clientBuilder;
+    private final SyncServerBuilder serverBuilder;
+
+    /**
+     * Internal API; use {@link Sync#hybrid(BoxStoreBuilder, String, SyncCredentials)} instead.
+     */
+    @Internal
+    SyncHybridBuilder(BoxStoreBuilder storeBuilder, String url, SyncCredentials authenticatorCredentials) {
+        BoxStoreBuilder storeBuilderServer = InternalAccess.clone(storeBuilder, "-server");
+        boxStore = storeBuilder.build();
+        boxStoreServer = storeBuilderServer.build();
+        SyncCredentials clientCredentials = authenticatorCredentials.createClone();
+        // Do not yet set URL, port may only be chosen once server is started, see buildAndStart()
+        clientBuilder = new SyncBuilder(boxStore).credentials(clientCredentials);
+        serverBuilder = new SyncServerBuilder(boxStoreServer, url, authenticatorCredentials);
+    }
+
+    /**
+     * Returns the builder of the client of the hybrid for additional configuration.
+     */
+    public SyncBuilder clientBuilder() {
+        return clientBuilder;
+    }
+
+    /**
+     * Returns the builder of the server of the hybrid for additional configuration.
+     */
+    public SyncServerBuilder serverBuilder() {
+        return serverBuilder;
+    }
+
+    /**
+     * Builds, starts and returns the hybrid.
+     * <p>
+     * Ensures the correct order of starting the server and client.
+     */
+    @SuppressWarnings("resource") // User is responsible for closing
+    public SyncHybrid buildAndStart() {
+        // Build and start the server first to obtain its URL, the port may have been set to 0 and dynamically assigned
+        SyncServer server = serverBuilder.buildAndStart();
+
+        SyncClient client = clientBuilder
+                .url(server.getUrl())
+                .buildAndStart();
+
+        return new SyncHybrid(boxStore, client, boxStoreServer, server);
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncLoginCodes.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncLoginCodes.java
index d0dabc8c..10f70b8e 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/SyncLoginCodes.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncLoginCodes.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2019-2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
 import io.objectbox.annotation.apihint.Experimental;
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncState.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncState.java
index 93e319fa..ea94f188 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/SyncState.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncState.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2019-2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
 /**
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/internal/Platform.java b/objectbox-java/src/main/java/io/objectbox/sync/internal/Platform.java
index fa5f799e..76bb39aa 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/internal/Platform.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/internal/Platform.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.internal;
 
 import java.lang.reflect.InvocationTargetException;
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/AbstractSyncListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/AbstractSyncListener.java
index 835099ee..34392c30 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/listener/AbstractSyncListener.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/AbstractSyncListener.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.listener;
 
 import io.objectbox.annotation.apihint.Experimental;
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncChangeListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncChangeListener.java
index d1149d44..993c4180 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncChangeListener.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncChangeListener.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2019-2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.listener;
 
 import io.objectbox.annotation.apihint.Experimental;
@@ -15,6 +31,7 @@
 public interface SyncChangeListener {
 
     // Note: this method is expected by JNI, check before modifying/removing it.
+
     /**
      * Called each time when data from sync was applied locally.
      *
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncCompletedListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncCompletedListener.java
index af658257..de67dc54 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncCompletedListener.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncCompletedListener.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.listener;
 
 /**
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncConnectionListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncConnectionListener.java
index 8dcabf60..b3622f47 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncConnectionListener.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncConnectionListener.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.listener;
 
 /**
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncListener.java
index be64c354..5a2c7ab2 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncListener.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncListener.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.listener;
 
 import io.objectbox.annotation.apihint.Experimental;
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncLoginListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncLoginListener.java
index a8769baa..fe70a3fb 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncLoginListener.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncLoginListener.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.listener;
 
 import io.objectbox.sync.SyncLoginCodes;
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncTimeListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncTimeListener.java
index 33b9339a..ec6355cb 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncTimeListener.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncTimeListener.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.listener;
 
 public interface SyncTimeListener {
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/package-info.java b/objectbox-java/src/main/java/io/objectbox/sync/package-info.java
index 6b972231..0b385d9e 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,19 +18,18 @@
  * <a href="https://objectbox.io/sync/">ObjectBox Sync</a> allows to automatically synchronize local data with a sync
  * destination (e.g. a sync server) and vice versa. This is the sync <b>client</b> package.
  * <p>
- * These are the typical steps to setup a sync client:
+ * These are the typical steps to set up a sync client:
  * <ol>
- *     <li>Create a BoxStore as usual (using MyObjectBox)</li>
- *     <li>Get a {@link io.objectbox.sync.SyncBuilder} using {@link io.objectbox.sync.Sync#client(
- *     io.objectbox.BoxStore, java.lang.String, io.objectbox.sync.SyncCredentials)}.
- *     Here you need to pass the {@link io.objectbox.BoxStore}, along with an URL to the sync destination (server),
- *     and credentials. For demo set ups, you could start with {@link io.objectbox.sync.SyncCredentials#none()}
- *     credentials.</li>
+ *     <li>Create a BoxStore as usual (using MyObjectBox).</li>
+ *     <li>Build a {@link io.objectbox.sync.SyncClient} using
+ *     {@link io.objectbox.sync.Sync#client(io.objectbox.BoxStore) Sync.client(boxStore)}, a
+ *     {@link io.objectbox.sync.SyncBuilder#url(java.lang.String)} and at least one set of credentials with
+ *     {@link io.objectbox.sync.SyncBuilder#credentials(io.objectbox.sync.SyncCredentials)}.</li>
  *     <li>Optional: use the {@link io.objectbox.sync.SyncBuilder} instance from the last step to configure the sync
  *     client and set initial listeners.</li>
- *     <li>Call {@link io.objectbox.sync.SyncBuilder#build()} to get an instance of
+ *     <li>Call {@link io.objectbox.sync.SyncBuilder#buildAndStart()} to get an instance of
  *     {@link io.objectbox.sync.SyncClient} (and hold on to it). Synchronization is now active.</li>
- *     <li>Optional: Interact with {@link io.objectbox.sync.SyncClient}</li>
+ *     <li>Optional: Interact with {@link io.objectbox.sync.SyncClient}.</li>
  * </ol>
  */
 @ParametersAreNonnullByDefault
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterFlags.java b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterFlags.java
new file mode 100644
index 00000000..ce03bf99
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterFlags.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+/**
+ * Special bit flags used in cluster mode only.
+ */
+@SuppressWarnings("unused")
+public final class ClusterFlags {
+  private ClusterFlags() { }
+  /**
+   * Indicates that this cluster always stays in the "follower" cluster role.
+   * Thus, it does not participate in leader elections.
+   * This is useful e.g. for weaker cluster nodes that should not become leaders.
+   */
+  public static final int FixedFollower = 1;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerConfig.java b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerConfig.java
new file mode 100644
index 00000000..5c4316d8
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerConfig.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Configuration to connect to another (remote) cluster peer.
+ * If this server is started in cluster mode, it connects to other cluster peers.
+ */
+@SuppressWarnings("unused")
+public final class ClusterPeerConfig extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static ClusterPeerConfig getRootAsClusterPeerConfig(ByteBuffer _bb) { return getRootAsClusterPeerConfig(_bb, new ClusterPeerConfig()); }
+  public static ClusterPeerConfig getRootAsClusterPeerConfig(ByteBuffer _bb, ClusterPeerConfig obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public ClusterPeerConfig __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public String url() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer urlAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+  public ByteBuffer urlInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); }
+  public io.objectbox.sync.Credentials credentials() { return credentials(new io.objectbox.sync.Credentials()); }
+  public io.objectbox.sync.Credentials credentials(io.objectbox.sync.Credentials obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
+
+  public static int createClusterPeerConfig(FlatBufferBuilder builder,
+      int urlOffset,
+      int credentialsOffset) {
+    builder.startTable(2);
+    ClusterPeerConfig.addCredentials(builder, credentialsOffset);
+    ClusterPeerConfig.addUrl(builder, urlOffset);
+    return ClusterPeerConfig.endClusterPeerConfig(builder);
+  }
+
+  public static void startClusterPeerConfig(FlatBufferBuilder builder) { builder.startTable(2); }
+  public static void addUrl(FlatBufferBuilder builder, int urlOffset) { builder.addOffset(0, urlOffset, 0); }
+  public static void addCredentials(FlatBufferBuilder builder, int credentialsOffset) { builder.addOffset(1, credentialsOffset, 0); }
+  public static int endClusterPeerConfig(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public ClusterPeerConfig get(int j) { return get(new ClusterPeerConfig(), j); }
+    public ClusterPeerConfig get(ClusterPeerConfig obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerInfo.java b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerInfo.java
new file mode 100644
index 00000000..bc815455
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerInfo.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2019-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.server;
+
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.sync.SyncCredentialsToken;
+
+/**
+ * Internal class to keep configuration for a cluster peer.
+ */
+@Internal
+final class ClusterPeerInfo {
+    String url;
+    SyncCredentialsToken credentials;
+
+    ClusterPeerInfo(String url, SyncCredentialsToken credentials) {
+        this.url = url;
+        this.credentials = credentials;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/JwtConfig.java b/objectbox-java/src/main/java/io/objectbox/sync/server/JwtConfig.java
new file mode 100644
index 00000000..02f9b3f0
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/JwtConfig.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class JwtConfig extends Table {
+    public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+    public static JwtConfig getRootAsJwtConfig(ByteBuffer _bb) { return getRootAsJwtConfig(_bb, new JwtConfig()); }
+    public static JwtConfig getRootAsJwtConfig(ByteBuffer _bb, JwtConfig obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+    public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+    public JwtConfig __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+    /**
+     * URL to fetch the current public key used to verify JWT signatures.
+     */
+    public String publicKeyUrl() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+    public ByteBuffer publicKeyUrlAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+    public ByteBuffer publicKeyUrlInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); }
+    /**
+     * Fixed public key used to sign JWT tokens; e.g. for development purposes.
+     * Supply either publicKey or publicKeyUrl, but not both.
+     */
+    public String publicKey() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; }
+    public ByteBuffer publicKeyAsByteBuffer() { return __vector_as_bytebuffer(6, 1); }
+    public ByteBuffer publicKeyInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); }
+    /**
+     * Cache expiration time in seconds for the public key(s) fetched from publicKeyUrl.
+     * If absent or zero, the default is used.
+     */
+    public long publicKeyCacheExpirationSeconds() { int o = __offset(8); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+    /**
+     * JWT claim "aud" (audience) used to verify JWT tokens.
+     */
+    public String claimAud() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; }
+    public ByteBuffer claimAudAsByteBuffer() { return __vector_as_bytebuffer(10, 1); }
+    public ByteBuffer claimAudInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 10, 1); }
+    /**
+     * JWT claim "iss" (issuer) used to verify JWT tokens.
+     */
+    public String claimIss() { int o = __offset(12); return o != 0 ? __string(o + bb_pos) : null; }
+    public ByteBuffer claimIssAsByteBuffer() { return __vector_as_bytebuffer(12, 1); }
+    public ByteBuffer claimIssInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 12, 1); }
+
+    public static int createJwtConfig(FlatBufferBuilder builder,
+                                      int publicKeyUrlOffset,
+                                      int publicKeyOffset,
+                                      long publicKeyCacheExpirationSeconds,
+                                      int claimAudOffset,
+                                      int claimIssOffset) {
+        builder.startTable(5);
+        JwtConfig.addClaimIss(builder, claimIssOffset);
+        JwtConfig.addClaimAud(builder, claimAudOffset);
+        JwtConfig.addPublicKeyCacheExpirationSeconds(builder, publicKeyCacheExpirationSeconds);
+        JwtConfig.addPublicKey(builder, publicKeyOffset);
+        JwtConfig.addPublicKeyUrl(builder, publicKeyUrlOffset);
+        return JwtConfig.endJwtConfig(builder);
+    }
+
+    public static void startJwtConfig(FlatBufferBuilder builder) { builder.startTable(5); }
+    public static void addPublicKeyUrl(FlatBufferBuilder builder, int publicKeyUrlOffset) { builder.addOffset(0, publicKeyUrlOffset, 0); }
+    public static void addPublicKey(FlatBufferBuilder builder, int publicKeyOffset) { builder.addOffset(1, publicKeyOffset, 0); }
+    public static void addPublicKeyCacheExpirationSeconds(FlatBufferBuilder builder, long publicKeyCacheExpirationSeconds) { builder.addInt(2, (int) publicKeyCacheExpirationSeconds, (int) 0L); }
+    public static void addClaimAud(FlatBufferBuilder builder, int claimAudOffset) { builder.addOffset(3, claimAudOffset, 0); }
+    public static void addClaimIss(FlatBufferBuilder builder, int claimIssOffset) { builder.addOffset(4, claimIssOffset, 0); }
+    public static int endJwtConfig(FlatBufferBuilder builder) {
+        int o = builder.endTable();
+        return o;
+    }
+
+    public static final class Vector extends BaseVector {
+        public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+        public JwtConfig get(int j) { return get(new JwtConfig(), j); }
+        public JwtConfig get(JwtConfig obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+    }
+}
\ No newline at end of file
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/PeerInfo.java b/objectbox-java/src/main/java/io/objectbox/sync/server/PeerInfo.java
deleted file mode 100644
index 0bd4581d..00000000
--- a/objectbox-java/src/main/java/io/objectbox/sync/server/PeerInfo.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package io.objectbox.sync.server;
-
-import io.objectbox.annotation.apihint.Experimental;
-import io.objectbox.sync.SyncCredentials;
-
-@Experimental
-class PeerInfo {
-    String url;
-    SyncCredentials credentials;
-
-    PeerInfo(String url, SyncCredentials credentials) {
-        this.url = url;
-        this.credentials = credentials;
-    }
-}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServer.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServer.java
index 00bfcc0a..b70d4b37 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServer.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServer.java
@@ -1,10 +1,25 @@
+/*
+ * Copyright 2019-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.server;
 
 import java.io.Closeable;
 
 import javax.annotation.Nullable;
 
-import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.sync.Sync;
 import io.objectbox.sync.listener.SyncChangeListener;
 
@@ -12,16 +27,18 @@
  * ObjectBox sync server. Build a server with {@link Sync#server}.
  */
 @SuppressWarnings("unused")
-@Experimental
 public interface SyncServer extends Closeable {
 
     /**
-     * Gets the URL the server is running at.
+     * Returns the URL this server is listening on, including the bound port (see {@link #getPort()}).
      */
     String getUrl();
 
     /**
-     * Gets the port the server has bound to.
+     * Returns the port this server listens on, or 0 if the server was not yet started.
+     * <p>
+     * This is especially useful if the port was assigned arbitrarily (a "0" port was used in the URL when building the
+     * server).
      */
     int getPort();
 
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerBuilder.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerBuilder.java
index b06d22d9..7e2045b6 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerBuilder.java
@@ -1,62 +1,148 @@
-package io.objectbox.sync.server;
+/*
+ * Copyright 2019-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-import io.objectbox.BoxStore;
-import io.objectbox.annotation.apihint.Experimental;
-import io.objectbox.sync.listener.SyncChangeListener;
-import io.objectbox.sync.SyncCredentials;
+package io.objectbox.sync.server;
 
-import javax.annotation.Nullable;
+import java.net.URI;
+import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.List;
 
+import javax.annotation.Nullable;
+
+import io.objectbox.BoxStore;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.internal.NativeLibraryUtils;
+import io.objectbox.sync.Credentials;
+import io.objectbox.sync.Sync;
+import io.objectbox.sync.SyncCredentials;
+import io.objectbox.sync.SyncCredentialsToken;
+import io.objectbox.sync.SyncFlags;
+import io.objectbox.sync.listener.SyncChangeListener;
+
 /**
  * Creates a {@link SyncServer} and allows to set additional configuration.
  */
-@SuppressWarnings({"unused", "UnusedReturnValue", "WeakerAccess"})
-@Experimental
-public class SyncServerBuilder {
+@SuppressWarnings({"unused", "UnusedReturnValue"})
+public final class SyncServerBuilder {
 
     final BoxStore boxStore;
-    final String url;
-    final List<SyncCredentials> credentials = new ArrayList<>();
-    final List<PeerInfo> peers = new ArrayList<>();
+    final URI url;
+    private final List<SyncCredentialsToken> credentials = new ArrayList<>();
 
-    @Nullable String certificatePath;
+    private @Nullable String certificatePath;
     SyncChangeListener changeListener;
+    private @Nullable String clusterId;
+    private final List<ClusterPeerInfo> clusterPeers = new ArrayList<>();
+    private int clusterFlags;
+    private long historySizeMaxKb;
+    private long historySizeTargetKb;
+    private int syncFlags;
+    private int syncServerFlags;
+    private int workerThreads;
 
+    private @Nullable String jwtPublicKey;
+    private @Nullable String jwtPublicKeyUrl;
+    private @Nullable String jwtClaimIss;
+    private @Nullable String jwtClaimAud;
+
+    /**
+     * Use {@link Sync#server(BoxStore, String, SyncCredentials)} instead.
+     */
+    @Internal
     public SyncServerBuilder(BoxStore boxStore, String url, SyncCredentials authenticatorCredentials) {
         checkNotNull(boxStore, "BoxStore is required.");
         checkNotNull(url, "Sync server URL is required.");
         checkNotNull(authenticatorCredentials, "Authenticator credentials are required.");
-        if (!BoxStore.isSyncServerAvailable()) {
-            throw new IllegalStateException(
-                    "This library does not include ObjectBox Sync Server. " +
-                            "Please visit https://objectbox.io/sync/ for options.");
-        }
+        NativeLibraryUtils.checkHasSyncServerFeature();
         this.boxStore = boxStore;
-        this.url = url;
+        try {
+            this.url = new URI(url);
+        } catch (URISyntaxException e) {
+            throw new IllegalArgumentException("Sync server URL is invalid: " + url, e);
+        }
         authenticatorCredentials(authenticatorCredentials);
     }
 
+    /**
+     * Use {@link Sync#server(BoxStore, String, SyncCredentials)} instead.
+     */
+    @Internal
+    public SyncServerBuilder(BoxStore boxStore, String url, SyncCredentials[] multipleAuthenticatorCredentials) {
+        checkNotNull(boxStore, "BoxStore is required.");
+        checkNotNull(url, "Sync server URL is required.");
+        checkNotNull(multipleAuthenticatorCredentials, "Authenticator credentials are required.");
+        NativeLibraryUtils.checkHasSyncServerFeature();
+        this.boxStore = boxStore;
+        try {
+            this.url = new URI(url);
+        } catch (URISyntaxException e) {
+            throw new IllegalArgumentException("Sync server URL is invalid: " + url, e);
+        }
+        for (SyncCredentials credentials : multipleAuthenticatorCredentials) {
+            authenticatorCredentials(credentials);
+        }
+    }
+
+    /**
+     * Sets the path to a directory that contains a cert.pem and key.pem file to use to establish encrypted
+     * connections.
+     * <p>
+     * Use the "wss://" protocol for the server URL to turn on encrypted connections.
+     */
     public SyncServerBuilder certificatePath(String certificatePath) {
+        checkNotNull(certificatePath, "Certificate path must not be null");
         this.certificatePath = certificatePath;
         return this;
     }
 
     /**
-     * Adds additional authenticator credentials to authenticate clients with.
+     * Adds additional authenticator credentials to authenticate clients or peers with.
+     * <p>
+     * For the embedded server, currently only {@link SyncCredentials#sharedSecret}, any JWT method like
+     * {@link SyncCredentials#jwtIdTokenServer()} as well as {@link SyncCredentials#none} are supported.
      */
     public SyncServerBuilder authenticatorCredentials(SyncCredentials authenticatorCredentials) {
         checkNotNull(authenticatorCredentials, "Authenticator credentials must not be null.");
-        credentials.add(authenticatorCredentials);
+        if (!(authenticatorCredentials instanceof SyncCredentialsToken)) {
+            throw new IllegalArgumentException("Sync credentials of type " + authenticatorCredentials.getType()
+                    + " are not supported");
+        }
+        SyncCredentialsToken tokenCredential = (SyncCredentialsToken) authenticatorCredentials;
+        SyncCredentials.CredentialsType type = tokenCredential.getType();
+        switch (type) {
+            case JWT_ID_TOKEN:
+            case JWT_ACCESS_TOKEN:
+            case JWT_REFRESH_TOKEN:
+            case JWT_CUSTOM_TOKEN:
+                if (tokenCredential.hasToken()) {
+                    throw new IllegalArgumentException("Must not supply a token for a credential of type "
+                            + authenticatorCredentials.getType());
+                }
+        }
+        credentials.add(tokenCredential);
         return this;
     }
 
     /**
      * Sets a listener to observe fine granular changes happening during sync.
      * <p>
-     * This listener can also be {@link SyncServer#setSyncChangeListener(SyncChangeListener) set or removed}
-     * on the Sync server directly.
+     * This listener can also be {@link SyncServer#setSyncChangeListener(SyncChangeListener) set or removed} on the Sync
+     * server directly.
      */
     public SyncServerBuilder changeListener(SyncChangeListener changeListener) {
         this.changeListener = changeListener;
@@ -64,29 +150,184 @@ public SyncServerBuilder changeListener(SyncChangeListener changeListener) {
     }
 
     /**
-     * Adds a server peer, to which this server should connect to as a client using {@link SyncCredentials#none()}.
+     * Enables cluster mode (requires the Cluster feature) and associates this cluster peer with the given ID.
+     * <p>
+     * Cluster peers need to share the same ID to be in the same cluster.
+     *
+     * @see #clusterPeer(String, SyncCredentials)
+     * @see #clusterFlags(int)
      */
-    public SyncServerBuilder peer(String url) {
-        return peer(url, SyncCredentials.none());
+    public SyncServerBuilder clusterId(String id) {
+        checkNotNull(id, "Cluster ID must not be null");
+        this.clusterId = id;
+        return this;
     }
 
     /**
-     * Adds a server peer, to which this server should connect to as a client using the given credentials.
+     * Adds a (remote) cluster peer, to which this server should connect to as a client using the given credentials.
+     * <p>
+     * To use this, must set a {@link #clusterId(String)}.
      */
-    public SyncServerBuilder peer(String url, SyncCredentials credentials) {
-        peers.add(new PeerInfo(url, credentials));
+    public SyncServerBuilder clusterPeer(String url, SyncCredentials credentials) {
+        if (!(credentials instanceof SyncCredentialsToken)) {
+            throw new IllegalArgumentException("Sync credentials of type " + credentials.getType()
+                    + " are not supported");
+        }
+        clusterPeers.add(new ClusterPeerInfo(url, (SyncCredentialsToken) credentials));
         return this;
     }
 
     /**
-     * Builds and returns a Sync server ready to {@link SyncServer#start()}.
+     * Sets bit flags to configure the cluster behavior of the Sync server (aka cluster peer).
+     * <p>
+     * To use this, must set a {@link #clusterId(String)}.
+     *
+     * @param flags One or more of {@link ClusterFlags}.
+     */
+    public SyncServerBuilder clusterFlags(int flags) {
+        this.clusterFlags = flags;
+        return this;
+    }
+
+    /**
+     * Sets the maximum transaction history size.
+     * <p>
+     * Once the maximum size is reached, old transaction logs are deleted to stay below this limit. This is sometimes
+     * also called "history pruning" in the context of Sync.
+     * <p>
+     * If not set or set to 0, defaults to no limit.
      *
+     * @see #historySizeTargetKb(long)
+     */
+    public SyncServerBuilder historySizeMaxKb(long historySizeMaxKb) {
+        this.historySizeMaxKb = historySizeMaxKb;
+        return this;
+    }
+
+    /**
+     * Sets the target transaction history size.
+     * <p>
+     * Once the maximum size ({@link #historySizeMaxKb(long)}) is reached, old transaction logs are deleted until this
+     * size target is reached (lower than the maximum size). Using this target size typically lowers the frequency of
+     * history pruning and thus may improve efficiency.
+     * <p>
+     * If not set or set to 0, defaults to {@link #historySizeMaxKb(long)}.
+     */
+    public SyncServerBuilder historySizeTargetKb(long historySizeTargetKb) {
+        this.historySizeTargetKb = historySizeTargetKb;
+        return this;
+    }
+
+    /**
+     * Sets bit flags to adjust Sync behavior, like additional logging.
+     *
+     * @param syncFlags One or more of {@link SyncFlags}.
+     */
+    public SyncServerBuilder syncFlags(int syncFlags) {
+        this.syncFlags = syncFlags;
+        return this;
+    }
+
+    /**
+     * Sets bit flags to configure the Sync server.
+     *
+     * @param syncServerFlags One or more of {@link SyncServerFlags}.
+     */
+    public SyncServerBuilder syncServerFlags(int syncServerFlags) {
+        this.syncServerFlags = syncServerFlags;
+        return this;
+    }
+
+    /**
+     * Sets the number of workers for the main task pool.
+     * <p>
+     * If not set or set to 0, this uses a hardware-dependant default, e.g. 3 * CPU "cores".
+     */
+    public SyncServerBuilder workerThreads(int workerThreads) {
+        this.workerThreads = workerThreads;
+        return this;
+    }
+
+    /**
+     * Sets the public key used to verify JWT tokens.
+     * <p>
+     * The public key should be in the PEM format.
+     * <p>
+     * However, typically the key is supplied using a JWKS file served from a {@link #jwtPublicKeyUrl(String)}.
+     * <p>
+     * See {@link #jwtPublicKeyUrl(String)} for a common configuration to enable JWT auth.
+     */
+    public SyncServerBuilder jwtPublicKey(String publicKey) {
+        this.jwtPublicKey = publicKey;
+        return this;
+    }
+
+    /**
+     * Sets the JWKS (Json Web Key Sets) URL to fetch the current public key used to verify JWT tokens.
+     * <p>
+     * A working JWT configuration can look like this:
+     * <pre>{@code
+     * SyncCredentials auth = SyncCredentials.jwtIdTokenServer();
+     * SyncServer server = Sync.server(store, url, auth)
+     *         .jwtPublicKeyUrl("https://example.com/public-key")
+     *         .jwtClaimAud("<audience>")
+     *         .jwtClaimIss("<issuer>")
+     *         .build();
+     * }</pre>
+     *
+     * See the <a href="https://sync.objectbox.io/sync-server-configuration/jwt-authentication">JWT authentication documentation</a>
+     * for details.
+     */
+    public SyncServerBuilder jwtPublicKeyUrl(String publicKeyUrl) {
+        this.jwtPublicKeyUrl = publicKeyUrl;
+        return this;
+    }
+
+    /**
+     * Sets the JWT claim "iss" (issuer) used to verify JWT tokens.
+     *
+     * @see #jwtPublicKeyUrl(String)
+     */
+    public SyncServerBuilder jwtClaimIss(String claimIss) {
+        this.jwtClaimIss = claimIss;
+        return this;
+    }
+
+    /**
+     * Sets the JWT claim "aud" (audience) used to verify JWT tokens.
+     *
+     * @see #jwtPublicKeyUrl(String)
+     */
+    public SyncServerBuilder jwtClaimAud(String claimAud) {
+        this.jwtClaimAud = claimAud;
+        return this;
+    }
+
+    private boolean hasJwtConfig() {
+        return jwtPublicKey != null || jwtPublicKeyUrl != null;
+    }
+
+    /**
+     * Builds and returns a Sync server ready to {@link SyncServer#start()}.
+     * <p>
      * Note: this clears all previously set authenticator credentials.
      */
     public SyncServer build() {
+        // Note: even when only using JWT auth, must supply one of the credentials of JWT type
         if (credentials.isEmpty()) {
             throw new IllegalStateException("At least one authenticator is required.");
         }
+        if (hasJwtConfig()) {
+            if (jwtClaimAud == null) {
+                throw new IllegalArgumentException("To use JWT authentication, claimAud must be set");
+            }
+            if (jwtClaimIss == null) {
+                throw new IllegalArgumentException("To use JWT authentication, claimIss must be set");
+            }
+        }
+        if (!clusterPeers.isEmpty() || clusterFlags != 0) {
+            checkNotNull(clusterId, "Cluster ID must be set to use cluster features.");
+        }
         return new SyncServerImpl(this);
     }
 
@@ -105,4 +346,145 @@ private void checkNotNull(Object object, String message) {
         }
     }
 
+    /**
+     * From this configuration, builds a {@link SyncServerOptions} FlatBuffer and returns it as bytes.
+     * <p>
+     * Clears configured credentials, they can not be used again after this returns.
+     */
+    byte[] buildSyncServerOptions() {
+        FlatBufferBuilder fbb = new FlatBufferBuilder();
+        // Always put values, even if they match the default values (defined in the generated classes)
+        fbb.forceDefaults(true);
+
+        // Serialize non-integer values first to get their offset
+        int urlOffset = fbb.createString(url.toString());
+        int certificatePathOffset = 0;
+        if (certificatePath != null) {
+            certificatePathOffset = fbb.createString(certificatePath);
+        }
+        int clusterIdOffset = 0;
+        if (clusterId != null) {
+            clusterIdOffset = fbb.createString(clusterId);
+        }
+        int authenticationMethodsOffset = buildAuthenticationMethods(fbb);
+        int clusterPeersVectorOffset = buildClusterPeers(fbb);
+        int jwtConfigOffset = 0;
+        if (hasJwtConfig()) {
+            jwtConfigOffset = buildJwtConfig(fbb, jwtPublicKey, jwtPublicKeyUrl, jwtClaimIss, jwtClaimAud);
+        }
+        // Clear credentials immediately to make abuse less likely,
+        // but only after setting all options to allow (re-)using the same credentials object
+        // for authentication and cluster peers login credentials.
+        for (SyncCredentialsToken credential : credentials) {
+            credential.clear();
+        }
+        for (ClusterPeerInfo peer : clusterPeers) {
+            peer.credentials.clear();
+        }
+
+        // After collecting all offsets, create options
+        SyncServerOptions.startSyncServerOptions(fbb);
+        SyncServerOptions.addUrl(fbb, urlOffset);
+        SyncServerOptions.addAuthenticationMethods(fbb, authenticationMethodsOffset);
+        if (syncFlags != 0) {
+            SyncServerOptions.addSyncFlags(fbb, syncFlags);
+        }
+        if (syncServerFlags != 0) {
+            SyncServerOptions.addSyncFlags(fbb, syncServerFlags);
+        }
+        if (certificatePathOffset != 0) {
+            SyncServerOptions.addCertificatePath(fbb, certificatePathOffset);
+        }
+        if (workerThreads != 0) {
+            SyncServerOptions.addWorkerThreads(fbb, workerThreads);
+        }
+        if (historySizeMaxKb != 0) {
+            SyncServerOptions.addHistorySizeMaxKb(fbb, historySizeMaxKb);
+        }
+        if (historySizeTargetKb != 0) {
+            SyncServerOptions.addHistorySizeTargetKb(fbb, historySizeTargetKb);
+        }
+        if (clusterIdOffset != 0) {
+            SyncServerOptions.addClusterId(fbb, clusterIdOffset);
+        }
+        if (clusterPeersVectorOffset != 0) {
+            SyncServerOptions.addClusterPeers(fbb, clusterPeersVectorOffset);
+        }
+        if (clusterFlags != 0) {
+            SyncServerOptions.addClusterFlags(fbb, clusterFlags);
+        }
+        if (jwtConfigOffset != 0) {
+            SyncServerOptions.addJwtConfig(fbb, jwtConfigOffset);
+        }
+        int offset = SyncServerOptions.endSyncServerOptions(fbb);
+        fbb.finish(offset);
+
+        return fbb.sizedByteArray();
+    }
+
+    private int buildAuthenticationMethods(FlatBufferBuilder fbb) {
+        int[] credentialsOffsets = new int[credentials.size()];
+        for (int i = 0; i < credentials.size(); i++) {
+            credentialsOffsets[i] = buildCredentials(fbb, credentials.get(i));
+        }
+        return SyncServerOptions.createAuthenticationMethodsVector(fbb, credentialsOffsets);
+    }
+
+    private int buildCredentials(FlatBufferBuilder fbb, SyncCredentialsToken tokenCredentials) {
+        int tokenBytesOffset = 0;
+        byte[] tokenBytes = tokenCredentials.getTokenBytes();
+        if (tokenBytes != null) {
+            tokenBytesOffset = Credentials.createBytesVector(fbb, tokenBytes);
+        }
+
+        Credentials.startCredentials(fbb);
+        Credentials.addType(fbb, tokenCredentials.getTypeId());
+        if (tokenBytesOffset != 0) {
+            Credentials.addBytes(fbb, tokenBytesOffset);
+        }
+        return Credentials.endCredentials(fbb);
+    }
+
+    private int buildJwtConfig(FlatBufferBuilder fbb, @Nullable String publicKey, @Nullable String publicKeyUrl, String claimIss, String claimAud) {
+        if (publicKey == null && publicKeyUrl == null) {
+            throw new IllegalArgumentException("Either publicKey or publicKeyUrl must be set");
+        }
+        int publicKeyOffset = 0;
+        int publicKeyUrlOffset = 0;
+        if (publicKey != null) {
+            publicKeyOffset = fbb.createString(publicKey);
+        } else {
+            publicKeyUrlOffset = fbb.createString(publicKeyUrl);
+        }
+        int claimIssOffset = fbb.createString(claimIss);
+        int claimAudOffset = fbb.createString(claimAud);
+        JwtConfig.startJwtConfig(fbb);
+        if (publicKeyOffset != 0) {
+            JwtConfig.addPublicKey(fbb, publicKeyOffset);
+        } else {
+            JwtConfig.addPublicKeyUrl(fbb, publicKeyUrlOffset);
+        }
+        JwtConfig.addClaimIss(fbb, claimIssOffset);
+        JwtConfig.addClaimAud(fbb, claimAudOffset);
+        return JwtConfig.endJwtConfig(fbb);
+    }
+
+    private int buildClusterPeers(FlatBufferBuilder fbb) {
+        if (clusterPeers.isEmpty()) {
+            return 0;
+        }
+
+        int[] peersOffsets = new int[clusterPeers.size()];
+        for (int i = 0; i < clusterPeers.size(); i++) {
+            ClusterPeerInfo peer = clusterPeers.get(i);
+
+            int urlOffset = fbb.createString(peer.url);
+            int credentialsOffset = buildCredentials(fbb, peer.credentials);
+
+            peersOffsets[i] = ClusterPeerConfig.createClusterPeerConfig(fbb, urlOffset, credentialsOffset);
+        }
+
+        return SyncServerOptions.createClusterPeersVector(fbb, peersOffsets);
+    }
+
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerFlags.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerFlags.java
new file mode 100644
index 00000000..ab037f2e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerFlags.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+/**
+ * Bit flags to configure the Sync Server.
+ */
+@SuppressWarnings("unused")
+public final class SyncServerFlags {
+  private SyncServerFlags() { }
+  /**
+   * By default, if the Sync Server allows logins without credentials, it logs a warning message.
+   * If this flag is set, the message is logged only as "info".
+   */
+  public static final int AuthenticationNoneLogInfo = 1;
+  /**
+   * By default, the Admin server is enabled; this flag disables it.
+   */
+  public static final int AdminDisabled = 2;
+  /**
+   * By default, the Sync Server logs messages when it starts and stops; this flag disables it.
+   */
+  public static final int LogStartStopDisabled = 4;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerImpl.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerImpl.java
index 0a011a14..ae126816 100644
--- a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerImpl.java
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerImpl.java
@@ -1,47 +1,56 @@
+/*
+ * Copyright 2019-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync.server;
 
-import io.objectbox.InternalAccess;
-import io.objectbox.annotation.apihint.Internal;
-import io.objectbox.sync.listener.SyncChangeListener;
-import io.objectbox.sync.SyncCredentials;
-import io.objectbox.sync.SyncCredentialsToken;
+import java.net.URI;
+import java.net.URISyntaxException;
 
 import javax.annotation.Nullable;
 
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.sync.listener.SyncChangeListener;
+
 /**
  * Internal sync server implementation. Use {@link SyncServer} to access functionality,
  * this class may change without notice.
  */
 @Internal
-public class SyncServerImpl implements SyncServer {
+public final class SyncServerImpl implements SyncServer {
 
-    private final String url;
+    private final URI url;
     private volatile long handle;
 
+    /**
+     * Protects listener instance from garbage collection.
+     */
+    @SuppressWarnings("unused")
     @Nullable
     private volatile SyncChangeListener syncChangeListener;
 
     SyncServerImpl(SyncServerBuilder builder) {
         this.url = builder.url;
 
-        long storeHandle = InternalAccess.getHandle(builder.boxStore);
-        long handle = nativeCreate(storeHandle, url, builder.certificatePath);
+        long storeHandle = builder.boxStore.getNativeStore();
+        long handle = nativeCreateFromFlatOptions(storeHandle, builder.buildSyncServerOptions());
         if (handle == 0) {
             throw new RuntimeException("Failed to create sync server: handle is zero.");
         }
         this.handle = handle;
 
-        for (SyncCredentials credentials : builder.credentials) {
-            SyncCredentialsToken credentialsInternal = (SyncCredentialsToken) credentials;
-            nativeSetAuthenticator(handle, credentialsInternal.getTypeId(), credentialsInternal.getTokenBytes());
-            credentialsInternal.clear(); // Clear immediately, not needed anymore.
-        }
-
-        for (PeerInfo peer : builder.peers) {
-            SyncCredentialsToken credentialsInternal = (SyncCredentialsToken) peer.credentials;
-            nativeAddPeer(handle, peer.url, credentialsInternal.getTypeId(), credentialsInternal.getTokenBytes());
-        }
-
         if (builder.changeListener != null) {
             setSyncChangeListener(builder.changeListener);
         }
@@ -57,7 +66,11 @@ private long getHandle() {
 
     @Override
     public String getUrl() {
-        return url;
+        try {
+            return new URI(url.getScheme(), null, url.getHost(), getPort(), null, null, null).toString();
+        } catch (URISyntaxException e) {
+            throw new RuntimeException("Server URL can not be constructed", e);
+        }
     }
 
     @Override
@@ -67,7 +80,8 @@ public int getPort() {
 
     @Override
     public boolean isRunning() {
-        return nativeIsRunning(getHandle());
+        long handle = this.handle;  // Do not call getHandle() as it throws if handle is 0
+        return handle != 0 && nativeIsRunning(handle);
     }
 
     @Override
@@ -110,7 +124,12 @@ protected void finalize() throws Throwable {
         super.finalize();
     }
 
-    private static native long nativeCreate(long storeHandle, String uri, @Nullable String certificatePath);
+    /**
+     * Creates a native Sync server instance with FlatBuffer {@link SyncServerOptions} {@code flatOptionsByteArray}.
+     *
+     * @return The handle of the native server instance.
+     */
+    private static native long nativeCreateFromFlatOptions(long storeHandle, byte[] flatOptionsByteArray);
 
     private native void nativeDelete(long handle);
 
@@ -122,10 +141,6 @@ protected void finalize() throws Throwable {
 
     private native int nativeGetPort(long handle);
 
-    private native void nativeSetAuthenticator(long handle, long credentialsType, @Nullable byte[] credentials);
-
-    private native void nativeAddPeer(long handle, String uri, long credentialsType, @Nullable byte[] credentials);
-
     private native String nativeGetStatsString(long handle);
 
     private native void nativeSetSyncChangesListener(long handle, @Nullable SyncChangeListener changesListener);
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerOptions.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerOptions.java
new file mode 100644
index 00000000..7ca1e66a
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerOptions.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * The Sync server configuration used to configure a starting Sync Server.
+ */
+@SuppressWarnings("unused")
+public final class SyncServerOptions extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static SyncServerOptions getRootAsSyncServerOptions(ByteBuffer _bb) { return getRootAsSyncServerOptions(_bb, new SyncServerOptions()); }
+  public static SyncServerOptions getRootAsSyncServerOptions(ByteBuffer _bb, SyncServerOptions obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public SyncServerOptions __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /**
+   * URL of this Sync Server on which the Sync protocol is exposed (where the server "binds" to).
+   * This is typically a WebSockets URL, i.e. starting with "ws://" or "wss://" (with SSL enabled).
+   * Once running, Sync Clients can connect here.
+   */
+  public String url() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer urlAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+  public ByteBuffer urlInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); }
+  /**
+   * A list of enabled authentication methods available to Sync Clients to login.
+   */
+  public io.objectbox.sync.Credentials authenticationMethods(int j) { return authenticationMethods(new io.objectbox.sync.Credentials(), j); }
+  public io.objectbox.sync.Credentials authenticationMethods(io.objectbox.sync.Credentials obj, int j) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; }
+  public int authenticationMethodsLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; }
+  public io.objectbox.sync.Credentials.Vector authenticationMethodsVector() { return authenticationMethodsVector(new io.objectbox.sync.Credentials.Vector()); }
+  public io.objectbox.sync.Credentials.Vector authenticationMethodsVector(io.objectbox.sync.Credentials.Vector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
+  /**
+   * Bit flags to configure the Sync Server that are also shared with Sync clients.
+   */
+  public long syncFlags() { int o = __offset(8); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Bit flags to configure the Sync Server.
+   */
+  public long syncServerFlags() { int o = __offset(10); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * The SSL certificate directory; SSL will be enabled if not empty.
+   * Expects the files cert.pem and key.pem present in this directory.
+   */
+  public String certificatePath() { int o = __offset(12); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer certificatePathAsByteBuffer() { return __vector_as_bytebuffer(12, 1); }
+  public ByteBuffer certificatePathInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 12, 1); }
+  /**
+   * By default (absent or zero given), this uses a hardware dependent default, e.g. 3 * CPU "cores"
+   */
+  public long workerThreads() { int o = __offset(14); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Once the maximum size is reached, old TX logs are deleted to stay below this limit.
+   * This is sometimes also called "history pruning" in the context of Sync.
+   * Absent or zero: no limit
+   */
+  public long historySizeMaxKb() { int o = __offset(16); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * Once the maximum size (historySizeMaxKb) is reached,
+   * old TX logs are deleted until this size target is reached (lower than the maximum size).
+   * Using this target size typically lowers the frequency of history pruning and thus may improve efficiency.
+   * If absent or zero, it defaults to historySizeMaxKb.
+   */
+  public long historySizeTargetKb() { int o = __offset(18); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * URL of the Admin (web server) to bind to.
+   * Once running, the user can open a browser to open the Admin web app.
+   */
+  public String adminUrl() { int o = __offset(20); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer adminUrlAsByteBuffer() { return __vector_as_bytebuffer(20, 1); }
+  public ByteBuffer adminUrlInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 20, 1); }
+  /**
+   * Number of worker threads used by the Admin web server.
+   */
+  public long adminThreads() { int o = __offset(22); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Enables cluster mode (requires the Cluster feature) and associates this cluster peer with the given ID.
+   * Cluster peers need to share the same ID to be in the same cluster.
+   */
+  public String clusterId() { int o = __offset(24); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer clusterIdAsByteBuffer() { return __vector_as_bytebuffer(24, 1); }
+  public ByteBuffer clusterIdInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 24, 1); }
+  /**
+   * List of other (remote) cluster peers to connect to.
+   */
+  public io.objectbox.sync.server.ClusterPeerConfig clusterPeers(int j) { return clusterPeers(new io.objectbox.sync.server.ClusterPeerConfig(), j); }
+  public io.objectbox.sync.server.ClusterPeerConfig clusterPeers(io.objectbox.sync.server.ClusterPeerConfig obj, int j) { int o = __offset(26); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; }
+  public int clusterPeersLength() { int o = __offset(26); return o != 0 ? __vector_len(o) : 0; }
+  public io.objectbox.sync.server.ClusterPeerConfig.Vector clusterPeersVector() { return clusterPeersVector(new io.objectbox.sync.server.ClusterPeerConfig.Vector()); }
+  public io.objectbox.sync.server.ClusterPeerConfig.Vector clusterPeersVector(io.objectbox.sync.server.ClusterPeerConfig.Vector obj) { int o = __offset(26); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
+  /**
+   * Bit flags to configure the cluster behavior of this sync server (aka cluster peer).
+   */
+  public long clusterFlags() { int o = __offset(28); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Optional configuration for JWT (JSON Web Token) authentication.
+   */
+  public io.objectbox.sync.server.JwtConfig jwtConfig() { return jwtConfig(new io.objectbox.sync.server.JwtConfig()); }
+  public io.objectbox.sync.server.JwtConfig jwtConfig(io.objectbox.sync.server.JwtConfig obj) { int o = __offset(30); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
+  /**
+   * Credential types that are required for clients logging in.
+   */
+  public long requiredCredentials(int j) { int o = __offset(32); return o != 0 ? (long)bb.getInt(__vector(o) + j * 4) & 0xFFFFFFFFL : 0; }
+  public int requiredCredentialsLength() { int o = __offset(32); return o != 0 ? __vector_len(o) : 0; }
+  public IntVector requiredCredentialsVector() { return requiredCredentialsVector(new IntVector()); }
+  public IntVector requiredCredentialsVector(IntVector obj) { int o = __offset(32); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
+  public ByteBuffer requiredCredentialsAsByteBuffer() { return __vector_as_bytebuffer(32, 4); }
+  public ByteBuffer requiredCredentialsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 32, 4); }
+
+  public static int createSyncServerOptions(FlatBufferBuilder builder,
+                                            int urlOffset,
+                                            int authenticationMethodsOffset,
+                                            long syncFlags,
+                                            long syncServerFlags,
+                                            int certificatePathOffset,
+                                            long workerThreads,
+                                            long historySizeMaxKb,
+                                            long historySizeTargetKb,
+                                            int adminUrlOffset,
+                                            long adminThreads,
+                                            int clusterIdOffset,
+                                            int clusterPeersOffset,
+                                            long clusterFlags,
+                                            int jwtConfigOffset,
+                                            int requiredCredentialsOffset) {
+    builder.startTable(15);
+    SyncServerOptions.addHistorySizeTargetKb(builder, historySizeTargetKb);
+    SyncServerOptions.addHistorySizeMaxKb(builder, historySizeMaxKb);
+    SyncServerOptions.addRequiredCredentials(builder, requiredCredentialsOffset);
+    SyncServerOptions.addJwtConfig(builder, jwtConfigOffset);
+    SyncServerOptions.addClusterFlags(builder, clusterFlags);
+    SyncServerOptions.addClusterPeers(builder, clusterPeersOffset);
+    SyncServerOptions.addClusterId(builder, clusterIdOffset);
+    SyncServerOptions.addAdminThreads(builder, adminThreads);
+    SyncServerOptions.addAdminUrl(builder, adminUrlOffset);
+    SyncServerOptions.addWorkerThreads(builder, workerThreads);
+    SyncServerOptions.addCertificatePath(builder, certificatePathOffset);
+    SyncServerOptions.addSyncServerFlags(builder, syncServerFlags);
+    SyncServerOptions.addSyncFlags(builder, syncFlags);
+    SyncServerOptions.addAuthenticationMethods(builder, authenticationMethodsOffset);
+    SyncServerOptions.addUrl(builder, urlOffset);
+    return SyncServerOptions.endSyncServerOptions(builder);
+  }
+
+  public static void startSyncServerOptions(FlatBufferBuilder builder) { builder.startTable(15); }
+  public static void addUrl(FlatBufferBuilder builder, int urlOffset) { builder.addOffset(0, urlOffset, 0); }
+  public static void addAuthenticationMethods(FlatBufferBuilder builder, int authenticationMethodsOffset) { builder.addOffset(1, authenticationMethodsOffset, 0); }
+  public static int createAuthenticationMethodsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startAuthenticationMethodsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static void addSyncFlags(FlatBufferBuilder builder, long syncFlags) { builder.addInt(2, (int) syncFlags, (int) 0L); }
+  public static void addSyncServerFlags(FlatBufferBuilder builder, long syncServerFlags) { builder.addInt(3, (int) syncServerFlags, (int) 0L); }
+  public static void addCertificatePath(FlatBufferBuilder builder, int certificatePathOffset) { builder.addOffset(4, certificatePathOffset, 0); }
+  public static void addWorkerThreads(FlatBufferBuilder builder, long workerThreads) { builder.addInt(5, (int) workerThreads, (int) 0L); }
+  public static void addHistorySizeMaxKb(FlatBufferBuilder builder, long historySizeMaxKb) { builder.addLong(6, historySizeMaxKb, 0L); }
+  public static void addHistorySizeTargetKb(FlatBufferBuilder builder, long historySizeTargetKb) { builder.addLong(7, historySizeTargetKb, 0L); }
+  public static void addAdminUrl(FlatBufferBuilder builder, int adminUrlOffset) { builder.addOffset(8, adminUrlOffset, 0); }
+  public static void addAdminThreads(FlatBufferBuilder builder, long adminThreads) { builder.addInt(9, (int) adminThreads, (int) 0L); }
+  public static void addClusterId(FlatBufferBuilder builder, int clusterIdOffset) { builder.addOffset(10, clusterIdOffset, 0); }
+  public static void addClusterPeers(FlatBufferBuilder builder, int clusterPeersOffset) { builder.addOffset(11, clusterPeersOffset, 0); }
+  public static int createClusterPeersVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startClusterPeersVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static void addClusterFlags(FlatBufferBuilder builder, long clusterFlags) { builder.addInt(12, (int) clusterFlags, (int) 0L); }
+  public static void addJwtConfig(FlatBufferBuilder builder, int jwtConfigOffset) { builder.addOffset(13, jwtConfigOffset, 0); }
+  public static void addRequiredCredentials(FlatBufferBuilder builder, int requiredCredentialsOffset) { builder.addOffset(14, requiredCredentialsOffset, 0); }
+  public static int createRequiredCredentialsVector(FlatBufferBuilder builder, long[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addInt((int) data[i]); return builder.endVector(); }
+  public static void startRequiredCredentialsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static int endSyncServerOptions(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+  public static void finishSyncServerOptionsBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset); }
+  public static void finishSizePrefixedSyncServerOptionsBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset); }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public SyncServerOptions get(int j) { return get(new SyncServerOptions(), j); }
+    public SyncServerOptions get(SyncServerOptions obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/Branch.java b/objectbox-java/src/main/java/io/objectbox/tree/Branch.java
index aebc8ccb..8b6e3463 100644
--- a/objectbox-java/src/main/java/io/objectbox/tree/Branch.java
+++ b/objectbox-java/src/main/java/io/objectbox/tree/Branch.java
@@ -1,9 +1,25 @@
-package io.objectbox.tree;
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-import io.objectbox.annotation.apihint.Experimental;
+package io.objectbox.tree;
 
 import javax.annotation.Nullable;
 
+import io.objectbox.annotation.apihint.Experimental;
+
 /**
  * A branch within a {@link Tree}. May have {@link #branch(String[]) branches} or {@link #leaf(String[]) leaves}.
  */
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/Leaf.java b/objectbox-java/src/main/java/io/objectbox/tree/Leaf.java
index 4cce9d06..c16a93ea 100644
--- a/objectbox-java/src/main/java/io/objectbox/tree/Leaf.java
+++ b/objectbox-java/src/main/java/io/objectbox/tree/Leaf.java
@@ -1,10 +1,27 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.tree;
 
-import io.objectbox.annotation.apihint.Experimental;
-import io.objectbox.model.PropertyType;
+import java.nio.charset.StandardCharsets;
 
 import javax.annotation.Nullable;
-import java.nio.charset.StandardCharsets;
+
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.model.PropertyType;
 
 /**
  * A data leaf represents a data value in a {@link Tree} as a child of a {@link Branch}.
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/LeafNode.java b/objectbox-java/src/main/java/io/objectbox/tree/LeafNode.java
index c2af4002..fcb4215e 100644
--- a/objectbox-java/src/main/java/io/objectbox/tree/LeafNode.java
+++ b/objectbox-java/src/main/java/io/objectbox/tree/LeafNode.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.tree;
 
 import io.objectbox.annotation.apihint.Experimental;
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/Tree.java b/objectbox-java/src/main/java/io/objectbox/tree/Tree.java
index c8e5645d..29535883 100644
--- a/objectbox-java/src/main/java/io/objectbox/tree/Tree.java
+++ b/objectbox-java/src/main/java/io/objectbox/tree/Tree.java
@@ -1,15 +1,32 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.tree;
 
+import java.io.Closeable;
+import java.util.concurrent.Callable;
+
+import javax.annotation.Nullable;
+
 import io.objectbox.BoxStore;
 import io.objectbox.InternalAccess;
 import io.objectbox.Transaction;
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.model.PropertyType;
 
-import javax.annotation.Nullable;
-import java.io.Closeable;
-import java.util.concurrent.Callable;
-
 /**
  * A higher level tree API operating on branch and leaf nodes.
  * Points to a root branch, can traverse child branches and read and write data in leafs.
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/package-info.java b/objectbox-java/src/main/java/io/objectbox/tree/package-info.java
index 6ac1230e..7fe6b05b 100644
--- a/objectbox-java/src/main/java/io/objectbox/tree/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/tree/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 ObjectBox Ltd. All rights reserved.
+ * Copyright 2021 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/web/objectbox-stylesheet.css b/objectbox-java/src/web/objectbox-stylesheet.css
new file mode 100644
index 00000000..a5a42aa6
--- /dev/null
+++ b/objectbox-java/src/web/objectbox-stylesheet.css
@@ -0,0 +1,61 @@
+/*
+CSS variables to override, taken from the default stylesheet generated in build/docs/javadoc/stylesheet.css
+They are also documented at https://docs.oracle.com/en/java/javase/21/javadoc/javadoc-css-themes.html
+*/
+:root {
+    /*!* body, block and code fonts *!*/
+    /*--body-font-family: 'DejaVu Sans', Arial, Helvetica, sans-serif;*/
+    /*--block-font-family: 'DejaVu Serif', Georgia, "Times New Roman", Times, serif;*/
+    /*--code-font-family: 'DejaVu Sans Mono', monospace;*/
+    /*!* Base font sizes for body and code elements *!*/
+    /*--body-font-size: 14px;*/
+    /*--code-font-size: 14px;*/
+    /*!* Text colors for body and block elements *!*/
+    /*--body-text-color: #353833;*/
+    /*--block-text-color: #474747;*/
+    /* Background colors for various structural elements */
+    /*--body-background-color: #ffffff;*/
+    /*--section-background-color: #f8f8f8;*/
+    /*--detail-background-color: #ffffff;*/
+    /* Colors for navigation bar and table captions */
+    --navbar-background-color: #17A6A6;
+    /*--navbar-text-color: #ffffff;*/
+    /* Background color for subnavigation and various headers */
+    /*--subnav-background-color: #dee3e9;*/
+    /* Background and text colors for selected tabs and navigation items */
+    --selected-background-color: #7DDC7D;
+    /*--selected-text-color: #253441;*/
+    /*--selected-link-color: #1f389c;*/
+    /* Background colors for generated tables */
+    /*--even-row-color: #ffffff;*/
+    /*--odd-row-color: #eeeeef;*/
+    /* Text color for page title */
+    /*--title-color: #2c4557;*/
+    /* Text colors for links */
+    /*--link-color: #4A6782;*/
+    --link-color-active: #E61955;
+    /* Snippet colors */
+    /*--snippet-background-color: #ebecee;*/
+    /*--snippet-text-color: var(--block-text-color);*/
+    /*--snippet-highlight-color: #f7c590;*/
+    /* Border colors for structural elements and user defined tables */
+    /*--border-color: #ededed;*/
+    /*--table-border-color: #000000;*/
+    /* Search input colors */
+    /*--search-input-background-color: #ffffff;*/
+    /*--search-input-text-color: #000000;*/
+    /*--search-input-placeholder-color: #909090;*/
+    /* Highlight color for active search tag target */
+    /*--search-tag-highlight-color: #ffff00;*/
+    /* Adjustments for icon and active background colors of copy-to-clipboard buttons */
+    /*--copy-icon-brightness: 100%;*/
+    /*--copy-button-background-color-active: rgba(168, 168, 176, 0.3);*/
+    /* Colors for invalid tag notifications */
+    /*--invalid-tag-background-color: #ffe6e6;*/
+    /*--invalid-tag-text-color: #000000;*/
+}
+
+/* Make code blocks scroll instead of stick out on small width */
+pre {
+    overflow-x: auto;
+}
diff --git a/objectbox-java/src/web/overview.html b/objectbox-java/src/web/overview.html
index 7500507a..f2ff5577 100644
--- a/objectbox-java/src/web/overview.html
+++ b/objectbox-java/src/web/overview.html
@@ -1,15 +1,14 @@
 <HTML>
 <BODY>
 <p>
-    Welcome to the JavaDocs for <a href="https://objectbox.io">ObjectBox</a>, the super-fast database for objects.
-    On these pages, you will find the API reference for the ObjectBox Java library.
+    Welcome to the Java API docs for <a href="https://objectbox.io">ObjectBox</a>, the super-fast database for objects.
 </p>
 <p>
-    The <b>main documentation</b> is available at <a href="https://docs.objectbox.io">docs.objectbox.io</a> and offers
-    a changelog, a <a href="https://docs.objectbox.io/getting-started">getting started guide</a>, and many more topics.
+    The <b>main documentation</b> is available at <a href="https://docs.objectbox.io">docs.objectbox.io</a>, including a
+    <a href="https://docs.objectbox.io/getting-started">getting started guide</a>.
 </p>
 <p>
-    GitHub links: <a href="https://github.com/objectbox/objectbox-java">ObjectBox Java</a>,
+    GitHub links: <a href="https://github.com/objectbox/objectbox-java">ObjectBox Java SDK</a>,
     <a href="https://github.com/objectbox/objectbox-examples">Examples for Java, Kotlin and Android</a>
 </p>
 
diff --git a/objectbox-kotlin/build.gradle b/objectbox-kotlin/build.gradle
deleted file mode 100644
index 144dc616..00000000
--- a/objectbox-kotlin/build.gradle
+++ /dev/null
@@ -1,73 +0,0 @@
-buildscript {
-    ext.javadocDir = file("$buildDir/docs/javadoc")
-}
-
-plugins {
-    id("kotlin")
-    id("org.jetbrains.dokka")
-    id("objectbox-publish")
-}
-
-// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
-// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
-tasks.withType(JavaCompile) {
-    options.release.set(8)
-}
-
-// Produce Java 8 byte code, would default to Java 6.
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
-    kotlinOptions {
-        jvmTarget = "1.8"
-    }
-}
-
-tasks.named("dokkaHtml") {
-    outputDirectory.set(javadocDir)
-
-    dokkaSourceSets {
-        configureEach {
-            // Fix "Can't find node by signature": have to manually point to dependencies.
-            // https://github.com/Kotlin/dokka/wiki/faq#dokka-complains-about-cant-find-node-by-signature-
-            externalDocumentationLink {
-                // Point to web javadoc for objectbox-java packages.
-                url.set(new URL("https://objectbox.io/docfiles/java/current/"))
-                // Note: Using JDK 9+ package-list is now called element-list.
-                packageListUrl.set(new URL("https://objectbox.io/docfiles/java/current/element-list"))
-            }
-        }
-    }
-}
-
-task javadocJar(type: Jar) {
-    dependsOn tasks.named("dokkaHtml")
-    group = 'build'
-    archiveClassifier.set('javadoc')
-    from "$javadocDir"
-}
-
-task sourcesJar(type: Jar) {
-    group = 'build'
-    archiveClassifier.set('sources')
-    from sourceSets.main.allSource
-}
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
-    // Note: compileOnly as we do not want to require library users to use coroutines.
-    compileOnly "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion"
-
-    api project(':objectbox-java')
-}
-
-// Set project-specific properties.
-publishing.publications {
-    mavenJava(MavenPublication) {
-        from components.java
-        artifact sourcesJar
-        artifact javadocJar
-        pom {
-            name = 'ObjectBox Kotlin'
-            description = 'ObjectBox is a fast NoSQL database for Objects'
-        }
-    }
-}
diff --git a/objectbox-kotlin/build.gradle.kts b/objectbox-kotlin/build.gradle.kts
new file mode 100644
index 00000000..a7502d54
--- /dev/null
+++ b/objectbox-kotlin/build.gradle.kts
@@ -0,0 +1,79 @@
+
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
+
+plugins {
+    alias(libs.plugins.kotlin.jvm)
+    id("objectbox.dokka-conventions")
+    id("objectbox.publishing-conventions")
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+kotlin {
+    compilerOptions {
+        // Produce Java 8 byte code, would default to Java 6
+        jvmTarget.set(JvmTarget.JVM_1_8)
+
+        // Allow consumers of this library to use the oldest possible Kotlin compiler and standard libraries.
+        // https://kotlinlang.org/docs/compatibility-modes.html
+        // https://kotlinlang.org/docs/kotlin-evolution-principles.html#compatibility-tools
+
+        // Prevents using newer language features, sets this as the Kotlin version in produced metadata. So consumers
+        // can compile this with a Kotlin compiler down to one minor version before this.
+        // Pick the oldest not deprecated version.
+        languageVersion.set(KotlinVersion.KOTLIN_2_2)
+        // Prevents using newer APIs from the Kotlin standard library. So consumers can run this library with a Kotlin
+        // standard library down to this version.
+        // Pick the oldest not deprecated version.
+        apiVersion.set(KotlinVersion.KOTLIN_2_2)
+        // Depend on the oldest compatible Kotlin standard libraries (by default the Kotlin plugin coerces it to the one
+        // matching its version). So consumers can safely use this or any later Kotlin standard library.
+        // Pick the first release matching the versions above.
+        // Note: when changing, also update coroutines dependency version (as this does not set that).
+        coreLibrariesVersion = "2.2.0"
+    }
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    group = "build"
+    archiveClassifier.set("sources")
+    from(sourceSets.main.get().allSource)
+}
+
+dependencies {
+    // Note: compileOnly so consumers do not depend on the coroutines library unless they manually
+    // add it.
+    compileOnly(libs.kotlin.coroutines.core.compat)
+
+    api(project(":objectbox-java"))
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxKotlin = "objectboxKotlin"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxKotlin) {
+            artifactId = "objectbox-kotlin"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            // Note: the javadocJar task is created by the objectbox.dokka-conventions plugin
+            artifact(tasks.named("javadocJar"))
+
+            pom {
+                name.set("ObjectBox Kotlin API")
+                description.set("ObjectBox is a fast NoSQL database for Objects")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxKotlin])
+}
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Box.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Box.kt
index 8360f637..6b3feda3 100644
--- a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Box.kt
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Box.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 ObjectBox Ltd. All rights reserved.
+ * Copyright 2021-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,13 +22,17 @@ import io.objectbox.query.QueryBuilder
 
 
 /**
+ * Note: new code should use the [Box.query] functions directly, including the new query API.
+ *
  * Allows building a query for this Box instance with a call to [build][QueryBuilder.build] to return a [Query] instance.
+ *
  * ```
  * val query = box.query {
  *     equal(Entity_.property, value)
  * }
  * ```
  */
+@Deprecated("New code should use query(queryCondition).build() instead.")
 inline fun <T> Box<T>.query(block: QueryBuilder<T>.() -> Unit): Query<T> {
     val builder = query()
     block(builder)
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/BoxStore.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/BoxStore.kt
index fb236f23..1385a219 100644
--- a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/BoxStore.kt
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/BoxStore.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 ObjectBox Ltd. All rights reserved.
+ * Copyright 2021 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,9 @@ package io.objectbox.kotlin
 
 import io.objectbox.Box
 import io.objectbox.BoxStore
+import kotlinx.coroutines.asCoroutineDispatcher
 import java.util.concurrent.Callable
+import java.util.concurrent.ThreadFactory
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 import kotlin.coroutines.suspendCoroutine
@@ -51,3 +53,42 @@ suspend fun <V : Any> BoxStore.awaitCallInTx(callable: Callable<V?>): V? {
         }
     }
 }
+
+/**
+ * Creates a coroutine dispatcher backed by a thread pool created with [BoxStore.newCachedThreadPoolExecutor] that
+ * automatically cleans up thread-local ObjectBox resources after each task.
+ *
+ * @return a [kotlinx.coroutines.CoroutineDispatcher] backed by an ObjectBox-aware cached thread pool
+ * @see BoxStore.newCachedThreadPoolExecutor
+ */
+fun BoxStore.newCachedThreadPoolDispatcher() = newCachedThreadPoolExecutor().asCoroutineDispatcher()
+
+/**
+ * Creates a coroutine dispatcher backed by a thread pool created with [BoxStore.newCachedThreadPoolExecutor] that
+ * automatically cleans up thread-local ObjectBox resources after each task.
+ *
+ * @return a [kotlinx.coroutines.CoroutineDispatcher] backed by an ObjectBox-aware cached thread pool
+ * @see BoxStore.newCachedThreadPoolExecutor
+ */
+fun BoxStore.newCachedThreadPoolDispatcher(threadFactory: ThreadFactory) =
+    newCachedThreadPoolExecutor(threadFactory).asCoroutineDispatcher()
+
+/**
+ * Creates a coroutine dispatcher backed by a thread pool created with [BoxStore.newFixedThreadPoolExecutor] that
+ * automatically cleans up thread-local ObjectBox resources after each task.
+ *
+ * @return a [kotlinx.coroutines.CoroutineDispatcher] backed by an ObjectBox-aware fixed thread pool
+ * @see BoxStore.newFixedThreadPoolExecutor
+ */
+fun BoxStore.newFixedThreadPoolDispatcher(nThreads: Int) =
+    newFixedThreadPoolExecutor(nThreads).asCoroutineDispatcher()
+
+/**
+ * Creates a coroutine dispatcher backed by a thread pool created with [BoxStore.newFixedThreadPoolExecutor] that
+ * automatically cleans up thread-local ObjectBox resources after each task.
+ *
+ * @return a [kotlinx.coroutines.CoroutineDispatcher] backed by an ObjectBox-aware fixed thread pool
+ * @see BoxStore.newFixedThreadPoolExecutor
+ */
+fun BoxStore.newFixedThreadPoolDispatcher(nThreads: Int, threadFactory: ThreadFactory) =
+    newFixedThreadPoolExecutor(nThreads, threadFactory).asCoroutineDispatcher()
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Flow.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Flow.kt
index af8dc5ed..b2d77c53 100644
--- a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Flow.kt
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Flow.kt
@@ -3,7 +3,6 @@ package io.objectbox.kotlin
 import io.objectbox.BoxStore
 import io.objectbox.query.Query
 import io.objectbox.reactive.SubscriptionBuilder
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.channels.trySendBlocking
 import kotlinx.coroutines.flow.Flow
@@ -24,7 +23,6 @@ import kotlinx.coroutines.flow.callbackFlow
  * box.query().subscribe().toFlow()
  * ```
  */
-@ExperimentalCoroutinesApi
 fun <T> SubscriptionBuilder<T>.toFlow(): Flow<T> = callbackFlow {
     val subscription = this@toFlow.observer {
             trySendBlocking(it)
@@ -33,13 +31,12 @@ fun <T> SubscriptionBuilder<T>.toFlow(): Flow<T> = callbackFlow {
 }
 
 /**
- * Shortcut for `BoxStore.subscribe(forClass).toFlow()`, see [toFlow].
+ * Shortcut for `BoxStore.subscribe(forClass).toFlow()`, see [BoxStore.subscribe] and [toFlow] for
+ * details.
  */
-@ExperimentalCoroutinesApi
 fun <T> BoxStore.flow(forClass: Class<T>): Flow<Class<T>> = this.subscribe(forClass).toFlow()
 
 /**
- * Shortcut for `query.subscribe().toFlow()`, see [toFlow].
+ * Shortcut for `query.subscribe().toFlow()`, see [Query.subscribe] and [toFlow] for details.
  */
-@ExperimentalCoroutinesApi
-fun <T> Query<T>.flow(): Flow<MutableList<T>> = this@flow.subscribe().toFlow()
\ No newline at end of file
+fun <T> Query<T>.flow(): Flow<MutableList<T>> = this@flow.subscribe().toFlow()
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Property.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Property.kt
index 8c662159..246b7356 100644
--- a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Property.kt
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Property.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/PropertyQueryCondition.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/PropertyQueryCondition.kt
index a3791f3f..af958d45 100644
--- a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/PropertyQueryCondition.kt
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/PropertyQueryCondition.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryBuilder.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryBuilder.kt
index b9162281..402f0e2a 100644
--- a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryBuilder.kt
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryBuilder.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 ObjectBox Ltd. All rights reserved.
+ * Copyright 2021 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryCondition.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryCondition.kt
index 76e7c54d..2f045924 100644
--- a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryCondition.kt
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryCondition.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/ToMany.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/ToMany.kt
index 43ef0d7f..e7ec349f 100644
--- a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/ToMany.kt
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/ToMany.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 ObjectBox Ltd. All rights reserved.
+ * Copyright 2021 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-meshsync-android/README.md b/objectbox-meshsync-android/README.md
new file mode 100644
index 00000000..c81a62c4
--- /dev/null
+++ b/objectbox-meshsync-android/README.md
@@ -0,0 +1,53 @@
+# ObjectBox Mesh Sync for Android
+
+Adds peer-to-peer (P2P) mesh synchronization between ObjectBox Sync clients on Android, without a
+central server, using [Google Nearby Connections](https://developers.google.com/nearby/connections/overview).
+
+This is a plain (no native code, single variant) Android library that apps add **in addition** to the
+Sync variant of the ObjectBox Android library (e.g. `objectbox-sync-android`), which contains the native
+mesh sync implementation. Keeping it separate avoids multiplying the variants of the main Android library
+(basic/sync × with/without Admin) and keeps the Nearby dependency out of apps that don't use mesh sync.
+
+What this library provides:
+
+- `AndroidMeshSync.createConfig(context, meshId)` creating a `MeshConfig` (see `objectbox-java`) with the
+  Nearby Connections mesh network attached, to pass to `SyncBuilder.mesh()`.
+- The permissions that may be required by Nearby Connections, merged into the app manifest 
+  (see [AndroidManifest.xml](src/main/AndroidManifest.xml)).
+- The `play-services-nearby` dependency.
+
+## Permissions
+
+Note that not all permissions this library adds may be required. Depending on a device's Android SDK
+version and your app's needs, only some of them may actually be necessary. For example, location 
+permissions are typically not required for Nearby Connections on recent Android releases.
+
+To remove them as needed, use [merge rule markers](https://developer.android.com/build/manage-manifests) 
+in your app's manifest, for example:
+
+```xml
+<uses-permission
+    android:name="android.permission.ACCESS_COARSE_LOCATION"
+    tools:node="remove" />
+<uses-permission
+    android:name="android.permission.ACCESS_FINE_LOCATION"
+    tools:node="remove" />
+```
+
+Also note that your app must [request any dangerous (runtime) permissions](https://developer.android.com/training/permissions/requesting) 
+at runtime when needed. This library provides a [MeshSyncPermissions](src/main/java/io/objectbox/meshsync/android/MeshSyncPermissions.kt)
+helper class to request the permissions included by default.
+
+## Usage
+
+```kotlin
+val meshConfig: MeshConfig = AndroidMeshSync.createConfig(context, "example.myapp.mesh")
+
+val syncClient: SyncClient = Sync.client(boxStore)
+        .url(SYNC_SERVER_URL)
+        .credentials(credentials)
+        .mesh(meshConfig)
+        .buildAndStart()
+
+val mesh: MeshSync? = syncClient.getMesh() // state, connected peer count, stats
+```
diff --git a/objectbox-meshsync-android/build.gradle.kts b/objectbox-meshsync-android/build.gradle.kts
new file mode 100644
index 00000000..1d5b228d
--- /dev/null
+++ b/objectbox-meshsync-android/build.gradle.kts
@@ -0,0 +1,161 @@
+import org.gradle.kotlin.dsl.support.uppercaseFirstChar
+
+plugins {
+    alias(libs.plugins.android.library)
+    id("objectbox.publishing-conventions")
+}
+
+val flavorAdminExcluded = "adminExcluded"
+val flavorAdminIncluded = "adminIncluded"
+// Note: build variant names also match names of created components
+val buildTypeRelease = "release"
+val variantAdminExcludedRelease = "${flavorAdminExcluded}${buildTypeRelease.uppercaseFirstChar()}"
+val variantAdminIncludedRelease = "${flavorAdminIncluded}${buildTypeRelease.uppercaseFirstChar()}"
+
+android {
+    namespace = "io.objectbox.meshsync.android"
+    // Note: increasing compile SDK also signals this library is compatible with any changes in that
+    // API level, see "behavior changes" for each Android version at https://developer.android.com/about/versions
+    compileSdk = 35 // Android 15 (Vanilla Ice Cream)
+
+    defaultConfig {
+        minSdk = 21 // Android 5.0 (Lollipop), like objectbox-android
+
+        // Dependencies: objectbox-android also has a "database" dimension,
+        // always pick its "sync" flavor.
+        missingDimensionStrategy("database", "sync")
+    }
+
+    buildTypes {
+        release {
+            // Currently not obfuscating/minifying with ProGuard/R8.
+            isMinifyEnabled = false
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
+        }
+    }
+
+    // Configure a flavor dimension based on if Admin is included in the Android database library.
+    // Note: common configuration defined in defaultConfig and buildTypes blocks above.
+    // https://developer.android.com/studio/build/build-variants#product-flavors
+    // Note: the name of this flavor should match the one of the depended on objectbox-android
+    // subproject, otherwise, additonal configuration is necessary to depend on the correct variant
+    // of it.
+    val dimensionAdmin = "admin"
+    flavorDimensions += listOf(dimensionAdmin)
+    productFlavors {
+        create(flavorAdminExcluded) {
+            dimension = dimensionAdmin
+        }
+        create(flavorAdminIncluded) {
+            dimension = dimensionAdmin
+        }
+    }
+
+    // Publish the release variants (variant = flavor combination + build type)
+    // https://developer.android.com/studio/publish-library/configure-pub-variants
+    publishing {
+        singleVariant(variantAdminExcludedRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+        singleVariant(variantAdminIncludedRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+    }
+
+    // Java 8 features support https://developer.android.com/studio/write/java8-support
+    // Note: this requires consuming projects to also enable this.
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    // For local unit tests enable use of Android framework with Robolectric
+    testOptions {
+        unitTests.isIncludeAndroidResources = true
+    }
+}
+
+val versionDatabaseLibraryJvm: String by rootProject.extra
+val versionDatabaseLibraryAndroidSync: String by rootProject.extra
+
+val adminExcludedImplementation by configurations.getting
+val adminIncludedImplementation by configurations.getting
+
+dependencies {
+    // Use "api" to add the Java library as a "compile" dependency in the POM as this library
+    // exposes APIs from it (MeshConfig). Regardless, it is expected that most consumers (or the
+    // Gradle plugin) add the Java library as a direct dependency.
+    api(project(":objectbox-java"))
+    // Use "implementation" to add the Nearby Connections library as a "runtime" dependency in the
+    // POM for consumers (it is required at runtime), but not expose any of its types via this
+    // library's API.
+    // Note: this library doesn't use Nearby APIs, but the Android database library it depends on
+    // does. Its artifact doesn't add the Nearby dependency as it's also used if not using mesh
+    // sync.
+    implementation(libs.play.services.nearby)
+
+    // Use "implementation" to add the Android database library as a "runtime" dependency in the
+    // POM for consumers as it is required at runtime, but doesn't expose any APIs.
+    // Note: as the artifacts produced by this project are also used by the ObjectBox Flutter
+    // package, don't add a dependency on objectbox-android to make it easier to release for Flutter
+    // only (and to avoid Flutter projects pulling in unused code and resources, such as for Admin).
+    adminExcludedImplementation("io.objectbox:objectbox-sync-android-db:$versionDatabaseLibraryAndroidSync")
+    adminIncludedImplementation("io.objectbox:objectbox-sync-android-db-admin:$versionDatabaseLibraryAndroidSync")
+
+    // Dependencies for unit tests running on the JVM (so not on an Android device/emulator)
+    testImplementation(libs.junit)
+    testImplementation(libs.androidx.test.core)
+    testImplementation(libs.robolectric)
+    testImplementation(libs.mockito.kotlin)
+    testImplementation("io.objectbox:objectbox-linux:${versionDatabaseLibraryJvm}")
+    testImplementation("io.objectbox:objectbox-macos:${versionDatabaseLibraryJvm}")
+    testImplementation("io.objectbox:objectbox-windows:${versionDatabaseLibraryJvm}")
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationMeshSyncAndroid = "objectboxMeshSyncAndroid"
+val publicationMeshSyncAndroidAdmin = "objectboxMeshSyncAndroidAdmin"
+publishing {
+    publications {
+        create<MavenPublication>(publicationMeshSyncAndroid) {
+            artifactId = "objectbox-meshsync-android"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminExcludedRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Mesh Sync for Android")
+            }
+        }
+        create<MavenPublication>(publicationMeshSyncAndroidAdmin) {
+            artifactId = "objectbox-meshsync-android-admin"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminIncludedRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Mesh Sync with Admin for Android")
+            }
+        }
+        // Additional common configuration for all Maven publications
+        withType<MavenPublication> {
+            pom {
+                description.set("Peer-to-peer mesh sync for ObjectBox Sync on Android using Google Nearby Connections")
+                packaging = "aar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationMeshSyncAndroid])
+    sign(publishing.publications[publicationMeshSyncAndroidAdmin])
+}
diff --git a/objectbox-meshsync-android/src/main/AndroidManifest.xml b/objectbox-meshsync-android/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..9980b5ab
--- /dev/null
+++ b/objectbox-meshsync-android/src/main/AndroidManifest.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <!--
+      Permissions that may be needed by the Nearby Connections API; these are merged into the
+      manifest of apps using this library.
+
+      Note that not all permissions may be required. Depending on a device's Android SDK version and
+      your app's needs, only some of them may actually be necessary. For example, location
+      permissions are typically not required for Nearby Connections on recent Android releases.
+
+      To remove them as needed, use [merge rule markers](https://developer.android.com/build/manage-manifests)
+      in your app's manifest, for example:
+
+      <uses-permission
+          android:name="android.permission.ACCESS_COARSE_LOCATION"
+          tools:node="remove" />
+      <uses-permission
+          android:name="android.permission.ACCESS_FINE_LOCATION"
+          tools:node="remove" />
+
+      Note that maxSdkVersion restrictions should not be added to the Wi-Fi or Bluetooth
+      permissions; the Nearby API appears to require them on all SDK versions.
+
+      Also note that your app must request any dangerous (runtime) permissions at runtime when
+      needed.
+    -->
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN"
+        android:usesPermissionFlags="neverForLocation"
+        tools:targetApi="s" />
+    <uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES"
+        android:usesPermissionFlags="neverForLocation"
+        tools:targetApi="tiramisu" />
+
+</manifest>
diff --git a/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/AndroidMeshSync.kt b/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/AndroidMeshSync.kt
new file mode 100644
index 00000000..c041cbf5
--- /dev/null
+++ b/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/AndroidMeshSync.kt
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.objectbox.meshsync.android
+
+import android.content.Context
+import io.objectbox.annotation.apihint.Experimental
+import io.objectbox.internal.NativeLibraryUtils
+import io.objectbox.meshsync.android.AndroidMeshSync.createConfig
+import io.objectbox.meshsync.android.internal.NearbyMeshNetwork
+import io.objectbox.sync.InternalSyncAccess
+import io.objectbox.sync.MeshConfig
+import io.objectbox.sync.SyncBuilder
+import io.objectbox.sync.SyncClient
+
+/**
+ * Peer-to-peer mesh sync for Android using [Google Nearby Connections](https://developers.google.com/nearby/connections/overview).
+ * 
+ * Use [createConfig] to create a [MeshConfig] with the Android mesh
+ * network attached, then pass it to [SyncBuilder.mesh]:
+ * 
+ * ```
+ * val meshConfig: MeshConfig = AndroidMeshSync.createConfig(context, "example.myapp.mesh")
+ * 
+ * val syncClient: SyncClient = Sync.client(boxStore)
+ *     .url(SYNC_SERVER_URL)
+ *     .credentials(credentials)
+ *     .mesh(meshConfig)
+ *     .buildAndStart()
+ * ```
+ * 
+ * The mesh starts and stops together with the sync client; query the running mesh via
+ * [SyncClient.getMesh].
+ *
+ * Requirements:
+ * 
+ * * The app must use the Sync variant of the ObjectBox Android library (such as
+ *   `objectbox-sync-android`), which includes the native mesh sync code.
+ * * This library adds the permissions required by Nearby Connections to the app manifest. However,
+ *   the app must request the dangerous (runtime) permissions, like location and the newer
+ *   Bluetooth/Wi-Fi permissions, before starting the sync client. [MeshSyncPermissions] may help
+ *   with that.
+ * 
+ */
+@Experimental
+object AndroidMeshSync {
+
+    /**
+     * Creates a mesh sync configuration with an Android (Nearby Connections) mesh network
+     * attached.
+     *
+     * Configure optional settings on the returned [MeshConfig] (chainable setters), then pass
+     * it to [SyncBuilder.mesh]. See the [class documentation][AndroidMeshSync] for an example.
+     * 
+     * @param context Android context (the application context is used internally).
+     * @param meshId The mesh network identifier; nodes with different IDs ignore each other. Also
+     * used as the Nearby Connections service ID, so it should be unique to your application, for
+     * example, based on your application ID (like `example.myapp.mesh`).
+     * @return a [MeshConfig] to optionally configure further and pass to [SyncBuilder.mesh].
+     */
+    @JvmStatic
+    fun createConfig(context: Context, meshId: String): MeshConfig {
+        NativeLibraryUtils.checkHasFeature()
+
+        // Create the config first: it validates meshId, avoiding the creation of a native network
+        // for bad input.
+        val config = InternalSyncAccess.createMeshConfig(meshId)
+        // Create the Nearby network (Java + paired native object) and register it with the config.
+        // The native network is owned by the MeshSync once the sync client is created;
+        // see NearbyMeshNetwork.stop().
+        val network = NearbyMeshNetwork(context.applicationContext, meshId)
+        InternalSyncAccess.addNetworkInternalHandle(config, network.nativeHandle)
+        return config
+    }
+
+}
diff --git a/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/MeshSyncPermissions.kt b/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/MeshSyncPermissions.kt
new file mode 100644
index 00000000..390b4285
--- /dev/null
+++ b/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/MeshSyncPermissions.kt
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.meshsync.android
+
+import android.Manifest
+import android.app.Activity
+import android.content.pm.PackageManager
+import android.os.Build
+import io.objectbox.sync.MeshSync
+import io.objectbox.sync.SyncClient
+
+/**
+ * Helps to request Android runtime permissions for Mesh Sync.
+ *
+ * Usage:
+ *
+ * 1. Create an instance in the [Activity] that should be used to request permissions.
+ * 2. Override [Activity.onRequestPermissionsResult] and call [notifyMeshIfPermissionsGranted].
+ * 3. Call [requestIfMissing] to show permission requests to the user.
+ *
+ * ```
+ * class ExampleSetupActivity : Activity() {
+ *
+ *     private val meshSyncPermissions = MeshSyncPermissions(this)
+ *
+ *     override fun onRequestPermissionsResult(
+ *         requestCode: Int,
+ *         permissions: Array<out String>,
+ *         grantResults: IntArray
+ *     ) {
+ *         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+ *         meshSyncPermissions.notifyMeshIfPermissionsGranted(
+ *             requestCode,
+ *             syncClient.mesh
+ *         )
+ *     }
+ *
+ *     fun onRequestPermissionsButtonClick() {
+ *         meshSyncPermissions.requestIfMissing()
+ *     }
+ * }
+ * ```
+ *
+ * If your app already [requests permissions](https://developer.android.com/training/permissions/requesting)
+ * for other purposes, it might want to use [missingRuntimePermissions] or [runtimePermissions]
+ * instead.
+ *
+ * Note that not all permissions this requests (as returned by [runtimePermissions] and declared in
+ * the included manifest) may be required. Depending on a device's Android SDK version and your
+ * app's needs, only some of them may actually be necessary. For example, location permissions are
+ * typically not required for Nearby Connections on recent Android releases.
+ */
+class MeshSyncPermissions(
+    private val activity: Activity
+) {
+
+    /**
+     * Requests any missing runtime permissions for Mesh Sync using the request code
+     * [PERMISSIONS_REQUEST_CODE].
+     *
+     * Note: before calling this, your code might want to check [Activity.shouldShowRequestPermissionRationale]
+     * if a rationale UI should be shown first. See how to
+     * [request permissions](https://developer.android.com/training/permissions/requesting).
+     */
+    fun requestIfMissing() {
+        val missingPermissions = missingRuntimePermissions()
+        if (missingPermissions.isEmpty()) {
+            return
+        }
+
+        // Before M, missingRuntimePermissions above would return an empty list
+        // and avoid calling this. But guard additionally for safety and to
+        // avoid a Lint error.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            activity.requestPermissions(missingPermissions.toTypedArray(), PERMISSIONS_REQUEST_CODE)
+        }
+    }
+
+    /**
+     * Returns `true` if the request code matches, all required permissions are granted and
+     * [MeshSync.retryNetworks] was called.
+     *
+     * Call this from [Activity.onRequestPermissionsResult] and pass the received [requestCode]
+     * and [SyncClient.getMesh] for [meshSync].
+     *
+     * Alternatively, your code can check itself if all [missingRuntimePermissions] are granted and
+     * then call [MeshSync.retryNetworks] (or create a [SyncClient]) itself.
+     */
+    fun notifyMeshIfPermissionsGranted(
+        requestCode: Int,
+        meshSync: MeshSync?
+    ): Boolean {
+        if (requestCode != PERMISSIONS_REQUEST_CODE) {
+            return false // Don't handle other requests
+        }
+        if (missingRuntimePermissions().size == runtimePermissions().size) {
+            return false // None of the requested runtime permissions granted
+        }
+
+        // Immediately retry if any permission was granted
+        meshSync?.retryNetworks()
+        return true
+    }
+
+    /**
+     * Returns the list of Mesh Sync runtime permissions that have not yet been granted.
+     */
+    fun missingRuntimePermissions(): List<String> {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            return emptyList() // No runtime permissions before API 23
+        }
+
+        return runtimePermissions()
+            .filter { activity.checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED }
+    }
+
+    companion object {
+        /** Request code used when calling [Activity.requestPermissions]. */
+        const val PERMISSIONS_REQUEST_CODE = 0x0B09
+
+        /**
+         * Returns dangerous (runtime) permissions that may be required for Mesh Sync on the current
+         * device, depending on its Android SDK version.
+         *
+         * See [MeshSyncPermissions] for additional notes on permissions.
+         */
+        fun runtimePermissions(): List<String> {
+            val permissions = mutableListOf(
+                Manifest.permission.ACCESS_COARSE_LOCATION,
+                Manifest.permission.ACCESS_FINE_LOCATION
+            )
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                permissions += Manifest.permission.BLUETOOTH_ADVERTISE
+                permissions += Manifest.permission.BLUETOOTH_CONNECT
+                permissions += Manifest.permission.BLUETOOTH_SCAN
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                permissions += Manifest.permission.NEARBY_WIFI_DEVICES
+            }
+            return permissions
+        }
+    }
+}
diff --git a/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/AndroidMeshSyncTest.kt b/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/AndroidMeshSyncTest.kt
new file mode 100644
index 00000000..c2a0cedc
--- /dev/null
+++ b/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/AndroidMeshSyncTest.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.objectbox.meshsync.android
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import io.objectbox.exception.FeatureNotAvailableException
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Tests run on the JVM using Robolectric against a JVM database library which does not include
+ * Sync.
+ *
+ * The internal objectbox repository has instrumented tests requiring the Sync feature and the
+ * Nearby Connections API run against the Android database library.
+ */
+@RunWith(RobolectricTestRunner::class)
+class AndroidMeshSyncTest {
+
+    @Test
+    fun createConfig_withoutSyncLibrary_throws() {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        val exception = assertThrows(FeatureNotAvailableException::class.java) {
+            AndroidMeshSync.createConfig(context, "test-mesh")
+        }
+        val message = exception.message!!
+        assertTrue(message, message.contains("does not include the Sync feature"))
+    }
+
+}
diff --git a/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/MeshSyncPermissionsTest.kt b/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/MeshSyncPermissionsTest.kt
new file mode 100644
index 00000000..f11a3d40
--- /dev/null
+++ b/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/MeshSyncPermissionsTest.kt
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.meshsync.android
+
+import android.Manifest
+import android.app.Activity
+import io.objectbox.sync.MeshSync
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.*
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.Shadows.shadowOf
+
+@RunWith(RobolectricTestRunner::class)
+class MeshSyncPermissionsTest {
+
+    private lateinit var activity: Activity
+    private lateinit var meshSyncPermissions: MeshSyncPermissions
+
+    @Before
+    fun setUp() {
+        activity = Robolectric.buildActivity(Activity::class.java).create().get()
+        meshSyncPermissions = MeshSyncPermissions(activity)
+    }
+
+    private fun grantAllPermissions() {
+        shadowOf(RuntimeEnvironment.getApplication())
+            .grantPermissions(*MeshSyncPermissions.runtimePermissions().toTypedArray())
+    }
+
+    @Test
+    fun requestIfMissing_allGranted_permissionsNotRequested() {
+        grantAllPermissions()
+
+        meshSyncPermissions.requestIfMissing()
+
+        assertNull(
+            "requestPermissions should not have been called when all permissions are granted",
+            shadowOf(activity).lastRequestedPermission
+        )
+    }
+
+    @Test
+    fun requestIfMissing_missing_requestsPermissions() {
+        meshSyncPermissions.requestIfMissing()
+
+        val lastRequest = shadowOf(activity).lastRequestedPermission
+        assertNotNull("requestPermissions should have been called on the Activity", lastRequest)
+        assertEquals(
+            "Request code should match PERMISSIONS_REQUEST_CODE",
+            MeshSyncPermissions.PERMISSIONS_REQUEST_CODE,
+            lastRequest!!.requestCode
+        )
+    }
+
+    private fun assertNotifyMeshIfPermissionsGranted(
+        requestCode: Int = MeshSyncPermissions.PERMISSIONS_REQUEST_CODE,
+        expectedHandled: Boolean,
+        expectRetryNetworksCalled: Boolean
+    ) {
+        val meshSync = mock(MeshSync::class.java)
+        val handled = meshSyncPermissions.notifyMeshIfPermissionsGranted(requestCode, meshSync)
+        assertEquals(expectedHandled, handled)
+        if (expectRetryNetworksCalled) verify(meshSync).retryNetworks()
+        else verify(meshSync, never()).retryNetworks()
+    }
+
+    @Test
+    fun notifyMeshIfPermissionsGranted_allGranted_retryNetworksCalled() {
+        grantAllPermissions()
+
+        assertNotifyMeshIfPermissionsGranted(
+            expectedHandled = true,
+            expectRetryNetworksCalled = true
+        )
+    }
+
+    @Test
+    fun notifyMeshIfPermissionsGranted_oneGranted_retryNetworksCalled() {
+        shadowOf(RuntimeEnvironment.getApplication())
+            .grantPermissions(Manifest.permission.NEARBY_WIFI_DEVICES)
+
+        assertNotifyMeshIfPermissionsGranted(
+            expectedHandled = true,
+            expectRetryNetworksCalled = true
+        )
+    }
+
+    @Test
+    fun notifyMeshIfPermissionsGranted_noneGranted_returnsFalse() {
+        assertNotifyMeshIfPermissionsGranted(
+            expectedHandled = false,
+            expectRetryNetworksCalled = false
+        )
+    }
+
+    @Test
+    fun notifyMeshIfPermissionsGranted_wrongCode_returnsFalse() {
+        // Not required with the current implementation, but things might change
+        grantAllPermissions()
+
+        assertNotifyMeshIfPermissionsGranted(
+            requestCode = 0x1234,
+            expectedHandled = false,
+            expectRetryNetworksCalled = false
+        )
+    }
+
+}
diff --git a/objectbox-rxjava/build.gradle b/objectbox-rxjava/build.gradle
deleted file mode 100644
index c1921b1f..00000000
--- a/objectbox-rxjava/build.gradle
+++ /dev/null
@@ -1,41 +0,0 @@
-plugins {
-    id("java-library")
-    id("objectbox-publish")
-}
-
-// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
-// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
-tasks.withType(JavaCompile) {
-    options.release.set(8)
-}
-
-dependencies {
-    api project(':objectbox-java')
-    api 'io.reactivex.rxjava2:rxjava:2.2.21'
-
-    testImplementation "junit:junit:$juniVersion"
-    testImplementation "org.mockito:mockito-core:$mockitoVersion"
-}
-
-task javadocJar(type: Jar, dependsOn: javadoc) {
-    archiveClassifier.set('javadoc')
-    from 'build/docs/javadoc'
-}
-
-task sourcesJar(type: Jar) {
-    archiveClassifier.set('sources')
-    from sourceSets.main.allSource
-}
-
-// Set project-specific properties.
-publishing.publications {
-    mavenJava(MavenPublication) {
-        from components.java
-        artifact sourcesJar
-        artifact javadocJar
-        pom {
-            name = 'ObjectBox RxJava API'
-            description = 'RxJava extension for ObjectBox'
-        }
-    }
-}
diff --git a/objectbox-rxjava/build.gradle.kts b/objectbox-rxjava/build.gradle.kts
new file mode 100644
index 00000000..8348ef3e
--- /dev/null
+++ b/objectbox-rxjava/build.gradle.kts
@@ -0,0 +1,53 @@
+plugins {
+    id("java-library")
+    id("objectbox.publishing-conventions")
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+dependencies {
+    api(project(":objectbox-java"))
+    api(libs.rxjava2)
+
+    testImplementation(libs.junit)
+    testImplementation(libs.mockito)
+}
+
+val javadocJar by tasks.registering(Jar::class) {
+    dependsOn(tasks.javadoc)
+    archiveClassifier.set("javadoc")
+    from("build/docs/javadoc")
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    archiveClassifier.set("sources")
+    from(sourceSets.main.get().allSource)
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxRxjava = "objectboxRxjava"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxRxjava) {
+            artifactId = "objectbox-rxjava"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            artifact(javadocJar)
+
+            pom {
+                name.set("ObjectBox RxJava API")
+                description.set("RxJava extension for ObjectBox")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxRxjava])
+}
diff --git a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java
index f6f585bb..b700de6b 100644
--- a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java
+++ b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java
index 13b838a0..25cdd099 100644
--- a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java
+++ b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java b/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java
index 6237c75a..88817347 100644
--- a/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java
+++ b/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java b/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java
index 55958a9b..df0432f3 100644
--- a/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java
+++ b/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java b/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java
index 7389effd..71aaadd9 100644
--- a/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java
+++ b/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava3/build.gradle b/objectbox-rxjava3/build.gradle
deleted file mode 100644
index c865ba9d..00000000
--- a/objectbox-rxjava3/build.gradle
+++ /dev/null
@@ -1,76 +0,0 @@
-buildscript {
-    ext.javadocDir = file("$buildDir/docs/javadoc")
-}
-
-plugins {
-    id("java-library")
-    id("kotlin")
-    id("org.jetbrains.dokka")
-    id("objectbox-publish")
-}
-
-// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
-// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
-tasks.withType(JavaCompile) {
-    options.release.set(8)
-}
-
-// Produce Java 8 byte code, would default to Java 6.
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
-    kotlinOptions {
-        jvmTarget = "1.8"
-    }
-}
-
-tasks.named("dokkaHtml") {
-    outputDirectory.set(javadocDir)
-
-    dokkaSourceSets {
-        configureEach {
-            // Fix "Can't find node by signature": have to manually point to dependencies.
-            // https://github.com/Kotlin/dokka/wiki/faq#dokka-complains-about-cant-find-node-by-signature-
-            externalDocumentationLink {
-                // Point to web javadoc for objectbox-java packages.
-                url.set(new URL("https://objectbox.io/docfiles/java/current/"))
-                // Note: Using JDK 9+ package-list is now called element-list.
-                packageListUrl.set(new URL("https://objectbox.io/docfiles/java/current/element-list"))
-            }
-        }
-    }
-}
-
-dependencies {
-    api project(':objectbox-java')
-    api 'io.reactivex.rxjava3:rxjava:3.0.11'
-    compileOnly "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
-
-    testImplementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
-    testImplementation "junit:junit:$juniVersion"
-    testImplementation "org.mockito:mockito-core:$mockitoVersion"
-}
-
-task javadocJar(type: Jar) {
-    dependsOn tasks.named("dokkaHtml")
-    group = 'build'
-    archiveClassifier.set('javadoc')
-    from "$javadocDir"
-}
-
-task sourcesJar(type: Jar) {
-    group = 'build'
-    archiveClassifier.set('sources')
-    from sourceSets.main.allSource
-}
-
-// Set project-specific properties.
-publishing.publications {
-    mavenJava(MavenPublication) {
-        from components.java
-        artifact sourcesJar
-        artifact javadocJar
-        pom {
-            name = 'ObjectBox RxJava 3 API'
-            description = 'RxJava 3 extensions for ObjectBox'
-        }
-    }
-}
diff --git a/objectbox-rxjava3/build.gradle.kts b/objectbox-rxjava3/build.gradle.kts
new file mode 100644
index 00000000..1c3cd605
--- /dev/null
+++ b/objectbox-rxjava3/build.gradle.kts
@@ -0,0 +1,60 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    id("java-library")
+    alias(libs.plugins.kotlin.jvm)
+    id("objectbox.dokka-conventions")
+    id("objectbox.publishing-conventions")
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+kotlin {
+    compilerOptions {
+        // Produce Java 8 byte code, would default to Java 6
+        jvmTarget.set(JvmTarget.JVM_1_8)
+    }
+}
+
+dependencies {
+    api(project(":objectbox-java"))
+    api(libs.rxjava3)
+
+    testImplementation(libs.junit)
+    testImplementation(libs.mockito)
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    group = "build"
+    archiveClassifier.set("sources")
+    from(sourceSets.main.get().allSource)
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxRxjava3 = "objectboxRxjava3"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxRxjava3) {
+            artifactId = "objectbox-rxjava3"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            // Note: the javadocJar task is created by the objectbox.dokka-conventions plugin
+            artifact(tasks.named("javadocJar"))
+
+            pom {
+                name.set("ObjectBox RxJava 3 API")
+                description.set("RxJava 3 extensions for ObjectBox")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxRxjava3])
+}
diff --git a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/Query.kt b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/Query.kt
index 6960f96e..b0a5f21e 100644
--- a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/Query.kt
+++ b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/Query.kt
@@ -9,7 +9,7 @@ import io.reactivex.rxjava3.core.Single
 /**
  * Shortcut for [`RxQuery.flowableOneByOne(query, strategy)`][RxQuery.flowableOneByOne].
  */
-fun <T> Query<T>.flowableOneByOne(strategy: BackpressureStrategy = BackpressureStrategy.BUFFER): Flowable<T> {
+fun <T : Any> Query<T>.flowableOneByOne(strategy: BackpressureStrategy = BackpressureStrategy.BUFFER): Flowable<T> {
     return RxQuery.flowableOneByOne(this, strategy)
 }
 
diff --git a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxBoxStore.java b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxBoxStore.java
index 79f8f1d0..e627bc6a 100644
--- a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxBoxStore.java
+++ b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxBoxStore.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxQuery.java b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxQuery.java
index feadfdd1..fea5d46c 100644
--- a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxQuery.java
+++ b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava3/src/test/java/io/objectbox/query/FakeQueryPublisher.java b/objectbox-rxjava3/src/test/java/io/objectbox/query/FakeQueryPublisher.java
index a550b4a1..a74dcd21 100644
--- a/objectbox-rxjava3/src/test/java/io/objectbox/query/FakeQueryPublisher.java
+++ b/objectbox-rxjava3/src/test/java/io/objectbox/query/FakeQueryPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava3/src/test/java/io/objectbox/query/MockQuery.java b/objectbox-rxjava3/src/test/java/io/objectbox/query/MockQuery.java
index 937556f3..d627b492 100644
--- a/objectbox-rxjava3/src/test/java/io/objectbox/query/MockQuery.java
+++ b/objectbox-rxjava3/src/test/java/io/objectbox/query/MockQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava3/src/test/java/io/objectbox/rx3/QueryObserverTest.java b/objectbox-rxjava3/src/test/java/io/objectbox/rx3/QueryObserverTest.java
index bdf70d98..a0602a65 100644
--- a/objectbox-rxjava3/src/test/java/io/objectbox/rx3/QueryObserverTest.java
+++ b/objectbox-rxjava3/src/test/java/io/objectbox/rx3/QueryObserverTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/scripts/set-version.sh b/scripts/set-version.sh
new file mode 100755
index 00000000..196b1ad0
--- /dev/null
+++ b/scripts/set-version.sh
@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# This script has a regular and a `--release` mode.
+#
+# In regular mode this script will:
+# - update `versionNumber` in `/build.gradle.kts`
+# - in `CHANGELOG.md`, if it doesn't exist, add a next release heading
+# - on confirmation, commit the changes
+# - suggest a git command to push the changes
+#
+# In release mode:
+# - ask to confirm `versionNumber` in `/build.gradle.kts`
+# - in `BoxStore.java` update `JNI_VERSION` to match `VERSION`
+# - in `README.md` update version numbers in known locations
+# - in `CHANGELOG.md` change the next version header to the new version and date
+# - on confirmation, commit the changes, create a release tag
+# - suggest git commands to push the changes
+
+# Parse optional --release flag
+releaseFlag=false
+for arg in "$@"; do
+    case "$arg" in
+        --release) releaseFlag=true ;;
+    esac
+done
+
+# macOS includes BSD versions of sed and grep, which have different options and syntax than the
+# expected GNU versions. So require users of this script to install gsed and ggrep.
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  if ! command -v gsed &>/dev/null; then
+    echo "Error: gsed is required but not installed. Install it, for example using 'brew install gnu-sed'."
+    exit 1
+  fi
+  if ! command -v ggrep &>/dev/null; then
+    echo "Error: ggrep is required but not installed. Install it, for example using 'brew install grep'."
+    exit 1
+  fi
+  sed="gsed"
+  grep="ggrep"
+else
+  sed="sed"
+  grep="grep"
+fi
+
+scriptDir="$(dirname "$0")"
+
+propVersionNumber="versionNumber"
+buildScriptFile="../build.gradle.kts"
+buildScriptPath="$scriptDir/$buildScriptFile"
+
+boxStorePath="$scriptDir/../objectbox-java/src/main/java/io/objectbox/BoxStore.java"
+readmePath="$scriptDir/../README.md"
+changelogPath="$scriptDir/../CHANGELOG.md"
+nextReleaseHeading="## Next release"
+
+# Extract the value of `versionNumber` in build.gradle.kts and store it in the versionCurrent variable
+buildScriptPath="$(dirname "$0")/$buildScriptFile"
+# Regex matches 'versionNumber = "..."', \K to only capture the version string inside the quotes
+versionCurrent=$($grep --only-matching --perl-regexp "$propVersionNumber"' = "\K[^"]+' "$buildScriptPath" || true)
+if [[ -z "$versionCurrent" ]]; then
+    echo "Error: could not find '$propVersionNumber' in '$buildScriptFile'"
+    exit 1
+fi
+
+echo ""
+echo "Maven artifacts version ($propVersionNumber in $buildScriptFile)"
+echo "Current:    $versionCurrent"
+
+if $releaseFlag; then
+    # Release: Confirm the current version
+    read -r -p "Press enter to confirm the current version, or enter a custom one: " versionInput
+    if [[ -n "$versionInput" ]]; then
+        versionNew="$versionInput"
+    else
+        versionNew="$versionCurrent"
+    fi
+else
+    # Suggest a next version
+    # Increment the last number in the version string (like 5.4.2 -> 5.4.3, 5.4.2-preview1 -> 5.4.2-preview2)
+    # Regex: captures the trailing digits and replaces them with a value increased by 1
+    [[ "$versionCurrent" =~ ^(.*[^0-9])([0-9]+)$ ]] || { echo "Error: $propVersionNumber '$versionCurrent' does not end with a number"; exit 1; }
+    versionSuggested="${BASH_REMATCH[1]}$(( BASH_REMATCH[2] + 1 ))"
+    echo "Suggested:  $versionSuggested"
+    read -r -p "Press enter to use the suggested version, or enter a custom one: " versionInput
+    if [[ -n "$versionInput" ]]; then
+        versionNew="$versionInput"
+    else
+        versionNew="$versionSuggested"
+    fi
+fi
+echo "Version will be $versionNew"
+
+# Change the value of `versionNumber` in build.gradle.kts to the value of versionNew
+$sed --in-place "s/$propVersionNumber = \"$versionCurrent\"/$propVersionNumber = \"$versionNew\"/" "$buildScriptPath"
+
+if $releaseFlag; then
+    # In BoxStore.java set JNI_VERSION to the value of VERSION (not using versionNew!) and print the used value
+    # Regex matches 'String VERSION = "...", \K to only capture the version string inside the quotes
+    versionJni=$($grep --only-matching --perl-regexp 'String VERSION = "\K[^"]+' "$boxStorePath" || true)
+    if [[ -z "$versionJni" ]]; then
+        echo "Error: could not find VERSION in BoxStore.java"
+        exit 1
+    fi
+    echo "Release: setting BoxStore.JNI_VERSION to $versionJni"
+    $sed --in-place "s/String JNI_VERSION = \".*\"/String JNI_VERSION = \"$versionJni\"/" "$boxStorePath"
+
+    # Change version strings in README.md to versionNew
+    echo "Release: updating README.md version strings"
+    $sed --in-place "s/objectbox = \".*\"/objectbox = \"$versionNew\"/g" "$readmePath"
+    $sed --in-place "s/id(\"io.objectbox\") version \".*\"/id(\"io.objectbox\") version \"$versionNew\"/g" "$readmePath"
+    $sed --in-place "s/val objectboxVersion by extra(\".*\")/val objectboxVersion by extra(\"$versionNew\")/g" "$readmePath"
+    $sed --in-place "s/ext.objectboxVersion = \".*\"/ext.objectboxVersion = \"$versionNew\"/g" "$readmePath"
+
+    # Change header "Next release" in CHANGELOG.md to "versionNew - YYYY-MM-DD"
+    echo "Release: updating CHANGELOG.md heading"
+    today=$(date +"%Y-%m-%d")
+    if $grep --quiet "^$nextReleaseHeading" "$changelogPath"; then
+        $sed --in-place "s/^$nextReleaseHeading/## $versionNew - $today/" "$changelogPath"
+    else
+        echo "⚠️ '$nextReleaseHeading' heading not found in CHANGELOG.md, check it contains changes for this release!"
+    fi
+else
+    # In CHANGELOG.md, if the first secondary heading is not "## Next release", add it
+    firstHeading=$($grep --max-count=1 "^## " "$changelogPath" || true)
+    if [[ "$firstHeading" != "$nextReleaseHeading" ]]; then
+        echo "Adding '$nextReleaseHeading' to CHANGELOG.md"
+        $sed --in-place "0,/^## /{s/^## /$nextReleaseHeading\n\n## /}" "$changelogPath"
+    fi
+fi
+
+# After confirmation commit any changes and for a release create a tag
+# Example for a release:
+# git commit --all --message="Prepare release 5.4.0"
+# git tag V5.4.0
+# For a regular run:
+# git commit --all --message="Publishing: increase version 5.4.0 -> 5.4.1"
+if $releaseFlag; then
+    commitMessage="Prepare release $versionNew"
+else
+    commitMessage="Publishing: increase version $versionCurrent -> $versionNew"
+fi
+tagRelease="V$versionNew"
+
+echo ""
+echo "About to run git commands:"
+echo "  git commit --all --message=\"$commitMessage\""
+if $releaseFlag; then
+    echo "  git tag $tagRelease"
+fi
+
+read -r -p "Reviewed changes? Proceed? [y/N] " confirm
+if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
+    echo "Aborted."
+    exit 1
+fi
+
+git commit --all --message="$commitMessage"
+if $releaseFlag; then
+    git tag "$tagRelease"
+fi
+
+# Print suggested git commands to push the changes
+# Note: add `--push-option=ci.skip` to avoid running CI
+# Examples:
+# git push origin publish --push-option=ci.skip
+# git push origin V5.4.0 --push-option=ci.skip
+
+currentBranch=$(git rev-parse --abbrev-ref HEAD)
+echo ""
+echo "Suggested commands to push these changes:"
+echo "  git push origin $currentBranch --push-option=ci.skip"
+if $releaseFlag; then
+    echo "  git push origin $tagRelease --push-option=ci.skip"
+fi
diff --git a/scripts/test-with-asan.sh b/scripts/test-with-asan.sh
new file mode 100755
index 00000000..b52ed90e
--- /dev/null
+++ b/scripts/test-with-asan.sh
@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+set -e
+
+# Enables running Gradle tasks with JNI libraries built with AddressSanitizer (ASan).
+#
+# Note: currently only objectbox feature branches build JNI libraries with ASan. If this is used
+# with "regularly" built JNI libraries this will run without error, but also NOT detect any issues.
+#
+# Arguments are passed directly to Gradle. If no arguments are specified runs the 'test' task.
+#
+# This script supports the following environment variables:
+#
+# - ASAN_LIB_SO: path to ASan library, if not set tries to detect path
+# - ASAN_SYMBOLIZER_PATH: path to llvm-symbolizer, if not set tries to detect path
+# - ASAN_OPTIONS: ASan options, if not set configures to not detect leaks
+#
+# The ASan detection is known to work with the buildenv-core:2024-07-11 image or Ubuntu 24.04 with a clang setup.
+
+# AddressSanitizer shared library (clang or gcc setup)
+# https://github.com/google/sanitizers/wiki/AddressSanitizer
+if [ -z "$ASAN_LIB_SO" ]; then  # If not supplied (e.g. by CI script), try to locate the lib:
+    ASAN_ARCH=$(uname -m) # x86_64 or aarch64
+    echo "No ASAN_LIB_SO defined, trying to locate dynamically..."
+    # Known to work on Ubuntu 24.04: Find in the typical llvm directory (using `tail` for latest version; `head` would be oldest")
+    ASAN_LIB_SO_CLANG_LATEST=$(find /usr/lib/llvm-*/ -name libclang_rt.asan-${ASAN_ARCH}.so | tail -1)
+    # Known to work with clang 16 on Rocky Linux 8.10 (path is like /usr/local/lib/clang/16/lib/x86_64-unknown-linux-gnu/libclang_rt.asan.so)
+    ASAN_LIB_SO_CLANG=$(clang -print-file-name=libclang_rt.asan.so || true)
+    # Approach via https://stackoverflow.com/a/54386573/551269, but use libasan.so.8 instead of libasan.so
+    # to not find the linker script, but the actual library (and to avoid parsing it out of the linker script).
+    ASAN_LIB_SO_GCC=$(gcc -print-file-name=libasan.so.8 || true)
+    echo "clang latest asan lib: ${ASAN_LIB_SO_CLANG_LATEST}"
+    echo "       clang asan lib: ${ASAN_LIB_SO_CLANG}"
+    echo "         gcc asan lib: ${ASAN_LIB_SO_GCC}"
+    # prefer clang version in case clang llvm-symbolizer is used (see below)
+    if [ -f "${ASAN_LIB_SO_CLANG_LATEST}" ]; then
+        export ASAN_LIB_SO="${ASAN_LIB_SO_CLANG_LATEST}"
+    elif [ -f "${ASAN_LIB_SO_CLANG}" ]; then
+        export ASAN_LIB_SO="${ASAN_LIB_SO_CLANG}"
+    elif [ -f "${ASAN_LIB_SO_GCC}" ]; then
+        export ASAN_LIB_SO="${ASAN_LIB_SO_GCC}"
+    else
+        echo "No asan lib found; please specify via ASAN_LIB_SO"
+        exit 1
+    fi
+fi
+
+# Set up llvm-symbolizer to symbolize a stack trace (clang setup only)
+# https://github.com/google/sanitizers/wiki/AddressSanitizerCallStack
+# Rocky Linux 8 (buildenv-core)
+if [ -z "$ASAN_SYMBOLIZER_PATH" ]; then
+    echo "ASAN_SYMBOLIZER_PATH not set, trying to find it in /usr/local/bin/..."
+    export ASAN_SYMBOLIZER_PATH="$(find /usr/local/bin/ -name llvm-symbolizer | tail -1 )"
+fi
+# Ubuntu 22.04
+if [ -z "$ASAN_SYMBOLIZER_PATH" ]; then
+    echo "ASAN_SYMBOLIZER_PATH not set, trying to find it in /usr/lib/llvm-*/..."
+    export ASAN_SYMBOLIZER_PATH="$(find /usr/lib/llvm-*/ -name llvm-symbolizer | tail -1)"
+fi
+
+# Turn off leak detection by default
+# https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer
+if [ -z "$ASAN_OPTIONS" ]; then
+    echo "ASAN_OPTIONS not set, setting default values"
+    export ASAN_OPTIONS="detect_leaks=0"
+fi
+
+echo ""
+echo "ℹ️ test-with-asan.sh final values:"
+echo "ASAN_LIB_SO: $ASAN_LIB_SO"
+echo "ASAN_SYMBOLIZER_PATH: $ASAN_SYMBOLIZER_PATH"
+echo "ASAN_OPTIONS: $ASAN_OPTIONS"
+echo "ASAN_LIB_SO resolves to:"
+ls -l $ASAN_LIB_SO
+echo "ASAN_SYMBOLIZER_PATH resolves to:"
+if [ -z "$ASAN_SYMBOLIZER_PATH" ]; then
+    echo "WARNING: ASAN_SYMBOLIZER_PATH not set, stack traces will not be symbolized"
+else
+    ls -l $ASAN_SYMBOLIZER_PATH
+fi
+
+if [[ $# -eq 0 ]] ; then
+    args=test
+else
+    args=$@
+fi
+
+echo ""
+echo "➡️ Running Gradle with arguments \"$args\" in directory $(pwd)..."
+LD_PRELOAD=${ASAN_LIB_SO} ./gradlew ${args}
diff --git a/scripts/update-flatbuffers.sh b/scripts/update-flatbuffers.sh
index 17e00b19..eb790bab 100644
--- a/scripts/update-flatbuffers.sh
+++ b/scripts/update-flatbuffers.sh
@@ -8,7 +8,7 @@ script_dir=$(dirname "$(readlink -f "$0")")
 cd "${script_dir}/.." # move to project root dir or exit on failure
 echo "Running in directory: $(pwd)"
 
-src="../flatbuffers/java/com/google/flatbuffers"
+src="../flatbuffers/java/src/main/java/com/google/flatbuffers"
 dest="objectbox-java/src/main/java/io/objectbox/flatbuffers"
 
 echo "Copying flatbuffers Java sources"
@@ -18,4 +18,4 @@ cp -v ${src}/*.java ${dest}/
 echo "Updating import statements of Java sources"
 find "${dest}" -type f -name "*.java" \
   -exec echo "Processing {}" \; \
-  -exec sed -i "s| com.google.flatbuffers| io.objectbox.flatbuffers|g" {} \;
\ No newline at end of file
+  -exec sed -i "s| com.google.flatbuffers| io.objectbox.flatbuffers|g" {} \;
diff --git a/settings.gradle b/settings.gradle
deleted file mode 100644
index 24da1d92..00000000
--- a/settings.gradle
+++ /dev/null
@@ -1,8 +0,0 @@
-include ':objectbox-java-api'
-include ':objectbox-java'
-include ':objectbox-kotlin'
-include ':objectbox-rxjava'
-include ':objectbox-rxjava3'
-
-include ':tests:objectbox-java-test'
-include ':tests:test-proguard'
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 00000000..0de155c9
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,71 @@
+pluginManagement {
+    includeBuild("build-logic")
+    repositories {
+        // Google: for Android plugin
+        google {
+            content {
+                includeGroupByRegex("com\\.android.*")
+                includeGroupByRegex("com\\.google.*")
+                includeGroupByRegex("androidx.*")
+            }
+        }
+        mavenCentral() // For dokka plugin
+        gradlePluginPortal()
+    }
+}
+
+// While this is an incubating API, it is the recommended way of declaring repositories:
+// https://docs.gradle.org/current/userguide/best_practices_dependencies.html#set_up_repositories_in_settings
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google() // For Android dependencies
+        mavenCentral()
+
+        // Internal ObjectBox repo to get snapshot versions of dependencies
+        val gitlabUrl = providers.gradleProperty("gitlabUrl")
+        val gitlabPrivateTokenName = providers.gradleProperty("gitlabPrivateTokenName")
+        val gitlabPrivateToken = providers.gradleProperty("gitlabPrivateToken")
+        if (gitlabUrl.isPresent) {
+            maven {
+                name = "GitLab"
+                url = uri("${gitlabUrl.get()}/api/v4/groups/objectbox/-/packages/maven")
+                credentials(HttpHeaderCredentials::class) {
+                    name = gitlabPrivateTokenName.orNull ?: "Private-Token"
+                    value = gitlabPrivateToken.get()
+                }
+                authentication {
+                    create<HttpHeaderAuthentication>("header")
+                }
+                println("Dependencies: added GitLab repository at $url")
+            }
+        } else {
+            println("Dependencies: GitLab repository NOT added, see settings file for required project properties")
+        }
+    }
+}
+
+plugins {
+    // Supports resolving toolchains for JVM projects
+    // https://docs.gradle.org/9.5.1/userguide/toolchains.html#sub:download_repositories
+    // https://github.com/gradle/foojay-toolchains/blob/main/CHANGELOG.md
+    id("org.gradle.toolchains.foojay-resolver-convention") version ("1.0.0")
+}
+
+rootProject.name = "objectbox-java"
+
+include(":objectbox-java-api")
+include(":objectbox-java")
+include(":objectbox-kotlin")
+include(":objectbox-rxjava")
+include(":objectbox-rxjava3")
+
+// Allow to conditionally exclude projects that require the Android SDK to build
+val excludeAndroid: String? by settings
+if (excludeAndroid == null) {
+    include(":objectbox-android")
+    include(":objectbox-meshsync-android")
+}
+
+include(":tests:objectbox-java-test")
+include(":tests:test-proguard")
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 00000000..4e2b96b1
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,22 @@
+# ObjectBox Java API tests
+
+Note: As the Gradle plugin and therefore code generation is not available, these tests use copies (partially customized
+for testing) of generated ObjectBox helper classes like `MyObjectBox`, meta and cursor classes.
+
+The following test projects exist:
+
+- [objectbox-java-test](objectbox-java-test): basic tests of Java APIs using JVM libraries with Sync (client only)
+  feature
+- [test-proguard](test-proguard): despite its name, only a very basic create, read and delete test using the regular JVM
+  library (so without Sync)
+
+Extended tests exist in the internal Java integration test repository.
+
+## Naming convention for tests
+
+All new test methods should be named like: `{subject}_{operation}_{expectation}`
+
+For ex. to test a date query condition: `date_lessAndGreater_works`
+
+Note: due to historic reasons existing test methods (written for JUnit 3) may be named differently (with a `test`
+prefix).
diff --git a/tests/objectbox-java-test/build.gradle b/tests/objectbox-java-test/build.gradle
deleted file mode 100644
index 44468ad8..00000000
--- a/tests/objectbox-java-test/build.gradle
+++ /dev/null
@@ -1,93 +0,0 @@
-apply plugin: 'java-library'
-apply plugin: 'kotlin'
-
-tasks.withType(JavaCompile) {
-    // Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
-    // https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
-    options.release.set(8)
-    // Note: Gradle defaults to the platform default encoding, make sure to always use UTF-8 for UTF-8 tests.
-    options.encoding = "UTF-8"
-}
-
-// Produce Java 8 byte code, would default to Java 6.
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
-    kotlinOptions {
-        jvmTarget = "1.8"
-    }
-}
-
-repositories {
-    // Native lib might be deployed only in internal repo
-    if (project.hasProperty('gitlabUrl')) {
-        println "gitlabUrl=$gitlabUrl added to repositories."
-        maven {
-            url "$gitlabUrl/api/v4/groups/objectbox/-/packages/maven"
-            name "GitLab"
-            credentials(HttpHeaderCredentials) {
-                name = project.hasProperty("gitlabTokenName") ? gitlabTokenName : "Private-Token"
-                value = gitlabPrivateToken
-            }
-            authentication {
-                header(HttpHeaderAuthentication)
-            }
-        }
-    } else {
-        println "Property gitlabUrl not set."
-    }
-}
-
-dependencies {
-    implementation project(':objectbox-java')
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
-    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion"
-    implementation project(':objectbox-kotlin')
-    implementation "org.greenrobot:essentials:$essentialsVersion"
-
-    // Check flag to use locally compiled version to avoid dependency cycles
-    if (!project.hasProperty('noObjectBoxTestDepencies') || !noObjectBoxTestDepencies) {
-        println "Using $obxJniLibVersion"
-        implementation obxJniLibVersion
-    } else {
-        println "Did NOT add native dependency"
-    }
-
-    testImplementation "junit:junit:$juniVersion"
-    // To test Coroutines
-    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutinesVersion")
-    // To test Kotlin Flow
-    testImplementation 'app.cash.turbine:turbine:0.5.2'
-}
-
-test {
-    if (System.getenv("TEST_WITH_JAVA_X86") == "true") {
-        // to run tests with 32-bit ObjectBox
-        def javaExecutablePath = System.getenv("JAVA_HOME_X86") + "\\bin\\java"
-        println("Will run tests with $javaExecutablePath")
-        executable = javaExecutablePath
-    } else if (System.getenv("TEST_JDK") != null) {
-        // To run tests on a different JDK, uses Gradle toolchains API (https://docs.gradle.org/current/userguide/toolchains.html)
-        def sdkVersionInt = System.getenv("TEST_JDK") as Integer
-        println("Will run tests with JDK $sdkVersionInt")
-        javaLauncher.set(javaToolchains.launcherFor {
-            languageVersion.set(JavaLanguageVersion.of(sdkVersionInt))
-        })
-    }
-
-    // This is pretty useless now because it floods console with warnings about internal Java classes
-    // However we might check from time to time, also with Java 9.
-    // jvmArgs '-Xcheck:jni'
-
-    filter {
-        // Note: Tree API currently incubating on Linux only.
-        if (!System.getProperty("os.name").toLowerCase().contains('linux')) {
-            excludeTestsMatching "io.objectbox.tree.*"
-        }
-    }
-
-    testLogging {
-        showStandardStreams = true
-        exceptionFormat = 'full'
-        displayGranularity = 2
-        events 'started', 'passed'
-    }
-}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/build.gradle.kts b/tests/objectbox-java-test/build.gradle.kts
new file mode 100644
index 00000000..c00657f4
--- /dev/null
+++ b/tests/objectbox-java-test/build.gradle.kts
@@ -0,0 +1,91 @@
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    id("java-library")
+    id("kotlin")
+}
+
+tasks.withType<JavaCompile> {
+    // Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+    // https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+    options.release.set(8)
+}
+
+kotlin {
+    compilerOptions {
+        // Produce Java 8 byte code, would default to Java 6
+        jvmTarget.set(JvmTarget.JVM_1_8)
+    }
+}
+
+val versionDatabaseLibraryJvmSync: String by rootProject.extra
+
+dependencies {
+    implementation(project(":objectbox-java"))
+    implementation(libs.kotlin.coroutines.core)
+    implementation(project(":objectbox-kotlin"))
+    implementation(libs.essentials)
+    implementation("io.objectbox:objectbox-sync-linux:$versionDatabaseLibraryJvmSync")
+    implementation("io.objectbox:objectbox-sync-macos:$versionDatabaseLibraryJvmSync")
+    implementation("io.objectbox:objectbox-sync-windows:$versionDatabaseLibraryJvmSync")
+
+    testImplementation(libs.junit)
+    // To test Coroutines
+    testImplementation(libs.kotlin.coroutines.test)
+    // To test Kotlin Flow
+    testImplementation(libs.turbine)
+}
+
+val testInMemory by tasks.registering(Test::class) {
+    group = "verification"
+    description = "Run unit tests with in-memory database"
+    systemProperty("obx.inMemory", true)
+}
+
+// Run in-memory tests as part of regular check run
+tasks.check {
+    dependsOn(testInMemory)
+}
+
+tasks.withType<Test> {
+    if (System.getenv("TEST_WITH_JAVA_X86") == "true") {
+        // To run tests with 32-bit ObjectBox
+        // Note: 32-bit JDK is only available on Windows
+        val javaExecutablePath = System.getenv("JAVA_HOME_X86") + "\\bin\\java.exe"
+        println("$name: will run tests with $javaExecutablePath")
+        executable = javaExecutablePath
+    } else if (System.getenv("TEST_JDK") != null) {
+        // To run tests on a different JDK, uses Gradle toolchains API (https://docs.gradle.org/current/userguide/toolchains.html)
+        val sdkVersionInt = System.getenv("TEST_JDK").toInt()
+        println("$name: will run tests with JDK $sdkVersionInt")
+        javaLauncher.set(javaToolchains.launcherFor {
+            languageVersion.set(JavaLanguageVersion.of(sdkVersionInt))
+        })
+    }
+
+    // This is pretty useless now because it floods console with warnings about internal Java classes
+    // However we might check from time to time, also with Java 9.
+    // jvmArgs "-Xcheck:jni"
+
+    filter {
+        // Note: Tree API currently incubating on Linux only.
+        if (!System.getProperty("os.name").lowercase().contains("linux")) {
+            excludeTestsMatching("io.objectbox.tree.*")
+        }
+    }
+
+    testLogging {
+        exceptionFormat = TestExceptionFormat.FULL
+        displayGranularity = 2
+        // Note: this overwrites showStandardStreams = true, so set it by
+        // adding the standard out/error events.
+        events = setOf(
+            TestLogEvent.STARTED,
+            TestLogEvent.PASSED,
+            TestLogEvent.STANDARD_OUT,
+            TestLogEvent.STANDARD_ERROR
+        )
+    }
+}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity.java
index 4a8ad27a..17553df3 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,12 +16,25 @@
 
 package io.objectbox;
 
-import javax.annotation.Nullable;
 import java.util.Arrays;
+import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
-/** In "real" entity would be annotated with @Entity. */
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.Entity;
+import io.objectbox.annotation.Id;
+import io.objectbox.annotation.Unsigned;
+
+/**
+ * The annotations in this class have no effect as the Gradle plugin is not configured in this project. They are
+ * informational to help maintain the test code that builds a model for this entity (see AbstractObjectBoxTest).
+ * <p>
+ * To test annotations and correct code generation, add a test in the Gradle plugin project. To test related features
+ * with a database at runtime, add a test in the internal integration test project.
+ */
+@Entity
 public class TestEntity {
 
     public static final String STRING_VALUE_THROW_IN_CONSTRUCTOR =
@@ -30,7 +43,7 @@ public class TestEntity {
     public static final String EXCEPTION_IN_CONSTRUCTOR_MESSAGE =
             "Hello, this is an exception from TestEntity constructor";
 
-    /** In "real" entity would be annotated with @Id. */
+    @Id
     private long id;
     private boolean simpleBoolean;
     private byte simpleByte;
@@ -45,14 +58,22 @@ public class TestEntity {
     /** Not-null value. */
     private String[] simpleStringArray;
     private List<String> simpleStringList;
-    /** In "real" entity would be annotated with @Unsigned. */
+    @Unsigned
     private short simpleShortU;
-    /** In "real" entity would be annotated with @Unsigned. */
+    @Unsigned
     private int simpleIntU;
-    /** In "real" entity would be annotated with @Unsigned. */
+    @Unsigned
     private long simpleLongU;
     private Map<String, Object> stringObjectMap;
     private Object flexProperty;
+    private boolean[] booleanArray;
+    private short[] shortArray;
+    private char[] charArray;
+    private int[] intArray;
+    private long[] longArray;
+    private float[] floatArray;
+    private double[] doubleArray;
+    private Date date;
 
     transient boolean noArgsConstructorCalled;
 
@@ -64,11 +85,32 @@ public TestEntity(long id) {
         this.id = id;
     }
 
-    public TestEntity(long id, boolean simpleBoolean, byte simpleByte, short simpleShort, int simpleInt,
-                      long simpleLong, float simpleFloat, double simpleDouble, String simpleString,
-                      byte[] simpleByteArray, String[] simpleStringArray, List<String> simpleStringList,
-                      short simpleShortU, int simpleIntU, long simpleLongU, Map<String, Object> stringObjectMap,
-                      Object flexProperty) {
+    public TestEntity(long id,
+                      boolean simpleBoolean,
+                      byte simpleByte,
+                      short simpleShort,
+                      int simpleInt,
+                      long simpleLong,
+                      float simpleFloat,
+                      double simpleDouble,
+                      String simpleString,
+                      byte[] simpleByteArray,
+                      String[] simpleStringArray,
+                      List<String> simpleStringList,
+                      short simpleShortU,
+                      int simpleIntU,
+                      long simpleLongU,
+                      Map<String, Object> stringObjectMap,
+                      Object flexProperty,
+                      boolean[] booleanArray,
+                      short[] shortArray,
+                      char[] charArray,
+                      int[] intArray,
+                      long[] longArray,
+                      float[] floatArray,
+                      double[] doubleArray,
+                      Date date
+    ) {
         this.id = id;
         this.simpleBoolean = simpleBoolean;
         this.simpleByte = simpleByte;
@@ -86,6 +128,14 @@ public TestEntity(long id, boolean simpleBoolean, byte simpleByte, short simpleS
         this.simpleLongU = simpleLongU;
         this.stringObjectMap = stringObjectMap;
         this.flexProperty = flexProperty;
+        this.booleanArray = booleanArray;
+        this.shortArray = shortArray;
+        this.charArray = charArray;
+        this.intArray = intArray;
+        this.longArray = longArray;
+        this.floatArray = floatArray;
+        this.doubleArray = doubleArray;
+        this.date = date;
         if (STRING_VALUE_THROW_IN_CONSTRUCTOR.equals(simpleString)) {
             throw new RuntimeException(EXCEPTION_IN_CONSTRUCTOR_MESSAGE);
         }
@@ -188,45 +238,40 @@ public List<String> getSimpleStringList() {
         return simpleStringList;
     }
 
-    public TestEntity setSimpleStringList(List<String> simpleStringList) {
+    public void setSimpleStringList(List<String> simpleStringList) {
         this.simpleStringList = simpleStringList;
-        return this;
     }
 
     public short getSimpleShortU() {
         return simpleShortU;
     }
 
-    public TestEntity setSimpleShortU(short simpleShortU) {
+    public void setSimpleShortU(short simpleShortU) {
         this.simpleShortU = simpleShortU;
-        return this;
     }
 
     public int getSimpleIntU() {
         return simpleIntU;
     }
 
-    public TestEntity setSimpleIntU(int simpleIntU) {
+    public void setSimpleIntU(int simpleIntU) {
         this.simpleIntU = simpleIntU;
-        return this;
     }
 
     public long getSimpleLongU() {
         return simpleLongU;
     }
 
-    public TestEntity setSimpleLongU(long simpleLongU) {
+    public void setSimpleLongU(long simpleLongU) {
         this.simpleLongU = simpleLongU;
-        return this;
     }
 
     public Map<String, Object> getStringObjectMap() {
         return stringObjectMap;
     }
 
-    public TestEntity setStringObjectMap(Map<String, Object> stringObjectMap) {
+    public void setStringObjectMap(Map<String, Object> stringObjectMap) {
         this.stringObjectMap = stringObjectMap;
-        return this;
     }
 
     @Nullable
@@ -234,9 +279,79 @@ public Object getFlexProperty() {
         return flexProperty;
     }
 
-    public TestEntity setFlexProperty(@Nullable Object flexProperty) {
+    public void setFlexProperty(@Nullable Object flexProperty) {
         this.flexProperty = flexProperty;
-        return this;
+    }
+
+    @Nullable
+    public boolean[] getBooleanArray() {
+        return booleanArray;
+    }
+
+    public void setBooleanArray(@Nullable boolean[] booleanArray) {
+        this.booleanArray = booleanArray;
+    }
+
+    @Nullable
+    public short[] getShortArray() {
+        return shortArray;
+    }
+
+    public void setShortArray(@Nullable short[] shortArray) {
+        this.shortArray = shortArray;
+    }
+
+    @Nullable
+    public char[] getCharArray() {
+        return charArray;
+    }
+
+    public void setCharArray(@Nullable char[] charArray) {
+        this.charArray = charArray;
+    }
+
+    @Nullable
+    public int[] getIntArray() {
+        return intArray;
+    }
+
+    public void setIntArray(@Nullable int[] intArray) {
+        this.intArray = intArray;
+    }
+
+    @Nullable
+    public long[] getLongArray() {
+        return longArray;
+    }
+
+    public void setLongArray(@Nullable long[] longArray) {
+        this.longArray = longArray;
+    }
+
+    @Nullable
+    public float[] getFloatArray() {
+        return floatArray;
+    }
+
+    public void setFloatArray(@Nullable float[] floatArray) {
+        this.floatArray = floatArray;
+    }
+
+    @Nullable
+    public double[] getDoubleArray() {
+        return doubleArray;
+    }
+
+    public void setDoubleArray(@Nullable double[] doubleArray) {
+        this.doubleArray = doubleArray;
+    }
+
+    public Date getDate() {
+        return date;
+    }
+
+    public void setDate(Date date) {
+        this.date = date;
     }
 
     @Override
@@ -259,6 +374,14 @@ public String toString() {
                 ", simpleLongU=" + simpleLongU +
                 ", stringObjectMap=" + stringObjectMap +
                 ", flexProperty=" + flexProperty +
+                ", booleanArray=" + Arrays.toString(booleanArray) +
+                ", shortArray=" + Arrays.toString(shortArray) +
+                ", charArray=" + Arrays.toString(charArray) +
+                ", intArray=" + Arrays.toString(intArray) +
+                ", longArray=" + Arrays.toString(longArray) +
+                ", floatArray=" + Arrays.toString(floatArray) +
+                ", doubleArray=" + Arrays.toString(doubleArray) +
+                ", date=" + date +
                 ", noArgsConstructorCalled=" + noArgsConstructorCalled +
                 '}';
     }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityCursor.java
index bf77e3a3..6727a063 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,14 +16,16 @@
 
 package io.objectbox;
 
+import java.util.Map;
+
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.converter.FlexObjectConverter;
 import io.objectbox.converter.StringFlexMapConverter;
 import io.objectbox.internal.CursorFactory;
 
-import java.util.Map;
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// TestEntity. But make sure to keep the INT_NULL_HACK to make it work with tests here.
 
-// NOTE: Copied from a plugin project (& removed some unused Properties).
 // THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
 
 /**
@@ -64,6 +66,14 @@ public Cursor<TestEntity> createCursor(io.objectbox.Transaction tx, long cursorH
     private final static int __ID_simpleLongU = TestEntity_.simpleLongU.id;
     private final static int __ID_stringObjectMap = TestEntity_.stringObjectMap.id;
     private final static int __ID_flexProperty = TestEntity_.flexProperty.id;
+    private final static int __ID_booleanArray = TestEntity_.booleanArray.id;
+    private final static int __ID_shortArray = TestEntity_.shortArray.id;
+    private final static int __ID_charArray = TestEntity_.charArray.id;
+    private final static int __ID_intArray = TestEntity_.intArray.id;
+    private final static int __ID_longArray = TestEntity_.longArray.id;
+    private final static int __ID_floatArray = TestEntity_.floatArray.id;
+    private final static int __ID_doubleArray = TestEntity_.doubleArray.id;
+    private final static int __ID_date = TestEntity_.date.id;
 
     public TestEntityCursor(io.objectbox.Transaction tx, long cursor, BoxStore boxStore) {
         super(tx, cursor, TestEntity_.__INSTANCE, boxStore);
@@ -79,12 +89,55 @@ public long getId(TestEntity entity) {
      *
      * @return The ID of the object within its box.
      */
+    @SuppressWarnings({"rawtypes", "unchecked"})
     @Override
     public long put(TestEntity entity) {
+        boolean[] booleanArray = entity.getBooleanArray();
+        int __id17 = booleanArray != null ? __ID_booleanArray : 0;
+
+        collectBooleanArray(cursor, 0, PUT_FLAG_FIRST,
+                __id17, booleanArray);
+
+        short[] shortArray = entity.getShortArray();
+        int __id18 = shortArray != null ? __ID_shortArray : 0;
+
+        collectShortArray(cursor, 0, 0,
+                __id18, shortArray);
+
+        char[] charArray = entity.getCharArray();
+        int __id19 = charArray != null ? __ID_charArray : 0;
+
+        collectCharArray(cursor, 0, 0,
+                __id19, charArray);
+
+        int[] intArray = entity.getIntArray();
+        int __id20 = intArray != null ? __ID_intArray : 0;
+
+        collectIntArray(cursor, 0, 0,
+                __id20, intArray);
+
+        long[] longArray = entity.getLongArray();
+        int __id21 = longArray != null ? __ID_longArray : 0;
+
+        collectLongArray(cursor, 0, 0,
+                __id21, longArray);
+
+        float[] floatArray = entity.getFloatArray();
+        int __id22 = floatArray != null ? __ID_floatArray : 0;
+
+        collectFloatArray(cursor, 0, 0,
+                __id22, floatArray);
+
+        double[] doubleArray = entity.getDoubleArray();
+        int __id23 = doubleArray != null ? __ID_doubleArray : 0;
+
+        collectDoubleArray(cursor, 0, 0,
+                __id23, doubleArray);
+
         String[] simpleStringArray = entity.getSimpleStringArray();
         int __id10 = simpleStringArray != null ? __ID_simpleStringArray : 0;
 
-        collectStringArray(cursor, 0, PUT_FLAG_FIRST,
+        collectStringArray(cursor, 0, 0,
                 __id10, simpleStringArray);
 
         java.util.List<String> simpleStringList = entity.getSimpleStringList();
@@ -108,17 +161,20 @@ public long put(TestEntity entity) {
                 __id9, simpleByteArray, __id15, __id15 != 0 ? stringObjectMapConverter.convertToDatabaseValue(stringObjectMap) : null,
                 __id16, __id16 != 0 ? flexPropertyConverter.convertToDatabaseValue(flexProperty) : null);
 
+        java.util.Date date = entity.getDate();
+        int __id24 = date != null ? __ID_date : 0;
+
         collect313311(cursor, 0, 0,
                 0, null, 0, null,
                 0, null, 0, null,
                 __ID_simpleLong, entity.getSimpleLong(), __ID_simpleLongU, entity.getSimpleLongU(),
-                INT_NULL_HACK ? 0 : __ID_simpleInt, entity.getSimpleInt(), __ID_simpleIntU, entity.getSimpleIntU(),
-                __ID_simpleShort, entity.getSimpleShort(), __ID_simpleShortU, entity.getSimpleShortU(),
+                __id24, __id24 != 0 ? date.getTime() : 0, INT_NULL_HACK ? 0 : __ID_simpleInt, entity.getSimpleInt(),
+                __ID_simpleIntU, entity.getSimpleIntU(), __ID_simpleShort, entity.getSimpleShort(),
                 __ID_simpleFloat, entity.getSimpleFloat(), __ID_simpleDouble, entity.getSimpleDouble());
 
         long __assignedId = collect004000(cursor, entity.getId(), PUT_FLAG_COMPLETE,
-                __ID_simpleByte, entity.getSimpleByte(), __ID_simpleBoolean, entity.getSimpleBoolean() ? 1 : 0,
-                0, 0, 0, 0);
+                __ID_simpleShortU, entity.getSimpleShortU(), __ID_simpleByte, entity.getSimpleByte(),
+                __ID_simpleBoolean, entity.getSimpleBoolean() ? 1 : 0, 0, 0);
 
         entity.setId(__assignedId);
 
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal.java
index 051d2a2f..9d37b5b7 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimalCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimalCursor.java
index 01e67968..6bfd89b7 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimalCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimalCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal_.java
index 95ec8b27..c74afa7a 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity_.java
index 4c248f28..a6e5097e 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +16,8 @@
 
 package io.objectbox;
 
+import java.util.Map;
+
 import io.objectbox.TestEntityCursor.Factory;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.converter.FlexObjectConverter;
@@ -24,9 +25,9 @@
 import io.objectbox.internal.CursorFactory;
 import io.objectbox.internal.IdGetter;
 
-import java.util.Map;
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// TestEntity.
 
-// NOTE: Copied from a plugin project (& removed some unused Properties).
 // THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
 
 /**
@@ -82,7 +83,7 @@ public final class TestEntity_ implements EntityInfo<TestEntity> {
             new io.objectbox.Property<>(__INSTANCE, 9, 10, byte[].class, "simpleByteArray");
 
     public final static io.objectbox.Property<TestEntity> simpleStringArray =
-            new io.objectbox.Property<>(__INSTANCE, 10, 11, String[].class, "simpleStringArray", false, "simpleStringArray");
+            new io.objectbox.Property<>(__INSTANCE, 10, 11, String[].class, "simpleStringArray");
 
     public final static io.objectbox.Property<TestEntity> simpleStringList =
             new io.objectbox.Property<>(__INSTANCE, 11, 15, java.util.List.class, "simpleStringList");
@@ -102,6 +103,30 @@ public final class TestEntity_ implements EntityInfo<TestEntity> {
     public final static io.objectbox.Property<TestEntity> flexProperty =
             new io.objectbox.Property<>(__INSTANCE, 16, 17, byte[].class, "flexProperty", false, "flexProperty", FlexObjectConverter.class, Object.class);
 
+    public final static io.objectbox.Property<TestEntity> booleanArray =
+            new io.objectbox.Property<>(__INSTANCE, 17, 26, boolean[].class, "booleanArray");
+
+    public final static io.objectbox.Property<TestEntity> shortArray =
+            new io.objectbox.Property<>(__INSTANCE, 18, 18, short[].class, "shortArray");
+
+    public final static io.objectbox.Property<TestEntity> charArray =
+            new io.objectbox.Property<>(__INSTANCE, 19, 19, char[].class, "charArray");
+
+    public final static io.objectbox.Property<TestEntity> intArray =
+            new io.objectbox.Property<>(__INSTANCE, 20, 20, int[].class, "intArray");
+
+    public final static io.objectbox.Property<TestEntity> longArray =
+            new io.objectbox.Property<>(__INSTANCE, 21, 21, long[].class, "longArray");
+
+    public final static io.objectbox.Property<TestEntity> floatArray =
+            new io.objectbox.Property<>(__INSTANCE, 22, 22, float[].class, "floatArray");
+
+    public final static io.objectbox.Property<TestEntity> doubleArray =
+            new io.objectbox.Property<>(__INSTANCE, 23, 23, double[].class, "doubleArray");
+
+    public final static io.objectbox.Property<TestEntity> date =
+            new io.objectbox.Property<>(__INSTANCE, 24, 24, java.util.Date.class, "date");
+
     @SuppressWarnings("unchecked")
     public final static io.objectbox.Property<TestEntity>[] __ALL_PROPERTIES = new io.objectbox.Property[]{
             id,
@@ -120,7 +145,15 @@ public final class TestEntity_ implements EntityInfo<TestEntity> {
             simpleIntU,
             simpleLongU,
             stringObjectMap,
-            flexProperty
+            flexProperty,
+            booleanArray,
+            shortArray,
+            charArray,
+            intArray,
+            longArray,
+            floatArray,
+            doubleArray,
+            date
     };
 
     public final static io.objectbox.Property<TestEntity> __ID_PROPERTY = id;
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex.java b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex.java
index 1bb9c503..290ec1dc 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndexCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndexCursor.java
index fde99d2e..20f9cc79 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndexCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndexCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex_.java
index dfa2ac1a..6b1d6341 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/MyObjectBox.java b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/MyObjectBox.java
index 3faaa9fd..29d21138 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/MyObjectBox.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/MyObjectBox.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer.java
index 8f6dc36b..7523f146 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,13 +20,19 @@
 import java.util.List;
 
 import io.objectbox.BoxStore;
+import io.objectbox.annotation.Backlink;
 import io.objectbox.annotation.Entity;
 import io.objectbox.annotation.Id;
 import io.objectbox.annotation.Index;
-import io.objectbox.annotation.apihint.Internal;
 
 /**
- * Entity mapped to table "CUSTOMER".
+ * Customer entity to test relations together with {@link Order}.
+ * <p>
+ * The annotations in this class have no effect as the Gradle plugin is not configured in this project. However, test
+ * code builds a model like if the annotations were processed.
+ * <p>
+ * There is a matching test in the internal integration test project where this is tested and model builder code can be
+ * "stolen" from.
  */
 @Entity
 public class Customer implements Serializable {
@@ -37,12 +43,16 @@ public class Customer implements Serializable {
     @Index
     private String name;
 
+    // Note: in a typical project the relation fields are initialized by the ObjectBox byte code transformer
+    // https://docs.objectbox.io/relations#initialization-magic
+
+    @Backlink(to = "customer")
     List<Order> orders = new ToMany<>(this, Customer_.orders);
 
     ToMany<Order> ordersStandalone = new ToMany<>(this, Customer_.ordersStandalone);
 
-    /** Used to resolve relations */
-    @Internal
+    // Note: in a typical project the BoxStore field is added by the ObjectBox byte code transformer
+    // https://docs.objectbox.io/relations#initialization-magic
     transient BoxStore __boxStore;
 
     public Customer() {
@@ -76,4 +86,5 @@ public List<Order> getOrders() {
     public ToMany<Order> getOrdersStandalone() {
         return ordersStandalone;
     }
+
 }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/CustomerCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/CustomerCursor.java
index 11a11b87..3b546c56 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/CustomerCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/CustomerCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,7 +22,8 @@
 import io.objectbox.Transaction;
 import io.objectbox.internal.CursorFactory;
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
 /**
  * Cursor for DB entity "Customer".
@@ -68,7 +69,7 @@ public long put(Customer entity) {
         entity.setId(__assignedId);
         entity.__boxStore = boxStoreForEntities;
 
-        checkApplyToManyToDb(entity.orders, Order.class);
+        checkApplyToManyToDb(entity.getOrders(), Order.class);
         checkApplyToManyToDb(entity.getOrdersStandalone(), Order.class);
 
         return __assignedId;
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer_.java
index bcb28f40..2889c134 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,7 +27,8 @@
 import io.objectbox.internal.ToOneGetter;
 import io.objectbox.relation.CustomerCursor.Factory;
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
 /**
  * Properties for entity "Customer". Can be used for QueryBuilder and for referencing DB names.
@@ -108,24 +108,24 @@ public long getId(Customer object) {
         }
     }
 
-    static final RelationInfo<Customer, Order> orders =
-            new RelationInfo<>(Customer_.__INSTANCE, Order_.__INSTANCE, new ToManyGetter<Customer>() {
+    public static final RelationInfo<Customer, Order> orders =
+            new RelationInfo<>(Customer_.__INSTANCE, Order_.__INSTANCE, new ToManyGetter<Customer, Order>() {
                 @Override
                 public List<Order> getToMany(Customer customer) {
                     return customer.getOrders();
                 }
-            }, Order_.customerId, new ToOneGetter<Order>() {
+            }, Order_.customerId, new ToOneGetter<Order, Customer>() {
                 @Override
                 public ToOne<Customer> getToOne(Order order) {
-                    return order.customer__toOne;
+                    return order.getCustomer();
                 }
             });
 
-    static final RelationInfo<Customer, Order> ordersStandalone =
-            new RelationInfo<>(Customer_.__INSTANCE, Order_.__INSTANCE, new ToManyGetter<Customer>() {
+    public static final RelationInfo<Customer, Order> ordersStandalone =
+            new RelationInfo<>(Customer_.__INSTANCE, Order_.__INSTANCE, new ToManyGetter<Customer, Order>() {
                 @Override
                 public List<Order> getToMany(Customer customer) {
-                    return customer.getOrders();
+                    return customer.getOrdersStandalone();
                 }
             }, 1);
 
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/MyObjectBox.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/MyObjectBox.java
index 5e6b8271..3e2ee529 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/MyObjectBox.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/MyObjectBox.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,8 +23,9 @@
 import io.objectbox.model.PropertyFlags;
 import io.objectbox.model.PropertyType;
 
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
 /**
  * Starting point for working with your ObjectBox. All boxes are set up for your objects here.
  * <p>
@@ -46,15 +47,15 @@ private static byte[] getModel() {
         modelBuilder.lastIndexId(2, 8919874872236271392L);
         modelBuilder.lastRelationId(1, 8943758920347589435L);
 
-        EntityBuilder entityBuilder;
-
-        entityBuilder = modelBuilder.entity("Customer");
+        EntityBuilder entityBuilder = modelBuilder.entity("Customer");
         entityBuilder.id(1, 8247662514375611729L).lastPropertyId(2, 7412962174183812632L);
         entityBuilder.property("_id", PropertyType.Long).id(1, 1888039726372206411L)
                 .flags(PropertyFlags.ID | PropertyFlags.ID_SELF_ASSIGNABLE);
         entityBuilder.property("name", PropertyType.String).id(2, 7412962174183812632L)
                 .flags(PropertyFlags.INDEXED).indexId(1, 5782921847050580892L);
+
         entityBuilder.relation("ordersStandalone", 1, 8943758920347589435L, 3, 6367118380491771428L);
+
         entityBuilder.entityDone();
 
 
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order.java
index 419d3cfc..6c0fc967 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,16 +18,19 @@
 
 import java.io.Serializable;
 
-import javax.annotation.Nullable;
-
 import io.objectbox.BoxStore;
 import io.objectbox.annotation.Entity;
 import io.objectbox.annotation.Id;
 import io.objectbox.annotation.NameInDb;
-import io.objectbox.annotation.apihint.Internal;
 
 /**
- * Entity mapped to table "ORDERS".
+ * Order entity to test relations together with {@link Customer}.
+ * <p>
+ * The annotations in this class have no effect as the Gradle plugin is not configured in this project. However, test
+ * code builds a model like if the annotations were processed.
+ * <p>
+ * There is a matching test in the internal integration test project where this is tested and model builder code can be
+ * "stolen" from.
  */
 @Entity
 @NameInDb("ORDERS")
@@ -39,15 +42,15 @@ public class Order implements Serializable {
     long customerId;
     String text;
 
-    private Customer customer;
+    // Note: in a typical project the relation fields are initialized by the ObjectBox byte code transformer
+    // https://docs.objectbox.io/relations#initialization-magic
+    @SuppressWarnings("FieldMayBeFinal")
+    private ToOne<Customer> customer = new ToOne<>(this, Order_.customer);
 
-    /** @Depreacted Used to resolve relations */
-    @Internal
+    // Note: in a typical project the BoxStore field is added by the ObjectBox byte code transformer
+    // https://docs.objectbox.io/relations#initialization-magic
     transient BoxStore __boxStore;
 
-    @Internal
-    transient ToOne<Customer> customer__toOne = new ToOne<>(this, Order_.customer);
-
     public Order() {
     }
 
@@ -94,20 +97,8 @@ public void setText(String text) {
         this.text = text;
     }
 
-    public Customer peekCustomer() {
+    public ToOne<Customer> getCustomer() {
         return customer;
     }
 
-    /** To-one relationship, resolved on first access. */
-    public Customer getCustomer() {
-        customer = customer__toOne.getTarget(this.customerId);
-        return customer;
-    }
-
-    /** Set the to-one relation including its ID property. */
-    public void setCustomer(@Nullable Customer customer) {
-        customer__toOne.setTarget(customer);
-        this.customer = customer;
-    }
-
 }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/OrderCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/OrderCursor.java
index d2eea268..999c664d 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/OrderCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/OrderCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,11 +18,11 @@
 
 import io.objectbox.BoxStore;
 import io.objectbox.Cursor;
-import io.objectbox.EntityInfo;
 import io.objectbox.Transaction;
 import io.objectbox.internal.CursorFactory;
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
 /**
  * Cursor for DB entity "ORDERS".
@@ -59,10 +59,11 @@ public long getId(Order entity) {
      */
     @Override
     public long put(Order entity) {
-        if(entity.customer__toOne.internalRequiresPutTarget()) {
+        ToOne<Customer> customer = entity.getCustomer();
+        if(customer != null && customer.internalRequiresPutTarget()) {
             Cursor<Customer> targetCursor = getRelationTargetCursor(Customer.class);
             try {
-                entity.customer__toOne.internalPutTarget(targetCursor);
+                customer.internalPutTarget(targetCursor);
             } finally {
                 targetCursor.close();
             }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order_.java
index 97bd5564..d6723e98 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,7 +24,8 @@
 import io.objectbox.internal.ToOneGetter;
 import io.objectbox.relation.OrderCursor.Factory;
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
 /**
  * Properties for entity "ORDERS". Can be used for QueryBuilder and for referencing DB names.
@@ -110,10 +110,10 @@ public long getId(Order object) {
         }
     }
 
-    static final RelationInfo<Order, Customer> customer = new RelationInfo<>(Order_.__INSTANCE, Customer_.__INSTANCE, customerId, new ToOneGetter<Order>() {
+    public static final RelationInfo<Order, Customer> customer = new RelationInfo<>(Order_.__INSTANCE, Customer_.__INSTANCE, customerId, new ToOneGetter<Order, Customer>() {
         @Override
         public ToOne<Customer> getToOne(Order object) {
-            return object.customer__toOne;
+            return object.getCustomer();
         }
     });
 
diff --git a/tests/objectbox-java-test/src/main/resources/testentity-index.json b/tests/objectbox-java-test/src/main/resources/testentity-index.json
deleted file mode 100644
index 27a056e1..00000000
--- a/tests/objectbox-java-test/src/main/resources/testentity-index.json
+++ /dev/null
@@ -1,87 +0,0 @@
-{
-  "id": 1,
-  "name": "TestEntity",
-  "metaVersion": 1,
-  "minMetaVersion": 1,
-  "properties": [
-    {
-      "id": 1,
-      "name": "id",
-      "entityId": 1,
-      "offset": 4,
-      "type": 6,
-      "flags": 1
-    },
-    {
-      "id": 2,
-      "name": "simpleBoolean",
-      "entityId": 1,
-      "offset": 6,
-      "type": 1
-    },
-    {
-      "id": 3,
-      "name": "simpleByte",
-      "entityId": 1,
-      "offset": 8,
-      "type": 2
-    },
-    {
-      "id": 4,
-      "name": "simpleShort",
-      "entityId": 1,
-      "offset": 10,
-      "type": 3
-    },
-    {
-      "id": 5,
-      "name": "simpleInt",
-      "entityId": 1,
-      "offset": 12,
-      "type": 5
-    },
-    {
-      "id": 6,
-      "name": "simpleLong",
-      "entityId": 1,
-      "offset": 14,
-      "type": 6
-    },
-    {
-      "id": 7,
-      "name": "simpleFloat",
-      "entityId": 1,
-      "offset": 16,
-      "type": 7
-    },
-    {
-      "id": 8,
-      "name": "simpleDouble",
-      "entityId": 1,
-      "offset": 18,
-      "type": 8
-    },
-    {
-      "id": 9,
-      "name": "simpleString",
-      "entityId": 1,
-      "offset": 20,
-      "type": 9
-    },
-    {
-      "id": 10,
-      "name": "simpleByteArray",
-      "entityId": 1,
-      "offset": 22,
-      "type": 23
-    }
-  ],
-  "indexes": [
-    {
-      "id": 1,
-      "name": "myIndex",
-      "entityId": 1,
-      "propertyIds": [9]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/main/resources/testentity.json b/tests/objectbox-java-test/src/main/resources/testentity.json
deleted file mode 100644
index ea68c75d..00000000
--- a/tests/objectbox-java-test/src/main/resources/testentity.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
-  "id": 1,
-  "name": "TestEntity",
-  "metaVersion": 1,
-  "minMetaVersion": 1,
-  "properties": [
-    {
-      "id": 1,
-      "name": "id",
-      "entityId": 1,
-      "offset": 4,
-      "type": 6,
-      "flags": 1
-    },
-    {
-      "id": 2,
-      "name": "simpleBoolean",
-      "entityId": 1,
-      "offset": 6,
-      "type": 1
-    },
-    {
-      "id": 3,
-      "name": "simpleByte",
-      "entityId": 1,
-      "offset": 8,
-      "type": 2
-    },
-    {
-      "id": 4,
-      "name": "simpleShort",
-      "entityId": 1,
-      "offset": 10,
-      "type": 3
-    },
-    {
-      "id": 5,
-      "name": "simpleInt",
-      "entityId": 1,
-      "offset": 12,
-      "type": 5
-    },
-    {
-      "id": 6,
-      "name": "simpleLong",
-      "entityId": 1,
-      "offset": 14,
-      "type": 6
-    },
-    {
-      "id": 7,
-      "name": "simpleFloat",
-      "entityId": 1,
-      "offset": 16,
-      "type": 7
-    },
-    {
-      "id": 8,
-      "name": "simpleDouble",
-      "entityId": 1,
-      "offset": 18,
-      "type": 8
-    },
-    {
-      "id": 9,
-      "name": "simpleString",
-      "entityId": 1,
-      "offset": 20,
-      "type": 9
-    },
-    {
-      "id": 10,
-      "name": "simpleByteArray",
-      "entityId": 1,
-      "offset": 22,
-      "type": 23
-    }
-  ]
-}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/AbstractObjectBoxTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/AbstractObjectBoxTest.java
index 365d7c5d..b6ce316a 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/AbstractObjectBoxTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/AbstractObjectBoxTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,15 +16,9 @@
 
 package io.objectbox;
 
-import io.objectbox.ModelBuilder.EntityBuilder;
-import io.objectbox.ModelBuilder.PropertyBuilder;
-import io.objectbox.annotation.IndexType;
-import io.objectbox.model.PropertyFlags;
-import io.objectbox.model.PropertyType;
 import org.junit.After;
 import org.junit.Before;
 
-import javax.annotation.Nullable;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
@@ -32,14 +26,27 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Random;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Stream;
 
+import javax.annotation.Nullable;
+
+import io.objectbox.ModelBuilder.EntityBuilder;
+import io.objectbox.ModelBuilder.PropertyBuilder;
+import io.objectbox.annotation.IndexType;
+import io.objectbox.config.DebugFlags;
+import io.objectbox.model.PropertyFlags;
+import io.objectbox.model.PropertyType;
+import io.objectbox.query.InternalAccess;
+
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -50,6 +57,11 @@ public abstract class AbstractObjectBoxTest {
      * Turns on additional log output, including logging of transactions or query parameters.
      */
     protected static final boolean DEBUG_LOG = false;
+
+    /**
+     * If instead of files the database should be in memory.
+     */
+    protected static final boolean IN_MEMORY = Objects.equals(System.getProperty("obx.inMemory"), "true");
     private static boolean printedVersionsOnce;
 
     protected File boxStoreDir;
@@ -80,6 +92,7 @@ static void printProcessId() {
     public void setUp() throws IOException {
         Cursor.TRACK_CREATION_STACK = true;
         Transaction.TRACK_CREATION_STACK = true;
+        InternalAccess.queryPublisherLogStates();
 
         // Note: is logged, so create before logging.
         boxStoreDir = prepareTempDir("object-store-test");
@@ -87,10 +100,12 @@ public void setUp() throws IOException {
         if (!printedVersionsOnce) {
             printedVersionsOnce = true;
             printProcessId();
-            System.out.println("ObjectBox Java version: " + BoxStore.getVersion());
-            System.out.println("ObjectBox Core version: " + BoxStore.getVersionNative());
+            System.out.println("ObjectBox Java SDK version: " + BoxStore.getVersion());
+            System.out.println("ObjectBox Database version: " + BoxStore.getVersionNative());
             System.out.println("First DB dir: " + boxStoreDir);
+            System.out.println("IN_MEMORY=" + IN_MEMORY);
             System.out.println("java.version=" + System.getProperty("java.version"));
+            System.out.println("java.vendor=" + System.getProperty("java.vendor"));
             System.out.println("file.encoding=" + System.getProperty("file.encoding"));
             System.out.println("sun.jnu.encoding=" + System.getProperty("sun.jnu.encoding"));
         }
@@ -103,11 +118,19 @@ public void setUp() throws IOException {
      * This works with Android without needing any context.
      */
     protected File prepareTempDir(String prefix) throws IOException {
-        File tempFile = File.createTempFile(prefix, "");
-        if (!tempFile.delete()) {
-            throw new IOException("Could not prep temp dir; file delete failed for " + tempFile.getAbsolutePath());
+        if (IN_MEMORY) {
+            // Instead of random temp directory, use random suffix for each test to avoid re-using existing database
+            // from other tests in case clean-up fails.
+            // Note: tearDown code will still work as the directory does not exist.
+            String randomPart = Long.toUnsignedString(random.nextLong());
+            return new File(BoxStore.IN_MEMORY_PREFIX + prefix + randomPart);
+        } else {
+            File tempFile = File.createTempFile(prefix, "");
+            if (!tempFile.delete()) {
+                throw new IOException("Could not prep temp dir; file delete failed for " + tempFile.getAbsolutePath());
+            }
+            return tempFile;
         }
-        return tempFile;
     }
 
     protected BoxStore createBoxStore() {
@@ -139,9 +162,9 @@ protected Box<TestEntity> getTestEntityBox() {
 
     @After
     public void tearDown() {
-        // Collect dangling Cursors and TXs before store closes
-        System.gc();
-        System.runFinalization();
+        // Note: do not collect dangling Cursors and Transactions before store closes (using System.gc()
+        // or System.runFinalization()). Tests should mirror user code and do that themselves (calling close())
+        // or rely on the library (through finalizers or BoxStore.close()).
 
         if (store != null) {
             try {
@@ -158,10 +181,13 @@ public void tearDown() {
                 logError("Could not clean up test", e);
             }
         }
-        deleteAllFiles(boxStoreDir);
+        cleanUpAllFiles(boxStoreDir);
     }
 
-    protected void deleteAllFiles(@Nullable File boxStoreDir) {
+    /**
+     * Manually clean up any leftover files to prevent interference with other tests.
+     */
+    protected void cleanUpAllFiles(@Nullable File boxStoreDir) {
         if (boxStoreDir != null && boxStoreDir.exists()) {
             try (Stream<Path> stream = Files.walk(boxStoreDir.toPath())) {
                 stream.sorted(Comparator.reverseOrder())
@@ -216,6 +242,13 @@ byte[] createTestModelWithTwoEntities(boolean withIndex) {
         return modelBuilder.build();
     }
 
+    /**
+     * When not using the {@link #store} of this to create a builder with the default test model.
+     */
+    protected BoxStoreBuilder createBuilderWithTestModel() {
+        return new BoxStoreBuilder(createTestModel(null));
+    }
+
     private void addTestEntity(ModelBuilder modelBuilder, @Nullable IndexType simpleStringIndexType) {
         lastEntityUid = ++lastUid;
         EntityBuilder entityBuilder = modelBuilder.entity("TestEntity").id(++lastEntityId, lastEntityUid);
@@ -262,7 +295,19 @@ private void addTestEntity(ModelBuilder modelBuilder, @Nullable IndexType simple
                 .id(TestEntity_.stringObjectMap.id, ++lastUid);
         entityBuilder.property("flexProperty", PropertyType.Flex).id(TestEntity_.flexProperty.id, ++lastUid);
 
-        int lastId = TestEntity_.flexProperty.id;
+        // Integer and floating point arrays
+        entityBuilder.property("booleanArray", PropertyType.BoolVector).id(TestEntity_.booleanArray.id, ++lastUid);
+        entityBuilder.property("shortArray", PropertyType.ShortVector).id(TestEntity_.shortArray.id, ++lastUid);
+        entityBuilder.property("charArray", PropertyType.CharVector).id(TestEntity_.charArray.id, ++lastUid);
+        entityBuilder.property("intArray", PropertyType.IntVector).id(TestEntity_.intArray.id, ++lastUid);
+        entityBuilder.property("longArray", PropertyType.LongVector).id(TestEntity_.longArray.id, ++lastUid);
+        entityBuilder.property("floatArray", PropertyType.FloatVector).id(TestEntity_.floatArray.id, ++lastUid);
+        entityBuilder.property("doubleArray", PropertyType.DoubleVector).id(TestEntity_.doubleArray.id, ++lastUid);
+
+        // Date property
+        entityBuilder.property("date", PropertyType.Date).id(TestEntity_.date.id, ++lastUid);
+        int lastId = TestEntity_.date.id;
+
         entityBuilder.lastPropertyId(lastId, lastUid);
         addOptionalFlagsToTestEntity(entityBuilder);
         entityBuilder.entityDone();
@@ -287,36 +332,51 @@ private void addTestEntityMinimal(ModelBuilder modelBuilder, boolean withIndex)
     }
 
     protected TestEntity createTestEntity(@Nullable String simpleString, int nr) {
+        boolean simpleBoolean = nr % 2 == 0;
+        short simpleShort = (short) (100 + nr);
+        int simpleLong = 1000 + nr;
+        float simpleFloat = 200 + nr / 10f;
+        double simpleDouble = 2000 + nr / 100f;
+        byte[] simpleByteArray = {1, 2, (byte) nr};
+        String[] simpleStringArray = {simpleString};
+
         TestEntity entity = new TestEntity();
         entity.setSimpleString(simpleString);
         entity.setSimpleInt(nr);
         entity.setSimpleByte((byte) (10 + nr));
-        entity.setSimpleBoolean(nr % 2 == 0);
-        entity.setSimpleShort((short) (100 + nr));
-        entity.setSimpleLong(1000 + nr);
-        entity.setSimpleFloat(200 + nr / 10f);
-        entity.setSimpleDouble(2000 + nr / 100f);
-        entity.setSimpleByteArray(new byte[]{1, 2, (byte) nr});
-        String[] stringArray = {simpleString};
-        entity.setSimpleStringArray(stringArray);
-        entity.setSimpleStringList(Arrays.asList(stringArray));
-        entity.setSimpleShortU((short) (100 + nr));
+        entity.setSimpleBoolean(simpleBoolean);
+        entity.setSimpleShort(simpleShort);
+        entity.setSimpleLong(simpleLong);
+        entity.setSimpleFloat(simpleFloat);
+        entity.setSimpleDouble(simpleDouble);
+        entity.setSimpleByteArray(simpleByteArray);
+        entity.setSimpleStringArray(simpleStringArray);
+        entity.setSimpleStringList(Arrays.asList(simpleStringArray));
+        entity.setSimpleShortU(simpleShort);
         entity.setSimpleIntU(nr);
-        entity.setSimpleLongU(1000 + nr);
+        entity.setSimpleLongU(simpleLong);
         if (simpleString != null) {
             Map<String, Object> stringObjectMap = new HashMap<>();
             stringObjectMap.put(simpleString, simpleString);
             entity.setStringObjectMap(stringObjectMap);
         }
         entity.setFlexProperty(simpleString);
+        entity.setBooleanArray(new boolean[]{simpleBoolean, false, true});
+        entity.setShortArray(new short[]{(short) -(100 + nr), simpleShort});
+        entity.setCharArray(simpleString != null ? simpleString.toCharArray() : null);
+        entity.setIntArray(new int[]{-nr, nr});
+        entity.setLongArray(new long[]{-simpleLong, simpleLong});
+        entity.setFloatArray(new float[]{-simpleFloat, simpleFloat});
+        entity.setDoubleArray(new double[]{-simpleDouble, simpleDouble});
+        entity.setDate(new Date(simpleLong));
         return entity;
     }
 
     protected TestEntity putTestEntity(@Nullable String simpleString, int nr) {
         TestEntity entity = createTestEntity(simpleString, nr);
-        long key = getTestEntityBox().put(entity);
-        assertTrue(key != 0);
-        assertEquals(key, entity.getId());
+        long id = getTestEntityBox().put(entity);
+        assertTrue(id != 0);
+        assertEquals(id, entity.getId());
         return entity;
     }
 
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java
index 31fd64b8..19f464a7 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,35 +16,40 @@
 
 package io.objectbox;
 
-import io.objectbox.exception.PagesCorruptException;
-import io.objectbox.model.ValidateOnOpenMode;
-import org.greenrobot.essentials.io.IoUtils;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.io.File;
-import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import io.objectbox.exception.DbFullException;
+import io.objectbox.exception.DbMaxDataSizeExceededException;
+
+
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
 
 public class BoxStoreBuilderTest extends AbstractObjectBoxTest {
 
     private BoxStoreBuilder builder;
 
+    private static final String LONG_STRING = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+
     @Override
     protected BoxStore createBoxStore() {
         // Standard setup of store not required
@@ -54,7 +59,7 @@ protected BoxStore createBoxStore() {
     @Before
     public void setUpBuilder() {
         BoxStore.clearDefaultStore();
-        builder = new BoxStoreBuilder(createTestModel(null)).directory(boxStoreDir);
+        builder = createBuilderWithTestModel().directory(boxStoreDir);
     }
 
     @Test
@@ -118,7 +123,73 @@ public void directoryUnicodePath() throws IOException {
             }
         }
 
-        deleteAllFiles(parentTestDir);
+        cleanUpAllFiles(parentTestDir);
+    }
+
+    @Test
+    public void directoryConflictingOptionsError() {
+        // using conflicting option after directory option
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .directory(boxStoreDir)
+                .name("options-test")
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .directory(boxStoreDir)
+                .baseDirectory(boxStoreDir)
+        );
+
+        // using directory option after conflicting option
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .name("options-test")
+                .directory(boxStoreDir)
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .baseDirectory(boxStoreDir)
+                .directory(boxStoreDir)
+        );
+    }
+
+    @Test
+    public void inMemoryConflictingOptionsError() {
+        // directory-based option after switching to in-memory
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .inMemory("options-test")
+                .name("options-test")
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .inMemory("options-test")
+                .directory(boxStoreDir)
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .inMemory("options-test")
+                .baseDirectory(boxStoreDir)
+        );
+
+        // in-memory after specifying directory-based option
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .name("options-test")
+                .inMemory("options-test")
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .directory(boxStoreDir)
+                .inMemory("options-test")
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .baseDirectory(boxStoreDir)
+                .inMemory("options-test")
+        );
+    }
+
+    @Test
+    public void inMemoryCreatesNoFiles() {
+        // let base class clean up store in tearDown method
+        store = createBuilderWithTestModel().inMemory("in-memory-test").build();
+
+        assertFalse(boxStoreDir.exists());
+        assertFalse(new File("memory").exists());
+        assertFalse(new File("memory:").exists());
+        String identifierPart = boxStoreDir.getPath().substring("memory:".length());
+        assertFalse(new File(identifierPart).exists());
     }
 
     @Test
@@ -168,88 +239,108 @@ public void readOnly() {
     }
 
     @Test
-    public void validateOnOpen() {
-        // Create a database first; we must create the model only once (ID/UID sequences would be different 2nd time)
-        byte[] model = createTestModel(null);
-        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
-        builder.entity(new TestEntity_());
-        store = builder.build();
+    public void maxSize_invalidValues_throw() {
+        // Max data larger than max database size throws.
+        builder.maxSizeInKByte(10);
+        IllegalArgumentException exSmaller = assertThrows(
+                IllegalArgumentException.class,
+                () -> builder.maxDataSizeInKByte(11)
+        );
+        assertEquals("maxDataSizeInKByte must be smaller than maxSizeInKByte.", exSmaller.getMessage());
 
-        TestEntity object = new TestEntity(0);
-        object.setSimpleString("hello hello");
-        long id = getTestEntityBox().put(object);
-        store.close();
-
-        // Then re-open database with validation and ensure db is operational
-        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
-        builder.entity(new TestEntity_());
-        builder.validateOnOpen(ValidateOnOpenMode.Full);
-        store = builder.build();
-        assertNotNull(getTestEntityBox().get(id));
-        getTestEntityBox().put(new TestEntity(0));
+        // Max database size smaller than max data size throws.
+        builder.maxDataSizeInKByte(9);
+        IllegalArgumentException exLarger = assertThrows(
+                IllegalArgumentException.class,
+                () -> builder.maxSizeInKByte(8)
+        );
+        assertEquals("maxSizeInKByte must be larger than maxDataSizeInKByte.", exLarger.getMessage());
     }
 
+    @Test
+    public void maxFileSize() {
+        assumeFalse(IN_MEMORY); // no max size support for in-memory
+
+        // To avoid frequently changing the limit choose one high enough to insert at least one object successfully,
+        // then keep inserting until the limit is hit.
+        builder = createBoxStoreBuilder(null);
+        builder.maxSizeInKByte(150);
+        store = builder.build();
 
-    @Test(expected = PagesCorruptException.class)
-    public void validateOnOpenCorruptFile() throws IOException {
-        File dir = prepareTempDir("object-store-test-corrupted");
-        File badDataFile = prepareBadDataFile(dir);
+        putTestEntity(LONG_STRING, 1); // Should work
 
-        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
-        builder.validateOnOpen(ValidateOnOpenMode.Full);
-        try {
-            store = builder.build();
-        } finally {
-            boolean delOk = badDataFile.delete();
-            delOk &= new File(dir, "lock.mdb").delete();
-            delOk &= dir.delete();
-            assertTrue(delOk);  // Try to delete all before asserting
+        boolean dbFullExceptionThrown = false;
+        for (int i = 2; i < 1000; i++) {
+            TestEntity testEntity = createTestEntity(LONG_STRING, i);
+            try {
+                getTestEntityBox().put(testEntity);
+            } catch (DbFullException e) {
+                dbFullExceptionThrown = true;
+                break;
+            }
         }
+        assertTrue("DbFullException was not thrown",  dbFullExceptionThrown);
+
+        // Check re-opening with larger size allows to insert again
+        store.close();
+        builder.maxSizeInKByte(200);
+        store = builder.build();
+        getTestEntityBox().put(createTestEntity(LONG_STRING, 1000));
     }
 
     @Test
-    public void usePreviousCommitWithCorruptFile() throws IOException {
-        File dir = prepareTempDir("object-store-test-corrupted");
-        prepareBadDataFile(dir);
-        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
-        builder.validateOnOpen(ValidateOnOpenMode.Full).usePreviousCommit();
+    public void maxDataSize() {
+        builder = createBoxStoreBuilder(null);
+        builder.maxDataSizeInKByte(1);
         store = builder.build();
-        String diagnoseString = store.diagnose();
-        assertTrue(diagnoseString.contains("entries=2"));
-        store.validate(0, true);
+
+        // Put until max data size is reached
+        TestEntity testEntity1 = putTestEntity(LONG_STRING, 1);
+        TestEntity testEntity2 = createTestEntity(LONG_STRING, 2);
+        DbMaxDataSizeExceededException maxDataExc = assertThrows(
+                DbMaxDataSizeExceededException.class,
+                () -> getTestEntityBox().put(testEntity2)
+        );
+        assertEquals("Exceeded user-set maximum by [bytes]: 560", maxDataExc.getMessage());
+
+        // Remove to get below max data size, then put again.
+        getTestEntityBox().remove(testEntity1);
+        getTestEntityBox().put(testEntity2);
+
+        // Alternatively, re-open with larger max data size.
         store.close();
-        assertTrue(store.deleteAllFiles());
+        builder.maxDataSizeInKByte(2);
+        store = builder.build();
+        putTestEntity(LONG_STRING, 3);
     }
 
+
     @Test
-    public void usePreviousCommitAfterFileCorruptException() throws IOException {
-        File dir = prepareTempDir("object-store-test-corrupted");
-        prepareBadDataFile(dir);
-        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
-        builder.validateOnOpen(ValidateOnOpenMode.Full);
-        try {
-            store = builder.build();
-            fail("Should have thrown");
-        } catch (PagesCorruptException e) {
-            builder.usePreviousCommit();
-            store = builder.build();
-        }
+    public void testCreateClone() {
+        builder = createBoxStoreBuilder(null);
+        store = builder.build();
+        putTestEntity(LONG_STRING, 1);
 
-        String diagnoseString = store.diagnose();
-        assertTrue(diagnoseString.contains("entries=2"));
-        store.validate(0, true);
-        store.close();
-        assertTrue(store.deleteAllFiles());
-    }
+        BoxStoreBuilder clonedBuilder = builder.createClone("-cloned");
+        assertEquals(clonedBuilder.directory.getAbsolutePath(), boxStoreDir.getAbsolutePath() + "-cloned");
 
-    private File prepareBadDataFile(File dir) throws IOException {
-        assertTrue(dir.mkdir());
-        File badDataFile = new File(dir, "data.mdb");
-        try (InputStream badIn = getClass().getResourceAsStream("corrupt-pageno-in-branch-data.mdb")) {
-            try (FileOutputStream badOut = new FileOutputStream(badDataFile)) {
-                IoUtils.copyAllBytes(badIn, badOut);
-            }
-        }
-        return badDataFile;
+        BoxStore clonedStore = clonedBuilder.build();
+        assertNotNull(clonedStore);
+        assertNotSame(store, clonedStore);
+        assertArrayEquals(store.getAllEntityTypeIds(), clonedStore.getAllEntityTypeIds());
+
+        Box<TestEntity> boxOriginal = store.boxFor(TestEntity.class);
+        assertEquals(1, boxOriginal.count());
+        Box<TestEntity> boxClone = clonedStore.boxFor(TestEntity.class);
+        assertEquals(0, boxClone.count());
+
+        boxClone.put(createTestEntity("I'm a clone", 2));
+        boxClone.put(createTestEntity("I'm a clone, too", 3));
+        assertEquals(2, boxClone.count());
+        assertEquals(1, boxOriginal.count());
+
+        store.close();
+        clonedStore.close();
+        clonedStore.deleteAllFiles();
     }
 }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreLogTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreLogTest.java
new file mode 100644
index 00000000..4ed1a932
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreLogTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2024 ObjectBox Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox;
+
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.IndexType;
+
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Sets a custom error output stream to assert log messages of {@link BoxStore}.
+ */
+public class BoxStoreLogTest extends AbstractObjectBoxTest {
+
+    private ByteArrayOutputStream errOutput;
+
+    @Override
+    protected BoxStoreBuilder createBoxStoreBuilder(@Nullable IndexType simpleStringIndexType) {
+        BoxStoreBuilder builder = super.createBoxStoreBuilder(simpleStringIndexType);
+        errOutput = new ByteArrayOutputStream();
+        builder.setErrorOutput(new PrintStream(errOutput));
+        return builder;
+    }
+
+    @Test
+    public void close_activeThreadPool_printsError() throws UnsupportedEncodingException {
+        // Submit two threads, one to the internal pool, that run longer
+        // than BoxStore.close waits on the pool to terminate
+        new Thread(() -> {
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException ignored) {
+            }
+        }).start();
+        store.internalScheduleThread(() -> {
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException ignored) {
+            }
+        });
+        // Close store to trigger thread pool shutdown, store waits 1 second for shutdown
+        store.close();
+
+        String errOutput = this.errOutput.toString("UTF-8");
+        assertTrue(errOutput.contains("ObjectBox thread pool not terminated in time"));
+        assertTrue(errOutput.contains("=== BEGIN OF DUMP ==="));
+        assertTrue(errOutput.contains("=== END OF DUMP ==="));
+        // Check that only pool threads or threads with stack traces that contain the objectbox package are printed
+        String[] lines = errOutput.split("\n");
+        String checkStackTrace = null;
+        for (String line : lines) {
+            if (line.startsWith("Thread:")) {
+                if (checkStackTrace != null) {
+                    fail("Expected stack trace to contain class in objectbox package");
+                }
+                if (!line.contains("ObjectBox-")) {
+                    checkStackTrace = line;
+                }
+            } else if (checkStackTrace != null) {
+                if (line.contains("objectbox")) {
+                    checkStackTrace = null;
+                }
+            }
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java
index 37d5fb3a..27fd8d74 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@
 
 package io.objectbox;
 
-import io.objectbox.exception.DbException;
 import org.junit.Test;
 import org.junit.function.ThrowingRunnable;
 
@@ -24,6 +23,9 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.RejectedExecutionException;
 
+import io.objectbox.exception.DbException;
+
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -32,6 +34,7 @@
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
 
 public class BoxStoreTest extends AbstractObjectBoxTest {
 
@@ -110,7 +113,8 @@ public void testClose() {
         store.setSyncClient(null);
 
         // Methods using the native store should throw.
-        assertThrowsStoreIsClosed(store::sizeOnDisk);
+        assertThrowsStoreIsClosed(store::getDbSize);
+        assertThrowsStoreIsClosed(store::getDbSizeOnDisk);
         assertThrowsStoreIsClosed(store::beginTx);
         assertThrowsStoreIsClosed(store::beginReadTx);
         assertThrowsStoreIsClosed(store::isReadOnly);
@@ -136,7 +140,7 @@ public void testClose() {
         assertThrowsStoreIsClosed(() -> store.subscribe(TestEntity.class));
         assertThrowsStoreIsClosed(store::startObjectBrowser);
         assertThrowsStoreIsClosed(() -> store.startObjectBrowser(12345));
-        assertThrowsStoreIsClosed(() -> store.startObjectBrowser(""));
+        assertThrowsStoreIsClosed(() -> store.startObjectBrowser("http://127.0.0.1"));
         // assertThrowsStoreIsClosed(store::stopObjectBrowser); // Requires mocking, not testing for now.
         assertThrowsStoreIsClosed(() -> store.setDbExceptionListener(null));
         // Internal thread pool is shut down as part of closing store, should no longer accept new work.
@@ -169,23 +173,40 @@ public void openSamePath_afterClose_works() {
         assertEquals(0, BoxStore.nativeGloballyActiveEntityTypes());
     }
 
+    @Test
+    public void openSamePath_closedByFinalizer_works() {
+        System.out.println("Removing reference to " + store);
+        store = null;
+
+        // When another Store is still open using the same path, a checker thread is started that periodically triggers
+        // garbage collection and finalization in the VM, which here should close store and allow store2 to be opened.
+        // Note that user code should not rely on this, see notes on BoxStore.finalize().
+        BoxStore store2 = createBoxStore();
+        store2.close();
+        System.out.println("Closed " + store2);
+    }
+
     @Test
     public void testOpenTwoBoxStoreTwoFiles() {
         File boxStoreDir2 = new File(boxStoreDir.getAbsolutePath() + "-2");
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(null)).directory(boxStoreDir2);
+        BoxStoreBuilder builder = createBuilderWithTestModel().directory(boxStoreDir2);
         builder.entity(new TestEntity_());
     }
 
     @Test
     public void testDeleteAllFiles() {
+        // Note: for in-memory can not really assert database is gone,
+        // e.g. using sizeOnDisk is not possible after closing the store from Java.
         closeStoreForTest();
     }
 
     @Test
     public void testDeleteAllFiles_staticDir() {
+        assumeFalse(IN_MEMORY);
         closeStoreForTest();
+
         File boxStoreDir2 = new File(boxStoreDir.getAbsolutePath() + "-2");
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(null)).directory(boxStoreDir2);
+        BoxStoreBuilder builder = createBuilderWithTestModel().directory(boxStoreDir2);
         BoxStore store2 = builder.build();
         store2.close();
 
@@ -196,6 +217,8 @@ public void testDeleteAllFiles_staticDir() {
 
     @Test
     public void testDeleteAllFiles_baseDirName() {
+        assumeFalse(IN_MEMORY);
+
         closeStoreForTest();
         File basedir = new File("test-base-dir");
         String name = "mydb";
@@ -208,7 +231,7 @@ public void testDeleteAllFiles_baseDirName() {
         File dbDir = new File(basedir, name);
         assertFalse(dbDir.exists());
 
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(null)).baseDirectory(basedir).name(name);
+        BoxStoreBuilder builder = createBuilderWithTestModel().baseDirectory(basedir).name(name);
         BoxStore store2 = builder.build();
         store2.close();
 
@@ -245,7 +268,9 @@ public void removeAllObjects() {
     }
 
     private void closeStoreForTest() {
-        assertTrue(boxStoreDir.exists());
+        if (!IN_MEMORY) {
+            assertTrue(boxStoreDir.exists());
+        }
         store.close();
         assertTrue(store.deleteAllFiles());
         assertFalse(boxStoreDir.exists());
@@ -271,7 +296,7 @@ public void testCallInReadTxWithRetry_callback() {
         final int[] countHolder = {0};
         final int[] countHolderCallback = {0};
 
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(null)).directory(boxStoreDir)
+        BoxStoreBuilder builder = createBuilderWithTestModel().directory(boxStoreDir)
                 .failedReadTxAttemptCallback((result, error) -> {
                     assertNotNull(error);
                     countHolderCallback[0]++;
@@ -295,22 +320,32 @@ private Callable<String> createTestCallable(final int[] countHolder) {
 
     @Test
     public void testSizeOnDisk() {
-        long size = store.sizeOnDisk();
-        assertTrue(size >= 8192);
+        // Note: initial database does have a non-zero (file) size.
+        assertTrue(store.getDbSize() > 0);
+
+        long sizeOnDisk = store.getDbSizeOnDisk();
+        // Check the file size is at least a reasonable value
+        assertTrue("Size is not reasonable", IN_MEMORY ? sizeOnDisk == 0 : sizeOnDisk > 10000 /* 10 KB */);
+
+        // Check the file size increases after inserting
+        putTestEntities(10);
+        long sizeOnDiskAfterPut = store.getDbSizeOnDisk();
+        assertTrue("Size did not increase", IN_MEMORY ? sizeOnDiskAfterPut == 0 : sizeOnDiskAfterPut > sizeOnDisk);
     }
 
     @Test
     public void validate() {
         putTestEntities(100);
 
+        // Note: not implemented for in-memory, returns 0.
         // No limit.
         long validated = store.validate(0, true);
-        assertEquals(9, validated);
+        assertTrue(IN_MEMORY ? validated == 0 : validated > 2 /* must be larger than with pageLimit == 1, see below */);
 
         // With limit.
         validated = store.validate(1, true);
         // 2 because the first page doesn't contain any actual data?
-        assertEquals(2, validated);
+        assertEquals(IN_MEMORY ? 0 : 2, validated);
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTestK.kt b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTestK.kt
index 462810b0..116998ac 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTestK.kt
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTestK.kt
@@ -2,10 +2,14 @@ package io.objectbox
 
 import io.objectbox.kotlin.awaitCallInTx
 import io.objectbox.kotlin.boxFor
-import kotlinx.coroutines.ExperimentalCoroutinesApi
+import io.objectbox.kotlin.newCachedThreadPoolDispatcher
+import io.objectbox.kotlin.newFixedThreadPoolDispatcher
+import kotlinx.coroutines.ExecutorCoroutineDispatcher
 import kotlinx.coroutines.test.runTest
-import org.junit.Assert.assertEquals
+import kotlinx.coroutines.withContext
+import org.junit.Assert.*
 import org.junit.Test
+import java.util.concurrent.Executors
 
 
 class BoxStoreTestK : AbstractObjectBoxTest() {
@@ -24,7 +28,6 @@ class BoxStoreTestK : AbstractObjectBoxTest() {
         assertEquals(boxJavaApi, box2)
     }
 
-    @ExperimentalCoroutinesApi
     @Test
     fun awaitCallInTx() {
         val box = store.boxFor<TestEntity>()
@@ -42,4 +45,66 @@ class BoxStoreTestK : AbstractObjectBoxTest() {
             assertEquals("Hello", note!!.simpleString)
         }
     }
+
+    /**
+     * This appears to duplicate [ObjectBoxThreadPoolExecutorTest.executor_cleansThreadResources], however,
+     * this makes sure that a coroutine continues to be executed like a runnable and clean up of
+     * [ObjectBoxThreadPoolExecutor] continues to work in this case.
+     */
+    @Test
+    fun dispatcherBackedByObjectBoxExecutor_cleansThreadResources() {
+        runTest {
+            // Use a single thread to make it easy to check thread-local Box resources have been cleaned up
+            val dispatcher = store.newFixedThreadPoolDispatcher(1)
+
+            val hasReaderCursor = withContext(dispatcher) {
+                val box = store.boxFor<TestEntity>()
+                val entity = createTestEntity("dispatcher-test", 1)
+                val id = box.put(entity)
+                box.get(id)
+                box.hasReaderCursorForCurrentThread()
+            }
+            // Verify that a thread-local reader cursor was created
+            assertTrue(hasReaderCursor)
+
+            // Check the thread-local reader cursor was released after the previous coroutine was executed
+            val hasReaderCursorAfter = withContext(dispatcher) {
+                store.boxFor<TestEntity>().hasReaderCursorForCurrentThread()
+            }
+            assertFalse(hasReaderCursorAfter)
+        }
+    }
+
+    @Test
+    fun newCachedThreadPoolDispatcher_works() {
+        runTest {
+            assertDispatcher(store.newCachedThreadPoolDispatcher())
+            assertDispatcher(store.newCachedThreadPoolDispatcher(Executors.defaultThreadFactory()))
+        }
+    }
+
+    @Test
+    fun newFixedThreadPoolDispatcher_works() {
+        runTest {
+            assertDispatcher(store.newFixedThreadPoolDispatcher(2))
+            assertDispatcher(store.newFixedThreadPoolDispatcher(2, Executors.defaultThreadFactory()))
+        }
+    }
+
+    /**
+     * Quickly checks the pre-configured dispatchers work.
+     */
+    private suspend fun assertDispatcher(dispatcher: ExecutorCoroutineDispatcher) {
+        dispatcher.use { dispatcher ->
+            // Create at least a write and a read transaction
+            val testEntity: TestEntity? = withContext(dispatcher) {
+                val box = store.boxFor<TestEntity>()
+                val entity = createTestEntity("dispatcher-test", 1)
+                val id = box.put(entity)
+
+                box.get(id)
+            }
+            assertEquals("dispatcher-test", testEntity!!.simpleString)
+        }
+    }
 }
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreValidationTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreValidationTest.java
new file mode 100644
index 00000000..88e5e28c
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreValidationTest.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright 2023-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox;
+
+import org.greenrobot.essentials.io.IoUtils;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import io.objectbox.config.ValidateOnOpenModePages;
+import io.objectbox.exception.FileCorruptException;
+import io.objectbox.exception.PagesCorruptException;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
+
+/**
+ * Tests validation (and recovery) options on opening a store.
+ */
+public class BoxStoreValidationTest extends AbstractObjectBoxTest {
+
+    private BoxStoreBuilder builder;
+
+    @Override
+    protected BoxStore createBoxStore() {
+        // Standard setup of store not required
+        return null;
+    }
+
+    @Before
+    public void setUpBuilder() {
+        BoxStore.clearDefaultStore();
+        builder = createBuilderWithTestModel().directory(boxStoreDir);
+    }
+
+    @Test
+    public void validateOnOpen() {
+        // Create a database first; we must create the model only once (ID/UID sequences would be different 2nd time)
+        byte[] model = createTestModel(null);
+        long id = buildNotCorruptedDatabase(model);
+
+        // Then re-open database with validation and ensure db is operational
+        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
+        builder.entity(new TestEntity_());
+        builder.validateOnOpen(ValidateOnOpenModePages.Full);
+        store = builder.build();
+        assertNotNull(getTestEntityBox().get(id));
+        getTestEntityBox().put(new TestEntity(0));
+    }
+
+
+    @Test
+    public void validateOnOpenCorruptFile() throws IOException {
+        assumeFalse(IN_MEMORY);
+
+        File dir = prepareTempDir("object-store-test-corrupted");
+        prepareBadDataFile(dir, "corrupt-pageno-in-branch-data.mdb");
+
+        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
+        builder.validateOnOpen(ValidateOnOpenModePages.Full);
+
+        @SuppressWarnings("resource")
+        FileCorruptException ex = assertThrows(PagesCorruptException.class, () -> builder.build());
+        assertEquals("Validating pages failed (page not found)", ex.getMessage());
+
+        // Clean up
+        cleanUpAllFiles(dir);
+    }
+
+    @Test
+    public void usePreviousCommitWithCorruptFile() throws IOException {
+        assumeFalse(IN_MEMORY);
+
+        File dir = prepareTempDir("object-store-test-corrupted");
+        prepareBadDataFile(dir, "corrupt-pageno-in-branch-data.mdb");
+        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
+        builder.validateOnOpen(ValidateOnOpenModePages.Full).usePreviousCommit();
+        store = builder.build();
+        String diagnoseString = store.diagnose();
+        assertTrue(diagnoseString.contains("entries=2"));
+        store.validate(0, true);
+        store.close();
+        assertTrue(store.deleteAllFiles());
+    }
+
+    @Test
+    public void usePreviousCommitAfterFileCorruptException() throws IOException {
+        assumeFalse(IN_MEMORY);
+
+        File dir = prepareTempDir("object-store-test-corrupted");
+        prepareBadDataFile(dir, "corrupt-pageno-in-branch-data.mdb");
+        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
+        builder.validateOnOpen(ValidateOnOpenModePages.Full);
+        try {
+            store = builder.build();
+            fail("Should have thrown");
+        } catch (PagesCorruptException e) {
+            builder.usePreviousCommit();
+            store = builder.build();
+        }
+
+        String diagnoseString = store.diagnose();
+        assertTrue(diagnoseString.contains("entries=2"));
+        store.validate(0, true);
+        store.close();
+        assertTrue(store.deleteAllFiles());
+    }
+
+    @Test
+    public void validateOnOpenKv() {
+        // Create a database first; we must create the model only once (ID/UID sequences would be different 2nd time)
+        byte[] model = createTestModel(null);
+        long id = buildNotCorruptedDatabase(model);
+
+        // Then re-open database with validation and ensure db is operational
+        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
+        builder.entity(new TestEntity_());
+        builder.validateOnOpenKv();
+        store = builder.build();
+        assertNotNull(getTestEntityBox().get(id));
+        getTestEntityBox().put(new TestEntity(0));
+    }
+
+    @Test
+    public void validateOnOpenKvCorruptFile() throws IOException {
+        assumeFalse(IN_MEMORY);
+        
+        File dir = prepareTempDir("obx-store-validate-kv-corrupted");
+        prepareBadDataFile(dir, "corrupt-keysize0-data.mdb");
+
+        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
+        builder.validateOnOpenKv();
+
+        @SuppressWarnings("resource")
+        FileCorruptException ex = assertThrows(FileCorruptException.class, () -> builder.build());
+        assertEquals("KV validation failed; key is empty (KV pair number: 1, key size: 0, data size: 112)",
+                ex.getMessage());
+
+        // Clean up
+        cleanUpAllFiles(dir);
+    }
+
+    /**
+     * Returns the id of the inserted test entity.
+     */
+    private long buildNotCorruptedDatabase(byte[] model) {
+        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
+        builder.entity(new TestEntity_());
+        store = builder.build();
+
+        TestEntity object = new TestEntity(0);
+        object.setSimpleString("hello hello");
+        long id = getTestEntityBox().put(object);
+        store.close();
+        return id;
+    }
+
+    /**
+     * Copies the given file from resources to the given directory as "data.mdb".
+     */
+    private void prepareBadDataFile(File dir, String resourceName) throws IOException {
+        assertTrue(dir.mkdir());
+        File badDataFile = new File(dir, "data.mdb");
+        try (InputStream badIn = getClass().getResourceAsStream(resourceName)) {
+            assertNotNull(badIn);
+            try (FileOutputStream badOut = new FileOutputStream(badDataFile)) {
+                IoUtils.copyAllBytes(badIn, badOut);
+            }
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java
index aee81a9b..fc669a14 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,14 +22,17 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
+
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 public class BoxTest extends AbstractObjectBoxTest {
@@ -51,6 +54,12 @@ public void testPutAndGet() {
         assertTrue(id != 0);
         assertEquals(id, entity.getId());
 
+        short valShort = 100 + simpleInt;
+        long valLong = 1000 + simpleInt;
+        float valFloat = 200 + simpleInt / 10f;
+        double valDouble = 2000 + simpleInt / 100f;
+        byte[] valByteArray = {1, 2, (byte) simpleInt};
+
         TestEntity entityRead = box.get(id);
         assertNotNull(entityRead);
         assertEquals(id, entityRead.getId());
@@ -58,11 +67,11 @@ public void testPutAndGet() {
         assertEquals(simpleInt, entityRead.getSimpleInt());
         assertEquals((byte) (10 + simpleInt), entityRead.getSimpleByte());
         assertFalse(entityRead.getSimpleBoolean());
-        assertEquals((short) (100 + simpleInt), entityRead.getSimpleShort());
-        assertEquals(1000 + simpleInt, entityRead.getSimpleLong());
-        assertEquals(200 + simpleInt / 10f, entityRead.getSimpleFloat(), 0);
-        assertEquals(2000 + simpleInt / 100f, entityRead.getSimpleDouble(), 0);
-        assertArrayEquals(new byte[]{1, 2, (byte) simpleInt}, entityRead.getSimpleByteArray());
+        assertEquals(valShort, entityRead.getSimpleShort());
+        assertEquals(valLong, entityRead.getSimpleLong());
+        assertEquals(valFloat, entityRead.getSimpleFloat(), 0);
+        assertEquals(valDouble, entityRead.getSimpleDouble(), 0);
+        assertArrayEquals(valByteArray, entityRead.getSimpleByteArray());
         String[] expectedStringArray = new String[]{simpleString};
         assertArrayEquals(expectedStringArray, entityRead.getSimpleStringArray());
         assertEquals(Arrays.asList(expectedStringArray), entityRead.getSimpleStringList());
@@ -72,6 +81,14 @@ public void testPutAndGet() {
         assertEquals(1, entityRead.getStringObjectMap().size());
         assertEquals(simpleString, entityRead.getStringObjectMap().get(simpleString));
         assertEquals(simpleString, entityRead.getFlexProperty());
+        assertArrayEquals(new boolean[]{false, false, true}, entity.getBooleanArray());
+        assertArrayEquals(new short[]{(short) -valShort, valShort}, entity.getShortArray());
+        assertArrayEquals(simpleString.toCharArray(), entity.getCharArray());
+        assertArrayEquals(new int[]{-simpleInt, simpleInt}, entity.getIntArray());
+        assertArrayEquals(new long[]{-valLong, valLong}, entity.getLongArray());
+        assertArrayEquals(new float[]{-valFloat, valFloat}, entityRead.getFloatArray(), 0);
+        assertArrayEquals(new double[]{-valDouble, valDouble}, entity.getDoubleArray(), 0);
+        assertEquals(new Date(1000 + simpleInt), entity.getDate());
     }
 
     @Test
@@ -87,7 +104,7 @@ public void testPutAndGet_defaultOrNullValues() {
         assertEquals(0, defaultEntity.getSimpleLong());
         assertEquals(0, defaultEntity.getSimpleFloat(), 0);
         assertEquals(0, defaultEntity.getSimpleDouble(), 0);
-        assertArrayEquals(null, defaultEntity.getSimpleByteArray());
+        assertNull(defaultEntity.getSimpleByteArray());
         assertNull(defaultEntity.getSimpleStringArray());
         assertNull(defaultEntity.getSimpleStringList());
         assertEquals(0, defaultEntity.getSimpleShortU());
@@ -95,6 +112,35 @@ public void testPutAndGet_defaultOrNullValues() {
         assertEquals(0, defaultEntity.getSimpleLongU());
         assertNull(defaultEntity.getStringObjectMap());
         assertNull(defaultEntity.getFlexProperty());
+        assertNull(defaultEntity.getBooleanArray());
+        assertNull(defaultEntity.getShortArray());
+        assertNull(defaultEntity.getCharArray());
+        assertNull(defaultEntity.getIntArray());
+        assertNull(defaultEntity.getLongArray());
+        assertNull(defaultEntity.getFloatArray());
+        assertNull(defaultEntity.getDoubleArray());
+        assertNull(defaultEntity.getDate());
+    }
+
+    // Note: There is a similar test using the Cursor API directly (which is deprecated) in CursorTest.
+    @Test
+    public void testPut_notAssignedId_fails() {
+        TestEntity entity = new TestEntity();
+        // Set ID that was not assigned
+        entity.setId(1);
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> box.put(entity));
+        assertEquals("ID is higher or equal to internal ID sequence: 1 (vs. 1). Use ID 0 (zero) to insert new objects.", ex.getMessage());
+    }
+
+    @Test
+    public void testPut_assignedId_inserts() {
+        long id = box.put(new TestEntity());
+        box.remove(id);
+        // Put with previously assigned ID should insert
+        TestEntity entity = new TestEntity();
+        entity.setId(id);
+        box.put(entity);
+        assertEquals(1L, box.count());
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/CursorBytesTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/CursorBytesTest.java
index 18700c29..9bcc4e27 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/CursorBytesTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/CursorBytesTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/CursorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/CursorTest.java
index 8bd7d660..98d43ab0 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/CursorTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/CursorTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,13 +16,21 @@
 
 package io.objectbox;
 
-import io.objectbox.annotation.IndexType;
 import org.junit.Test;
 
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 
-import static org.junit.Assert.*;
+import io.objectbox.annotation.IndexType;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 
 public class CursorTest extends AbstractObjectBoxTest {
 
@@ -49,15 +57,20 @@ public void testPutAndGetEntity() {
         transaction.abort();
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testPutEntityWithInvalidId() {
         TestEntity entity = new TestEntity();
         entity.setId(777);
         Transaction transaction = store.beginTx();
         Cursor<TestEntity> cursor = transaction.createCursor(TestEntity.class);
+
         try {
-            cursor.put(entity);
+            IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+                    () -> cursor.put(entity));
+            assertEquals(ex.getMessage(), "ID is higher or equal to internal ID sequence: 777 (vs. 1)." +
+                    " Use ID 0 (zero) to insert new objects.");
         } finally {
+            // Always clean up, even if assertions fail, to avoid misleading clean-up errors.
             cursor.close();
             transaction.close();
         }
@@ -215,17 +228,37 @@ public void testClose() {
         }
     }
 
+    /**
+     * Begin the first write-TX and ensure the second one blocks until the first one is closed.
+     * A secondary test goal is to check races of a closing TX and a closing store.
+     */
     @Test
     public void testWriteTxBlocksOtherWriteTx() throws InterruptedException {
+        // To change the likelihood of the TX vs store closing race, close the store using one of 3 different variants.
+        // Assign and print the randomly chosen variant beforehand so it does not mess with thread timings later.
+        // Warning: test variant 2 only manually, it will close the write-TX from a non-owner thread (in BoxStore.close)
+        // where the native database is expected to panic.
+        int closeStoreVariant = ThreadLocalRandom.current().nextInt(2 /* 3 - test variant 2 manually, see above */);
+        System.out.println("Closing store variant: " + closeStoreVariant);
+
         long time = System.currentTimeMillis();
         Transaction tx = store.beginTx();
         long duration = System.currentTimeMillis() - time; // Usually 0 on desktop
         final CountDownLatch latchBeforeBeginTx = new CountDownLatch(1);
         final CountDownLatch latchAfterBeginTx = new CountDownLatch(1);
+        final CountDownLatch latchCloseStoreInMainThread = closeStoreVariant != 0 ? new CountDownLatch(1) : null;
         new Thread(() -> {
             latchBeforeBeginTx.countDown();
             Transaction tx2 = store.beginTx();
             latchAfterBeginTx.countDown();
+
+            if (closeStoreVariant != 0) {
+                try {
+                    assertTrue(latchCloseStoreInMainThread.await(5, TimeUnit.SECONDS));
+                } catch (InterruptedException e) {
+                    throw new RuntimeException("Interrupted", e);
+                }
+            }
             tx2.close();
         }).start();
         assertTrue(latchBeforeBeginTx.await(1, TimeUnit.SECONDS));
@@ -233,6 +266,16 @@ public void testWriteTxBlocksOtherWriteTx() throws InterruptedException {
         assertFalse(latchAfterBeginTx.await(waitTime, TimeUnit.MILLISECONDS));
         tx.close();
         assertTrue(latchAfterBeginTx.await(waitTime * 2, TimeUnit.MILLISECONDS));
+
+        // closeStoreVariant == 0: not latch waiting, close store when tearing down test
+        if (closeStoreVariant == 1) {
+            // This variant tries to close the store and the TX at the same time.
+            latchCloseStoreInMainThread.countDown();
+            store.close();  // Maybe this runs a tiny bit before the close() in teardown(?)
+        } else if (closeStoreVariant == 2) {
+            store.close();  // Enforces closing the store before the TX.
+            latchCloseStoreInMainThread.countDown();
+        }
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/DebugCursorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/DebugCursorTest.java
index 37c81423..77cd0a77 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/DebugCursorTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/DebugCursorTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/FlowTest.kt b/tests/objectbox-java-test/src/test/java/io/objectbox/FlowTest.kt
index 31f4408e..34b4972a 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/FlowTest.kt
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/FlowTest.kt
@@ -3,40 +3,34 @@ package io.objectbox
 import app.cash.turbine.test
 import io.objectbox.kotlin.flow
 import io.objectbox.kotlin.query
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.runBlocking
 import org.junit.Assert.assertEquals
 import org.junit.Test
-import kotlin.time.ExperimentalTime
 
 
 class FlowTest : AbstractObjectBoxTest() {
 
-    @ExperimentalTime
-    @ExperimentalCoroutinesApi
     @Test
     fun flow_box() {
         runBlocking {
             store.flow(TestEntity::class.java).test {
-                assertEquals(TestEntity::class.java, expectItem())
+                assertEquals(TestEntity::class.java, awaitItem())
                 putTestEntities(1)
-                // Note: expectItem suspends until event, so no need to wait on OBX publisher thread.
-                assertEquals(TestEntity::class.java, expectItem())
+                // Note: awaitItem suspends until event, so no need to wait on OBX publisher thread.
+                assertEquals(TestEntity::class.java, awaitItem())
                 cancel() // expect no more events
             }
         }
     }
 
-    @ExperimentalTime
-    @ExperimentalCoroutinesApi
     @Test
     fun flow_query() {
         runBlocking {
             testEntityBox.query {}.flow().test {
-                assertEquals(0, expectItem().size)
+                assertEquals(0, awaitItem().size)
                 putTestEntities(1)
-                // Note: expectItem suspends until event, so no need to wait on OBX publisher thread.
-                assertEquals(1, expectItem().size)
+                // Note: awaitItem suspends until event, so no need to wait on OBX publisher thread.
+                assertEquals(1, awaitItem().size)
                 cancel() // expect no more events
             }
         }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/JniBasicsTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/JniBasicsTest.java
index 6c95e384..d9b12f2b 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/JniBasicsTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/JniBasicsTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/NonArgConstructorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/NonArgConstructorTest.java
index cfd36959..26d37484 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/NonArgConstructorTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/NonArgConstructorTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectBoxThreadPoolExecutorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectBoxThreadPoolExecutorTest.java
new file mode 100644
index 00000000..9c05293c
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectBoxThreadPoolExecutorTest.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox;
+
+import org.junit.Test;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Tests {@link ObjectBoxThreadPoolExecutor}.
+ */
+public class ObjectBoxThreadPoolExecutorTest extends AbstractObjectBoxTest {
+
+    @Test
+    public void executor_cleansThreadResources() throws Exception {
+        // Use a single thread to make it easy to check thread-local Box resources have been cleaned up
+        ObjectBoxThreadPoolExecutor executor = store.newFixedThreadPoolExecutor(1);
+
+        try {
+            // Submit a runnable that uses a Box API that will create a thread-local reader cursor
+            Future<Object[]> readResult = executor.submit(() -> {
+                Box<TestEntity> box = store.boxFor(TestEntity.class);
+                TestEntity entity = new TestEntity();
+                entity.setSimpleString("executor-test");
+                long id = box.put(entity);
+
+                TestEntity testEntity = box.get(id); // Creates a thread-local reader cursor
+
+                boolean hasReaderCursor = box.hasReaderCursorForCurrentThread();
+
+                return new Object[]{testEntity, hasReaderCursor};
+            });
+            Object[] result = readResult.get(1, TimeUnit.SECONDS);
+
+            TestEntity testEntity = (TestEntity) result[0];
+            assertNotNull(testEntity);
+            assertEquals("executor-test", testEntity.getSimpleString());
+
+            // Verify that a thread-local reader cursor was created
+            Boolean hasReaderCursor = (Boolean) result[1];
+            assertTrue(hasReaderCursor);
+
+            // Check the thread-local reader cursor has been released after the previous runnable was executed
+            Future<Boolean> cleanedResult = executor.submit(() -> {
+                Box<TestEntity> box = store.boxFor(TestEntity.class);
+                return box.hasReaderCursorForCurrentThread();
+            });
+            assertFalse(cleanedResult.get(1, TimeUnit.SECONDS));
+        } finally {
+            executor.shutdown();
+            assertTrue(executor.awaitTermination(1, TimeUnit.SECONDS));
+        }
+    }
+
+    @Test
+    public void newCachedThreadPoolExecutor_works() throws Exception {
+        assertExecutor(store.newCachedThreadPoolExecutor());
+        assertExecutor(store.newCachedThreadPoolExecutor(Executors.defaultThreadFactory()));
+    }
+
+    @Test
+    public void newFixedThreadPoolExecutor_works() throws Exception {
+        assertExecutor(store.newFixedThreadPoolExecutor(2));
+        assertExecutor(store.newFixedThreadPoolExecutor(2, Executors.defaultThreadFactory()));
+    }
+
+    /**
+     * Quickly checks the pre-configured executors works.
+     */
+    private void assertExecutor(ObjectBoxThreadPoolExecutor executor) throws Exception {
+        try {
+            // Create at least a write and a read transaction
+            Future<TestEntity> future = executor.submit(() -> {
+                Box<TestEntity> box = store.boxFor(TestEntity.class);
+                TestEntity entity = new TestEntity();
+                entity.setSimpleString("executor-test");
+                long id = box.put(entity);
+
+                return box.get(id);
+            });
+            TestEntity testEntity = future.get(1, TimeUnit.SECONDS);
+            assertNotNull(testEntity);
+            assertEquals("executor-test", testEntity.getSimpleString());
+        } finally {
+            executor.shutdown();
+            assertTrue(executor.awaitTermination(1, TimeUnit.SECONDS));
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectClassObserverTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectClassObserverTest.java
index 36ffdcfa..409d70ca 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectClassObserverTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectClassObserverTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/TestUtils.java b/tests/objectbox-java-test/src/test/java/io/objectbox/TestUtils.java
index 51c57400..c7f89b01 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/TestUtils.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/TestUtils.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/TransactionTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/TransactionTest.java
index 94fd7b9f..181a27dc 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/TransactionTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/TransactionTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,13 +16,11 @@
 
 package io.objectbox;
 
-import io.objectbox.exception.DbException;
-import io.objectbox.exception.DbExceptionListener;
-import io.objectbox.exception.DbMaxReadersExceededException;
 import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.function.ThrowingRunnable;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
@@ -32,7 +30,15 @@
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import io.objectbox.exception.DbException;
+import io.objectbox.exception.DbExceptionListener;
+import io.objectbox.exception.DbMaxReadersExceededException;
+import io.objectbox.query.Query;
+
 
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
@@ -43,6 +49,7 @@
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
 
 public class TransactionTest extends AbstractObjectBoxTest {
 
@@ -164,28 +171,28 @@ public void testTransactionReset() {
         transaction.abort();
     }
 
-    @Test(expected = IllegalStateException.class)
+    @Test
     public void testCreateCursorAfterAbortException() {
         Transaction tx = store.beginReadTx();
         tx.abort();
-        tx.createKeyValueCursor();
+        IllegalStateException ex = assertThrows(IllegalStateException.class, tx::createKeyValueCursor);
+        assertTrue(ex.getMessage().contains("TX is not active anymore"));
     }
 
-    @Test(expected = IllegalStateException.class)
+    @Test
     public void testCommitAfterAbortException() {
         Transaction tx = store.beginTx();
         tx.abort();
-        tx.commit();
+        IllegalStateException ex = assertThrows(IllegalStateException.class, tx::commit);
+        assertTrue(ex.getMessage().contains("TX is not active anymore"));
     }
 
-    @Test(expected = IllegalStateException.class)
+    @Test
     public void testCommitReadTxException() {
         Transaction tx = store.beginReadTx();
-        try {
-            tx.commit();
-        } finally {
-            tx.abort();
-        }
+        IllegalStateException ex = assertThrows(IllegalStateException.class, tx::commit);
+        assertEquals("Read transactions may not be committed - use abort instead", ex.getMessage());
+        tx.abort();
     }
 
     @Test
@@ -194,18 +201,19 @@ public void testCommitReadTxException_exceptionListener() {
         DbExceptionListener exceptionListener = e -> exs[0] = e;
         Transaction tx = store.beginReadTx();
         store.setDbExceptionListener(exceptionListener);
-        try {
-            tx.commit();
-            fail("Should have thrown");
-        } catch (IllegalStateException e) {
-            tx.abort();
-            assertSame(e, exs[0]);
-        }
+        IllegalStateException e = assertThrows(IllegalStateException.class, tx::commit);
+        tx.abort();
+        assertSame(e, exs[0]);
     }
 
-    @Test(expected = IllegalStateException.class)
+    @Test
     public void testCancelExceptionOutsideDbExceptionListener() {
-        DbExceptionListener.cancelCurrentException();
+        IllegalStateException e = assertThrows(
+                IllegalStateException.class,
+                DbExceptionListener::cancelCurrentException
+        );
+        assertEquals("Canceling Java exceptions can only be done from inside exception listeners",
+                e.getMessage());
     }
 
     @Test
@@ -291,6 +299,7 @@ public void testClose() {
         assertFalse(tx.isClosed());
         tx.close();
         assertTrue(tx.isClosed());
+        assertFalse(tx.isActive());
 
         // Double close should be fine
         tx.close();
@@ -304,7 +313,6 @@ public void testClose() {
         assertThrowsTxClosed(tx::renew);
         assertThrowsTxClosed(tx::createKeyValueCursor);
         assertThrowsTxClosed(() -> tx.createCursor(TestEntity.class));
-        assertThrowsTxClosed(tx::isActive);
         assertThrowsTxClosed(tx::isRecycled);
     }
 
@@ -313,6 +321,55 @@ private void assertThrowsTxClosed(ThrowingRunnable runnable) {
         assertEquals("Transaction is closed", ex.getMessage());
     }
 
+    @Test
+    public void nativeCallInTx_storeIsClosed_throws() throws InterruptedException {
+        // Ignore test on Windows, it was observed to crash with EXCEPTION_ACCESS_VIOLATION
+        assumeFalse(TestUtils.isWindows());
+
+        System.out.println("NOTE This test will cause \"Transaction is still active\" and \"Irrecoverable memory error\" error logs!");
+
+        CountDownLatch callableIsReady = new CountDownLatch(1);
+        CountDownLatch storeIsClosed = new CountDownLatch(1);
+        CountDownLatch callableIsDone = new CountDownLatch(1);
+        AtomicReference<Exception> callableException = new AtomicReference<>();
+
+        // Goal: be just passed closed checks on the Java side, about to call a native query API.
+        // Then close the Store, then call the native API. The native API call should not crash the VM.
+        Callable<Void> waitingCallable = () -> {
+            Box<TestEntity> box = store.boxFor(TestEntity.class);
+            Query<TestEntity> query = box.query().build();
+            // Obtain Cursor handle before closing the Store as getActiveTxCursor() has a closed check
+            long cursorHandle = InternalAccess.getActiveTxCursorHandle(box);
+            
+            callableIsReady.countDown();
+            try {
+                if (!storeIsClosed.await(5, TimeUnit.SECONDS)) {
+                    throw new IllegalStateException("Store did not close within 5 seconds");
+                }
+                // Call native query API within the transaction (opened by callInReadTx below)
+                io.objectbox.query.InternalAccess.nativeFindFirst(query, cursorHandle);
+                query.close();
+            } catch (Exception e) {
+                callableException.set(e);
+            }
+            callableIsDone.countDown();
+            return null;
+        };
+        new Thread(() -> store.callInReadTx(waitingCallable)).start();
+
+        callableIsReady.await();
+        store.close();
+        storeIsClosed.countDown();
+
+        if (!callableIsDone.await(10, TimeUnit.SECONDS)) {
+            fail("Callable did not finish within 10 seconds");
+        }
+        Exception exception = callableException.get();
+        assertTrue(exception instanceof IllegalStateException);
+        // Note: the "State" at the end of the message may be different depending on platform, so only assert prefix
+        assertTrue(exception.getMessage().startsWith("Illegal Store instance detected! This is a severe usage error that must be fixed."));
+    }
+
     @Test
     public void testRunInTxRecursive() {
         final Box<TestEntity> box = getTestEntityBox();
@@ -366,12 +423,90 @@ public void testCallInReadTx() {
     }
 
     @Test
-    public void testRunInReadTxAndThenPut() {
+    public void testRunInTx_closesActiveTxCursor() {
+        final Box<TestEntity> box = getTestEntityBox();
+        AtomicBoolean hasCursorInTx = new AtomicBoolean(false);
+        store.runInTx(() -> {
+            box.count(); // Call Box API that creates a reader/activeTxCursor
+            hasCursorInTx.set(box.hasActiveTxCursorForCurrentThread());
+        });
+        // Verify a cursor for the active tx was created
+        assertTrue(hasCursorInTx.get());
+        // Check it was released
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+
+        // Verify the same in case the runnable throws
+        try {
+            store.runInTx(() -> {
+                box.count();
+                throw new IllegalStateException("Throw in transaction");
+            });
+        } catch (IllegalStateException ignored) {}
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+    }
+
+    @Test
+    public void testCallInTx_closesActiveTxCursor() throws Exception {
         final Box<TestEntity> box = getTestEntityBox();
-        store.runInReadTx(box::count);
-        // Verify that box does not hang on to the read-only TX by doing a put
+        Boolean hasCursorInTx = store.callInTx(() -> {
+            box.count(); // Call Box API that creates a reader/activeTxCursor
+            return box.hasActiveTxCursorForCurrentThread();
+        });
+        // Verify a cursor for the active tx was created
+        assertTrue(hasCursorInTx);
+        // Check it was released
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+
+        // Verify the same in case the callable throws
+        try {
+            store.callInTx(() -> {
+                box.count();
+                throw new IllegalStateException("Throw in transaction");
+            });
+        } catch (IllegalStateException ignored) {}
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+    }
+
+    @Test
+    public void testRunInReadTx_closesActiveTxCursor() {
+        final Box<TestEntity> box = getTestEntityBox();
+        store.runInReadTx(box::count); // Call Box API that creates a reader/activeTxCursor
+        // Verify that box does not hang on to the read-only TX: if it would, count() would re-use the cursor/tx from
+        // above and not see the put object.
+        putTestEntityAndExpectCount(1);
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+
+        // Verify the same in case the runnable throws
+        assertThrows(IllegalStateException.class, () -> store.runInReadTx(() -> {
+            box.count();
+            throw new IllegalStateException("Throw in transaction");
+        }));
+        putTestEntityAndExpectCount(2);
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+    }
+
+    @Test
+    public void testCallInReadTx_closesActiveTxCursor() {
+        final Box<TestEntity> box = getTestEntityBox();
+        store.callInReadTx(box::count); // Call Box API that creates a reader/activeTxCursor
+        // Verify that box does not hang on to the read-only TX: if it would, count() would re-use the cursor/tx from
+        // above and not see the put object.
+        putTestEntityAndExpectCount(1);
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+
+        // Verify the same in case the callable throws
+        assertThrows(IllegalStateException.class, () -> store.callInReadTx(() -> {
+            box.count();
+            throw new IllegalStateException("Throw in transaction");
+        }));
+        putTestEntityAndExpectCount(2);
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+    }
+
+    private void putTestEntityAndExpectCount(int expectedCount) {
+        Box<TestEntity> box = getTestEntityBox();
         box.put(new TestEntity());
-        assertEquals(1, box.count());
+        assertEquals(expectedCount, box.count());
     }
 
     @Test
@@ -387,9 +522,13 @@ public void testRunInReadTx_recursiveWriteTxFails() {
         });
     }
 
-    @Test(expected = DbException.class)
+    @Test
     public void testRunInReadTx_putFails() {
-        store.runInReadTx(() -> getTestEntityBox().put(new TestEntity()));
+        DbException e = assertThrows(
+                DbException.class,
+                () -> store.runInReadTx(() -> getTestEntityBox().put(new TestEntity()))
+        );
+        assertEquals("Cannot put in read transaction", e.getMessage());
     }
 
     @Test
@@ -534,4 +673,66 @@ private void runThreadPoolReaderTest(Runnable runnable) throws Exception {
             txTask.get(1, TimeUnit.MINUTES);  // 1s would be enough for normally, but use 1 min to allow debug sessions
         }
     }
+
+    @Test
+    public void runInTx_forwardsException() {
+        // Exception from callback is forwarded.
+        RuntimeException e = assertThrows(
+                RuntimeException.class,
+                () -> store.runInTx(() -> {
+                    throw new RuntimeException("Thrown inside callback");
+                })
+        );
+        assertEquals("Thrown inside callback", e.getMessage());
+
+        // Can create a new transaction afterward.
+        store.runInTx(() -> store.boxFor(TestEntity.class).count());
+    }
+
+    @Test
+    public void runInReadTx_forwardsException() {
+        // Exception from callback is forwarded.
+        RuntimeException e = assertThrows(
+                RuntimeException.class,
+                () -> store.runInReadTx(() -> {
+                    throw new RuntimeException("Thrown inside callback");
+                })
+        );
+        assertEquals("Thrown inside callback", e.getMessage());
+
+        // Can create a new transaction afterward.
+        store.runInReadTx(() -> store.boxFor(TestEntity.class).count());
+    }
+
+    @Test
+    public void callInTx_forwardsException() throws Exception {
+        // Exception from callback is forwarded.
+        Exception e = assertThrows(
+                Exception.class,
+                () -> store.callInTx(() -> {
+                    throw new Exception("Thrown inside callback");
+                })
+        );
+        assertEquals("Thrown inside callback", e.getMessage());
+
+        // Can create a new transaction afterward.
+        store.callInTx(() -> store.boxFor(TestEntity.class).count());
+    }
+
+    @Test
+    public void callInReadTx_forwardsException() {
+        // Exception from callback is forwarded, but wrapped inside a RuntimeException.
+        RuntimeException e = assertThrows(
+                RuntimeException.class,
+                () -> store.callInReadTx(() -> {
+                    throw new IOException("Thrown inside callback");
+                })
+        );
+        assertEquals("Callable threw exception", e.getMessage());
+        assertTrue(e.getCause() instanceof IOException);
+        assertEquals("Thrown inside callback", e.getCause().getMessage());
+
+        // Can create a new transaction afterward.
+        store.callInReadTx(() -> store.boxFor(TestEntity.class).count());
+    }
 }
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexMapConverterTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexMapConverterTest.java
index c718dbe8..72c07db2 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexMapConverterTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexMapConverterTest.java
@@ -1,14 +1,32 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 import org.junit.Test;
 
-import javax.annotation.Nullable;
 import java.time.Instant;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
+import javax.annotation.Nullable;
+
+
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThrows;
@@ -37,6 +55,7 @@ public void keysString_valsSupportedTypes_works() {
         map.put("long", 1L);
         map.put("float", 1.3f);
         map.put("double", -1.4d);
+        map.put("null", null);
         Map<String, Object> restoredMap = convertAndBack(map, converter);
         // Java integers are returned as Long if one value is larger than 32 bits, so expect Long.
         map.put("byte", 1L);
@@ -158,10 +177,12 @@ public void nestedMap_works() {
         Map<String, String> embeddedMap1 = new HashMap<>();
         embeddedMap1.put("Hello1", "Grüezi1");
         embeddedMap1.put("💡1", "Idea1");
+        embeddedMap1.put("null1", null);
         map.put("Hello", embeddedMap1);
         Map<String, String> embeddedMap2 = new HashMap<>();
         embeddedMap2.put("Hello2", "Grüezi2");
         embeddedMap2.put("💡2", "Idea2");
+        embeddedMap2.put("null2", null);
         map.put("💡", embeddedMap2);
         convertAndBackThenAssert(map, converter);
     }
@@ -181,6 +202,7 @@ public void nestedList_works() {
         embeddedList1.add(-2L);
         embeddedList1.add(1.3f);
         embeddedList1.add(-1.4d);
+        embeddedList1.add(null);
         map.put("Hello", embeddedList1);
         List<Object> embeddedList2 = new LinkedList<>();
         embeddedList2.add("Grüezi");
@@ -213,17 +235,12 @@ public void nestedListByteArray_works() {
     }
 
     @Test
-    public void nullKeyOrValue_throws() {
+    public void nullKey_throws() {
         FlexObjectConverter converter = new StringFlexMapConverter();
         Map<String, String> map = new HashMap<>();
 
-        map.put("Hello", null);
-        convertThenAssertThrows(map, converter, "Map keys or values must not be null");
-
-        map.clear();
-
         map.put(null, "Idea");
-        convertThenAssertThrows(map, converter, "Map keys or values must not be null");
+        convertThenAssertThrows(map, converter, "Map keys must not be null");
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexObjectConverterTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexObjectConverterTest.java
index e4ba3ca8..56f7c73e 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexObjectConverterTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexObjectConverterTest.java
@@ -1,13 +1,30 @@
+/*
+ * Copyright 2021-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 import org.junit.Test;
 
-import javax.annotation.Nullable;
 import java.util.LinkedList;
 import java.util.List;
 
+import javax.annotation.Nullable;
+
+
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThrows;
 
 /**
  * Tests {@link FlexObjectConverter} basic types and flexible list conversion.
@@ -55,6 +72,7 @@ public void list_works() {
         list.add(-2L);
         list.add(1.3f);
         list.add(-1.4d);
+        list.add(null);
         List<Object> restoredList = convertAndBack(list, converter);
         // Java integers are returned as Long as one element is larger than 32 bits, so expect Long.
         list.set(2, 1L);
@@ -63,14 +81,6 @@ public void list_works() {
         // Java Float is returned as Double, so expect Double.
         list.set(6, (double) 1.3f);
         assertEquals(list, restoredList);
-
-        // list with null element
-        list.add(null);
-        IllegalArgumentException exception = assertThrows(
-                IllegalArgumentException.class,
-                () -> convertAndBack(list, converter)
-        );
-        assertEquals("List elements must not be null", exception.getMessage());
     }
 
     @SuppressWarnings("unchecked")
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/exception/ExceptionTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/exception/ExceptionTest.java
index 75b0e08f..d3cb1a77 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/exception/ExceptionTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/exception/ExceptionTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/index/IndexReaderRenewTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/index/IndexReaderRenewTest.java
index 21cf1f31..0a43a1d4 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/index/IndexReaderRenewTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/index/IndexReaderRenewTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/AbstractQueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/AbstractQueryTest.java
index b29720e5..877d5aea 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/AbstractQueryTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/AbstractQueryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2018-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,19 +16,19 @@
 
 package io.objectbox.query;
 
-import io.objectbox.annotation.IndexType;
 import org.junit.Before;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import javax.annotation.Nullable;
+
 import io.objectbox.AbstractObjectBoxTest;
 import io.objectbox.Box;
 import io.objectbox.BoxStoreBuilder;
-import io.objectbox.DebugFlags;
 import io.objectbox.TestEntity;
-
-import javax.annotation.Nullable;
+import io.objectbox.annotation.IndexType;
+import io.objectbox.config.DebugFlags;
 
 public class AbstractQueryTest extends AbstractObjectBoxTest {
     protected Box<TestEntity> box;
@@ -55,11 +55,25 @@ public void setUpBox() {
      * <li>simpleFloat = [400.0..400.9]</li>
      * <li>simpleDouble = [2020.00..2020.09] (approximately)</li>
      * <li>simpleByteArray = [{1,2,2000}..{1,2,2009}]</li>
+     * <li>boolArray = [{true, false, true}..{false, false, true}]</li>
+     * <li>shortArray = [{-2100,2100}..{-2109,2109}]</li>
+     * <li>intArray = [{-2000,2000}..{-2009,2009}]</li>
+     * <li>longArray = [{-3000,3000}..{-3009,3009}]</li>
+     * <li>floatArray = [{-400.0,400.0}..{-400.9,400.9}]</li>
+     * <li>doubleArray = [{-2020.00,2020.00}..{-2020.09,2020.09}] (approximately)</li>
+     * <li>date = [Date(3000)..Date(3009)]</li>
      */
     public List<TestEntity> putTestEntitiesScalars() {
         return putTestEntities(10, null, 2000);
     }
 
+    /**
+     * Puts 5 TestEntity starting at nr 1 using {@link AbstractObjectBoxTest#createTestEntity(String, int)}.
+     * <li>simpleString = banana, apple, bar, banana milk shake, foo bar</li>
+     * <li>simpleStringArray = [simpleString]</li>
+     * <li>simpleStringList = [simpleString]</li>
+     * <li>charArray = simpleString.toCharArray()</li>
+     */
     List<TestEntity> putTestEntitiesStrings() {
         List<TestEntity> entities = new ArrayList<>();
         entities.add(createTestEntity("banana", 1));
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/FlexQueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/FlexQueryTest.java
index af3e35c7..af97295d 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/FlexQueryTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/FlexQueryTest.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.query;
 
 import io.objectbox.TestEntity;
@@ -11,6 +27,8 @@
 import java.util.List;
 import java.util.Map;
 
+import static io.objectbox.TestEntity_.stringObjectMap;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
@@ -113,7 +131,7 @@ public void contains_stringObjectMap() {
 
         // contains throws when used with flex property.
         IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-                () -> box.query(TestEntity_.stringObjectMap.contains("banana-string")));
+                () -> box.query(stringObjectMap.contains("banana-string")));
         assertEquals("Property type is neither a string nor array of strings: Flex", exception.getMessage());
 
         // containsElement only matches if key is equal.
@@ -126,41 +144,146 @@ public void contains_stringObjectMap() {
         assertContainsKey("banana-map");
 
         // containsKeyValue only matches if key and value is equal.
-        assertContainsKeyValue("banana-string", "banana");
-        assertContainsKeyValue("banana-long", -1L);
-        // containsKeyValue only supports strings and integers.
+        assertQueryCondition(stringObjectMap.equalKeyValue("banana-string", "banana", QueryBuilder.StringOrder.CASE_SENSITIVE), 1);
+        assertQueryCondition(stringObjectMap.equalKeyValue("banana-long", -1L), 1);
 
         // setParameters works with strings and integers.
         Query<TestEntity> setParamQuery = box.query(
-                TestEntity_.stringObjectMap.containsKeyValue("", "").alias("contains")
+                stringObjectMap.equalKeyValue("", "", QueryBuilder.StringOrder.CASE_SENSITIVE).alias("contains")
         ).build();
         assertEquals(0, setParamQuery.find().size());
 
-        setParamQuery.setParameters(TestEntity_.stringObjectMap, "banana-string", "banana");
+        setParamQuery.setParameters(stringObjectMap, "banana-string", "banana");
         List<TestEntity> setParamResults = setParamQuery.find();
         assertEquals(1, setParamResults.size());
         assertTrue(setParamResults.get(0).getStringObjectMap().containsKey("banana-string"));
 
-        setParamQuery.setParameters("contains", "banana milk shake-long", Long.toString(1));
+        setParamQuery.setParameters("contains", "banana milk shake-string", "banana milk shake");
         setParamResults = setParamQuery.find();
         assertEquals(1, setParamResults.size());
-        assertTrue(setParamResults.get(0).getStringObjectMap().containsKey("banana milk shake-long"));
+        assertTrue(setParamResults.get(0).getStringObjectMap().containsKey("banana milk shake-string"));
+
+        setParamQuery.close();
     }
 
     private void assertContainsKey(String key) {
-        List<TestEntity> results = box.query(
-                TestEntity_.stringObjectMap.containsElement(key)
-        ).build().find();
-        assertEquals(1, results.size());
-        assertTrue(results.get(0).getStringObjectMap().containsKey(key));
+        try (Query<TestEntity> query = box.query(
+                stringObjectMap.containsElement(key)
+        ).build()) {
+            List<TestEntity> results = query.find();
+            assertEquals(1, results.size());
+            assertTrue(results.get(0).getStringObjectMap().containsKey(key));
+        }
     }
 
-    private void assertContainsKeyValue(String key, Object value) {
-        List<TestEntity> results = box.query(
-                TestEntity_.stringObjectMap.containsKeyValue(key, value.toString())
-        ).build().find();
-        assertEquals(1, results.size());
-        assertTrue(results.get(0).getStringObjectMap().containsKey(key));
-        assertEquals(value, results.get(0).getStringObjectMap().get(key));
+    private TestEntity createObjectWithStringObjectMap(String s, long l, double d) {
+        TestEntity entity = new TestEntity();
+        Map<String, Object> map = new HashMap<>();
+        map.put("key-string", s);
+        map.put("key-long", l);
+        map.put("key-double", d);
+        entity.setStringObjectMap(map);
+        return entity;
+    }
+
+    private List<TestEntity> createObjectsWithStringObjectMap() {
+        return Arrays.asList(
+                createObjectWithStringObjectMap("apple", -1L, -0.2d),
+                createObjectWithStringObjectMap("Cherry", 3L, -1234.56d),
+                createObjectWithStringObjectMap("Apple", 234234234L, 1234.56d),
+                createObjectWithStringObjectMap("pineapple", -567L, 0.1d)
+        );
+    }
+
+    @Test
+    public void greaterKeyValue_stringObjectMap() {
+        List<TestEntity> objects = createObjectsWithStringObjectMap();
+        box.put(objects);
+        long apple = objects.get(0).getId();
+        long Cherry = objects.get(1).getId();
+        long Apple = objects.get(2).getId();
+        long pineapple = objects.get(3).getId();
+
+        // Note: CASE_SENSITIVE orders like "Apple, Cherry, apple, pineapple"
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_SENSITIVE), apple, pineapple);
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_INSENSITIVE), pineapple);
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-long", -2L), apple, Cherry, Apple);
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-long", 234234234L));
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-double", 0.0d), Apple, pineapple);
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-double", 1234.56d));
+    }
+
+    @Test
+    public void greaterEqualsKeyValue_stringObjectMap() {
+        List<TestEntity> objects = createObjectsWithStringObjectMap();
+        box.put(objects);
+        long apple = objects.get(0).getId();
+        long Cherry = objects.get(1).getId();
+        long Apple = objects.get(2).getId();
+        long pineapple = objects.get(3).getId();
+
+        // Note: CASE_SENSITIVE orders like "Apple, Cherry, apple, pineapple"
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_SENSITIVE), apple, Cherry, pineapple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_INSENSITIVE), Cherry, pineapple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-long", -2L), apple, Cherry, Apple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-long", 234234234L), Apple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-double", 0.05d), Apple, pineapple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-double", 1234.54d), Apple);
+    }
+
+    @Test
+    public void lessKeyValue_stringObjectMap() {
+        List<TestEntity> objects = createObjectsWithStringObjectMap();
+        box.put(objects);
+        long apple = objects.get(0).getId();
+        long Cherry = objects.get(1).getId();
+        long Apple = objects.get(2).getId();
+        long pineapple = objects.get(3).getId();
+
+        // Note: CASE_SENSITIVE orders like "Apple, Cherry, apple, pineapple"
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_SENSITIVE), Apple);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_INSENSITIVE), apple, Apple);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-long", -2L), pineapple);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-long", 6734234234L), apple, Cherry, Apple, pineapple);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-double", 0.0d), apple, Cherry);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-double", 1234.56d), apple, Cherry, pineapple);
+    }
+
+    @Test
+    public void lessEqualsKeyValue_stringObjectMap() {
+        List<TestEntity> objects = createObjectsWithStringObjectMap();
+        box.put(objects);
+        long apple = objects.get(0).getId();
+        long Cherry = objects.get(1).getId();
+        long Apple = objects.get(2).getId();
+        long pineapple = objects.get(3).getId();
+
+        // Note: CASE_SENSITIVE orders like "Apple, Cherry, apple, pineapple"
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_SENSITIVE), Cherry, Apple);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_INSENSITIVE), apple, Cherry, Apple);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-long", -1L), apple, pineapple);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-long", -567L), pineapple);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-double", 0.0d), apple, Cherry);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-double", 1234.56d), apple, Cherry, Apple, pineapple);
+    }
+
+    private void assertQueryCondition(PropertyQueryCondition<TestEntity> condition, long... expectedIds) {
+        try (Query<TestEntity> query = box.query(condition).build()) {
+            List<TestEntity> results = query.find();
+            assertResultIds(expectedIds, results);
+        }
+    }
+
+    private void assertResultIds(long[] expected, List<TestEntity> results) {
+        assertArrayEquals(expected, results.stream().mapToLong(TestEntity::getId).toArray());
     }
+
 }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/LazyListTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/LazyListTest.java
index 4e8b9078..14956362 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/LazyListTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/LazyListTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -176,6 +176,29 @@ public void testUncached() {
         }
     }
 
+    @Test
+    public void listIterator_indexOutOfBounds_throws() {
+        putTestEntities(3);
+        LazyList<TestEntity> listLazy = getTestEntityBox().query().build().findLazyCached();
+        int size = listLazy.size();
+
+        try {
+            listLazy.listIterator(-1);
+            fail("listIterator should throw for negative index");
+        } catch (IndexOutOfBoundsException expected) {
+            // Expected, OK
+        }
+
+        try {
+            listLazy.listIterator(size + 1);
+            fail("listIterator should throw for index larger than size");
+        } catch (IndexOutOfBoundsException expected) {
+            // Expected, OK
+        }
+
+        assertNotNull(listLazy.listIterator(size));
+    }
+
 
     protected void assertIds(List<TestEntity> list, List<TestEntity> list2) {
         for (int i = 0; i < list.size(); i++) {
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/PropertyQueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/PropertyQueryTest.java
index 856ddf64..6e6ca2f1 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/PropertyQueryTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/PropertyQueryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryCopyTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryCopyTest.java
new file mode 100644
index 00000000..f6859d26
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryCopyTest.java
@@ -0,0 +1,116 @@
+package io.objectbox.query;
+
+import io.objectbox.TestEntity;
+import io.objectbox.TestEntity_;
+import org.junit.Test;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.Assert.*;
+
+public class QueryCopyTest extends AbstractQueryTest {
+
+    @Test
+    public void queryCopy_isClone() {
+        putTestEntity("orange", 1);
+        TestEntity banana = putTestEntity("banana", 2);
+        putTestEntity("apple", 3);
+        TestEntity bananaMilkShake = putTestEntity("banana milk shake", 4);
+        putTestEntity("pineapple", 5);
+        putTestEntity("papaya", 6);
+
+        // Only even nr: 2, 4, 6.
+        QueryFilter<TestEntity> filter = entity -> entity.getSimpleInt() % 2 == 0;
+        // Reverse insert order: 6, 4, 2.
+        Comparator<TestEntity> comparator = Comparator.comparingLong(testEntity -> -testEntity.getId());
+
+        Query<TestEntity> queryOriginal = box.query(TestEntity_.simpleString.contains("").alias("fruit"))
+                .filter(filter)
+                .sort(comparator)
+                .build();
+        // Only bananas: 4, 2.
+        queryOriginal.setParameter("fruit", banana.getSimpleString());
+
+        Query<TestEntity> queryCopy = queryOriginal.copy();
+
+        // Object instances and native query handle should differ.
+        assertNotEquals(queryOriginal, queryCopy);
+        assertNotEquals(queryOriginal.handle, queryCopy.handle);
+
+        // Verify results are identical.
+        List<TestEntity> resultsOriginal = queryOriginal.find();
+        queryOriginal.close();
+        List<TestEntity> resultsCopy = queryCopy.find();
+        queryCopy.close();
+        assertEquals(2, resultsOriginal.size());
+        assertEquals(2, resultsCopy.size());
+        assertTestEntityEquals(bananaMilkShake, resultsOriginal.get(0));
+        assertTestEntityEquals(bananaMilkShake, resultsCopy.get(0));
+        assertTestEntityEquals(banana, resultsOriginal.get(1));
+        assertTestEntityEquals(banana, resultsCopy.get(1));
+    }
+
+    @Test
+    public void queryCopy_setParameter_noEffectOriginal() {
+        TestEntity orange = putTestEntity("orange", 1);
+        TestEntity banana = putTestEntity("banana", 2);
+
+        Query<TestEntity> queryOriginal = box
+                .query(TestEntity_.simpleString.equal(orange.getSimpleString()).alias("fruit"))
+                .build();
+
+        // Set parameter on clone that changes result.
+        Query<TestEntity> queryCopy = queryOriginal.copy()
+                .setParameter("fruit", banana.getSimpleString());
+
+        List<TestEntity> resultsOriginal = queryOriginal.find();
+        queryOriginal.close();
+        assertEquals(1, resultsOriginal.size());
+        assertTestEntityEquals(orange, resultsOriginal.get(0));
+
+        List<TestEntity> resultsCopy = queryCopy.find();
+        queryCopy.close();
+        assertEquals(1, resultsCopy.size());
+        assertTestEntityEquals(banana, resultsCopy.get(0));
+    }
+
+    private void assertTestEntityEquals(TestEntity expected, TestEntity actual) {
+        assertEquals(expected.getId(), actual.getId());
+        assertEquals(expected.getSimpleString(), actual.getSimpleString());
+    }
+
+    @Test
+    public void queryThreadLocal() throws InterruptedException {
+        Query<TestEntity> queryOriginal = box.query().build();
+        QueryThreadLocal<TestEntity> threadLocal = new QueryThreadLocal<>(queryOriginal);
+
+        AtomicReference<Query<TestEntity>> queryThreadAtomic = new AtomicReference<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        new Thread(() -> {
+            queryThreadAtomic.set(threadLocal.get());
+            latch.countDown();
+        }).start();
+
+        assertTrue(latch.await(1, TimeUnit.SECONDS));
+
+        Query<TestEntity> queryThread = queryThreadAtomic.get();
+        Query<TestEntity> queryMain = threadLocal.get();
+
+        // Assert that initialValue returns something.
+        assertNotNull(queryThread);
+        assertNotNull(queryMain);
+
+        // Assert that initialValue returns clones.
+        assertNotEquals(queryThread.handle, queryOriginal.handle);
+        assertNotEquals(queryMain.handle, queryOriginal.handle);
+        assertNotEquals(queryThread.handle, queryMain.handle);
+
+        queryOriginal.close();
+        queryMain.close();
+        queryThread.close();
+    }
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryObserverTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryObserverTest.java
index ef15f6c8..79654d7c 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryObserverTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryObserverTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -235,6 +235,60 @@ public void transform_inOrderOfPublish() {
         assertEquals(2, (int) placing.get(1));
     }
 
+    @Test
+    public void queryCloseWaitsOnPublisher() throws InterruptedException {
+        CountDownLatch beforeBlockPublisher = new CountDownLatch(1);
+        CountDownLatch blockPublisher = new CountDownLatch(1);
+        CountDownLatch beforeQueryClose = new CountDownLatch(1);
+        CountDownLatch afterQueryClose = new CountDownLatch(1);
+
+        AtomicBoolean publisherBlocked = new AtomicBoolean(false);
+        AtomicBoolean waitedBeforeQueryClose = new AtomicBoolean(false);
+
+        new Thread(() -> {
+            Query<TestEntity> query = box.query().build();
+            query.subscribe()
+                    .onlyChanges() // prevent initial publish call
+                    .observer(data -> {
+                beforeBlockPublisher.countDown();
+                try {
+                    publisherBlocked.set(blockPublisher.await(1, TimeUnit.SECONDS));
+                } catch (InterruptedException e) {
+                    throw new RuntimeException("Observer was interrupted while waiting", e);
+                }
+            });
+
+            // Trigger the query publisher, prepare so it runs its loop, incl. the query, at least twice
+            // and block it from completing the first loop using the observer.
+            query.publish();
+            query.publish();
+
+            try {
+                waitedBeforeQueryClose.set(beforeQueryClose.await(1, TimeUnit.SECONDS));
+            } catch (InterruptedException e) {
+                throw new RuntimeException("Thread was interrupted while waiting before closing query", e);
+            }
+            query.close();
+            afterQueryClose.countDown();
+        }).start();
+
+        // Wait for observer to block the publisher
+        assertTrue(beforeBlockPublisher.await(1, TimeUnit.SECONDS));
+        // Start closing the query
+        beforeQueryClose.countDown();
+
+        // While the publisher is blocked, the query close call should block
+        assertFalse(afterQueryClose.await(100, TimeUnit.MILLISECONDS));
+
+        // After the publisher is unblocked and can stop, the query close call should complete
+        blockPublisher.countDown();
+        assertTrue(afterQueryClose.await(100, TimeUnit.MILLISECONDS));
+
+        // Verify latches were triggered due to reaching 0, not due to timeout
+        assertTrue(publisherBlocked.get());
+        assertTrue(waitedBeforeQueryClose.get());
+    }
+
     private void putTestEntitiesScalars() {
         putTestEntities(10, null, 2000);
     }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryRelationCountTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryRelationCountTest.java
new file mode 100644
index 00000000..665849cf
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryRelationCountTest.java
@@ -0,0 +1,50 @@
+package io.objectbox.query;
+
+import io.objectbox.relation.AbstractRelationTest;
+import io.objectbox.relation.Customer;
+import io.objectbox.relation.Customer_;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class QueryRelationCountTest extends AbstractRelationTest {
+
+    @Test
+    public void queryRelationCount() {
+        // Customer without orders.
+        putCustomer();
+        // Customer with 2 orders.
+        Customer customerWithOrders = putCustomer();
+        putOrder(customerWithOrders, "First order");
+        putOrder(customerWithOrders, "Second order");
+
+        // Find customer with no orders.
+        try (Query<Customer> query = customerBox
+                .query(Customer_.orders.relationCount(0))
+                .build()) {
+            List<Customer> customer = query.find();
+            assertEquals(1, customer.size());
+            assertEquals(0, customer.get(0).getOrders().size());
+        }
+
+        // Find customer with two orders.
+        try (Query<Customer> query = customerBox
+                .query(Customer_.orders.relationCount(2))
+                .build()) {
+            List<Customer> customer = query.find();
+            assertEquals(1, customer.size());
+            assertEquals(2, customer.get(0).getOrders().size());
+        }
+
+        // Find no customer with three orders.
+        try (Query<Customer> query = customerBox
+                .query(Customer_.orders.relationCount(3))
+                .build()) {
+            List<Customer> customer = query.find();
+            assertEquals(0, customer.size());
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryScalarVectorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryScalarVectorTest.java
new file mode 100644
index 00000000..aafc51ce
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryScalarVectorTest.java
@@ -0,0 +1,239 @@
+package io.objectbox.query;
+
+import java.util.Arrays;
+import java.util.List;
+
+import io.objectbox.Property;
+import io.objectbox.TestEntity;
+import org.junit.Test;
+
+import static io.objectbox.TestEntity_.charArray;
+import static io.objectbox.TestEntity_.doubleArray;
+import static io.objectbox.TestEntity_.floatArray;
+import static io.objectbox.TestEntity_.intArray;
+import static io.objectbox.TestEntity_.longArray;
+import static io.objectbox.TestEntity_.shortArray;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+/**
+ * Tests querying properties that are integer or floating point arrays.
+ */
+public class QueryScalarVectorTest extends AbstractQueryTest {
+
+    /**
+     * Note: byte array is tested separately in {@link QueryTest}.
+     */
+    @Test
+    public void integer() {
+        List<TestEntity> entities = putTestEntitiesScalars();
+        List<Property<TestEntity>> properties = Arrays.asList(
+                shortArray,
+                intArray,
+                longArray
+        );
+        long[] ids = entities.stream().mapToLong(TestEntity::getId).toArray();
+
+        long id5 = ids[4];
+        List<Long> params5 = Arrays.asList(
+                2104L, // short
+                2004L, // int
+                3004L // long
+        );
+        long[] id6To10 = Arrays.stream(ids).filter(value -> value > id5).toArray();
+
+        long id10 = ids[9];
+        List<Long> params10 = Arrays.asList(
+                2109L, // short
+                2009L, // int
+                3009L // long
+        );
+
+        for (int i = 0; i < properties.size(); i++) {
+            Property<TestEntity> property = properties.get(i);
+            Long param5 = params5.get(i);
+            Long param10 = params10.get(i);
+
+            // "greater" which behaves like "has element greater".
+            try (Query<TestEntity> query = box.query()
+                    .greater(property, 3010)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, param5);
+                assertArrayEquals(id6To10, query.findIds());
+            }
+            // "greater or equal", only check equal
+            try (Query<TestEntity> query = box.query()
+                    .greaterOrEqual(property, param10)
+                    .build()) {
+                assertEquals(id10, query.findUniqueId());
+            }
+
+            // "less" which behaves like "has element less".
+            try (Query<TestEntity> query = box.query()
+                    .less(property, -3010)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, -param5);
+                assertArrayEquals(id6To10, query.findIds());
+            }
+            // "less or equal", only check equal
+            try (Query<TestEntity> query = box.query()
+                    .lessOrEqual(property, -param10)
+                    .build()) {
+                assertEquals(id10, query.findUniqueId());
+            }
+
+            // Note: "equal" for scalar arrays is actually "contains element".
+            try (Query<TestEntity> query = box.query()
+                    .equal(property, -1)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, param5);
+                assertEquals(id5, query.findUniqueId());
+            }
+
+            // Note: "not equal" for scalar arrays does not do anything useful.
+            try (Query<TestEntity> query = box.query()
+                    .notEqual(property, param5)
+                    .build()) {
+                assertArrayEquals(ids, query.findIds());
+            }
+        }
+
+    }
+
+    @Test
+    public void charArray() {
+        List<TestEntity> entities = putTestEntitiesStrings();
+        long[] ids = entities.stream().mapToLong(TestEntity::getId).toArray();
+
+        Property<TestEntity> property = charArray;
+        long id2 = entities.get(1).getId();
+        long id4 = entities.get(3).getId();
+        long[] id3to5 = Arrays.stream(ids).filter(value -> value > id2).toArray();
+
+        // "greater" which behaves like "has element greater".
+        try (Query<TestEntity> query = box.query()
+                .greater(property, 'x')
+                .build()) {
+            assertEquals(0, query.findUniqueId());
+
+            query.setParameter(property, 'p' /* apple */);
+            assertArrayEquals(id3to5, query.findIds());
+        }
+        // "greater or equal", only check equal
+        try (Query<TestEntity> query = box.query()
+                .greaterOrEqual(property, 's' /* banana milk shake */)
+                .build()) {
+            assertEquals(id4, query.findUniqueId());
+        }
+
+        // "less" which behaves like "has element less".
+        long[] id4And5 = new long[]{ids[3], ids[4]};
+        try (Query<TestEntity> query = box.query()
+                .less(property, ' ')
+                .build()) {
+            assertEquals(0, query.findUniqueId());
+
+            query.setParameter(property, 'a');
+            assertArrayEquals(id4And5, query.findIds());
+        }
+        // "less or equal", only check equal
+        try (Query<TestEntity> query = box.query()
+                .lessOrEqual(property, ' ')
+                .build()) {
+            assertArrayEquals(id4And5, query.findIds());
+        }
+
+        // Note: "equal" for scalar arrays is actually "contains element".
+        try (Query<TestEntity> query = box.query()
+                .equal(property, 'x')
+                .build()) {
+            assertEquals(0, query.findUniqueId());
+            
+            query.setParameter(property, 'p' /* apple */);
+            assertEquals(id2, query.findUniqueId());
+        }
+
+        // Note: "not equal" for scalar arrays does not do anything useful.
+        try (Query<TestEntity> query = box.query()
+                .notEqual(property, 'p' /* apple */)
+                .build()) {
+            assertArrayEquals(
+                    entities.stream().mapToLong(TestEntity::getId).toArray(),
+                    query.findIds()
+            );
+        }
+    }
+
+    @Test
+    public void floatingPoint() {
+        List<TestEntity> entities = putTestEntitiesScalars();
+        List<Property<TestEntity>> properties = Arrays.asList(
+                floatArray,
+                doubleArray
+        );
+        long[] ids = entities.stream().mapToLong(TestEntity::getId).toArray();
+
+        long id5 = ids[4];
+        List<Double> params5 = Arrays.asList(
+                400.4, // float
+                (double) (2000 + 2004 / 100f) // double
+        );
+        long[] id6To10 = Arrays.stream(ids).filter(value -> value > id5).toArray();
+
+        long id10 = ids[9];
+        List<Double> params10 = Arrays.asList(
+                400.9, // float
+                (double) (2000 + 2009 / 100f) // double
+        );
+
+        for (int i = 0; i < properties.size(); i++) {
+            Property<TestEntity> property = properties.get(i);
+            System.out.println(property);
+            Double param5 = params5.get(i);
+            Double param10 = params10.get(i);
+
+            // "greater" which behaves like "has element greater".
+            try (Query<TestEntity> query = box.query()
+                    .greater(property, 2021.0)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, param5);
+                assertArrayEquals(id6To10, query.findIds());
+            }
+            // "greater or equal", only check equal
+            try (Query<TestEntity> query = box.query()
+                    .greaterOrEqual(property, param10)
+                    .build()) {
+                assertEquals(id10, query.findUniqueId());
+            }
+
+            // "less" which behaves like "has element less".
+            try (Query<TestEntity> query = box.query()
+                    .less(property, -param5)
+                    .build()) {
+                assertArrayEquals(id6To10, query.findIds());
+            }
+            // "less or equal", only check equal
+            try (Query<TestEntity> query = box.query()
+                    .lessOrEqual(property, -2021.0)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, -param10);
+                assertEquals(id10, query.findUniqueId());
+            }
+
+            // "equal" which is actually "between" for floating point, is not supported.
+            assertThrows(IllegalArgumentException.class, () -> box.query().equal(property, param5, 0));
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java
index e043e3c5..3c618e16 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright © 2016 ObjectBox Ltd. <https://objectbox.io/>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,27 +16,26 @@
 
 package io.objectbox.query;
 
+import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
 import io.objectbox.Box;
 import io.objectbox.BoxStore;
 import io.objectbox.BoxStoreBuilder;
-import io.objectbox.DebugFlags;
 import io.objectbox.TestEntity;
 import io.objectbox.TestEntity_;
 import io.objectbox.TestUtils;
 import io.objectbox.exception.DbExceptionListener;
 import io.objectbox.exception.NonUniqueResultException;
 import io.objectbox.query.QueryBuilder.StringOrder;
-import io.objectbox.relation.MyObjectBox;
-import io.objectbox.relation.Order;
-import io.objectbox.relation.Order_;
-import org.junit.Test;
-import org.junit.function.ThrowingRunnable;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
 
+import static io.objectbox.TestEntity_.date;
 import static io.objectbox.TestEntity_.simpleBoolean;
 import static io.objectbox.TestEntity_.simpleByteArray;
 import static io.objectbox.TestEntity_.simpleFloat;
@@ -58,6 +57,17 @@
 
 public class QueryTest extends AbstractQueryTest {
 
+    @Test
+    public void createIfStoreClosed_throws() {
+        store.close();
+
+        IllegalStateException ex = assertThrows(
+                IllegalStateException.class,
+                () -> box.query()
+        );
+        assertEquals("Store is closed", ex.getMessage());
+    }
+
     @Test
     public void testBuild() {
         try (Query<TestEntity> query = box.query().build()) {
@@ -104,36 +114,38 @@ public void useAfterQueryClose_fails() {
         assertThrowsQueryIsClosed(query::count);
         assertThrowsQueryIsClosed(query::describe);
         assertThrowsQueryIsClosed(query::describeParameters);
+        assertThrowsQueryIsClosed(query::findFirst);
+        assertThrowsQueryIsClosed(query::findUnique);
         assertThrowsQueryIsClosed(query::find);
         assertThrowsQueryIsClosed(() -> query.find(0, 1));
-        assertThrowsQueryIsClosed(query::findFirst);
+        assertThrowsQueryIsClosed(query::findFirstId);
+        assertThrowsQueryIsClosed(query::findUniqueId);
         assertThrowsQueryIsClosed(query::findIds);
         assertThrowsQueryIsClosed(() -> query.findIds(0, 1));
         assertThrowsQueryIsClosed(query::findLazy);
         assertThrowsQueryIsClosed(query::findLazyCached);
-        assertThrowsQueryIsClosed(query::findUnique);
         assertThrowsQueryIsClosed(query::remove);
 
         // For setParameter(s) the native method is not actually called, so fine to use incorrect alias and property.
         assertThrowsQueryIsClosed(() -> query.setParameter("none", "value"));
         assertThrowsQueryIsClosed(() -> query.setParameters("none", "a", "b"));
         assertThrowsQueryIsClosed(() -> query.setParameter("none", 1));
-        assertThrowsQueryIsClosed(() -> query.setParameters("none", new int[]{1, 2}));
-        assertThrowsQueryIsClosed(() -> query.setParameters("none", new long[]{1, 2}));
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", new int[]{1, 2}));
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", new long[]{1, 2}));
         assertThrowsQueryIsClosed(() -> query.setParameters("none", 1, 2));
         assertThrowsQueryIsClosed(() -> query.setParameter("none", 1.0));
         assertThrowsQueryIsClosed(() -> query.setParameters("none", 1.0, 2.0));
-        assertThrowsQueryIsClosed(() -> query.setParameters("none", new String[]{"a", "b"}));
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", new String[]{"a", "b"}));
         assertThrowsQueryIsClosed(() -> query.setParameter("none", new byte[]{1, 2}));
         assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, "value"));
         assertThrowsQueryIsClosed(() -> query.setParameters(simpleString, "a", "b"));
         assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, 1));
-        assertThrowsQueryIsClosed(() -> query.setParameters(simpleString, new int[]{1, 2}));
-        assertThrowsQueryIsClosed(() -> query.setParameters(simpleString, new long[]{1, 2}));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, new int[]{1, 2}));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, new long[]{1, 2}));
         assertThrowsQueryIsClosed(() -> query.setParameters(simpleString, 1, 2));
         assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, 1.0));
         assertThrowsQueryIsClosed(() -> query.setParameters(simpleString, 1.0, 2.0));
-        assertThrowsQueryIsClosed(() -> query.setParameters(simpleString, new String[]{"a", "b"}));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, new String[]{"a", "b"}));
         assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, new byte[]{1, 2}));
 
         // find would throw once first results are obtained, but shouldn't allow creating an observer to begin with.
@@ -150,7 +162,7 @@ private void assertThrowsQueryIsClosed(ThrowingRunnable runnable) {
     public void useAfterStoreClose_failsIfUsingStore() {
         Query<TestEntity> query = box.query(
                 simpleString.equal("")
-                        .and(stringObjectMap.containsKeyValue("", ""))
+                        .and(stringObjectMap.equalKeyValue("", "", StringOrder.CASE_SENSITIVE))
                         .and(simpleInt.equal(0))
                         .and(simpleInt.oneOf(new int[]{0}).alias("oneOf4"))
                         .and(simpleLong.oneOf(new long[]{0}).alias("oneOf8"))
@@ -162,14 +174,16 @@ public void useAfterStoreClose_failsIfUsingStore() {
 
         // All methods accessing the store throw.
         assertThrowsStoreIsClosed(query::count);
+        assertThrowsStoreIsClosed(query::findFirst);
+        assertThrowsStoreIsClosed(query::findUnique);
         assertThrowsStoreIsClosed(query::find);
         assertThrowsStoreIsClosed(() -> query.find(0, 1));
-        assertThrowsStoreIsClosed(query::findFirst);
+        assertThrowsStoreIsClosed(query::findFirstId);
+        assertThrowsStoreIsClosed(query::findUniqueId);
         assertThrowsStoreIsClosed(query::findIds);
         assertThrowsStoreIsClosed(() -> query.findIds(0, 1));
         assertThrowsStoreIsClosed(query::findLazy);
         assertThrowsStoreIsClosed(query::findLazyCached);
-        assertThrowsStoreIsClosed(query::findUnique);
         assertThrowsStoreIsClosed(query::remove);
         assertThrowsStoreIsClosed(() -> query.subscribe().observer(data -> {
         }));
@@ -184,12 +198,12 @@ public void useAfterStoreClose_failsIfUsingStore() {
         assertThrowsEntityDeleted(() -> query.setParameter(simpleString, "value"));
         assertThrowsEntityDeleted(() -> query.setParameters(stringObjectMap, "a", "b"));
         assertThrowsEntityDeleted(() -> query.setParameter(simpleInt, 1));
-        assertThrowsEntityDeleted(() -> query.setParameters("oneOf4", new int[]{1, 2}));
-        assertThrowsEntityDeleted(() -> query.setParameters("oneOf8", new long[]{1, 2}));
+        assertThrowsEntityDeleted(() -> query.setParameter("oneOf4", new int[]{1, 2}));
+        assertThrowsEntityDeleted(() -> query.setParameter("oneOf8", new long[]{1, 2}));
         assertThrowsEntityDeleted(() -> query.setParameters("between", 1, 2));
         assertThrowsEntityDeleted(() -> query.setParameter(simpleInt, 1.0));
         assertThrowsEntityDeleted(() -> query.setParameters("between", 1.0, 2.0));
-        assertThrowsEntityDeleted(() -> query.setParameters("oneOfS", new String[]{"a", "b"}));
+        assertThrowsEntityDeleted(() -> query.setParameter("oneOfS", new String[]{"a", "b"}));
         assertThrowsEntityDeleted(() -> query.setParameter(simpleByteArray, new byte[]{1, 2}));
     }
 
@@ -207,10 +221,10 @@ private void assertThrowsEntityDeleted(ThrowingRunnable runnable) {
     public void testNullNotNull() {
         List<TestEntity> scalars = putTestEntitiesScalars();
         List<TestEntity> strings = putTestEntitiesStrings();
-        try (Query<TestEntity> notNull = box.query().notNull(simpleString).build()) {
+        try (Query<TestEntity> notNull = box.query(simpleString.notNull()).build()) {
             assertEquals(strings.size(), notNull.count());
         }
-        try (Query<TestEntity> isNull = box.query().isNull(simpleString).build()) {
+        try (Query<TestEntity> isNull = box.query(simpleString.isNull()).build()) {
             assertEquals(scalars.size(), isNull.count());
         }
     }
@@ -325,11 +339,11 @@ public void testIntIn() {
             assertEquals(3, query.count());
 
             int[] valuesInt2 = {2003};
-            query.setParameters(simpleInt, valuesInt2);
+            query.setParameter(simpleInt, valuesInt2);
             assertEquals(1, query.count());
 
             int[] valuesInt3 = {2003, 2007};
-            query.setParameters("int", valuesInt3);
+            query.setParameter("int", valuesInt3);
             assertEquals(2, query.count());
         }
     }
@@ -343,11 +357,11 @@ public void testLongIn() {
             assertEquals(3, query.count());
 
             long[] valuesLong2 = {3003};
-            query.setParameters(simpleLong, valuesLong2);
+            query.setParameter(simpleLong, valuesLong2);
             assertEquals(1, query.count());
 
             long[] valuesLong3 = {3003, 3007};
-            query.setParameters("long", valuesLong3);
+            query.setParameter("long", valuesLong3);
             assertEquals(2, query.count());
         }
     }
@@ -361,11 +375,11 @@ public void testIntNotIn() {
             assertEquals(7, query.count());
 
             int[] valuesInt2 = {2003};
-            query.setParameters(simpleInt, valuesInt2);
+            query.setParameter(simpleInt, valuesInt2);
             assertEquals(9, query.count());
 
             int[] valuesInt3 = {2003, 2007};
-            query.setParameters("int", valuesInt3);
+            query.setParameter("int", valuesInt3);
             assertEquals(8, query.count());
         }
     }
@@ -379,11 +393,11 @@ public void testLongNotIn() {
             assertEquals(7, query.count());
 
             long[] valuesLong2 = {3003};
-            query.setParameters(simpleLong, valuesLong2);
+            query.setParameter(simpleLong, valuesLong2);
             assertEquals(9, query.count());
 
             long[] valuesLong3 = {3003, 3007};
-            query.setParameters("long", valuesLong3);
+            query.setParameter("long", valuesLong3);
             assertEquals(8, query.count());
         }
     }
@@ -460,6 +474,7 @@ private void assertOffsetLimitEdgeCases(OffsetLimitFunction function) {
     public void testString() {
         List<TestEntity> entities = putTestEntitiesStrings();
         int count = entities.size();
+        
         try (Query<TestEntity> equal = box.query()
                 .equal(simpleString, "banana", StringOrder.CASE_INSENSITIVE)
                 .build()) {
@@ -476,11 +491,25 @@ public void testString() {
                 .build()) {
             assertEquals(4, getUniqueNotNull(startsEndsWith).getId());
         }
+
+        // contains
         try (Query<TestEntity> contains = box.query()
                 .contains(simpleString, "nana", StringOrder.CASE_INSENSITIVE)
                 .build()) {
             assertEquals(2, contains.count());
         }
+        // Verify case-sensitive setting has no side effects for non-ASCII characters
+        box.put(createTestEntity("Note that Îñţérñåţîöñåļîžåţîờñ is key", 6));
+        try (Query<TestEntity> contains = box.query()
+                .contains(simpleString, "Îñţérñåţîöñåļîžåţîờñ", StringOrder.CASE_SENSITIVE)
+                .build()) {
+            assertEquals(1, contains.count());
+        }
+        try (Query<TestEntity> contains = box.query()
+                .contains(simpleString, "Îñţérñåţîöñåļîžåţîờñ", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            assertEquals(1, contains.count());
+        }
     }
 
     @Test
@@ -649,7 +678,7 @@ public void testStringIn() {
             assertEquals("foo bar", entities.get(2).getSimpleString());
 
             String[] values2 = {"bar"};
-            query.setParameters(simpleString, values2);
+            query.setParameter(simpleString, values2);
             entities = query.find();
         }
         assertEquals(2, entities.size());
@@ -915,6 +944,35 @@ public void testRemove() {
         assertEquals(4, box.count());
     }
 
+    @Test
+    public void findFirstId() {
+        putTestEntitiesScalars();
+        try (Query<TestEntity> query = box.query(simpleInt.greater(2006)).build()) {
+            assertEquals(8, query.findFirstId());
+        }
+        // No result.
+        try (Query<TestEntity> query = box.query(simpleInt.equal(-1)).build()) {
+            assertEquals(0, query.findFirstId());
+        }
+    }
+
+    @Test
+    public void findUniqueId() {
+        putTestEntitiesScalars();
+        try (Query<TestEntity> query = box.query(simpleInt.equal(2006)).build()) {
+            assertEquals(7, query.findUniqueId());
+        }
+        // No result.
+        try (Query<TestEntity> query = box.query(simpleInt.equal(-1)).build()) {
+            assertEquals(0, query.findUniqueId());
+        }
+        // More than one result.
+        try (Query<TestEntity> query = box.query(simpleInt.greater(2006)).build()) {
+            NonUniqueResultException e = assertThrows(NonUniqueResultException.class, query::findUniqueId);
+            assertEquals("Query does not have a unique result (more than one result): 3", e.getMessage());
+        }
+    }
+
     @Test
     public void testFindIds() {
         putTestEntitiesScalars();
@@ -1190,7 +1248,7 @@ public void testForEachBreak() {
     // TODO can we improve? More than just "still works"?
     public void testQueryAttempts() {
         store.close();
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(null)).directory(boxStoreDir)
+        BoxStoreBuilder builder = createBuilderWithTestModel().directory(boxStoreDir)
                 .queryAttempts(5)
                 .failedReadTxAttemptCallback((result, error) -> {
                     if (error != null) {
@@ -1207,29 +1265,84 @@ public void testQueryAttempts() {
     }
 
     @Test
-    public void testDateParam() {
-        store.close();
-        assertTrue(store.deleteAllFiles());
-        store = MyObjectBox.builder().baseDirectory(boxStoreDir).debugFlags(DebugFlags.LOG_QUERY_PARAMETERS).build();
-
+    public void date_equal_and_setParameter_works() {
         Date now = new Date();
-        Order order = new Order();
-        order.setDate(now);
-        Box<Order> box = store.boxFor(Order.class);
-        box.put(order);
+        TestEntity entity = new TestEntity();
+        entity.setDate(now);
+        Box<TestEntity> box = store.boxFor(TestEntity.class);
+        box.put(entity);
+
+        try (Query<TestEntity> query = box.query(TestEntity_.date.equal(0)).build()) {
+            assertEquals(0, query.count());
+            query.setParameter(TestEntity_.date, now);
+            assertEquals(1, query.count());
+        }
 
-        Query<Order> query = box.query().equal(Order_.date, 0).build();
-        assertEquals(0, query.count());
+        // Again, but using alias
+        try (Query<TestEntity> aliasQuery = box.query(TestEntity_.date.equal(0)).parameterAlias("date").build()) {
+            assertEquals(0, aliasQuery.count());
+            aliasQuery.setParameter("date", now);
+            assertEquals(1, aliasQuery.count());
+        }
+    }
 
-        query.setParameter(Order_.date, now);
-        assertEquals(1, query.count());
+    @Test
+    public void date_between_works() {
+        putTestEntitiesScalars();
+        try (Query<TestEntity> query = box.query(date.between(new Date(3002L), new Date(3008L))).build()) {
+            assertEquals(7, query.count());
+        }
+    }
 
-        // Again, but using alias
-        Query<Order> aliasQuery = box.query().equal(Order_.date, 0).parameterAlias("date").build();
-        assertEquals(0, aliasQuery.count());
+    @Test
+    public void date_lessAndGreater_works() {
+        putTestEntitiesScalars();
+        try (Query<TestEntity> query = box.query(date.less(new Date(3002L))).build()) {
+            assertEquals(2, query.count());
+        }
+        try (Query<TestEntity> query = box.query(date.lessOrEqual(new Date(3003L))).build()) {
+            assertEquals(4, query.count());
+        }
+        try (Query<TestEntity> query = box.query(date.greater(new Date(3008L))).build()) {
+            assertEquals(1, query.count());
+        }
+        try (Query<TestEntity> query = box.query(date.greaterOrEqual(new Date(3008L))).build()) {
+            assertEquals(2, query.count());
+        }
+    }
+
+    @Test
+    public void date_oneOf_works() {
+        putTestEntitiesScalars();
+        Date[] valuesDate = new Date[]{new Date(3002L), new Date(), new Date(0)};
+        try (Query<TestEntity> query = box.query(date.oneOf(valuesDate)).build()) {
+            assertEquals(1, query.count());
+        }
+        Date[] valuesDate2 = new Date[]{new Date()};
+        try (Query<TestEntity> query = box.query(date.oneOf(valuesDate2)).build()) {
+            assertEquals(0, query.count());
+        }
+        Date[] valuesDate3 = new Date[]{new Date(3002L), new Date(3009L)};
+        try (Query<TestEntity> query = box.query(date.oneOf(valuesDate3)).build()) {
+            assertEquals(2, query.count());
+        }
+    }
 
-        aliasQuery.setParameter("date", now);
-        assertEquals(1, aliasQuery.count());
+    @Test
+    public void date_notOneOf_works() {
+        putTestEntitiesScalars();
+        Date[] valuesDate = new Date[]{new Date(3002L), new Date(), new Date(0)};
+        try (Query<TestEntity> query = box.query(date.notOneOf(valuesDate)).build()) {
+            assertEquals(9, query.count());
+        }
+        Date[] valuesDate2 = new Date[]{new Date()};
+        try (Query<TestEntity> query = box.query(date.notOneOf(valuesDate2)).build()) {
+            assertEquals(10, query.count());
+        }
+        Date[] valuesDate3 = new Date[]{new Date(3002L), new Date(3009L)};
+        try (Query<TestEntity> query = box.query(date.notOneOf(valuesDate3)).build()) {
+            assertEquals(8, query.count());
+        }
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest2.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest2.java
index 90cec623..9a9b9260 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest2.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTestK.kt b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTestK.kt
index 6e60b4cb..47867956 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTestK.kt
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTestK.kt
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.query
 
 import io.objectbox.TestEntity_
@@ -19,7 +35,8 @@ class QueryTestK : AbstractQueryTest() {
         val resultJava = box.query().`in`(TestEntity_.simpleLong, valuesLong).build().use {
             it.findFirst()
         }
-        val result = box.query {
+        // Keep testing the old query API on purpose
+        @Suppress("DEPRECATION") val result = box.query {
             inValues(TestEntity_.simpleLong, valuesLong)
         }.use {
             it.findFirst()
@@ -33,8 +50,8 @@ class QueryTestK : AbstractQueryTest() {
         putTestEntity("Fry", 12)
         putTestEntity("Fry", 10)
 
-        // current query API
-        val query = box.query {
+        // Old query API
+        @Suppress("DEPRECATION") val query = box.query {
             less(TestEntity_.simpleInt, 12)
             or()
             inValues(TestEntity_.simpleLong, longArrayOf(1012))
@@ -46,7 +63,7 @@ class QueryTestK : AbstractQueryTest() {
         assertEquals(10, results[0].simpleInt)
         assertEquals(12, results[1].simpleInt)
 
-        // suggested query API
+        // New query API
         val newQuery = box.query(
                 (TestEntity_.simpleInt less 12 or (TestEntity_.simpleLong oneOf longArrayOf(1012)))
                         and (TestEntity_.simpleString equal "Fry")
@@ -101,11 +118,11 @@ class QueryTestK : AbstractQueryTest() {
         assertEquals(3, query.count())
 
         val valuesInt2 = intArrayOf(2003)
-        query.setParameters(TestEntity_.simpleInt, valuesInt2)
+        query.setParameter(TestEntity_.simpleInt, valuesInt2)
         assertEquals(1, query.count())
 
         val valuesInt3 = intArrayOf(2003, 2007)
-        query.setParameters("int", valuesInt3)
+        query.setParameter("int", valuesInt3)
         assertEquals(2, query.count())
     }
 
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/AbstractRelationTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/AbstractRelationTest.java
index 65ee0e91..dd94eafb 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/AbstractRelationTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/AbstractRelationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2023 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,7 +27,7 @@
 import io.objectbox.Box;
 import io.objectbox.BoxStore;
 import io.objectbox.BoxStoreBuilder;
-import io.objectbox.DebugFlags;
+import io.objectbox.config.DebugFlags;
 
 public abstract class AbstractRelationTest extends AbstractObjectBoxTest {
 
@@ -55,16 +55,23 @@ public void initBoxes() {
         orderBox.removeAll();
     }
 
+    /**
+     * Puts customer Joe.
+     */
     protected Customer putCustomer() {
+        return putCustomer("Joe");
+    }
+
+    Customer putCustomer(String name) {
         Customer customer = new Customer();
-        customer.setName("Joe");
+        customer.setName(name);
         customerBox.put(customer);
         return customer;
     }
 
     protected Order putOrder(@Nullable Customer customer, @Nullable String text) {
         Order order = new Order();
-        order.setCustomer(customer);
+        order.getCustomer().setTarget(customer);
         order.setText(text);
         orderBox.put(order);
         return order;
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/LinkQueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/LinkQueryTest.java
new file mode 100644
index 00000000..e8720b99
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/LinkQueryTest.java
@@ -0,0 +1,56 @@
+package io.objectbox.relation;
+
+import io.objectbox.query.Query;
+import io.objectbox.query.QueryBuilder;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * Tests link conditions for queries to filter on related entities.
+ * <p>
+ * There are more extensive tests in integration tests.
+ */
+public class LinkQueryTest extends AbstractRelationTest {
+
+    @Test
+    public void link_withRegularCondition() {
+        Customer john = putCustomer("John");
+        putOrder(john, "Apples");
+        putOrder(john, "Oranges");
+
+        Customer alice = putCustomer("Alice");
+        putOrder(alice, "Apples");
+        putOrder(alice, "Bananas");
+
+        // link condition matches orders from Alice
+        // simple regular condition matches single order for both
+        QueryBuilder<Order> builder = orderBox
+                .query(Order_.text.equal("Apples"));
+        builder.link(Order_.customer)
+                .apply(Customer_.name.equal("Alice").alias("name"));
+
+        try (Query<Order> query = builder.build()) {
+            Order order = query.findUnique();
+            assertNotNull(order);
+            assertEquals("Apples", order.getText());
+            assertEquals("Alice", order.getCustomer().getTarget().getName());
+        }
+
+        // link condition matches orders from Alice
+        // complex regular conditions matches two orders for John, one for Alice
+        QueryBuilder<Order> builderComplex = orderBox
+                .query(Order_.text.equal("Apples").or(Order_.text.equal("Oranges")));
+        builderComplex.link(Order_.customer)
+                .apply(Customer_.name.equal("Alice"));
+
+        try (Query<Order> query = builderComplex.build()) {
+            Order order = query.findUnique();
+            assertNotNull(order);
+            assertEquals("Apples", order.getText());
+            assertEquals("Alice", order.getCustomer().getTarget().getName());
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/MultithreadedRelationTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/MultithreadedRelationTest.java
index ed19935b..4f6c7981 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/MultithreadedRelationTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/MultithreadedRelationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationEagerTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationEagerTest.java
index b3a6a51c..6da0b595 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationEagerTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationEagerTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -94,20 +94,20 @@ public void testEagerToSingle() {
         // full list
         List<Order> orders = orderBox.query().eager(Order_.customer).build().find();
         assertEquals(2, orders.size());
-        assertTrue(orders.get(0).customer__toOne.isResolved());
-        assertTrue(orders.get(1).customer__toOne.isResolved());
+        assertTrue(orders.get(0).getCustomer().isResolved());
+        assertTrue(orders.get(1).getCustomer().isResolved());
 
         // full list paginated
         orders = orderBox.query().eager(Order_.customer).build().find(0, 10);
         assertEquals(2, orders.size());
-        assertTrue(orders.get(0).customer__toOne.isResolved());
-        assertTrue(orders.get(1).customer__toOne.isResolved());
+        assertTrue(orders.get(0).getCustomer().isResolved());
+        assertTrue(orders.get(1).getCustomer().isResolved());
 
         // list with eager limit
         orders = orderBox.query().eager(1, Order_.customer).build().find();
         assertEquals(2, orders.size());
-        assertTrue(orders.get(0).customer__toOne.isResolved());
-        assertFalse(orders.get(1).customer__toOne.isResolved());
+        assertTrue(orders.get(0).getCustomer().isResolved());
+        assertFalse(orders.get(1).getCustomer().isResolved());
 
         // forEach
         final int[] count = {0};
@@ -119,12 +119,12 @@ public void testEagerToSingle() {
 
         // first
         Order order = orderBox.query().eager(Order_.customer).build().findFirst();
-        assertTrue(order.customer__toOne.isResolved());
+        assertTrue(order.getCustomer().isResolved());
 
         // unique
         orderBox.remove(order);
         order = orderBox.query().eager(Order_.customer).build().findUnique();
-        assertTrue(order.customer__toOne.isResolved());
+        assertTrue(order.getCustomer().isResolved());
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java
index 8bb4ff08..89abfb71 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,9 +37,9 @@ public void testRelationToOne() {
 
         Order order1 = orderBox.get(order.getId());
         assertEquals(customer.getId(), order1.getCustomerId());
-        assertNull(order1.peekCustomer());
-        assertEquals(customer.getId(), order1.getCustomer().getId());
-        assertNotNull(order1.peekCustomer());
+        assertNull(order1.getCustomer().getCachedTarget());
+        assertEquals(customer.getId(), order1.getCustomer().getTarget().getId());
+        assertNotNull(order1.getCustomer().getCachedTarget());
     }
 
     @Test
@@ -85,7 +85,7 @@ public void testRelationToMany_activeRelationshipChanges() {
         ((ToMany<Order>) orders).reset();
         assertEquals(1, orders.size());
 
-        order2.setCustomer(null);
+        order2.getCustomer().setTarget(null);
         orderBox.put(order2);
 
         ((ToMany<Order>) orders).reset();
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyStandaloneTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyStandaloneTest.java
index c427b954..90a56502 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyStandaloneTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyStandaloneTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyTest.java
index 31adc972..1b9c0873 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToOneTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToOneTest.java
index 86be8fa7..1ab8b85a 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToOneTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToOneTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -100,7 +100,7 @@ public void testPutNewSourceAndTarget() {
         Customer target = new Customer();
         target.setName("target1");
 
-        ToOne<Customer> toOne = source.customer__toOne;
+        ToOne<Customer> toOne = source.getCustomer();
         assertTrue(toOne.isResolved());
         assertTrue(toOne.isNull());
         assertNull(toOne.getCachedTarget());
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/sync/ConnectivityMonitorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/ConnectivityMonitorTest.java
index 54ec2ccc..9ec4f81e 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/sync/ConnectivityMonitorTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/ConnectivityMonitorTest.java
@@ -1,8 +1,24 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
-import io.objectbox.sync.listener.SyncTimeListener;
 import org.junit.Test;
 
+import java.util.List;
 
 import javax.annotation.Nullable;
 
@@ -11,6 +27,7 @@
 import io.objectbox.sync.listener.SyncConnectionListener;
 import io.objectbox.sync.listener.SyncListener;
 import io.objectbox.sync.listener.SyncLoginListener;
+import io.objectbox.sync.listener.SyncTimeListener;
 
 
 import static org.junit.Assert.assertEquals;
@@ -99,6 +116,16 @@ public String getServerUrl() {
             return null;
         }
 
+        @Override
+        public MeshSync getMesh() {
+            return null;
+        }
+
+        @Override
+        public List<String> getUrls() {
+            return null;
+        }
+
         @Override
         public boolean isStarted() {
             return false;
@@ -153,9 +180,32 @@ public void setSyncChangeListener(@Nullable SyncChangeListener listener) {
         public void setSyncTimeListener(@Nullable SyncTimeListener timeListener) {
         }
 
+        @Override
+        public void putFilterVariable(String name, String value) {
+        }
+
+        @Override
+        public void removeFilterVariable(String name) {
+        }
+
+        @Override
+        public void removeAllFilterVariables() {
+        }
+
+        @Override
+        public void applyFilterVariables() {
+        }
+
         @Override
         public void setLoginCredentials(SyncCredentials credentials) {
+        }
 
+        @Override
+        public void setLoginCredentials(List<SyncCredentials> credentials) {
+        }
+
+        @Override
+        public void setLoginCredentials(SyncCredentials[] multipleCredentials) {
         }
 
         @Override
@@ -165,17 +215,14 @@ public boolean awaitFirstLogin(long millisToWait) {
 
         @Override
         public void start() {
-
         }
 
         @Override
         public void stop() {
-
         }
 
         @Override
         public void close() {
-
         }
 
         @Override
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncMeshTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncMeshTest.java
new file mode 100644
index 00000000..9dbd68dd
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncMeshTest.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import org.junit.Test;
+
+import io.objectbox.AbstractObjectBoxTest;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+
+/**
+ * Does basic tests of the peer-to-peer mesh sync API.
+ */
+public class SyncMeshTest extends AbstractObjectBoxTest {
+
+    private static final String TEST_MESH_ID = "test-mesh";
+    private static final String TEST_SERVER_URL = "ws://127.0.0.1:9999";
+
+    @Test
+    public void meshConfig_setsAllValues() {
+        MeshConfig config = InternalSyncAccess.createMeshConfig(TEST_MESH_ID)
+                .maxConnectionCount(4)
+                .backoffMillis(5000)
+                .evictionBackoffMillis(20000)
+                .requestTimeoutMillis(3000)
+                .advertisingDelayMillis(1000)
+                .advertisingRetryMillis(2000)
+                .advertisingRetryMaxMillis(30000)
+                .connectDelayMillis(500)
+                .initialDiscoveryDurationSeconds(20)
+                .discoveryDurationSeconds(10)
+                .discoveryPauseSeconds(30)
+                .discoveryPauseJitterSeconds(10)
+                .txLogBatchSizeKb(50)
+                .txLogBatchMaxCount(500);
+        InternalSyncAccess.addNetworkInternalHandle(config, 12345);
+
+        assertEquals(TEST_MESH_ID, config.meshId);
+        assertEquals(Integer.valueOf(4), config.maxConnectionCount);
+        assertEquals(Integer.valueOf(5000), config.backoffMillis);
+        assertEquals(Integer.valueOf(20000), config.evictionBackoffMillis);
+        assertEquals(Integer.valueOf(3000), config.requestTimeoutMillis);
+        assertEquals(Integer.valueOf(1000), config.advertisingDelayMillis);
+        assertEquals(Integer.valueOf(2000), config.advertisingRetryMillis);
+        assertEquals(Integer.valueOf(30000), config.advertisingRetryMaxMillis);
+        assertEquals(Integer.valueOf(500), config.connectDelayMillis);
+        assertEquals(Integer.valueOf(20), config.initialDiscoveryDurationSeconds);
+        assertEquals(Integer.valueOf(10), config.discoveryDurationSeconds);
+        assertEquals(Integer.valueOf(30), config.discoveryPauseSeconds);
+        assertEquals(Integer.valueOf(10), config.discoveryPauseJitterSeconds);
+        assertEquals(Integer.valueOf(50), config.txLogBatchSizeKb);
+        assertEquals(Integer.valueOf(500), config.txLogBatchMaxCount);
+        assertEquals(1, config.networkInternalHandles.size());
+        assertEquals(Long.valueOf(12345), config.networkInternalHandles.get(0));
+    }
+
+    @Test
+    public void meshConfig_defaultsToNoValues() {
+        MeshConfig config = InternalSyncAccess.createMeshConfig(TEST_MESH_ID);
+
+        assertEquals(TEST_MESH_ID, config.meshId);
+        assertNull(config.maxConnectionCount);
+        assertNull(config.backoffMillis);
+        assertNull(config.evictionBackoffMillis);
+        assertNull(config.requestTimeoutMillis);
+        assertNull(config.advertisingDelayMillis);
+        assertNull(config.advertisingRetryMillis);
+        assertNull(config.advertisingRetryMaxMillis);
+        assertNull(config.connectDelayMillis);
+        assertNull(config.initialDiscoveryDurationSeconds);
+        assertNull(config.discoveryDurationSeconds);
+        assertNull(config.discoveryPauseSeconds);
+        assertNull(config.discoveryPauseJitterSeconds);
+        assertNull(config.txLogBatchSizeKb);
+        assertNull(config.txLogBatchMaxCount);
+        assertEquals(0, config.networkInternalHandles.size());
+    }
+
+    @Test
+    public void meshConfig_emptyMeshId_throws() {
+        assertThrows(IllegalArgumentException.class, () -> InternalSyncAccess.createMeshConfig(""));
+        //noinspection DataFlowIssue
+        assertThrows(IllegalArgumentException.class, () -> InternalSyncAccess.createMeshConfig(null));
+    }
+
+    @Test
+    public void meshState_fromId_mapsKnownValues() {
+        MeshState[] states = MeshState.values();
+        for (MeshState state : states) {
+            assertEquals(state, MeshState.fromId(state.id));
+        }
+    }
+
+    @Test
+    public void meshState_fromId_mapsUnknownValues() {
+        assertEquals(MeshState.UNKNOWN, MeshState.fromId(-1));
+        MeshState[] states = MeshState.values();
+        assertEquals(MeshState.UNKNOWN, MeshState.fromId(states[states.length - 1].id + 1));
+    }
+
+    @Test
+    public void clientWithMesh_getMeshWorks() {
+        MeshConfig config = InternalSyncAccess.createMeshConfig(TEST_MESH_ID);
+
+        try (SyncClient client = Sync.client(store)
+                .url(TEST_SERVER_URL)
+                .credentials(SyncCredentials.none())
+                .mesh(config)
+                .build()) {
+            MeshSync mesh = client.getMesh();
+            assertNotNull(mesh);
+
+            assertEquals(MeshState.CREATED, mesh.getState());
+            assertEquals("Created", mesh.getStateString());
+            assertEquals(0, mesh.getConnectedPeerCount());
+            for (MeshStats counter : MeshStats.values()) {
+                assertEquals(0, mesh.getStats(counter));
+            }
+
+            client.close();
+            // The mesh is owned by the client, accessing it after close should throw
+            assertThrows(IllegalStateException.class, mesh::getState);
+            assertNull(this.store.getSyncClient());
+        }
+    }
+
+    @Test
+    public void clientWithoutMesh_getMeshReturnsNull() {
+        try (SyncClient client = Sync.client(store)
+                .url(TEST_SERVER_URL)
+                .credentials(SyncCredentials.none())
+                .build()) {
+            assertNull(client.getMesh());
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncTest.java
index 48ba0d26..c73ab354 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncTest.java
@@ -1,56 +1,333 @@
+/*
+ * Copyright 2020-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.sync;
 
 import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 import io.objectbox.AbstractObjectBoxTest;
-import io.objectbox.BoxStore;
+import io.objectbox.exception.FeatureNotAvailableException;
 
 
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
+/**
+ * This subproject includes JVM libraries with the Sync feature (so client only). These tests verify
+ * Java APIs behave as expected in that case.
+ * <p>
+ * The Java integration test repository has basic API tests that use JVM libraries without the Sync
+ * feature as well as extended functional tests for Sync client and server.
+ */
 public class SyncTest extends AbstractObjectBoxTest {
 
-    /**
-     * Ensure that non-sync native library correctly reports sync client availability.
-     * <p>
-     * Note: this test is mirrored in objectbox-integration-test sync tests, where sync is available.
-     */
+    // Not specifying a port to use random available one to avoid collisions
+    // Not using encrypted connection (wss protocol) as this requires a working certificate setup
+    private static final String TEST_SERVER_URL = "ws://127.0.0.1";
+
     @Test
-    public void clientIsNotAvailable() {
-        assertFalse(Sync.isAvailable());
+    public void clientIsAvailable() {
+        assertTrue(Sync.isAvailable());
     }
 
-    /**
-     * Ensure that non-sync native library correctly reports sync server availability.
-     * <p>
-     * Note: this test is mirrored in objectbox-integration-test sync tests, where sync is available.
-     */
     @Test
     public void serverIsNotAvailable() {
         assertFalse(Sync.isServerAvailable());
+        assertFalse(Sync.isHybridAvailable());
     }
 
     @Test
-    public void creatingSyncClient_throws() {
-        IllegalStateException exception = assertThrows(
-                IllegalStateException.class,
-                () -> Sync.client(store, "wss://127.0.0.1", SyncCredentials.none())
+    public void creatingSyncServer_throws() {
+        FeatureNotAvailableException exception = assertThrows(
+                FeatureNotAvailableException.class,
+                () -> Sync.server(store, TEST_SERVER_URL, SyncCredentials.none())
         );
         String message = exception.getMessage();
-        assertTrue(message, message.contains("does not include ObjectBox Sync") &&
-                message.contains("https://objectbox.io/sync") && !message.contains("erver"));
+        assertTrue(message, message.contains("does not include the Sync Server feature")
+                && message.contains("https://objectbox.io/sync/"));
+    }
+
+    /**
+     * Can't re-use builder as credentials are cleared.
+     */
+    private SyncBuilder clientBuilder() {
+        return Sync.client(store)
+                .url(TEST_SERVER_URL)
+                .credentials(SyncCredentials.none());
     }
 
     @Test
-    public void creatingSyncServer_throws() {
-        IllegalStateException exception = assertThrows(
-                IllegalStateException.class,
-                () -> Sync.server(store, "wss://127.0.0.1", SyncCredentials.none())
-        );
-        String message = exception.getMessage();
-        assertTrue(message, message.contains("does not include ObjectBox Sync Server") &&
-                message.contains("https://objectbox.io/sync"));
+    public void clientReferenceIsKeptInStore() {
+        assertNull(store.getSyncClient());
+
+        // Once created, reference is added to store.
+        try (SyncClient client = clientBuilder().build()) {
+            assertNotNull(client);
+            assertEquals(client, store.getSyncClient());
+
+            // If created, creating again fails for same store.
+            IllegalStateException exception = assertThrows(
+                    IllegalStateException.class,
+                    clientBuilder()::build
+            );
+            assertEquals(
+                    "The given store is already associated with a Sync client, close it first.",
+                    exception.getMessage()
+            );
+        }
+        // Closing cleared reference from store
+        assertNull(store.getSyncClient());
+
+        // Creating again works after closing.
+        try (SyncClient client = clientBuilder().build()) {
+            assertNotNull(client);
+            assertEquals(client, store.getSyncClient());
+        }
+    }
+
+    @Test
+    public void clientStates_noServer() {
+        try (SyncClientImpl syncClient = (SyncClientImpl) clientBuilder().build()) {
+            assertEquals(SyncState.CREATED, syncClient.getSyncState());
+
+            syncClient.start();
+            assertEquals(SyncState.STARTED, syncClient.getSyncState());
+
+            syncClient.stop();
+            assertEquals(SyncState.STOPPED, syncClient.getSyncState());
+        }
+    }
+
+    @Test
+    public void clientIsClosed_nativeMethodsThrow() {
+        SyncClient syncClient = clientBuilder().build();
+
+        syncClient.close();
+
+        assertEquals(TEST_SERVER_URL, syncClient.getUrls().get(0));
+        assertEquals(0, syncClient.getLastLoginCode());
+        assertFalse(syncClient.isLoggedIn());
+        syncClient.setSyncLoginListener(null);
+        syncClient.setSyncCompletedListener(null);
+        syncClient.setSyncTimeListener(null);
+        syncClient.setSyncConnectionListener(null);
+        assertFalse(syncClient.isStarted());
+
+        assertThrows(IllegalStateException.class, syncClient::getServerTimeNanos);
+        assertThrows(IllegalStateException.class, syncClient::getServerTimeDiffNanos);
+        assertThrows(IllegalStateException.class, syncClient::getRoundtripTimeNanos);
+        assertThrows(IllegalStateException.class, ((SyncClientImpl) syncClient)::getSyncState);
+        assertThrows(IllegalStateException.class, () -> syncClient.setSyncChangeListener(null));
+        assertThrows(IllegalStateException.class, () -> syncClient.setSyncListener(null));
+        assertThrows(IllegalStateException.class, () -> syncClient.putFilterVariable("name", "value"));
+        assertThrows(IllegalStateException.class, () -> syncClient.removeFilterVariable("name"));
+        assertThrows(IllegalStateException.class, syncClient::removeAllFilterVariables);
+        assertThrows(IllegalStateException.class, () -> syncClient.setLoginCredentials(SyncCredentials.none()));
+
+        SyncCredentials[] multipleCredentials = new SyncCredentials[]{
+                SyncCredentials.userAndPassword("user", "password"),
+                SyncCredentials.jwtAccessToken("access-token")
+        };
+        assertThrows(IllegalStateException.class, () -> syncClient.setLoginCredentials(multipleCredentials));
+
+        assertThrows(IllegalStateException.class, () -> syncClient.awaitFirstLogin(1));
+        assertThrows(IllegalStateException.class, syncClient::start);
+        assertThrows(IllegalStateException.class, syncClient::stop);
+        assertThrows(IllegalStateException.class, syncClient::requestUpdates);
+        assertThrows(IllegalStateException.class, syncClient::requestUpdatesOnce);
+        assertThrows(IllegalStateException.class, syncClient::cancelUpdates);
+        assertThrows(IllegalStateException.class, syncClient::notifyConnectionAvailable);
+
+        // Calling close again shouldn't call native method again, so shouldn't throw.
+        // Needs to behave this way as close() is also called by finalize().
+        syncClient.close();
+    }
+
+    @Test
+    public void syncClient_missingStore_throws() {
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> Sync.client(null));
+    }
+
+    @Test
+    public void syncClient_missingUrl_throws() {
+        // If a null URL is passed
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> Sync.client(store).url(null));
+        List<String> nullUrl = new ArrayList<>();
+        nullUrl.add(null);
+        assertThrowsIsNull(() -> Sync.client(store).urls(nullUrl));
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> Sync.client(store).urls(null));
+
+        // If no URLs are passed
+        //noinspection resource
+        IllegalArgumentException noUrls = assertThrows(IllegalArgumentException.class,
+                () -> Sync.client(store).urls(Collections.emptyList()).build());
+        assertEquals("At least one URL must be added to sync client options", noUrls.getMessage());
+    }
+
+    @Test
+    public void syncClient_credentials() {
+        // If no credentials are passed
+        //noinspection resource
+        IllegalArgumentException noCreds = assertThrows(IllegalArgumentException.class,
+                () -> Sync.client(store).url(TEST_SERVER_URL).build());
+        assertTrue(noCreds.getMessage().contains("Credentials must be provided"));
+        //noinspection DataFlowIssue,resource
+        assertThrowsIsNull(() -> Sync.client(store).url(TEST_SERVER_URL)
+                .credentials((SyncCredentials) null).build());
+        //noinspection DataFlowIssue,resource
+        assertThrowsIsNull(() -> Sync.client(store).url(TEST_SERVER_URL)
+                .credentials((List<SyncCredentials>) null).build());
+
+        // If credentials are changed after creating the client
+        try (SyncClient syncClient = clientBuilder().build()) {
+            // Single credentials item
+            //noinspection DataFlowIssue
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.setLoginCredentials((SyncCredentials) null));
+            syncClient.setLoginCredentials(SyncCredentials.none());
+            syncClient.setLoginCredentials(SyncCredentials.google("secret"));
+            syncClient.setLoginCredentials(SyncCredentials.sharedSecret("secret"));
+            syncClient.setLoginCredentials(SyncCredentials.none());
+
+            // Multiple credentials items
+            //noinspection DataFlowIssue
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.setLoginCredentials((SyncCredentials[]) null));
+            SyncCredentials[] credentials = {
+                    SyncCredentials.sharedSecret("<shared-secret>"),
+                    SyncCredentials.jwtAccessToken("<jwt-access-token>")
+            };
+            syncClient.setLoginCredentials(credentials);
+            syncClient.setLoginCredentials(new SyncCredentials[]{});
+            IllegalArgumentException nullArrayItemEx = assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.setLoginCredentials(new SyncCredentials[]{
+                            SyncCredentials.sharedSecret("<shared-secret>"),
+                            null}));
+            assertTrue(nullArrayItemEx.getMessage().contains("credentials is not a supported type"));
+            // Note: the variant accepting a list forwards to the single item and array variant, so
+            // just test the error case.
+            IllegalArgumentException emptyListEx = assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.setLoginCredentials(new ArrayList<>()));
+            assertTrue(emptyListEx.getMessage().contains("Credentials must be provided"));
+        }
+    }
+
+    @Test
+    public void credentials_cloningAndClearing_works() {
+        SyncCredentialsToken credentials = (SyncCredentialsToken) SyncCredentials.sharedSecret("secret");
+        SyncCredentialsToken clonedCredentials = credentials.createClone();
+
+        assertNotSame(credentials, clonedCredentials);
+        assertArrayEquals(clonedCredentials.getTokenBytes(), credentials.getTokenBytes());
+        credentials.clear();
+        assertThrows(IllegalStateException.class, credentials::getTokenBytes);
+        assertArrayEquals(clonedCredentials.getTokenBytes(), "secret".getBytes(StandardCharsets.UTF_8));
+    }
+
+    @Test
+    public void syncClient_requestUpdatesMode() {
+        try (SyncClient syncClient = clientBuilder()
+                .requestUpdatesMode(SyncBuilder.RequestUpdatesMode.MANUAL)
+                .build()) {
+            // Try to change request updates mode while not connected.
+            syncClient.start();
+            // All below should return false, because the client is not connected.
+            assertFalse(syncClient.requestUpdatesOnce());
+            assertFalse(syncClient.requestUpdates());
+            assertFalse(syncClient.cancelUpdates());
+        }
+    }
+
+    @Test
+    public void syncClient_filterVariables() {
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> clientBuilder().filterVariable(null, ""));
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> clientBuilder().filterVariable("", null));
+
+        try (SyncClient syncClient = clientBuilder()
+                .filterVariable("test-var-1", "test value 1")
+                .build()) {
+            syncClient.putFilterVariable("test-var-2", "test value 2");
+            syncClient.removeFilterVariable("test-var-2");
+            syncClient.putFilterVariable("test-var-2", "");
+            syncClient.removeAllFilterVariables();
+            syncClient.applyFilterVariables(); // no-op as client is not logged in
+
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.putFilterVariable("", "value"));
+            //noinspection DataFlowIssue
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.putFilterVariable(null, "value"));
+            //noinspection DataFlowIssue
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.putFilterVariable("name", null));
+        }
+    }
+
+    @Test
+    public void syncClient_trustedCertificates() {
+        clientBuilder()
+                .trustedCertificates(new String[]{})
+                .build()
+                .close();
+
+        clientBuilder()
+                .trustedCertificates(new String[]{
+                        "/path/to/does-not-exist-1.crt",
+                        "/path/to/does-not-exist-2.crt"
+                })
+                .build()
+                .close();
+    }
+
+    @Test
+    public void syncClient_flags() {
+        clientBuilder()
+                .flags(-1)
+                .build()
+                .close();
+
+        clientBuilder()
+                .flags(SyncFlags.DebugLogIdMapping
+                        | SyncFlags.ClientKeepDataOnSyncError
+                        | SyncFlags.DebugLogFilterVariables
+                        | SyncFlags.RemoveWithObjectData
+                        | SyncFlags.DebugLogTxLogs
+                        | SyncFlags.SkipInvalidTxOps)
+                .build().close();
+    }
+
+    private void assertThrowsIsNull(ThrowingRunnable runnable) {
+        IllegalArgumentException isNullEx = assertThrows(IllegalArgumentException.class, runnable);
+        assertTrue(isNullEx.getMessage().contains("must not be null"));
     }
 }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch_.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch_.java
index 7a31f3ca..26a0b8b4 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch_.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch_.java
@@ -106,7 +106,7 @@ public long getId(DataBranch object) {
 
     /** To-one relation "parent" to target entity "DataBranch". */
     public static final RelationInfo<DataBranch, DataBranch> parent =
-            new RelationInfo<>(DataBranch_.__INSTANCE, DataBranch_.__INSTANCE, parentId, new ToOneGetter<DataBranch>() {
+            new RelationInfo<>(DataBranch_.__INSTANCE, DataBranch_.__INSTANCE, parentId, new ToOneGetter<DataBranch, DataBranch>() {
                 @Override
                 public ToOne<DataBranch> getToOne(DataBranch entity) {
                     return entity.parent;
@@ -115,7 +115,7 @@ public ToOne<DataBranch> getToOne(DataBranch entity) {
 
     /** To-one relation "metaBranch" to target entity "MetaBranch". */
     public static final RelationInfo<DataBranch, MetaBranch> metaBranch =
-            new RelationInfo<>(DataBranch_.__INSTANCE, MetaBranch_.__INSTANCE, metaBranchId, new ToOneGetter<DataBranch>() {
+            new RelationInfo<>(DataBranch_.__INSTANCE, MetaBranch_.__INSTANCE, metaBranchId, new ToOneGetter<DataBranch, MetaBranch>() {
                 @Override
                 public ToOne<MetaBranch> getToOne(DataBranch entity) {
                     return entity.metaBranch;
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf_.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf_.java
index 3b433789..a5068560 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf_.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf_.java
@@ -118,7 +118,7 @@ public long getId(DataLeaf object) {
 
     /** To-one relation "dataBranch" to target entity "DataBranch". */
     public static final RelationInfo<DataLeaf, DataBranch> dataBranch =
-            new RelationInfo<>(DataLeaf_.__INSTANCE, io.objectbox.tree.DataBranch_.__INSTANCE, dataBranchId, new ToOneGetter<DataLeaf>() {
+            new RelationInfo<>(DataLeaf_.__INSTANCE, io.objectbox.tree.DataBranch_.__INSTANCE, dataBranchId, new ToOneGetter<DataLeaf, DataBranch>() {
                 @Override
                 public ToOne<DataBranch> getToOne(DataLeaf entity) {
                     return entity.dataBranch;
@@ -127,7 +127,7 @@ public ToOne<DataBranch> getToOne(DataLeaf entity) {
 
     /** To-one relation "metaLeaf" to target entity "MetaLeaf". */
     public static final RelationInfo<DataLeaf, MetaLeaf> metaLeaf =
-            new RelationInfo<>(DataLeaf_.__INSTANCE, io.objectbox.tree.MetaLeaf_.__INSTANCE, metaLeafId, new ToOneGetter<DataLeaf>() {
+            new RelationInfo<>(DataLeaf_.__INSTANCE, io.objectbox.tree.MetaLeaf_.__INSTANCE, metaLeafId, new ToOneGetter<DataLeaf, MetaLeaf>() {
                 @Override
                 public ToOne<MetaLeaf> getToOne(DataLeaf entity) {
                     return entity.metaLeaf;
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch_.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch_.java
index fba17354..cfbe6893 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch_.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch_.java
@@ -106,7 +106,7 @@ public long getId(MetaBranch object) {
 
     /** To-one relation "parent" to target entity "MetaBranch". */
     public static final RelationInfo<MetaBranch, MetaBranch> parent =
-            new RelationInfo<>(MetaBranch_.__INSTANCE, MetaBranch_.__INSTANCE, parentId, new ToOneGetter<MetaBranch>() {
+            new RelationInfo<>(MetaBranch_.__INSTANCE, MetaBranch_.__INSTANCE, parentId, new ToOneGetter<MetaBranch, MetaBranch>() {
                 @Override
                 public ToOne<MetaBranch> getToOne(MetaBranch entity) {
                     return entity.parent;
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf_.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf_.java
index 5213cb24..0610fee8 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf_.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf_.java
@@ -129,7 +129,7 @@ public long getId(MetaLeaf object) {
 
     /** To-one relation "branch" to target entity "MetaBranch". */
     public static final RelationInfo<MetaLeaf, MetaBranch> branch =
-            new RelationInfo<>(MetaLeaf_.__INSTANCE, MetaBranch_.__INSTANCE, branchId, new ToOneGetter<MetaLeaf>() {
+            new RelationInfo<>(MetaLeaf_.__INSTANCE, MetaBranch_.__INSTANCE, branchId, new ToOneGetter<MetaLeaf, MetaBranch>() {
                 @Override
                 public ToOne<MetaBranch> getToOne(MetaLeaf entity) {
                     return entity.branch;
diff --git a/tests/objectbox-java-test/src/test/resources/io/objectbox/corrupt-keysize0-data.mdb b/tests/objectbox-java-test/src/test/resources/io/objectbox/corrupt-keysize0-data.mdb
new file mode 100644
index 00000000..7b9af7f7
Binary files /dev/null and b/tests/objectbox-java-test/src/test/resources/io/objectbox/corrupt-keysize0-data.mdb differ
diff --git a/tests/test-proguard/build.gradle b/tests/test-proguard/build.gradle
deleted file mode 100644
index 547fe50d..00000000
--- a/tests/test-proguard/build.gradle
+++ /dev/null
@@ -1,42 +0,0 @@
-apply plugin: 'java-library'
-
-// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
-// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
-tasks.withType(JavaCompile) {
-    options.release.set(8)
-}
-
-repositories {
-    // Native lib might be deployed only in internal repo
-    if (project.hasProperty('gitlabUrl')) {
-        println "gitlabUrl=$gitlabUrl added to repositories."
-        maven {
-            url "$gitlabUrl/api/v4/groups/objectbox/-/packages/maven"
-            name "GitLab"
-            credentials(HttpHeaderCredentials) {
-                name = project.hasProperty("gitlabTokenName") ? gitlabTokenName : "Private-Token"
-                value = gitlabPrivateToken
-            }
-            authentication {
-                header(HttpHeaderAuthentication)
-            }
-        }
-    } else {
-        println "Property gitlabUrl not set."
-    }
-}
-
-dependencies {
-    implementation project(':objectbox-java')
-    implementation project(':objectbox-java-api')
-
-    // Check flag to use locally compiled version to avoid dependency cycles
-    if (!project.hasProperty('noObjectBoxTestDepencies') || !noObjectBoxTestDepencies) {
-        println "Using $obxJniLibVersion"
-        implementation obxJniLibVersion
-    } else {
-        println "Did NOT add native dependency"
-    }
-
-    testImplementation "junit:junit:$juniVersion"
-}
diff --git a/tests/test-proguard/build.gradle.kts b/tests/test-proguard/build.gradle.kts
new file mode 100644
index 00000000..1cfb27ac
--- /dev/null
+++ b/tests/test-proguard/build.gradle.kts
@@ -0,0 +1,20 @@
+plugins {
+    id("java-library")
+}
+
+tasks.withType<JavaCompile> {
+    // Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+    // https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+    options.release.set(8)
+}
+
+val versionDatabaseLibraryJvm: String by rootProject.extra
+
+dependencies {
+    implementation(project(":objectbox-java"))
+    implementation("io.objectbox:objectbox-linux:$versionDatabaseLibraryJvm")
+    implementation("io.objectbox:objectbox-macos:$versionDatabaseLibraryJvm")
+    implementation("io.objectbox:objectbox-windows:$versionDatabaseLibraryJvm")
+
+    testImplementation(libs.junit)
+}
diff --git a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/MyObjectBox.java b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/MyObjectBox.java
index c1da86fc..32c5ce77 100644
--- a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/MyObjectBox.java
+++ b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/MyObjectBox.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity.java b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity.java
index 66670f20..eeaf26fd 100644
--- a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity.java
+++ b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntityCursor.java b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntityCursor.java
index 34413f5f..6cd03c55 100644
--- a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntityCursor.java
+++ b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntityCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity_.java b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity_.java
index 32c22eda..9fec4622 100644
--- a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity_.java
+++ b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.