release: bump 0.7.8 -> 0.7.9 (#234)

Version bump 0.7.8 -> 0.7.9 for the Java binding release.

.gitattributes

@@ -16,3 +16,15 @@ bindings/c/include/wickra.h text eol=lf
 go.mod text eol=lf
 go.sum text eol=lf
 
+# Java sources (including the generated binding) are pinned to LF so the
+# committed files stay stable regardless of the committer's autocrlf setting.
+*.java text eol=lf
+
+# R binding: `R CMD check` requires LF in sources, Makevars and shell scripts.
+*.R text eol=lf
+*.Rd text eol=lf
+bindings/r/configure.win text eol=lf
+bindings/r/src/Makevars text eol=lf
+bindings/r/src/Makevars.win text eol=lf
+bindings/r/src/wickra.c text eol=lf
+

.github/ISSUE_TEMPLATE/bug_report.md

@@ -30,7 +30,7 @@ assignees: ""
 ## Environment
 
 - Wickra version:
-- Language / binding: <!-- Rust crate / Python / Node / WASM / C ABI / C# (.NET) / Go -->
+- Language / binding: <!-- Rust crate / Python / Node / WASM / C ABI / C# (.NET) / Go / Java / R -->
 - OS and architecture:
 - Rust / Python / Node / .NET version (If relevant):
 

.github/ISSUE_TEMPLATE/bug_report_detailed.md

@@ -16,6 +16,11 @@ assignees: []
 - [ ] Python (`pip install wickra`)
 - [ ] Node.js (`npm install wickra`)
 - [ ] WebAssembly
+- [ ] C ABI (`bindings/c`)
+- [ ] C# / .NET (`Wickra` on NuGet)
+- [ ] Go (`bindings/go`)
+- [ ] Java (`org.wickra:wickra` on Maven Central)
+- [ ] R (`bindings/r`)
 - [ ] Docs / examples only
 
 ## Environment

.github/ISSUE_TEMPLATE/feature_request.md

@@ -28,6 +28,8 @@ assignees: ""
 - [ ] Should be exposed in the C ABI
 - [ ] Should be exposed in the C# / .NET binding
 - [ ] Should be exposed in the Go binding
+- [ ] Should be exposed in the Java binding
+- [ ] Should be exposed in the R binding
 
 ## Additional context
 

.github/ISSUE_TEMPLATE/performance_regression.md

@@ -13,7 +13,7 @@ assignees: []
 ## Affected code path
 
 - Indicator / API: `e.g. EMA.update`
-- Binding: `Rust / Python / Node / Wasm / C ABI / C# (.NET) / Go`
+- Binding: `Rust / Python / Node / Wasm / C ABI / C# (.NET) / Go / Java / R`
 - Hot loop or one-shot call?
 
 ## Versions compared

.github/ISSUE_TEMPLATE/question.md

@@ -33,4 +33,4 @@ import wickra as ta
 ## Environment (Only if relevant)
 
 - Wickra version: `e.g. 0.4.2`
-- Binding: `Rust / Python / Node / Wasm / C ABI / C# (.NET) / Go`
+- Binding: `Rust / Python / Node / Wasm / C ABI / C# (.NET) / Go / Java / R`

.github/PULL_REQUEST_TEMPLATE.md

@@ -22,7 +22,7 @@
 - [ ] `cargo clippy --workspace --all-targets -- -D warnings` is clean.
 - [ ] `cargo test --workspace` passes.
 - [ ] New behaviour has tests; bug fixes have a regression test.
-- [ ] Public API changes are mirrored in the Python / Node / WASM bindings, and the C ABI + C# + Go bindings are regenerated
+- [ ] Public API changes are mirrored in the Python / Node / WASM bindings, and the C ABI + C# + Go + Java + R bindings are regenerated
       and their type stubs (If applicable).
 - [ ] The relevant page on the [documentation site](https://docs.wickra.org)
       and the `README.md` are updated (If applicable). Docs edits go to a

.github/PULL_REQUEST_TEMPLATE/detailed.md

@@ -26,6 +26,8 @@ Please fill in the sections below. Delete any that don't apply.
 - [ ] C ABI (`bindings/c`)
 - [ ] C# / .NET binding (`bindings/csharp`)
 - [ ] Go binding (`bindings/go`)
+- [ ] Java binding (`bindings/java`)
+- [ ] R binding (`bindings/r`)
 - [ ] Examples / docs
 
 ## Linked issues

.github/workflows/ci.yml

@@ -826,6 +826,147 @@ jobs:
             go run "./$d"
           done
 
+  r:
+    name: R on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    env:
+      WICKRA_INCLUDE_DIR: ${{ github.workspace }}/bindings/c/include
+      WICKRA_LIB_DIR: ${{ github.workspace }}/target/release
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true
+        timeout-minutes: 6
+
+      # The binding compiles a thin .Call glue layer against the C ABI hub; build
+      # the library first. On Windows configure.win bundles a renamed copy
+      # (wickra_abi.dll) so the package's own wickra.dll does not collide with it.
+      - name: Build the C ABI library
+        run: cargo build -p wickra-c --release
+
+      - name: Set up R
+        uses: r-lib/actions/setup-r@a51a8012b0aab7c32ef9d19bf54da93f3254335e # v2
+        with:
+          r-version: "release"
+          use-public-rspm: true
+
+      # Use the repos configured by setup-r (use-public-rspm) so Linux installs
+      # binary packages — building testthat's deps from source is slow and flaky.
+      - name: Install test dependency
+        run: Rscript -e 'install.packages("testthat")'
+
+      - name: Install and test the R binding
+        shell: bash
+        # github.workspace is a backslash path on Windows; configure.win (sh) and
+        # mingw need forward slashes. On Linux/macOS the rpath points at
+        # WICKRA_LIB_DIR; export the loader path too as a belt-and-suspenders.
+        run: |
+          export WICKRA_INCLUDE_DIR="${WICKRA_INCLUDE_DIR//\\//}"
+          export WICKRA_LIB_DIR="${WICKRA_LIB_DIR//\\//}"
+          export LD_LIBRARY_PATH="$WICKRA_LIB_DIR:$LD_LIBRARY_PATH"
+          export DYLD_LIBRARY_PATH="$WICKRA_LIB_DIR:$DYLD_LIBRARY_PATH"
+          R CMD INSTALL bindings/r
+          Rscript -e 'library(testthat); library(wickra); test_dir("bindings/r/tests/testthat", stop_on_failure = TRUE)'
+
+      - name: Run the offline R examples
+        shell: bash
+        run: |
+          export WICKRA_LIB_DIR="${WICKRA_LIB_DIR//\\//}"
+          export LD_LIBRARY_PATH="$WICKRA_LIB_DIR:$LD_LIBRARY_PATH"
+          export DYLD_LIBRARY_PATH="$WICKRA_LIB_DIR:$DYLD_LIBRARY_PATH"
+          cd examples/r
+          for f in streaming backtest multi_timeframe parallel_assets \
+                   strategy_rsi_mean_reversion strategy_macd_adx strategy_bollinger_squeeze; do
+            Rscript "$f.R"
+          done
+
+      # fetch_btcusdt / live_binance need the network (and jsonlite / websocket);
+      # build-check that they parse without running them.
+      - name: Parse the network R examples
+        run: Rscript -e 'invisible(lapply(c("examples/r/fetch_btcusdt.R", "examples/r/live_binance.R"), parse)); cat("network R examples parse OK\n")'
+
+  java:
+    name: Java on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
+
+      # The binding links the C ABI hub at runtime through the Java FFM API; build
+      # it first so WickraNative's development fallback finds
+      # target/release/wickra.{so,dylib,dll}. JDK 22+ is required for the final FFM
+      # API, so it is installed explicitly (runners ship 17/21).
+      - name: Build the C ABI library
+        run: cargo build -p wickra-c --release
+
+      - name: Set up JDK 22
+        id: setup-java
+        continue-on-error: true
+        uses: actions/setup-java@c1e323688fd81a25caa38c78aa6df2d33d3e20d9 # v4
+        with:
+          distribution: temurin
+          java-version: "22"
+          cache: maven
+
+      - name: Retry JDK setup (CDN flake)
+        if: steps.setup-java.outcome == 'failure'
+        shell: bash
+        run: |
+          echo "::warning::setup-java failed (likely CDN flake), waiting 30s before retry..."
+          sleep 30
+
+      - name: Set up JDK 22 (retry)
+        if: steps.setup-java.outcome == 'failure'
+        uses: actions/setup-java@c1e323688fd81a25caa38c78aa6df2d33d3e20d9 # v4
+        with:
+          distribution: temurin
+          java-version: "22"
+          cache: maven
+
+      - name: Java info
+        run: java -version
+
+      # `install` runs the archetype test suite (the real FFI boundary check) and
+      # installs the binding to the local repo so the examples can resolve it.
+      - name: Test and install the Java binding
+        run: mvn -B -f bindings/java install
+
+      - name: Build the Java examples
+        run: mvn -B -f examples/java compile
+
+      # Run only the offline examples (fetch_btcusdt / live_binance need network).
+      - name: Run the offline Java examples
+        shell: bash
+        run: |
+          for cls in Streaming Backtest MultiTimeframe ParallelAssets \
+                     StrategyRsiMeanReversion StrategyMacdAdx StrategyBollingerSqueeze; do
+            mvn -B -q -f examples/java exec:exec -Dexec.mainClass="org.wickra.examples.$cls"
+          done
+
   # The cross-library benchmark has moved to a dedicated scheduled workflow
   # (.github/workflows/bench.yml) — see audit finding R10. It runs nightly
   # at 03:00 UTC and on-demand via `workflow_dispatch`, and is no longer on

.github/workflows/release.yml

@@ -706,6 +706,75 @@ jobs:
           path: nupkg/*.nupkg
           if-no-files-found: error
 
+  # Publish the Java binding to Maven Central. Independent of the GitHub-release
+  # job so a Java hiccup never blocks the C/C++ asset release. The Maven Central
+  # namespace (org.wickra) is verified; authentication uses the Sonatype Central
+  # Portal token (CENTRAL_USERNAME / CENTRAL_PASSWORD) and artifacts are signed
+  # with the GPG key (GPG_PRIVATE_KEY / GPG_PASSPHRASE). The pom version must
+  # match the release tag (kept in sync by the version-bump checklist).
+  java-publish:
+    name: Publish to Maven Central
+    needs: c-abi-build
+    runs-on: ubuntu-latest
+    environment: release
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Download the C ABI native libraries
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: c-abi-*
+          path: c-abi-artifacts
+
+      - name: Stage native libraries into resources/native/<os>-<arch>
+        shell: bash
+        run: |
+          set -e
+          declare -A PLAT=(
+            [x86_64-unknown-linux-gnu]=linux-x64
+            [aarch64-unknown-linux-gnu]=linux-arm64
+            [x86_64-apple-darwin]=osx-x64
+            [aarch64-apple-darwin]=osx-arm64
+            [x86_64-pc-windows-msvc]=win-x64
+            [aarch64-pc-windows-msvc]=win-arm64
+          )
+          base=bindings/java/src/main/resources/native
+          for target in "${!PLAT[@]}"; do
+            archive=$(find c-abi-artifacts -name "wickra-c-$target.tar.gz" | head -1)
+            if [ -z "$archive" ]; then
+              echo "::error::missing native artifact for $target"; exit 1
+            fi
+            tmp=$(mktemp -d); tar -xzf "$archive" -C "$tmp"
+            dest="$base/${PLAT[$target]}"; mkdir -p "$dest"
+            for f in libwickra.so libwickra.dylib wickra.dll; do
+              src=$(find "$tmp" -name "$f" | head -1)
+              [ -n "$src" ] && cp "$src" "$dest/"
+            done
+            echo "staged ${PLAT[$target]}:"; ls -l "$dest"
+          done
+
+      # setup-java writes a settings.xml with the 'central' server credentials
+      # (mapped from the env vars below) and imports the GPG signing key.
+      - name: Set up JDK 22 + Maven Central credentials + GPG
+        uses: actions/setup-java@c1e323688fd81a25caa38c78aa6df2d33d3e20d9 # v4
+        with:
+          distribution: temurin
+          java-version: "22"
+          server-id: central
+          server-username: CENTRAL_USERNAME
+          server-password: CENTRAL_PASSWORD
+          gpg-private-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          gpg-passphrase: GPG_PASSPHRASE
+
+      - name: Deploy to Maven Central
+        env:
+          CENTRAL_USERNAME: ${{ secrets.CENTRAL_USERNAME }}
+          CENTRAL_PASSWORD: ${{ secrets.CENTRAL_PASSWORD }}
+          GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
+        run: mvn -B -f bindings/java -Prelease deploy -DskipTests
+
   github-release:
     name: Attach assets to the draft GitHub Release
     needs: [cargo-publish, python-publish, node-publish, wasm-publish, c-abi-build]

.github/workflows/sync-about.yml

@@ -86,10 +86,17 @@ jobs:
       # merge ref) so the counter check validates exactly what will land. On
       # push events we check out the default ref. No push is made, so a shallow
       # checkout is enough.
+      #
+      # Check out by head SHA, not head ref (branch name): a fast `gh pr merge
+      # --squash --delete-branch` deletes the head branch the moment the PR
+      # merges, often before this queued read-only check reaches its checkout.
+      # Fetching the now-gone `refs/heads/<branch>` then fails the run (exit 1).
+      # The head SHA stays reachable via `refs/pull/N/head` after the branch is
+      # gone, so the checkout — and the run — survives an instant merge.
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           fetch-depth: 1
-          ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.ref || github.ref }}
+          ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.ref }}
           repository: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name || github.repository }}
 
       - name: Count indicators
@@ -149,7 +156,7 @@ jobs:
           # actually live (Cloudflare Pages, P8.1); merging this PR is therefore
           # gated on the domain resolving, otherwise the About link would 404.
           homepage="https://docs.wickra.org"
-          desc="Streaming-first technical indicators with a Rust core and Python, Node.js, WebAssembly, C ABI, .NET, and Go bindings. ${n} indicators, O(1) per-tick updates, no system dependencies. Drop-in TA-Lib replacement."
+          desc="Streaming-first technical indicators with a Rust core and Python, Node.js, WebAssembly, C ABI, .NET, Go, Java, and R bindings. ${n} indicators, O(1) per-tick updates, no system dependencies. Drop-in TA-Lib replacement."
           # Enforce the homepage unconditionally — it is a constant, so this both
           # corrects the stale kingchenc URL and self-heals any future drift.
           # Same Administration-write permission as --description (no extra scope).

ARCHITECTURE.md

@@ -46,8 +46,9 @@ wasm-bindgen). The C ABI is the *hub* every other C-capable language links
 against: it builds to a `cdylib`/`staticlib` plus a generated `wickra.h`, and
 downstream languages link that one artifact rather than each re-wrapping the
 core. C and C++ link it directly; the **C# / .NET** binding (`bindings/csharp`,
-on NuGet) and the **Go** binding (`bindings/go`, cgo) are generated from
-`wickra.h`, with Java / R planned the same way.
+on NuGet), the **Go** binding (`bindings/go`, cgo), the **R** binding
+(`bindings/r`, `.Call`) and the **Java** binding (`bindings/java`, the Java FFM
+API / Panama, on Maven Central) are all generated from `wickra.h`.
 
 | Crate | Path | What it owns | Public deps |
 |---|---|---|---|

CHANGELOG.md

@@ -5,7 +5,25 @@ All notable changes to Wickra are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.7.9] - 2026-06-09
+### Added
+- **Java binding (`bindings/java`)** — a Java binding reaching the C ABI hub
+  through the Java Foreign Function & Memory API (Panama, `java.lang.foreign`,
+  final in Java 22) rather than JNI or jextract, exposing all 514 indicators as
+  idiomatic `AutoCloseable` classes. The downcall handles, per-indicator
+  wrappers and output records are generated from `wickra.h`; the opaque handle is
+  a `MemorySegment` freed by a `java.lang.ref.Cleaner` action. Ships a full
+  example suite mirroring the C, C#, Go and R examples; published to Maven
+  Central as `org.wickra:wickra`.
+
+## [0.7.8] - 2026-06-09
+### Added
+- **R binding (`bindings/r`)** — an R package reaching the C ABI hub through R's
+  native `.Call` interface, exposing all 514 indicators as constructors that
+  return a `wickra_indicator` object with `update`/`batch`/`reset` methods. The
+  C glue and R wrappers are generated from `wickra.h`; the native handle is freed
+  by a registered finalizer. Ships a full example suite mirroring the C, C# and
+  Go examples; distributed for r-universe / source install.
 
 ## [0.7.7] - 2026-06-09
 ### Added
@@ -1443,7 +1461,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   optional Binance live feed.
 - Bindings for Python, Node.js, and WebAssembly.
 
-[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.7.7...HEAD
+[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.7.9...HEAD
+[0.7.9]: https://github.com/wickra-lib/wickra/compare/v0.7.8...v0.7.9
+[0.7.8]: https://github.com/wickra-lib/wickra/compare/v0.7.7...v0.7.8
 [0.7.7]: https://github.com/wickra-lib/wickra/compare/v0.7.6...v0.7.7
 [0.7.6]: https://github.com/wickra-lib/wickra/compare/v0.7.5...v0.7.6
 [0.7.5]: https://github.com/wickra-lib/wickra/compare/v0.7.4...v0.7.5

CONTRIBUTING.md

@@ -24,6 +24,8 @@ licensed as above, without any additional terms or conditions.
 | `bindings/c` | C ABI — `cdylib` + `staticlib` + generated `include/wickra.h`. The hub for C / C++ and any C-capable language. |
 | `bindings/csharp` | .NET binding over the C ABI (`Wickra` on NuGet) — `[LibraryImport]` P/Invoke generated from `wickra.h`. |
 | `bindings/go` | Go binding over the C ABI via cgo (module tag `bindings/go/vX.Y.Z`) — wrappers generated from `wickra.h`. |
+| `bindings/r` | R binding over the C ABI via `.Call` (R package) — C glue + R wrappers generated from `wickra.h`. |
+| `bindings/java` | Java binding over the C ABI via the FFM API (Panama, Maven Central) — wrappers generated from `wickra.h`. |
 | `examples/` | Runnable examples. |
 | `docs/` | Pointer to the documentation site (docs.wickra.org); the docs live in the `wickra-lib/wickra-docs` repo. |
 
@@ -110,7 +112,11 @@ installed. Dependabot also keeps the `.github/requirements` pins current.
   commit `src/lib.rs` + `include/wickra.h`. The C# binding (`bindings/csharp`) is
   generated from `wickra.h`, so regenerate and commit its `Generated/*.g.cs` too.
   The Go binding (`bindings/go`) is likewise generated from `wickra.h`, so
-  regenerate and commit `indicators_gen.go` (`gofmt`-clean).
+  regenerate and commit `indicators_gen.go` (`gofmt`-clean). The R binding
+  (`bindings/r`) is generated from `wickra.h` too, so regenerate and commit
+  `src/wickra.c` + `R/indicators.R`. The Java binding (`bindings/java`) is
+  generated from `wickra.h` as well, so regenerate and commit its
+  `src/main/java/org/wickra/*.java`.
 - **Docs.** Update the relevant page on the
   [documentation site](https://docs.wickra.org) and the
   `README.md` when behaviour or the public API changes. The docs live in

Cargo.lock

@@ -1944,7 +1944,7 @@ dependencies = [
 
 [[package]]
 name = "wickra"
-version = "0.7.7"
+version = "0.7.9"
 dependencies = [
  "approx",
  "criterion",
@@ -1955,7 +1955,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-bench"
-version = "0.7.7"
+version = "0.7.9"
 dependencies = [
  "criterion",
  "kand",
@@ -1967,14 +1967,14 @@ dependencies = [
 
 [[package]]
 name = "wickra-c"
-version = "0.7.7"
+version = "0.7.9"
 dependencies = [
  "wickra-core",
 ]
 
 [[package]]
 name = "wickra-core"
-version = "0.7.7"
+version = "0.7.9"
 dependencies = [
  "approx",
  "proptest",
@@ -1984,7 +1984,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-data"
-version = "0.7.7"
+version = "0.7.9"
 dependencies = [
  "approx",
  "csv",
@@ -2001,7 +2001,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-examples"
-version = "0.7.7"
+version = "0.7.9"
 dependencies = [
  "serde_json",
  "tokio",
@@ -2011,7 +2011,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-node"
-version = "0.7.7"
+version = "0.7.9"
 dependencies = [
  "napi",
  "napi-build",
@@ -2021,7 +2021,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-python"
-version = "0.7.7"
+version = "0.7.9"
 dependencies = [
  "numpy",
  "pyo3",
@@ -2030,7 +2030,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-wasm"
-version = "0.7.7"
+version = "0.7.9"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

Cargo.toml

@@ -14,7 +14,7 @@ members = [
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.7.7"
+version = "0.7.9"
 authors = ["kingchenc <support@wickra.org>"]
 edition = "2021"
 rust-version = "1.86"
@@ -26,7 +26,7 @@ keywords = ["finance", "trading", "indicators", "technical-analysis", "ta"]
 categories = ["finance", "mathematics", "science"]
 
 [workspace.dependencies]
-wickra-core = { path = "crates/wickra-core", version = "0.7.7" }
+wickra-core = { path = "crates/wickra-core", version = "0.7.9" }
 
 thiserror = "2"
 rayon = "1.10"

README.md

@@ -20,7 +20,7 @@
 
 Wickra is a multi-language technical-analysis library with a Rust core and
 native bindings for Python, Node.js and WebAssembly, plus a C ABI that C, C++,
-C# / .NET, Go and any other C-capable language links against. Every indicator is a
+C# / .NET, Go, Java, R and any other C-capable language links against. Every indicator is a
 state machine that updates in O(1) per new data point, so live trading bots and
 historical backtests share the exact same implementation.
 
@@ -51,7 +51,8 @@ Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**:
   [WASM](https://docs.wickra.org/Quickstart-WASM),
   [C](https://docs.wickra.org/Quickstart-C),
   [C#](https://docs.wickra.org/Quickstart-CSharp),
-  [Go](https://docs.wickra.org/Quickstart-Go).
+  [Go](https://docs.wickra.org/Quickstart-Go),
+  [R](https://docs.wickra.org/Quickstart-R).
 - **Indicators** — a per-indicator deep dive (formula, parameters, warmup) for
   every one of the 514 indicators; start at the
   [indicators overview](https://docs.wickra.org/Indicators-Overview).
@@ -77,7 +78,7 @@ times to get there.
   metrics — every single one updating in **O(1) per tick**. TA-Lib ships ~150 and
   none of them stream.
 - **One Rust core, five first-class targets.** Native **Python · Node.js ·
-  WebAssembly · Rust** plus a **C ABI** for C / C++, C# / .NET, Go and any other C-capable language —
+  WebAssembly · Rust** plus a **C ABI** for C / C++, C# / .NET, Go, Java, R and any other C-capable language —
   identical math, identical results, zero per-language reimplementation and zero
   GIL bottleneck.
 - **Correct by construction, not by hope.** Every `update` validates its input,
@@ -102,7 +103,7 @@ Every other library forces one of those compromises. Wickra doesn't:
 | Library          | Install     | Streaming   | Languages                   | Indicators | Active |
 |------------------|-------------|-------------|-----------------------------|-----------:|--------|
 | **★ Wickra**| **clean**   | **yes, O(1)** | **Rust · Python · Node · WASM** | **514** | **yes** |
-|                  |             |               | **C · C# · Go**                 |            |        |
+|                  |             |               | **C · C# · Go · Java · R**          |            |        |
 | kand             | clean       | yes         | Python · WASM · Rust        |       ~60  | yes    |
 | ta-rs            | clean       | yes         | Rust only                   |       ~30  | stale  |
 | yata             | clean       | partial     | Rust only                   |       ~35  | yes    |
@@ -174,7 +175,7 @@ construct it in signed mode (`Doji::new().signed()`, `Doji(signed=True)`,
 `new Doji(true)`) for a dragonfly / gravestone `±1` reading.
 
 Adding a new indicator means implementing one trait in Rust; every binding
-inherits it automatically (the C ABI — and the C# and Go bindings generated from
+inherits it automatically (the C ABI — and the C#, Go, Java and R bindings generated from
 it — regenerate from the core).
 
 ## Languages
@@ -188,6 +189,8 @@ it — regenerate from the core).
 | C / C++ (C ABI)   | header + library, see [`bindings/c`](bindings/c) | `examples/c/streaming.c` |
 | C# / .NET (C ABI) | `dotnet add package Wickra`, see [`bindings/csharp`](bindings/csharp) | `examples/csharp/streaming` |
 | Go (cgo, C ABI)   | `go get github.com/wickra-lib/wickra/bindings/go`, see [`bindings/go`](bindings/go) | `examples/go/streaming` |
+| Java (FFM, C ABI)  | Maven Central `org.wickra:wickra`, see [`bindings/java`](bindings/java) | `examples/java` (`Streaming`) |
+| R (`.Call`, C ABI) | `R CMD INSTALL bindings/r`, see [`bindings/r`](bindings/r) | `examples/r/streaming.R` |
 
 Each binding ships several runnable examples (streaming, backtest, live feed);
 [`examples/README.md`](examples/README.md) is the full cross-language index.
@@ -259,7 +262,9 @@ wickra/
 │   ├── wasm/                wasm-bindgen (browsers, bundlers, Node)
 │   ├── c/                   C ABI (cdylib + staticlib) + generated include/wickra.h
 │   ├── csharp/              .NET binding over the C ABI (publishes on NuGet)
-│   └── go/                  Go binding over the C ABI via cgo (module tag)
+│   ├── go/                  Go binding over the C ABI via cgo (module tag)
+│   ├── r/                   R binding over the C ABI via .Call (R package)
+│   └── java/                Java binding over the C ABI via the FFM API (Maven Central)
 ├── examples/                examples/README.md indexes every language
 │   ├── data/                real BTCUSDT OHLCV datasets, one per timeframe
 │   ├── rust/                Rust workspace member (`wickra-examples`)
@@ -268,7 +273,9 @@ wickra/
 │   ├── wasm/                browser demo for `wickra-wasm`
 │   ├── c/                   C smoke + streaming, C++ RAII wrapper
 │   ├── csharp/              streaming, backtest, strategies (load `Wickra`)
-│   └── go/                  streaming, backtest, strategies (cgo binding)
+│   ├── go/                  streaming, backtest, strategies (cgo binding)
+│   ├── r/                   streaming, backtest, strategies (.Call binding)
+│   └── java/                streaming, backtest, strategies (FFM binding)
 └── .github/workflows/       CI and release pipelines
 ```
 
@@ -308,6 +315,13 @@ dotnet test bindings/csharp/Wickra.Tests/Wickra.Tests.csproj
 # Go binding (requires a C compiler for cgo; links the C ABI above)
 cp target/release/libwickra.so bindings/go/lib/   # .dylib on macOS, wickra.dll on Windows
 cd bindings/go && go test ./...
+
+# R binding (requires a C toolchain / Rtools; links the C ABI above)
+WICKRA_INCLUDE_DIR="$PWD/bindings/c/include" WICKRA_LIB_DIR="$PWD/target/release" \
+  R CMD INSTALL bindings/r
+
+# Java binding (requires JDK 22+ and Maven; links the C ABI above)
+mvn -f bindings/java test
 ```
 
 ## Testing
@@ -329,6 +343,10 @@ Every layer is covered; run the suites with the commands in
   and reference values.
 - `bindings/go`: `go test` cases covering one indicator per FFI archetype
   (scalar/batch, multi-output, bars, profile, array input), reset, and lifecycle.
+- `bindings/r`: `testthat` cases covering one indicator per FFI archetype
+  (scalar/batch, multi-output, bars, profile, array input), reset, and validation.
+- `bindings/java`: JUnit cases covering one indicator per FFI archetype
+  (scalar/batch, multi-output, bars, profile, array input) plus batch equivalence.
 
 ## Contributing
 

ROADMAP.md

@@ -22,7 +22,7 @@ minor releases; breaking changes are called out in the changelog.
 - **Performance.** Keep per-tick updates O(1) and maintain the benchmark suite;
   investigate further allocation and cache improvements.
 - **Bindings parity.** Keep the Python, Node.js and WebAssembly bindings — plus
-  the C ABI and the C# / .NET and Go bindings generated from it — in lockstep with the
+  the C ABI and the C# / .NET, Go, Java and R bindings generated from it — in lockstep with the
   Rust core, including type stubs and platform coverage.
 - **Documentation.** Maintain a deep-dive page per indicator on
   <https://docs.wickra.org>, plus quickstarts and cookbook material.

SUPPORT.md

@@ -7,7 +7,7 @@ Thanks for using Wickra! Here is where to get help, depending on what you need.
 Most questions are answered in the documentation:
 
 - **Docs site:** <https://docs.wickra.org> — quickstarts for Rust, Python,
-  Node.js, WebAssembly, C, C# and Go, a per-indicator reference, warmup periods, the
+  Node.js, WebAssembly, C, C#, Go, Java and R, a per-indicator reference, warmup periods, the
   data layer, and an FAQ.
 - **README:** <https://github.com/wickra-lib/wickra#readme> — installation and a
   quick overview.

THREAT_MODEL.md

@@ -4,7 +4,7 @@ This document describes Wickra's attack surface and the threats considered,
 together with their mitigations. It complements the security assurance case in
 [`SECURITY.md`](SECURITY.md). Wickra is a computational technical-analysis
 library (a Rust core with Python, Node.js and WebAssembly bindings plus a C ABI
-and the .NET and Go bindings built on it),
+and the .NET, Go, Java and R bindings built on it),
 not a network service or trading system; the attack surface is correspondingly
 small.
 

bindings/c/README.md

@@ -9,7 +9,7 @@
 library plus a generated `wickra.h` — no system dependencies.**
 
 Wickra is a multi-language technical-analysis library with a Rust core and
-bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C#, Go and any
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C#, Go, Java, R and any
 other C-capable language. Every indicator is an O(1)
 streaming state machine, so live trading bots and historical backtests share
 the exact same implementation. This package is the **C ABI hub**: it compiles the

bindings/csharp/README.md

@@ -9,7 +9,7 @@
 prebuilt native library, no system dependencies.**
 
 Wickra is a multi-language technical-analysis library with a Rust core and
-bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C#, Go and any
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C#, Go, Java, R and any
 other C-capable language. Every indicator is an O(1)
 streaming state machine, so live trading bots and historical backtests share
 the exact same implementation. This package is the .NET binding; it consumes the

bindings/csharp/Wickra/Wickra.csproj

@@ -11,7 +11,7 @@
 
     <!-- NuGet package metadata -->
     <PackageId>Wickra</PackageId>
-    <Version>0.7.7</Version>
+    <Version>0.7.9</Version>
     <Authors>kingchenc</Authors>
     <Description>High-performance streaming technical-analysis indicators (514 indicators) for .NET, backed by the native Rust core via the Wickra C ABI.</Description>
     <PackageLicenseExpression>MIT OR Apache-2.0</PackageLicenseExpression>

bindings/go/README.md

@@ -8,7 +8,7 @@
 **Streaming-first technical indicators for Go, over the Wickra C ABI hub via cgo.**
 
 Wickra is a multi-language technical-analysis library with a Rust core and
-bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C#, Go and
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C#, Go, Java, R and
 any other C-capable language. Every indicator is an O(1) streaming state machine,
 so live trading bots and historical backtests share the exact same
 implementation. This package is the Go binding; it consumes the C ABI hub through

bindings/java/.gitignore

@@ -0,0 +1,6 @@
+# Maven build output
+target/
+
+# Native libraries staged for packaging (produced by the release pipeline from
+# the wickra-c-<triple>.tar.gz assets; never committed to source).
+src/main/resources/native/

bindings/java/README.md

@@ -0,0 +1,102 @@
+# Wickra — Java
+
+[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![Maven Central](https://img.shields.io/maven-central/v/org.wickra/wickra.svg?logo=apache-maven&color=blue)](https://central.sonatype.com/artifact/org.wickra/wickra)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT_OR_Apache--2.0-blue)](https://github.com/wickra-lib/wickra#license)
+
+**Streaming-first technical indicators for the JVM, on the Java Foreign Function
+& Memory API — prebuilt native library, no JNI, no system dependencies.**
+
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C#, Go, Java, R
+and any other C-capable language. Every indicator is an O(1) streaming state
+machine, so live trading bots and historical backtests share the exact same
+implementation. This package is the Java binding; it consumes the C ABI hub
+through the Panama FFM API (`java.lang.foreign`) and exposes all 514
+streaming-first indicators as idiomatic `AutoCloseable` classes.
+
+## Requirements
+
+- **Java 22 or later** (the FFM API is final since Java 22; no preview flag).
+- The FFM API is *restricted*: pass `--enable-native-access=ALL-UNNAMED` when you
+  run your application to silence the native-access warning.
+
+## Install
+
+Maven:
+
+```xml
+<dependency>
+  <groupId>org.wickra</groupId>
+  <artifactId>wickra</artifactId>
+  <version>0.7.9</version>
+</dependency>
+```
+
+Gradle:
+
+```kotlin
+implementation("org.wickra:wickra:0.7.9")
+```
+
+The native library ships prebuilt per platform (Linux, macOS, Windows — x64 and
+arm64) inside the jar and is extracted automatically on first use. There is
+nothing to compile.
+
+## Quick start
+
+```java
+import org.wickra.Ema;
+import org.wickra.Rsi;
+
+// Batch: run an indicator over a whole series (NaN at warmup positions).
+double[] prices = new double[1000];
+for (int i = 0; i < prices.length; i++) {
+    prices[i] = 100.0 + i * 0.1;
+}
+try (Ema ema = new Ema(20)) {
+    double[] values = ema.batch(prices);
+}
+
+// Streaming: the same indicator, fed tick by tick in O(1).
+try (Rsi rsi = new Rsi(14)) {
+    for (double price : liveFeed) {
+        double value = rsi.update(price); // NaN during warmup, no recomputation
+        if (Double.isFinite(value) && value > 70) {
+            System.out.println("overbought");
+        }
+    }
+}
+```
+
+`batch(prices)` and feeding the same prices through `update()` produce identical
+values — the equivalence is enforced by the test suite. Multi-output indicators
+(MACD, Bollinger, ADX, …) return a `record`, `null` while warming up. Each
+indicator owns a native handle freed by a `Cleaner`; `close()` releases it
+eagerly (use try-with-resources).
+
+## Documentation
+
+The full indicator catalogue, guides, quickstarts, and API reference live in
+the main repository and documentation site:
+
+- **Repository & full indicator list:** <https://github.com/wickra-lib/wickra>
+- **Docs** (quickstarts, cookbook, TA-Lib migration): <https://docs.wickra.org>
+- **Runnable examples:** [`examples/java/`](https://github.com/wickra-lib/wickra/tree/main/examples/java)
+
+Wickra ships native bindings for Python, Node.js, WebAssembly and Rust, plus a
+C ABI hub that any C-capable language (C, C++, Go, C#, Java, R) links against —
+all exposing the same indicators from the shared, `unsafe`-forbidden Rust core.
+
+## Disclaimer
+
+Wickra is an indicator toolkit, not a trading system. The values it computes
+are deterministic transforms of the input data — they are not financial advice
+and do not predict the market. Any use in a live trading context is at your own
+risk. The library is provided **as is**, without warranty of any kind.
+
+## License
+
+Licensed under either of [Apache-2.0](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.

bindings/java/pom.xml

@@ -0,0 +1,171 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>org.wickra</groupId>
+  <artifactId>wickra</artifactId>
+  <version>0.7.9</version>
+  <packaging>jar</packaging>
+
+  <name>Wickra</name>
+  <description>High-performance streaming technical-analysis indicators (514 indicators) for the
+    JVM, backed by the native Rust core through the Wickra C ABI via the Java FFM API (Panama).</description>
+  <url>https://github.com/wickra-lib/wickra</url>
+
+  <licenses>
+    <license>
+      <name>MIT</name>
+      <url>https://opensource.org/licenses/MIT</url>
+      <distribution>repo</distribution>
+    </license>
+    <license>
+      <name>Apache-2.0</name>
+      <url>https://www.apache.org/licenses/LICENSE-2.0</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>kingchenc</id>
+      <name>kingchenc</name>
+      <url>https://github.com/kingchenc</url>
+    </developer>
+  </developers>
+
+  <scm>
+    <connection>scm:git:https://github.com/wickra-lib/wickra.git</connection>
+    <developerConnection>scm:git:https://github.com/wickra-lib/wickra.git</developerConnection>
+    <url>https://github.com/wickra-lib/wickra</url>
+  </scm>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <maven.compiler.release>22</maven.compiler.release>
+    <junit.version>5.10.2</junit.version>
+    <!-- The FFM API is restricted; grant native access to the unnamed module so
+         tests and examples run without warnings. Consumers pass the same flag. -->
+    <native.access.arg>--enable-native-access=ALL-UNNAMED</native.access.arg>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter</artifactId>
+      <version>${junit.version}</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.13.0</version>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>3.2.5</version>
+        <configuration>
+          <argLine>${native.access.arg}</argLine>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>3.4.1</version>
+        <configuration>
+          <archive>
+            <manifestEntries>
+              <!-- Grant native access when the jar is run directly. -->
+              <Enable-Native-Access>ALL-UNNAMED</Enable-Native-Access>
+            </manifestEntries>
+          </archive>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+
+  <profiles>
+    <!--
+      Release profile (CI only, gated): attaches source + javadoc jars, GPG-signs
+      every artifact, and publishes to Maven Central via the central-publishing
+      plugin. The native libraries are unpacked from the wickra-c-<triple>.tar.gz
+      release assets into src/main/resources/native/<os>-<arch>/ before `mvn deploy`,
+      so the published jar carries every platform's library.
+    -->
+    <profile>
+      <id>release</id>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-source-plugin</artifactId>
+            <version>3.3.1</version>
+            <executions>
+              <execution>
+                <id>attach-sources</id>
+                <goals><goal>jar-no-fork</goal></goals>
+              </execution>
+            </executions>
+          </plugin>
+
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-javadoc-plugin</artifactId>
+            <version>3.7.0</version>
+            <configuration>
+              <!-- Generated members are self-descriptive; do not fail on doclint. -->
+              <doclint>none</doclint>
+              <quiet>true</quiet>
+            </configuration>
+            <executions>
+              <execution>
+                <id>attach-javadocs</id>
+                <goals><goal>jar</goal></goals>
+              </execution>
+            </executions>
+          </plugin>
+
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-gpg-plugin</artifactId>
+            <version>3.2.4</version>
+            <executions>
+              <execution>
+                <id>sign-artifacts</id>
+                <phase>verify</phase>
+                <goals><goal>sign</goal></goals>
+                <configuration>
+                  <!-- Non-interactive signing on CI: modern GPG needs loopback
+                       pinentry to take the passphrase from the env without a TTY. -->
+                  <gpgArguments>
+                    <arg>--pinentry-mode</arg>
+                    <arg>loopback</arg>
+                  </gpgArguments>
+                </configuration>
+              </execution>
+            </executions>
+          </plugin>
+
+          <plugin>
+            <groupId>org.sonatype.central</groupId>
+            <artifactId>central-publishing-maven-plugin</artifactId>
+            <version>0.5.0</version>
+            <extensions>true</extensions>
+            <configuration>
+              <publishingServerId>central</publishingServerId>
+              <autoPublish>true</autoPublish>
+            </configuration>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+  </profiles>
+</project>

bindings/java/src/main/java/org/wickra/AbandonedBaby.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AbandonedBaby indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AbandonedBaby implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AbandonedBaby() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ABANDONED_BABY_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AbandonedBaby parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ABANDONED_BABY_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ABANDONED_BABY_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ABANDONED_BABY_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ABANDONED_BABY_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Abcd.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Abcd indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Abcd implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Abcd() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ABCD_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Abcd parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ABCD_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ABCD_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ABCD_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ABCD_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AbsoluteBreadthIndex.java

@@ -0,0 +1,72 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AbsoluteBreadthIndex indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AbsoluteBreadthIndex implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AbsoluteBreadthIndex() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AbsoluteBreadthIndex parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
+        if (volume.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newHigh.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newLow.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (aboveMa.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (onBuySignal.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
+            MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
+            MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
+            MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
+            return (double) NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AccelerationBands.java

@@ -0,0 +1,62 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AccelerationBands indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AccelerationBands implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AccelerationBands(int period, double factor) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ACCELERATION_BANDS_NEW.invokeExact((long) period, factor);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AccelerationBands parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ACCELERATION_BANDS_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public AccelerationBandsOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(24L);
+            byte ok = (byte) NativeMethods.WICKRA_ACCELERATION_BANDS_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new AccelerationBandsOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ACCELERATION_BANDS_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AccelerationBandsOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record AccelerationBandsOutput(double upper, double middle, double lower) {}

bindings/java/src/main/java/org/wickra/AcceleratorOscillator.java

@@ -0,0 +1,95 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AcceleratorOscillator indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AcceleratorOscillator implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AcceleratorOscillator(int aoFast, int aoSlow, int signalPeriod) {
+        if (aoFast < 0) {
+            throw new IllegalArgumentException("aoFast must be non-negative");
+        }
+        if (aoSlow < 0) {
+            throw new IllegalArgumentException("aoSlow must be non-negative");
+        }
+        if (signalPeriod < 0) {
+            throw new IllegalArgumentException("signalPeriod must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_NEW.invokeExact((long) aoFast, (long) aoSlow, (long) signalPeriod);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AcceleratorOscillator parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdOscillator.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AdOscillator indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AdOscillator implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AdOscillator() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AD_OSCILLATOR_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AdOscillator parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AD_OSCILLATOR_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_AD_OSCILLATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_AD_OSCILLATOR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AD_OSCILLATOR_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdVolumeLine.java

@@ -0,0 +1,72 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AdVolumeLine indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AdVolumeLine implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AdVolumeLine() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AD_VOLUME_LINE_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AdVolumeLine parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AD_VOLUME_LINE_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
+        if (volume.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newHigh.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newLow.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (aboveMa.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (onBuySignal.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
+            MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
+            MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
+            MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
+            return (double) NativeMethods.WICKRA_AD_VOLUME_LINE_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AD_VOLUME_LINE_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdaptiveCci.java

@@ -0,0 +1,89 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AdaptiveCci indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AdaptiveCci implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AdaptiveCci(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_CCI_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AdaptiveCci parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADAPTIVE_CCI_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ADAPTIVE_CCI_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ADAPTIVE_CCI_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADAPTIVE_CCI_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdaptiveCycle.java

@@ -0,0 +1,66 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AdaptiveCycle indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AdaptiveCycle implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AdaptiveCycle() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_CYCLE_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AdaptiveCycle parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADAPTIVE_CYCLE_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_ADAPTIVE_CYCLE_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ADAPTIVE_CYCLE_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADAPTIVE_CYCLE_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdaptiveLaguerreFilter.java

@@ -0,0 +1,69 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AdaptiveLaguerreFilter indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AdaptiveLaguerreFilter implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AdaptiveLaguerreFilter(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AdaptiveLaguerreFilter parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdaptiveRsi.java

@@ -0,0 +1,69 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AdaptiveRsi indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AdaptiveRsi implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AdaptiveRsi(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_RSI_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AdaptiveRsi parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADAPTIVE_RSI_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_ADAPTIVE_RSI_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ADAPTIVE_RSI_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADAPTIVE_RSI_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Adl.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Adl indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Adl implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Adl() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADL_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Adl parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADL_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ADL_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ADL_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADL_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdvanceBlock.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AdvanceBlock indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AdvanceBlock implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AdvanceBlock() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADVANCE_BLOCK_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AdvanceBlock parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADVANCE_BLOCK_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ADVANCE_BLOCK_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ADVANCE_BLOCK_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADVANCE_BLOCK_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdvanceDecline.java

@@ -0,0 +1,72 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AdvanceDecline indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AdvanceDecline implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AdvanceDecline() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADVANCE_DECLINE_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AdvanceDecline parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADVANCE_DECLINE_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
+        if (volume.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newHigh.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newLow.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (aboveMa.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (onBuySignal.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
+            MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
+            MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
+            MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
+            return (double) NativeMethods.WICKRA_ADVANCE_DECLINE_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADVANCE_DECLINE_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdvanceDeclineRatio.java

@@ -0,0 +1,72 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AdvanceDeclineRatio indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AdvanceDeclineRatio implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AdvanceDeclineRatio() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AdvanceDeclineRatio parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
+        if (volume.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newHigh.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newLow.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (aboveMa.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (onBuySignal.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
+            MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
+            MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
+            MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
+            return (double) NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Adx.java

@@ -0,0 +1,62 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Adx indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Adx implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Adx(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADX_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Adx parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADX_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public AdxOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(24L);
+            byte ok = (byte) NativeMethods.WICKRA_ADX_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new AdxOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADX_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AdxOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record AdxOutput(double plusDi, double minusDi, double adx) {}

bindings/java/src/main/java/org/wickra/Adxr.java

@@ -0,0 +1,89 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Adxr indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Adxr implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Adxr(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ADXR_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Adxr parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADXR_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ADXR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ADXR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ADXR_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Alligator.java

@@ -0,0 +1,68 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Alligator indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Alligator implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Alligator(int jawPeriod, int teethPeriod, int lipsPeriod) {
+        if (jawPeriod < 0) {
+            throw new IllegalArgumentException("jawPeriod must be non-negative");
+        }
+        if (teethPeriod < 0) {
+            throw new IllegalArgumentException("teethPeriod must be non-negative");
+        }
+        if (lipsPeriod < 0) {
+            throw new IllegalArgumentException("lipsPeriod must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ALLIGATOR_NEW.invokeExact((long) jawPeriod, (long) teethPeriod, (long) lipsPeriod);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Alligator parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ALLIGATOR_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public AlligatorOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(24L);
+            byte ok = (byte) NativeMethods.WICKRA_ALLIGATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new AlligatorOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ALLIGATOR_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AlligatorOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record AlligatorOutput(double jaw, double teeth, double lips) {}

bindings/java/src/main/java/org/wickra/Alma.java

@@ -0,0 +1,69 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Alma indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Alma implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Alma(int period, double offset, double sigma) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ALMA_NEW.invokeExact((long) period, offset, sigma);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Alma parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ALMA_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_ALMA_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ALMA_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ALMA_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Alpha.java

@@ -0,0 +1,73 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Alpha indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Alpha implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Alpha(int period, double riskFree) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ALPHA_NEW.invokeExact((long) period, riskFree);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Alpha parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ALPHA_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double x, double y) {
+        try {
+            return (double) NativeMethods.WICKRA_ALPHA_UPDATE.invokeExact(handle, x, y);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] x, double[] y) {
+        int n = x.length;
+        if (y.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment xSeg = a.allocateFrom(JAVA_DOUBLE, x);
+            MemorySegment ySeg = a.allocateFrom(JAVA_DOUBLE, y);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ALPHA_BATCH.invokeExact(handle, xSeg, ySeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ALPHA_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AmihudIlliquidity.java

@@ -0,0 +1,54 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AmihudIlliquidity indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AmihudIlliquidity implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AmihudIlliquidity(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AmihudIlliquidity parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double price, double size, boolean isBuy, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_UPDATE.invokeExact(handle, price, size, (byte) (isBuy ? 1 : 0), timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AnchoredRsi.java

@@ -0,0 +1,66 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AnchoredRsi indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AnchoredRsi implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AnchoredRsi() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ANCHORED_RSI_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AnchoredRsi parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ANCHORED_RSI_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_ANCHORED_RSI_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ANCHORED_RSI_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ANCHORED_RSI_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AnchoredVwap.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AnchoredVwap indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AnchoredVwap implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AnchoredVwap() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ANCHORED_VWAP_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AnchoredVwap parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ANCHORED_VWAP_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ANCHORED_VWAP_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ANCHORED_VWAP_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ANCHORED_VWAP_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AndrewsPitchfork.java

@@ -0,0 +1,62 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AndrewsPitchfork indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AndrewsPitchfork implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AndrewsPitchfork(int strength) {
+        if (strength < 0) {
+            throw new IllegalArgumentException("strength must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ANDREWS_PITCHFORK_NEW.invokeExact((long) strength);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AndrewsPitchfork parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ANDREWS_PITCHFORK_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public AndrewsPitchforkOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(24L);
+            byte ok = (byte) NativeMethods.WICKRA_ANDREWS_PITCHFORK_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new AndrewsPitchforkOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ANDREWS_PITCHFORK_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AndrewsPitchforkOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record AndrewsPitchforkOutput(double median, double upper, double lower) {}

bindings/java/src/main/java/org/wickra/Apo.java

@@ -0,0 +1,72 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Apo indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Apo implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Apo(int fast, int slow) {
+        if (fast < 0) {
+            throw new IllegalArgumentException("fast must be non-negative");
+        }
+        if (slow < 0) {
+            throw new IllegalArgumentException("slow must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_APO_NEW.invokeExact((long) fast, (long) slow);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Apo parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_APO_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_APO_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_APO_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_APO_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Aroon.java

@@ -0,0 +1,61 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Aroon indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Aroon implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Aroon(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AROON_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Aroon parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AROON_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public AroonOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(16L);
+            byte ok = (byte) NativeMethods.WICKRA_AROON_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new AroonOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AROON_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AroonOscillator.java

@@ -0,0 +1,89 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AroonOscillator indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AroonOscillator implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AroonOscillator(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AROON_OSCILLATOR_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AroonOscillator parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AROON_OSCILLATOR_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_AROON_OSCILLATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_AROON_OSCILLATOR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AROON_OSCILLATOR_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AroonOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record AroonOutput(double up, double down) {}

bindings/java/src/main/java/org/wickra/Atr.java

@@ -0,0 +1,89 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Atr indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Atr implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Atr(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ATR_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Atr parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ATR_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ATR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ATR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ATR_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AtrBands.java

@@ -0,0 +1,62 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AtrBands indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AtrBands implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AtrBands(int period, double multiplier) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ATR_BANDS_NEW.invokeExact((long) period, multiplier);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AtrBands parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ATR_BANDS_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public AtrBandsOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(24L);
+            byte ok = (byte) NativeMethods.WICKRA_ATR_BANDS_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new AtrBandsOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ATR_BANDS_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AtrBandsOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record AtrBandsOutput(double upper, double middle, double lower) {}

bindings/java/src/main/java/org/wickra/AtrRatchet.java

@@ -0,0 +1,61 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AtrRatchet indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AtrRatchet implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AtrRatchet(int atrPeriod, double startMult, double increment) {
+        if (atrPeriod < 0) {
+            throw new IllegalArgumentException("atrPeriod must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ATR_RATCHET_NEW.invokeExact((long) atrPeriod, startMult, increment);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AtrRatchet parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ATR_RATCHET_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public AtrRatchetOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(16L);
+            byte ok = (byte) NativeMethods.WICKRA_ATR_RATCHET_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new AtrRatchetOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ATR_RATCHET_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AtrRatchetOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record AtrRatchetOutput(double value, double direction) {}

bindings/java/src/main/java/org/wickra/AtrTrailingStop.java

@@ -0,0 +1,89 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AtrTrailingStop indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AtrTrailingStop implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AtrTrailingStop(int atrPeriod, double multiplier) {
+        if (atrPeriod < 0) {
+            throw new IllegalArgumentException("atrPeriod must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_ATR_TRAILING_STOP_NEW.invokeExact((long) atrPeriod, multiplier);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AtrTrailingStop parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ATR_TRAILING_STOP_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_ATR_TRAILING_STOP_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_ATR_TRAILING_STOP_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_ATR_TRAILING_STOP_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AutoFib.java

@@ -0,0 +1,63 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AutoFib indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AutoFib implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AutoFib() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AUTO_FIB_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AutoFib parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AUTO_FIB_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public AutoFibOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(56L);
+            byte ok = (byte) NativeMethods.WICKRA_AUTO_FIB_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new AutoFibOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L),
+                out.get(JAVA_DOUBLE, 24L),
+                out.get(JAVA_DOUBLE, 32L),
+                out.get(JAVA_DOUBLE, 40L),
+                out.get(JAVA_DOUBLE, 48L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AUTO_FIB_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AutoFibOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record AutoFibOutput(double level0, double level236, double level382, double level500, double level618, double level786, double level1000) {}

bindings/java/src/main/java/org/wickra/Autocorrelation.java

@@ -0,0 +1,72 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Autocorrelation indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Autocorrelation implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Autocorrelation(int period, int lag) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        if (lag < 0) {
+            throw new IllegalArgumentException("lag must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AUTOCORRELATION_NEW.invokeExact((long) period, (long) lag);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Autocorrelation parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AUTOCORRELATION_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_AUTOCORRELATION_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_AUTOCORRELATION_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AUTOCORRELATION_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AutocorrelationPeriodogram.java

@@ -0,0 +1,72 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AutocorrelationPeriodogram indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AutocorrelationPeriodogram implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AutocorrelationPeriodogram(int minPeriod, int maxPeriod) {
+        if (minPeriod < 0) {
+            throw new IllegalArgumentException("minPeriod must be non-negative");
+        }
+        if (maxPeriod < 0) {
+            throw new IllegalArgumentException("maxPeriod must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_NEW.invokeExact((long) minPeriod, (long) maxPeriod);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AutocorrelationPeriodogram parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AverageDailyRange.java

@@ -0,0 +1,89 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AverageDailyRange indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AverageDailyRange implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AverageDailyRange(int period, int utcOffsetMinutes) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_NEW.invokeExact((long) period, utcOffsetMinutes);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AverageDailyRange parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AverageDrawdown.java

@@ -0,0 +1,69 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AverageDrawdown indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AverageDrawdown implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AverageDrawdown(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AVERAGE_DRAWDOWN_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AverageDrawdown parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AVERAGE_DRAWDOWN_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_AVERAGE_DRAWDOWN_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_AVERAGE_DRAWDOWN_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AVERAGE_DRAWDOWN_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AvgPrice.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AvgPrice indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AvgPrice implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AvgPrice() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AVG_PRICE_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AvgPrice parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AVG_PRICE_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_AVG_PRICE_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_AVG_PRICE_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AVG_PRICE_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AwesomeOscillator.java

@@ -0,0 +1,92 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AwesomeOscillator indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AwesomeOscillator implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AwesomeOscillator(int fast, int slow) {
+        if (fast < 0) {
+            throw new IllegalArgumentException("fast must be non-negative");
+        }
+        if (slow < 0) {
+            throw new IllegalArgumentException("slow must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AWESOME_OSCILLATOR_NEW.invokeExact((long) fast, (long) slow);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AwesomeOscillator parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AWESOME_OSCILLATOR_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_AWESOME_OSCILLATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_AWESOME_OSCILLATOR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AWESOME_OSCILLATOR_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/AwesomeOscillatorHistogram.java

@@ -0,0 +1,95 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming AwesomeOscillatorHistogram indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class AwesomeOscillatorHistogram implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public AwesomeOscillatorHistogram(int fast, int slow, int smaPeriod) {
+        if (fast < 0) {
+            throw new IllegalArgumentException("fast must be non-negative");
+        }
+        if (slow < 0) {
+            throw new IllegalArgumentException("slow must be non-negative");
+        }
+        if (smaPeriod < 0) {
+            throw new IllegalArgumentException("smaPeriod must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_NEW.invokeExact((long) fast, (long) slow, (long) smaPeriod);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid AwesomeOscillatorHistogram parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BalanceOfPower.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BalanceOfPower indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BalanceOfPower implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BalanceOfPower() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BALANCE_OF_POWER_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BalanceOfPower parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BALANCE_OF_POWER_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_BALANCE_OF_POWER_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BALANCE_OF_POWER_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BALANCE_OF_POWER_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BandpassFilter.java

@@ -0,0 +1,69 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BandpassFilter indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BandpassFilter implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BandpassFilter(int period, double bandwidth) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BANDPASS_FILTER_NEW.invokeExact((long) period, bandwidth);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BandpassFilter parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BANDPASS_FILTER_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_BANDPASS_FILTER_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BANDPASS_FILTER_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BANDPASS_FILTER_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Bat.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Bat indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Bat implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Bat() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BAT_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Bat parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BAT_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_BAT_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BAT_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BAT_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BeltHold.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BeltHold indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BeltHold implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BeltHold() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BELT_HOLD_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BeltHold parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BELT_HOLD_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_BELT_HOLD_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BELT_HOLD_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BELT_HOLD_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Beta.java

@@ -0,0 +1,73 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Beta indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Beta implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Beta(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BETA_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Beta parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BETA_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double x, double y) {
+        try {
+            return (double) NativeMethods.WICKRA_BETA_UPDATE.invokeExact(handle, x, y);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] x, double[] y) {
+        int n = x.length;
+        if (y.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment xSeg = a.allocateFrom(JAVA_DOUBLE, x);
+            MemorySegment ySeg = a.allocateFrom(JAVA_DOUBLE, y);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BETA_BATCH.invokeExact(handle, xSeg, ySeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BETA_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BetaNeutralSpread.java

@@ -0,0 +1,73 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BetaNeutralSpread indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BetaNeutralSpread implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BetaNeutralSpread(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BetaNeutralSpread parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double x, double y) {
+        try {
+            return (double) NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_UPDATE.invokeExact(handle, x, y);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] x, double[] y) {
+        int n = x.length;
+        if (y.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment xSeg = a.allocateFrom(JAVA_DOUBLE, x);
+            MemorySegment ySeg = a.allocateFrom(JAVA_DOUBLE, y);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_BATCH.invokeExact(handle, xSeg, ySeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BetterVolume.java

@@ -0,0 +1,89 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BetterVolume indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BetterVolume implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BetterVolume(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BETTER_VOLUME_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BetterVolume parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BETTER_VOLUME_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_BETTER_VOLUME_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BETTER_VOLUME_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BETTER_VOLUME_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BipowerVariation.java

@@ -0,0 +1,69 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BipowerVariation indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BipowerVariation implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BipowerVariation(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BIPOWER_VARIATION_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BipowerVariation parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BIPOWER_VARIATION_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_BIPOWER_VARIATION_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BIPOWER_VARIATION_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BIPOWER_VARIATION_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BodySizePct.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BodySizePct indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BodySizePct implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BodySizePct() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BODY_SIZE_PCT_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BodySizePct parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BODY_SIZE_PCT_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_BODY_SIZE_PCT_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BODY_SIZE_PCT_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BODY_SIZE_PCT_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BollingerBands.java

@@ -0,0 +1,63 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BollingerBands indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BollingerBands implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BollingerBands(int period, double multiplier) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BOLLINGER_BANDS_NEW.invokeExact((long) period, multiplier);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BollingerBands parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BOLLINGER_BANDS_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public BollingerOutput update(double value) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(32L);
+            byte ok = (byte) NativeMethods.WICKRA_BOLLINGER_BANDS_UPDATE.invokeExact(handle, value, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new BollingerOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L),
+                out.get(JAVA_DOUBLE, 24L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BOLLINGER_BANDS_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BollingerBandwidth.java

@@ -0,0 +1,69 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BollingerBandwidth indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BollingerBandwidth implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BollingerBandwidth(int period, double multiplier) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_NEW.invokeExact((long) period, multiplier);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BollingerBandwidth parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BollingerOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record BollingerOutput(double upper, double middle, double lower, double stddev) {}

bindings/java/src/main/java/org/wickra/BomarBands.java

@@ -0,0 +1,62 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BomarBands indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BomarBands implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BomarBands(int period, double coverage) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BOMAR_BANDS_NEW.invokeExact((long) period, coverage);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BomarBands parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BOMAR_BANDS_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public BomarBandsOutput update(double value) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(24L);
+            byte ok = (byte) NativeMethods.WICKRA_BOMAR_BANDS_UPDATE.invokeExact(handle, value, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new BomarBandsOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BOMAR_BANDS_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BomarBandsOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record BomarBandsOutput(double upper, double middle, double lower) {}

bindings/java/src/main/java/org/wickra/BreadthThrust.java

@@ -0,0 +1,75 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BreadthThrust indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BreadthThrust implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BreadthThrust(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BREADTH_THRUST_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BreadthThrust parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BREADTH_THRUST_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
+        if (volume.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newHigh.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newLow.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (aboveMa.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (onBuySignal.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
+            MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
+            MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
+            MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
+            return (double) NativeMethods.WICKRA_BREADTH_THRUST_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BREADTH_THRUST_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Breakaway.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Breakaway indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Breakaway implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Breakaway() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BREAKAWAY_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Breakaway parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BREAKAWAY_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_BREAKAWAY_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BREAKAWAY_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BREAKAWAY_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BullishPercentIndex.java

@@ -0,0 +1,72 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BullishPercentIndex indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BullishPercentIndex implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BullishPercentIndex() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BullishPercentIndex parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
+        if (volume.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newHigh.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (newLow.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (aboveMa.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        if (onBuySignal.length != change.length) {
+            throw new IllegalArgumentException("input arrays in the same group must have equal length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
+            MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
+            MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
+            MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
+            return (double) NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/BurkeRatio.java

@@ -0,0 +1,69 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming BurkeRatio indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class BurkeRatio implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public BurkeRatio(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BURKE_RATIO_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid BurkeRatio parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BURKE_RATIO_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_BURKE_RATIO_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BURKE_RATIO_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BURKE_RATIO_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Butterfly.java

@@ -0,0 +1,86 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Butterfly indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Butterfly implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Butterfly() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_BUTTERFLY_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Butterfly parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BUTTERFLY_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_BUTTERFLY_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_BUTTERFLY_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_BUTTERFLY_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/CalendarSpread.java

@@ -0,0 +1,51 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming CalendarSpread indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class CalendarSpread implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public CalendarSpread() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_CALENDAR_SPREAD_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid CalendarSpread parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CALENDAR_SPREAD_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_CALENDAR_SPREAD_UPDATE.invokeExact(handle, fundingRate, markPrice, indexPrice, futuresPrice, openInterest, longSize, shortSize, takerBuyVolume, takerSellVolume, longLiquidation, shortLiquidation, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_CALENDAR_SPREAD_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/CalmarRatio.java

@@ -0,0 +1,69 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming CalmarRatio indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class CalmarRatio implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public CalmarRatio(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_CALMAR_RATIO_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid CalmarRatio parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CALMAR_RATIO_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double value) {
+        try {
+            return (double) NativeMethods.WICKRA_CALMAR_RATIO_UPDATE.invokeExact(handle, value);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] input) {
+        int n = input.length;
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_CALMAR_RATIO_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_CALMAR_RATIO_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/Camarilla.java

@@ -0,0 +1,65 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Camarilla indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Camarilla implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Camarilla() {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_CAMARILLA_NEW.invokeExact();
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Camarilla parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CAMARILLA_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public CamarillaPivotsOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(72L);
+            byte ok = (byte) NativeMethods.WICKRA_CAMARILLA_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new CamarillaPivotsOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L),
+                out.get(JAVA_DOUBLE, 24L),
+                out.get(JAVA_DOUBLE, 32L),
+                out.get(JAVA_DOUBLE, 40L),
+                out.get(JAVA_DOUBLE, 48L),
+                out.get(JAVA_DOUBLE, 56L),
+                out.get(JAVA_DOUBLE, 64L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_CAMARILLA_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/CamarillaPivotsOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record CamarillaPivotsOutput(double pp, double r1, double r2, double r3, double r4, double s1, double s2, double s3, double s4) {}

bindings/java/src/main/java/org/wickra/CandleVolume.java

@@ -0,0 +1,61 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming CandleVolume indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class CandleVolume implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public CandleVolume(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_CANDLE_VOLUME_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid CandleVolume parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CANDLE_VOLUME_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public CandleVolumeOutput update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(16L);
+            byte ok = (byte) NativeMethods.WICKRA_CANDLE_VOLUME_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new CandleVolumeOutput(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_CANDLE_VOLUME_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/CandleVolumeOutput.java

@@ -0,0 +1,5 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+/** Output record produced by the matching indicator. */
+public record CandleVolumeOutput(double body, double width) {}

bindings/java/src/main/java/org/wickra/Cci.java

@@ -0,0 +1,89 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Cci indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Cci implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Cci(int period) {
+        if (period < 0) {
+            throw new IllegalArgumentException("period must be non-negative");
+        }
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_CCI_NEW.invokeExact((long) period);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Cci parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CCI_FREE);
+    }
+
+    /** Push one observation; returns the indicator value (NaN during warmup). */
+    public double update(double open, double high, double low, double close, double volume, long timestamp) {
+        try {
+            return (double) NativeMethods.WICKRA_CCI_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Vectorized update over a whole series; NaN at warmup positions. */
+    public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
+        int n = open.length;
+        if (high.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (low.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (close.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (volume.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        if (timestamp.length != n) {
+            throw new IllegalArgumentException("all input arrays must have the same length");
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
+            MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
+            MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
+            MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
+            MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
+            MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
+            MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
+            NativeMethods.WICKRA_CCI_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
+            double[] out = new double[n];
+            MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
+            return out;
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Reset to the just-constructed state. */
+    public void reset() {
+        try {
+            NativeMethods.WICKRA_CCI_RESET.invokeExact(handle);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}