release: bump 0.8.2 -> 0.8.3 (#249 )

Version bump 0.8.2 → 0.8.3, releasing the per-binding throughput benchmark work (merged in #246). Bumped via `ScriptHelpers/bump_version.py` across all manual touchpoints — `Cargo.toml`, `pyproject.toml`, the Node `package.json` + 6 platform packages + both lockfiles, the Java `pom.xml`s + README, the C# `.csproj`, the R `DESCRIPTION` — plus `Cargo.lock` (via `cargo build`) and the `CHANGELOG.md` `[0.8.3]` section and compare URLs. CHANGELOG `[0.8.3]`: - Per-binding throughput benchmarks for all 9 targets (BENCHMARKS.md §3). - C ABI archetype test (`examples/c/archetypes.c`). `cargo fmt`, `cargo test --workspace --all-features` (all green) and `cargo clippy --workspace --all-targets --all-features -D warnings` pass. The docs/webpage version strings are bumped by `sync-about.yml` on the `v*` tag — not touched here.
Per-binding throughput benchmarks + test-coverage gaps (#246 )
2026-06-10 03:55:39 +02:00 · 2026-06-10 03:46:38 +02:00 · 2026-06-10 01:57:10 +02:00 · 2026-06-10 01:44:48 +02:00 · 2026-06-10 01:08:37 +02:00 · 2026-06-10 00:47:13 +02:00
56 changed files with 12661 additions and 123 deletions
@@ -11,10 +11,13 @@ bindings/c/include/wickra.h text eol=lf
 *.cs text eol=lf

 # Go sources (including the generated binding) are pinned to LF so gofmt's CI
-# check never trips on a CRLF checkout on Windows.
+# check never trips on a CRLF checkout on Windows. The vendored C ABI header is
+# a committed copy of bindings/c/include/wickra.h (the parent dir is outside the
+# Go module), pinned to LF so the drift check never trips on CRLF.
 *.go text eol=lf
 go.mod text eol=lf
 go.sum text eol=lf
+bindings/go/include/wickra.h 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.
@@ -23,8 +26,9 @@ go.sum 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 text eol=lf
 bindings/r/configure.win text eol=lf
-bindings/r/src/Makevars text eol=lf
+bindings/r/src/Makevars.in text eol=lf
 bindings/r/src/Makevars.win text eol=lf
 bindings/r/src/wickra.c text eol=lf

@@ -778,15 +778,36 @@ jobs:
      - name: Build the C ABI library
        run: cargo build -p wickra-c --release

+      - name: Vendored header in sync with the C ABI
+        shell: bash
+        # bindings/go/include/wickra.h is a committed copy of the cbindgen header
+        # (the parent ../c/include is outside the Go module, so it must be
+        # vendored). Fail if it drifts from the source of truth.
+        run: |
+          if ! diff -u bindings/c/include/wickra.h bindings/go/include/wickra.h; then
+            echo "::error::bindings/go/include/wickra.h is stale — copy bindings/c/include/wickra.h over it"
+            exit 1
+          fi
+
      - name: Stage the native library
        shell: bash
+        # Stage into lib/<goos>_<goarch>/ to match the per-platform cgo LDFLAGS.
+        # CI builds the host target, so RUNNER_OS/ARCH give the right directory
+        # (note macos-latest is arm64).
        run: |
-          mkdir -p bindings/go/lib
-          case "$RUNNER_OS" in
-            Linux)   cp target/release/libwickra.so    bindings/go/lib/ ;;
-            macOS)   cp target/release/libwickra.dylib  bindings/go/lib/ ;;
-            Windows) cp target/release/wickra.dll       bindings/go/lib/ ;;
+          case "$RUNNER_ARCH" in
+            X64) arch=amd64 ;;
+            ARM64) arch=arm64 ;;
+            *) echo "::error::unsupported RUNNER_ARCH '$RUNNER_ARCH'"; exit 1 ;;
          esac
+          case "$RUNNER_OS" in
+            Linux)   dir="linux_$arch";   lib=target/release/libwickra.so ;;
+            macOS)   dir="darwin_$arch";  lib=target/release/libwickra.dylib ;;
+            Windows) dir="windows_$arch"; lib=target/release/wickra.dll ;;
+          esac
+          mkdir -p "bindings/go/lib/$dir"
+          cp "$lib" "bindings/go/lib/$dir/"
+          echo "WICKRA_GO_LIBDIR=$PWD/bindings/go/lib/$dir" >> "$GITHUB_ENV"

      - name: Go info
        run: go version
@@ -801,9 +822,11 @@ jobs:

      - name: Vet and test the Go binding
        shell: bash
-        # On Windows there is no rpath; the loader resolves wickra.dll via PATH.
+        # On Windows there is no rpath; the loader resolves wickra.dll via PATH
+        # (WICKRA_GO_LIBDIR is the per-platform staged lib dir). Linux/macOS use
+        # the rpath baked by the per-platform cgo LDFLAGS.
        run: |
-          export PATH="$PWD/bindings/go/lib:$PATH"
+          export PATH="$WICKRA_GO_LIBDIR:$PATH"
          cd bindings/go
          go vet ./...
          go test ./...
@@ -811,7 +834,7 @@ jobs:
      - name: Build the Go examples
        shell: bash
        run: |
-          export PATH="$PWD/bindings/go/lib:$PATH"
+          export PATH="$WICKRA_GO_LIBDIR:$PATH"
          cd examples/go
          go build ./...

@@ -819,7 +842,7 @@ jobs:
      - name: Run the offline Go examples
        shell: bash
        run: |
-          export PATH="$PWD/bindings/go/lib:$PATH"
+          export PATH="$WICKRA_GO_LIBDIR:$PATH"
          cd examples/go
          for d in streaming backtest multi_timeframe parallel_assets \
                   strategy_rsi_mean_reversion strategy_macd_adx strategy_bollinger_squeeze; do
@@ -868,23 +891,24 @@ jobs:

      - 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.
+        # github.workspace is a backslash path on Windows; configure(.win) (sh) and
+        # mingw need forward slashes. WICKRA_*_DIR makes configure use the locally
+        # built C ABI (dev override) instead of downloading the release asset, so
+        # CI is version-independent. Deliberately do NOT set LD_LIBRARY_PATH /
+        # DYLD_LIBRARY_PATH: the lib is bundled into the package and must resolve
+        # via the rpath ($ORIGIN / @loader_path) baked by configure — that is the
+        # self-contained install path real users (and r-universe) get.
        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
+        # No loader-path exports: the installed package is self-contained (bundled
+        # lib + rpath), so the examples exercise exactly what end users run.
        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
@@ -775,6 +775,97 @@ jobs:
          GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
        run: mvn -B -f bindings/java -Prelease deploy -DskipTests

+  # Mirror the in-repo Go module (bindings/go) to the standalone wickra-go
+  # repository so `go get github.com/wickra-lib/wickra-go` builds with no extra
+  # steps. The in-repo module keeps the prebuilt libraries git-ignored; the
+  # mirror commits them per platform under lib/<goos>_<goarch>/ alongside the
+  # vendored header. Independent of the GitHub-release job so a Go hiccup never
+  # blocks the C/C++ asset release. The push uses a fine-grained PAT
+  # (WICKRA_GO_MIRROR_TOKEN, contents:write on wickra-go); the mirror is a
+  # derived artifact, so its bot commit is intentionally unsigned.
+  go-mirror:
+    name: Mirror the Go module to wickra-go
+    needs: c-abi-build
+    runs-on: ubuntu-latest
+    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: Assemble the wickra-go module tree
+        shell: bash
+        run: |
+          set -e
+          out=wickra-go-module
+          mkdir -p "$out/include" "$out/lib"
+          # Single-package Go source + vendored C ABI header.
+          cp bindings/go/*.go "$out/"
+          cp bindings/go/include/wickra.h "$out/include/"
+          cp bindings/go/README.md "$out/"
+          # Ship the dual license so pkg.go.dev detects a redistributable license.
+          cp LICENSE-MIT LICENSE-APACHE "$out/"
+          # Standalone module path (the in-repo go.mod points at the subdir).
+          printf 'module github.com/wickra-lib/wickra-go\n\ngo 1.23\n' > "$out/go.mod"
+          # Point install instructions at the standalone module path.
+          sed -i 's#github.com/wickra-lib/wickra/bindings/go#github.com/wickra-lib/wickra-go#g' \
+            "$out/README.md" "$out"/*.go
+          # Stage each prebuilt library under lib/<goos>_<goarch>/ (committed in
+          # the mirror, unlike the in-repo lib/.gitignore). "<dir> <libfile>".
+          declare -A GO=(
+            [x86_64-unknown-linux-gnu]="linux_amd64 libwickra.so"
+            [aarch64-unknown-linux-gnu]="linux_arm64 libwickra.so"
+            [x86_64-apple-darwin]="darwin_amd64 libwickra.dylib"
+            [aarch64-apple-darwin]="darwin_arm64 libwickra.dylib"
+            [x86_64-pc-windows-msvc]="windows_amd64 wickra.dll"
+            [aarch64-pc-windows-msvc]="windows_arm64 wickra.dll"
+          )
+          for target in "${!GO[@]}"; do
+            read -r dir libfile <<< "${GO[$target]}"
+            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"
+            src=$(find "$tmp" -name "$libfile" | head -1)
+            if [ -z "$src" ]; then
+              echo "::error::missing $libfile for $target"; exit 1
+            fi
+            mkdir -p "$out/lib/$dir"; cp "$src" "$out/lib/$dir/"
+          done
+          echo "assembled module:"; find "$out" -type f | sort
+
+      - name: Push to wickra-go and tag the release
+        shell: bash
+        env:
+          MIRROR_TOKEN: ${{ secrets.WICKRA_GO_MIRROR_TOKEN }}
+        run: |
+          set -e
+          version="${GITHUB_REF_NAME#v}"
+          remote="https://x-access-token:${MIRROR_TOKEN}@github.com/wickra-lib/wickra-go.git"
+          git clone -q "$remote" mirror-repo
+          cd mirror-repo
+          git config user.name "wickra-bot"
+          git config user.email "support@wickra.org"
+          git symbolic-ref HEAD refs/heads/main
+          # Replace all tracked content with the freshly assembled tree.
+          find . -mindepth 1 -maxdepth 1 -not -name .git -exec rm -rf {} +
+          cp -r ../wickra-go-module/. .
+          git add -A
+          if git diff --cached --quiet; then
+            echo "wickra-go already up to date; tagging only"
+          else
+            git -c commit.gpgsign=false commit -q -m "Release v$version"
+          fi
+          git push origin HEAD:refs/heads/main
+          git tag "v$version"
+          git push origin "v$version"
+
  github-release:
    name: Attach assets to the draft GitHub Release
    needs: [cargo-publish, python-publish, node-publish, wasm-publish, c-abi-build]
@@ -332,12 +332,14 @@ jobs:
            exit 0
          fi
          cd docs-ver
-          # Published-versions table rows (crates.io / PyPI / npm): replace only the
-          # version number, leaving the trailing padding + pipe intact. The '.' in
-          # the quickstart pattern matches the literal backtick around the version
-          # without needing a backtick in this shell string. Historical "since
-          # X.Y.Z" references contain no such anchor and are never matched.
-          sed -i -E "s/^(\| (crates\.io|PyPI|npm) .*\| )[0-9]+\.[0-9]+\.[0-9]+/\1${version}/" overview.md
+          # Published-versions table rows (all registries): replace only the
+          # version number, leaving the trailing padding + pipe intact. The
+          # registry name is matched whether plain or wrapped in a markdown link
+          # (\[?...\]?). The '.' in the quickstart pattern matches the literal
+          # backtick around the version without needing a backtick in this shell
+          # string. Historical "since X.Y.Z" references contain no such anchor and
+          # are never matched.
+          sed -i -E "s/^(\| \[?(crates\.io|PyPI|npm|NuGet|Maven Central|Go|r-universe)\]?.*\| )[0-9]+\.[0-9]+\.[0-9]+/\1${version}/" overview.md
          sed -i -E "s/(published crate is at version .)[0-9]+\.[0-9]+\.[0-9]+/\1${version}/" Quickstart-Rust.md
          if git diff --quiet; then
            echo "Docs version already at ${version}."
@@ -55,6 +55,7 @@ bindings/node/npm-debug.log*

 # WASM build output
 bindings/wasm/pkg/
+bindings/wasm/pkg-node/

 # Python venv
 .venv/
@@ -94,3 +94,75 @@ cargo bench -p wickra-bench            # Rust core vs kand / ta-rs / yata
 pip install -e bindings/python[bench]  # Python peers
 python -m benchmarks.compare_libraries
 ```
+
+## 3. Per-binding throughput — the cost of the boundary
+
+The sections above compare Wickra against other libraries, which only exists for
+Python and Rust (there is no comparable streaming TA library for C, C#, Go, Java,
+R or WebAssembly to benchmark against). Every binding calls the **same** Rust
+core, so these per-binding benchmarks are **not** a speed claim and **not** a
+cross-library ratio — they document the raw cost of crossing each language's FFI
+boundary, in million updates per second (Mupd/s).
+
+Each binding ships a small `throughput` benchmark that feeds a synthetic OHLCV
+series through three indicators chosen by call-signature archetype — `SMA(20)`
+(1-in → 1-out), `ATR(14)` (multi-in → 1-out) and `MACD(12,26,9)` (1-in →
+multi-out). Two things fall out of the numbers:
+
+- **Batch converges.** A `batch` call crosses the boundary once and the Rust core
+  computes the whole series internally, so batch throughput is roughly the same
+  in every binding — close to the core speed.
+- **Streaming reveals the boundary.** A per-tick `update` crosses the boundary
+  once per value, so streaming throughput is where the bindings differ: the raw C
+  ABI and P/Invoke-style calls are nearly free, while managed or interpreted
+  per-call marshalling (cgo, FFM, the R/WASM boundary) costs more per tick.
+
+The Rust core ships the same benchmark with **no** FFI boundary
+(`examples/rust/.../throughput.rs`) — it is the ceiling each binding is measured
+against and the value the batch paths converge towards.
+
+`SMA(20)`, 200 000 bars, median of 3 runs, on the reference machine (Windows 11,
+AMD Ryzen 9 9950X):
+
+| Target               | streaming (Mupd/s) | batch (Mupd/s) |
+|----------------------|-------------------:|---------------:|
+| Rust core (no FFI)   |                391 |            500 |
+| C                    |                383 |            330 |
+| C# / .NET            |                337 |            244 |
+| Python               |                 33 |            488 |
+| Java                 |                 28 |            175 |
+| Go                   |                 24 |            400 |
+| WebAssembly          |                 19 |            167 |
+| Node.js              |                 17 |             10 |
+| R                    |                0.1 |            193 |
+
+Streaming spans more than three orders of magnitude — the raw C ABI (383) is
+nearly the FFI-free Rust ceiling (391), while R's per-call interpreter overhead
+(0.1) makes streaming ~2000× slower than its own batch. Batch converges near the
+core speed for the zero-copy bindings (numpy, slices, typed arrays); the two
+outliers are Node — whose napi `batch` boxes every element into a JS `Array` —
+and R. These are machine-dependent and reflect FFI overhead, not algorithm
+speed.
+
+These are throughput numbers, not competitive numbers — the "Wickra is fast"
+claim lives in sections 1 and 2 (Rust core + the Python/Rust cross-library runs).
+
+Run any target's benchmark (build the C ABI library first where it links one):
+
+```bash
+cargo run -p wickra-examples --release --bin throughput           # Rust core baseline (no FFI)
+
+node bindings/node/benchmarks/throughput.js                       # native napi-rs
+( cd bindings/python && python -m benchmarks.throughput )         # native PyO3
+( cd bindings/wasm && wasm-pack build --target nodejs --out-dir pkg-node --release ) \
+  && node bindings/wasm/benchmarks/throughput.mjs                 # wasm boundary
+
+cargo build -p wickra-c --release                                 # the C ABI hub
+cmake -S bindings/c/benchmarks -B build/cbench && cmake --build build/cbench \
+  && ./build/cbench/throughput                                    # raw C ABI
+dotnet run -c Release --project bindings/csharp/benchmarks        # C# / .NET (P/Invoke)
+( cd bindings/go/benchmarks && go run . )                         # Go (cgo)
+mvn -q -f bindings/java install -DskipTests \
+  && mvn -q -f bindings/java/benchmarks exec:exec -Dexec.mainClass=org.wickra.benchmarks.Throughput
+Rscript bindings/r/benchmarks/throughput.R                        # R (.Call)
+```
@@ -5,6 +5,56 @@ 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).

+## [0.8.3] - 2026-06-10
+### Added
+- **Per-binding throughput benchmarks** — every target now ships a `throughput`
+  benchmark mirroring the Node `throughput.js`: streaming and batch
+  updates-per-second for `SMA(20)`, `ATR(14)` and `MACD(12,26,9)` over a
+  synthetic OHLCV series. New for Python (`bindings/python/benchmarks/`), C
+  (`bindings/c/benchmarks/`), C# (`bindings/csharp/benchmarks/`), Go
+  (`bindings/go/benchmarks/`), Java (`bindings/java/benchmarks/`), R
+  (`bindings/r/benchmarks/`), WebAssembly (`bindings/wasm/benchmarks/`) and the
+  Rust core baseline (`examples/rust/.../throughput.rs`, no FFI). They measure
+  each binding's FFI overhead — the same Rust core runs underneath all of them —
+  and are documented in [BENCHMARKS.md](BENCHMARKS.md) §3, not a cross-library
+  speed claim.
+- **C ABI archetype test** — `examples/c/archetypes.c` exercises one indicator
+  per FFI archetype (scalar, multi-output, bars, profile, array input) through
+  the C boundary, matching the Go/R/Java suites.
+
+## [0.8.2] - 2026-06-10
+### Fixed
+- **R binding builds for WebAssembly** — `bindings/r/configure` now builds the
+  C ABI from source for the `wasm32-unknown-emscripten` target (r-universe /
+  webR) using the build image's cargo + emscripten, instead of failing with
+  "unsupported OS Emscripten". rayon is dropped on wasm via
+  `--no-default-features`; the indicators are pure computation, so the serial
+  path is functionally identical.
+
+## [0.8.1] - 2026-06-10
+### Fixed
+- **`wickra-go` license** — the release-time Go module mirror now ships the dual
+  `LICENSE-MIT` and `LICENSE-APACHE` files, so pkg.go.dev detects a
+  redistributable license for `github.com/wickra-lib/wickra-go`. The previous
+  mirror shipped no license file.
+
+## [0.8.0] - 2026-06-09
+### Added
+- **Standalone `wickra-go` module** — the Go binding is now mirrored to a
+  dedicated `github.com/wickra-lib/wickra-go` repository on every release, with
+  the prebuilt C ABI libraries committed per platform under
+  `lib/<goos>_<goarch>/` and the C ABI header vendored alongside the source, so
+  `go get github.com/wickra-lib/wickra-go` builds with no extra steps. The
+  in-repo `bindings/go` module is unchanged for repo-clone workflows.
+
+### Changed
+- **Go binding (`bindings/go`) is self-contained** — the C ABI header is now
+  vendored inside the module (`bindings/go/include/wickra.h`) instead of being
+  referenced from the parent `bindings/c` directory, and the cgo link flags
+  resolve the prebuilt library per `GOOS`/`GOARCH` under `lib/<goos>_<goarch>/`.
+  This removes the dependency on a full repository checkout for building the
+  module.
+
 ## [0.7.9] - 2026-06-09
 ### Added
 - **Java binding (`bindings/java`)** — a Java binding reaching the C ABI hub
@@ -1461,7 +1511,11 @@ 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.9...HEAD
+[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.8.3...HEAD
+[0.8.3]: https://github.com/wickra-lib/wickra/compare/v0.8.2...v0.8.3
+[0.8.2]: https://github.com/wickra-lib/wickra/compare/v0.8.1...v0.8.2
+[0.8.1]: https://github.com/wickra-lib/wickra/compare/v0.8.0...v0.8.1
+[0.8.0]: https://github.com/wickra-lib/wickra/compare/v0.7.9...v0.8.0
 [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
@@ -1944,7 +1944,7 @@ dependencies = [

 [[package]]
 name = "wickra"
-version = "0.7.9"
+version = "0.8.3"
 dependencies = [
 "approx",
 "criterion",
@@ -1955,7 +1955,7 @@ dependencies = [

 [[package]]
 name = "wickra-bench"
-version = "0.7.9"
+version = "0.8.3"
 dependencies = [
 "criterion",
 "kand",
@@ -1967,14 +1967,14 @@ dependencies = [

 [[package]]
 name = "wickra-c"
-version = "0.7.9"
+version = "0.8.3"
 dependencies = [
 "wickra-core",
 ]

 [[package]]
 name = "wickra-core"
-version = "0.7.9"
+version = "0.8.3"
 dependencies = [
 "approx",
 "proptest",
@@ -1984,7 +1984,7 @@ dependencies = [

 [[package]]
 name = "wickra-data"
-version = "0.7.9"
+version = "0.8.3"
 dependencies = [
 "approx",
 "csv",
@@ -2001,7 +2001,7 @@ dependencies = [

 [[package]]
 name = "wickra-examples"
-version = "0.7.9"
+version = "0.8.3"
 dependencies = [
 "serde_json",
 "tokio",
@@ -2011,7 +2011,7 @@ dependencies = [

 [[package]]
 name = "wickra-node"
-version = "0.7.9"
+version = "0.8.3"
 dependencies = [
 "napi",
 "napi-build",
@@ -2021,7 +2021,7 @@ dependencies = [

 [[package]]
 name = "wickra-python"
-version = "0.7.9"
+version = "0.8.3"
 dependencies = [
 "numpy",
 "pyo3",
@@ -2030,7 +2030,7 @@ dependencies = [

 [[package]]
 name = "wickra-wasm"
-version = "0.7.9"
+version = "0.8.3"
 dependencies = [
 "console_error_panic_hook",
 "js-sys",
@@ -14,7 +14,7 @@ members = [
 exclude = ["fuzz"]

 [workspace.package]
-version = "0.7.9"
+version = "0.8.3"
 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.9" }
+wickra-core = { path = "crates/wickra-core", version = "0.8.3" }

 thiserror = "2"
 rayon = "1.10"
@@ -10,6 +10,9 @@
 [![PyPI](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/pypi.svg)](https://pypi.org/project/wickra/)
 [![npm](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/npm.svg)](https://www.npmjs.com/package/wickra)
 [![NuGet](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/nuget.svg)](https://www.nuget.org/packages/Wickra)
+[![Maven Central](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/maven.svg)](https://central.sonatype.com/artifact/org.wickra/wickra)
+[![Go module](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/go.svg)](https://pkg.go.dev/github.com/wickra-lib/wickra-go)
+[![R-universe](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/r-universe.svg)](https://wickra-lib.r-universe.dev)
 [![License: MIT OR Apache-2.0](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/license.svg)](#license)
 [![OpenSSF Scorecard](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/scorecard.svg)](https://scorecard.dev/viewer/?uri=github.com/wickra-lib/wickra)
 [![OpenSSF Best Practices](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/best-practices.svg)](https://www.bestpractices.dev/projects/13094)
@@ -52,6 +55,7 @@ Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**:
  [C](https://docs.wickra.org/Quickstart-C),
  [C#](https://docs.wickra.org/Quickstart-CSharp),
  [Go](https://docs.wickra.org/Quickstart-Go),
+  [Java](https://docs.wickra.org/Quickstart-Java),
  [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
@@ -102,8 +106,7 @@ Every other library forces one of those compromises. Wickra doesn't:

 | Library          | Install     | Streaming   | Languages                   | Indicators | Active |
 |------------------|-------------|-------------|-----------------------------|-----------:|--------|
-| **★&nbsp;Wickra**| **clean**   | **yes, O(1)** | **Rust · Python · Node · WASM** | **514** | **yes** |
-|                  |             |               | **C · C# · Go · Java · R**          |            |        |
+| **★&nbsp;Wickra**| **clean**   | **yes, O(1)** | **Rust · Python · Node · WASM · C · C# · Go · Java · R** | **514** | **yes** |
 | kand             | clean       | yes         | Python · WASM · Rust        |       ~60  | yes    |
 | ta-rs            | clean       | yes         | Rust only                   |       ~30  | stale  |
 | yata             | clean       | partial     | Rust only                   |       ~35  | yes    |
@@ -341,6 +344,10 @@ Every layer is covered; run the suites with the commands in
  values across all indicators.
 - `bindings/wasm`: `wasm-bindgen-test` cases for constructors, equivalence,
  and reference values.
+- `bindings/c`: Rust unit tests over the FFI boundary, plus C and C++ smoke
+  tests and offline example `ctest`s run on the three OSes.
+- `bindings/csharp`: `dotnet test` cases covering one indicator per FFI archetype
+  (scalar/batch, multi-output, bars, profile, array input) plus SMA 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
@@ -42,5 +42,18 @@ cast_sign_loss = "allow"
 similar_names = "allow"
 float_cmp = "allow"

+[features]
+# `parallel` (rayon-backed batch in wickra-core) is on by default for native
+# builds. The wasm32-unknown-emscripten target has no threads, so the R
+# package's wasm build (r-universe / webR) compiles this crate with
+# --no-default-features to drop rayon; wickra-core falls back to its serial
+# batch path, which is cfg-gated behind the same feature.
+default = ["parallel"]
+parallel = ["wickra-core/parallel"]
+
 [dependencies]
-wickra-core = { workspace = true }
+# Direct path dep rather than `workspace = true`: a member-level
+# `default-features = false` is ignored when inheriting a workspace dep that
+# does not set it, which would leave rayon in the wasm build. wickra-c is
+# `publish = false`, so no version pin is needed (and none to keep in sync).
+wickra-core = { path = "../../crates/wickra-core", default-features = false }
@@ -54,6 +54,20 @@ Multi-output indicators (MACD, Bollinger, ADX, …) take a pointer to a `#[repr(
 struct and return a `bool`. The optional `wickra.hpp` wraps any handle in a
 move-only `wickra::Handle` for exception-safe C++ lifetimes.

+## Benchmark
+
+`benchmarks/throughput.c` reports streaming and batch updates-per-second for
+`SMA`, `ATR` and `MACD`. As the thinnest binding it is the floor of the
+per-binding FFI overhead — not a cross-library ratio (the same Rust core runs
+under every binding); see the repository
+[BENCHMARKS.md](https://github.com/wickra-lib/wickra/blob/main/BENCHMARKS.md) §3.
+
+```bash
+cargo build -p wickra-c --release
+cmake -S benchmarks -B build && cmake --build build
+./build/throughput
+```
+
 ## Documentation

 The full indicator catalogue, guides, quickstarts, and API reference live in
@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.15)
+project(wickra_c_benchmarks C)
+
+# Directory holding the compiled Wickra C library (cargo output), e.g.
+# <workspace>/target/release. Override with -DWICKRA_LIB_DIR=/path/to/target/release.
+if(NOT DEFINED WICKRA_LIB_DIR)
+    set(WICKRA_LIB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../target/release")
+endif()
+set(WICKRA_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../include")
+
+# Pick the right link target per platform/toolchain.
+#  - MSVC links the generated import library (wickra.dll.lib).
+#  - MinGW/gcc on Windows links the DLL directly.
+#  - Unix links the shared object / dylib.
+if(WIN32)
+    set(WICKRA_RUNTIME "${WICKRA_LIB_DIR}/wickra.dll")
+    if(MSVC)
+        set(WICKRA_LINK_LIB "${WICKRA_LIB_DIR}/wickra.dll.lib")
+    else()
+        set(WICKRA_LINK_LIB "${WICKRA_LIB_DIR}/wickra.dll")
+    endif()
+elseif(APPLE)
+    set(WICKRA_LINK_LIB "${WICKRA_LIB_DIR}/libwickra.dylib")
+else()
+    set(WICKRA_LINK_LIB "${WICKRA_LIB_DIR}/libwickra.so")
+endif()
+
+add_executable(throughput throughput.c)
+target_include_directories(throughput PRIVATE "${WICKRA_INCLUDE_DIR}")
+target_link_libraries(throughput PRIVATE "${WICKRA_LINK_LIB}")
+if(UNIX AND NOT APPLE)
+    target_link_libraries(throughput PRIVATE m)
+endif()
+
+# On Windows copy the DLL next to the executable so the loader finds it.
+if(WIN32)
+    add_custom_command(TARGET throughput POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                "${WICKRA_RUNTIME}" "$<TARGET_FILE_DIR:throughput>")
+endif()
@@ -0,0 +1,167 @@
+/*
+ * Throughput benchmark for the Wickra C ABI.
+ *
+ * Measures how many indicator updates per second the C ABI sustains, both
+ * per-tick (streaming `_update`) and bulk (`_batch`), over a synthetic OHLCV
+ * series. It is the C counterpart of the Node throughput.js and the Rust
+ * criterion benches: it benchmarks Wickra's own O(1) streaming engine through
+ * the raw C boundary (there is no comparable streaming TA library to compare
+ * against), so the headline number is raw throughput, not a cross-library
+ * ratio. C is the thinnest binding, so these numbers are the floor of the
+ * per-binding FFI overhead the higher-level bindings build on.
+ *
+ * Three indicators are timed, chosen by call-signature archetype rather than
+ * algorithm: SMA (1-in -> 1-out), ATR (multi-in -> 1-out), and MACD
+ * (1-in -> multi-out). Streaming is timed for all three; batch only for the
+ * single-output SMA and ATR (the C ABI has no MACD batch entry point).
+ *
+ * Build the C ABI library first, then build and run the benchmark:
+ *
+ *   cargo build -p wickra-c --release
+ *   cmake -S bindings/c/benchmarks -B build/cbench -DCMAKE_BUILD_TYPE=Release
+ *   cmake --build build/cbench
+ *   ./build/cbench/throughput            # 200k bars (default)
+ *   ./build/cbench/throughput 1000000
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <stdint.h>
+
+#include "wickra.h"
+
+#ifdef _WIN32
+#include <windows.h>
+static double now_ns(void) {
+    static LARGE_INTEGER freq;
+    static int init = 0;
+    LARGE_INTEGER counter;
+    if (!init) {
+        QueryPerformanceFrequency(&freq);
+        init = 1;
+    }
+    QueryPerformanceCounter(&counter);
+    return (double)counter.QuadPart * 1e9 / (double)freq.QuadPart;
+}
+#else
+#include <time.h>
+static double now_ns(void) {
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return (double)ts.tv_sec * 1e9 + (double)ts.tv_nsec;
+}
+#endif
+
+static double median3(double a, double b, double c) {
+    if ((a <= b && b <= c) || (c <= b && b <= a)) return b;
+    if ((b <= a && a <= c) || (c <= a && a <= b)) return a;
+    return c;
+}
+
+/* Run `body` once as warmup, then time three repetitions and store the median
+ * elapsed nanoseconds in `dst`. `body` is a brace-enclosed statement block. */
+#define MEASURE(dst, body)                                  \
+    do {                                                    \
+        body;                                               \
+        double s0, s1, s2, t0;                              \
+        t0 = now_ns(); body; s0 = now_ns() - t0;            \
+        t0 = now_ns(); body; s1 = now_ns() - t0;            \
+        t0 = now_ns(); body; s2 = now_ns() - t0;            \
+        (dst) = median3(s0, s1, s2);                        \
+    } while (0)
+
+int main(int argc, char **argv) {
+    size_t bars = 200000;
+    if (argc > 1) {
+        long n = strtol(argv[1], NULL, 10);
+        if (n >= 1000) {
+            bars = (size_t)n;
+        }
+    }
+    const size_t n = bars;
+
+    /* Deterministic synthetic OHLCV (no RNG, so runs are comparable). */
+    double *open = malloc(n * sizeof(double));
+    double *high = malloc(n * sizeof(double));
+    double *low = malloc(n * sizeof(double));
+    double *close = malloc(n * sizeof(double));
+    double *volume = malloc(n * sizeof(double));
+    int64_t *timestamp = malloc(n * sizeof(int64_t));
+    double *out = malloc(n * sizeof(double)); /* reused batch scratch buffer */
+    if (!open || !high || !low || !close || !volume || !timestamp || !out) {
+        fprintf(stderr, "allocation failed\n");
+        return 1;
+    }
+    for (size_t i = 0; i < n; i++) {
+        double mid = 100 + sin((double)i * 0.001) * 20 + (double)i * 1e-4;
+        double c = mid + sin((double)i * 0.05) * 2;
+        close[i] = c;
+        open[i] = mid;
+        high[i] = fmax(c, mid) + 1.5;
+        low[i] = fmin(c, mid) - 1.5;
+        volume[i] = 1000 + (double)(i % 97) * 13;
+        timestamp[i] = (int64_t)i;
+    }
+
+    double ns;
+    double sma_stream, sma_batch, atr_stream, atr_batch, macd_stream;
+
+    MEASURE(ns, {
+        struct Sma *ind = wickra_sma_new(20);
+        for (size_t i = 0; i < n; i++) wickra_sma_update(ind, close[i]);
+        wickra_sma_free(ind);
+    });
+    sma_stream = (double)n / (ns / 1e9) / 1e6;
+
+    MEASURE(ns, {
+        struct Sma *ind = wickra_sma_new(20);
+        wickra_sma_batch(ind, close, out, n);
+        wickra_sma_free(ind);
+    });
+    sma_batch = (double)n / (ns / 1e9) / 1e6;
+
+    MEASURE(ns, {
+        struct Atr *ind = wickra_atr_new(14);
+        for (size_t i = 0; i < n; i++)
+            wickra_atr_update(ind, open[i], high[i], low[i], close[i], volume[i], timestamp[i]);
+        wickra_atr_free(ind);
+    });
+    atr_stream = (double)n / (ns / 1e9) / 1e6;
+
+    MEASURE(ns, {
+        struct Atr *ind = wickra_atr_new(14);
+        wickra_atr_batch(ind, open, high, low, close, volume, timestamp, out, n);
+        wickra_atr_free(ind);
+    });
+    atr_batch = (double)n / (ns / 1e9) / 1e6;
+
+    MEASURE(ns, {
+        struct MacdIndicator *ind = wickra_macd_indicator_new(12, 26, 9);
+        struct WickraMacdOutput value;
+        for (size_t i = 0; i < n; i++) wickra_macd_indicator_update(ind, close[i], &value);
+        wickra_macd_indicator_free(ind);
+    });
+    macd_stream = (double)n / (ns / 1e9) / 1e6;
+
+    printf("Wickra C throughput - %zu bars (median of 3 runs)\n\n", n);
+    printf("%-22s%20s%18s\n", "Indicator", "streaming (Mupd/s)", "batch (Mupd/s)");
+    printf("------------------------------------------------------------\n");
+    printf("%-22s%20.1f%18.1f\n", "SMA(20)", sma_stream, sma_batch);
+    printf("%-22s%20.1f%18.1f\n", "ATR(14)", atr_stream, atr_batch);
+    printf("%-22s%20.1f%18s\n", "MACD(12,26,9)", macd_stream, "-");
+
+    printf("\nMupd/s = million indicator updates per second. Streaming is the per-tick\n"
+           "`_update` path (one C call per value); batch is the bulk array path (one\n"
+           "C call). Higher is better. Numbers are machine-dependent - use them for\n"
+           "relative comparison, not as a speed claim.\n");
+
+    free(open);
+    free(high);
+    free(low);
+    free(close);
+    free(volume);
+    free(timestamp);
+    free(out);
+    return 0;
+}
@@ -52,6 +52,18 @@ foreach (var price in liveFeed)
 values — the equivalence is enforced by the test suite. Multi-output indicators
 (MACD, Bollinger, ADX, …) return a nullable `record struct`, `null` while warming up.

+## Benchmark
+
+`benchmarks/` reports streaming and batch updates-per-second for `SMA`, `ATR`
+and `MACD`. It measures this binding's FFI overhead, not a cross-library ratio
+(the same Rust core runs under every binding) — see the repository
+[BENCHMARKS.md](https://github.com/wickra-lib/wickra/blob/main/BENCHMARKS.md) §3.
+
+```bash
+cargo build -p wickra-c --release
+dotnet run -c Release --project benchmarks
+```
+
 ## Documentation

 The full indicator catalogue, guides, quickstarts, and API reference live in
@@ -11,7 +11,7 @@

    <!-- NuGet package metadata -->
    <PackageId>Wickra</PackageId>
-    <Version>0.7.9</Version>
+    <Version>0.8.3</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>
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <!-- Standalone throughput benchmark for the Wickra C# binding.
+       See Program.cs for run instructions. Requires the C ABI library; the
+       binding's dev DllImportResolver falls back to target/release. -->
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+    <AssemblyName>Wickra.Benchmarks</AssemblyName>
+    <RootNamespace>Wickra.Benchmarks</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Wickra\Wickra.csproj" />
+  </ItemGroup>
+
+</Project>
@@ -0,0 +1,101 @@
+// Throughput benchmark for the Wickra C# binding.
+//
+// Measures how many indicator updates per second the binding sustains, both
+// per-tick (streaming Update) and bulk (Batch), over a synthetic OHLCV series.
+// It is the C# counterpart of the Node throughput.js and the Rust criterion
+// benches: it benchmarks Wickra's own O(1) streaming engine across the
+// managed<->C-ABI boundary (there is no comparable streaming TA library on
+// NuGet to compare against), so the headline number is raw per-binding
+// throughput / FFI overhead, not a cross-library ratio.
+//
+// Three indicators are timed, chosen by FFI call-signature archetype rather
+// than algorithm: SMA (1-in -> 1-out), ATR (multi-in -> 1-out), and MACD
+// (1-in -> multi-out). Streaming is timed for all three; batch only for the
+// single-output SMA and ATR (multi-output batch is not exposed uniformly).
+//
+//   cargo build -p wickra-c --release
+//   dotnet run -c Release --project bindings/csharp/benchmarks            # 200k bars
+//   dotnet run -c Release --project bindings/csharp/benchmarks -- --bars 1000000
+
+using System.Diagnostics;
+using System.Globalization;
+using Wickra;
+
+// Deterministic, locale-independent number formatting for the report.
+CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
+
+int bars = 200_000;
+for (int i = 0; i < args.Length - 1; i++)
+{
+    if (args[i] == "--bars" && int.TryParse(args[i + 1], out var n) && n >= 1000)
+    {
+        bars = n;
+    }
+}
+
+// Deterministic synthetic OHLCV (no RNG, so runs are comparable).
+var open = new double[bars];
+var high = new double[bars];
+var low = new double[bars];
+var close = new double[bars];
+var volume = new double[bars];
+var timestamp = new long[bars];
+for (int i = 0; i < bars; i++)
+{
+    double mid = 100 + Math.Sin(i * 0.001) * 20 + i * 1e-4;
+    double c = mid + Math.Sin(i * 0.05) * 2;
+    close[i] = c;
+    open[i] = mid;
+    high[i] = Math.Max(c, mid) + 1.5;
+    low[i] = Math.Min(c, mid) - 1.5;
+    volume[i] = 1000 + (i % 97) * 13;
+    timestamp[i] = i;
+}
+
+double Mups(double ns) => bars / (ns / 1e9) / 1e6;
+
+// Median elapsed-ns over a few repetitions, after one warmup pass.
+double TimeNs(Action fn, int reps = 3)
+{
+    fn(); // warmup (JIT + cache)
+    var samples = new double[reps];
+    for (int r = 0; r < reps; r++)
+    {
+        long t0 = Stopwatch.GetTimestamp();
+        fn();
+        samples[r] = (Stopwatch.GetTimestamp() - t0) * (1e9 / Stopwatch.Frequency);
+    }
+    Array.Sort(samples);
+    return samples[reps / 2];
+}
+
+// SMA (scalar 1-in/1-out), ATR (multi-in/1-out), MACD (1-in/multi-out).
+var indicators = new (string Name, Action Stream, Action? Batch)[]
+{
+    ("SMA(20)",
+        () => { using var ind = new Sma(20); for (int i = 0; i < bars; i++) ind.Update(close[i]); },
+        () => { using var ind = new Sma(20); ind.Batch(close); }),
+    ("ATR(14)",
+        () => { using var ind = new Atr(14); for (int i = 0; i < bars; i++) ind.Update(open[i], high[i], low[i], close[i], volume[i], timestamp[i]); },
+        () => { using var ind = new Atr(14); ind.Batch(open, high, low, close, volume, timestamp); }),
+    ("MACD(12,26,9)",
+        () => { using var ind = new MacdIndicator(12, 26, 9); for (int i = 0; i < bars; i++) ind.Update(close[i]); },
+        null), // multi-output: streaming only
+};
+
+Console.WriteLine($"Wickra C# throughput - {bars:N0} bars (median of 3 runs)\n");
+Console.WriteLine($"{"Indicator",-22}{"streaming (Mupd/s)",20}{"batch (Mupd/s)",18}");
+Console.WriteLine(new string('-', 60));
+
+foreach (var (name, stream, batch) in indicators)
+{
+    string streamMups = Mups(TimeNs(stream)).ToString("F1");
+    string batchMups = batch is null ? "-" : Mups(TimeNs(batch)).ToString("F1");
+    Console.WriteLine($"{name,-22}{streamMups,20}{batchMups,18}");
+}
+
+Console.WriteLine(
+    "\nMupd/s = million indicator updates per second. Streaming is the per-tick\n" +
+    "Update path crossing the managed<->C-ABI boundary once per value; batch is\n" +
+    "the bulk array path (one boundary crossing). Higher is better. Numbers are\n" +
+    "machine-dependent - use them for relative comparison, not as a speed claim.");
@@ -2,7 +2,7 @@

 [![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)
-[![Go Reference](https://pkg.go.dev/badge/github.com/wickra-lib/wickra/bindings/go.svg)](https://pkg.go.dev/github.com/wickra-lib/wickra/bindings/go)
+[![Go module](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/go.svg)](https://pkg.go.dev/github.com/wickra-lib/wickra/bindings/go)
 [![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 Go, over the Wickra C ABI hub via cgo.**
@@ -16,24 +16,38 @@ cgo and exposes all 514 streaming-first indicators as idiomatic types.

 ## Install

+Use the published **`wickra-go`** module, which bundles the prebuilt C ABI
+library for every platform, so `go get` + `go build` works with no extra steps
+(a C compiler is still required, as the binding uses cgo):
+
 ```bash
-go get github.com/wickra-lib/wickra/bindings/go
+go get github.com/wickra-lib/wickra-go
 ```

-The binding uses cgo, so a C compiler is required, and it links against the
-prebuilt Wickra C ABI library. Build that library from the workspace and stage
-it under this package's `lib/` directory:
+```go
+import wickra "github.com/wickra-lib/wickra-go"
+```
+
+`wickra-go` is generated from this directory by the release pipeline: it mirrors
+the Go sources, the vendored C ABI header (`include/wickra.h`) and the prebuilt
+libraries under `lib/<goos>_<goarch>/`. On Linux/macOS the library path is baked
+in via rpath; on Windows the DLL must be discoverable at run time (next to the
+executable or on `PATH`).
+
+### Building from this repository (contributors)
+
+This `bindings/go` directory is the development source. To build it directly,
+compile the C ABI and stage the library into the per-platform directory cgo
+links against:

 ```bash
 cargo build -p wickra-c --release
-cp target/release/libwickra.so    bindings/go/lib/   # Linux
-cp target/release/libwickra.dylib bindings/go/lib/   # macOS
-cp target/release/wickra.dll      bindings/go/lib/   # Windows (also on PATH at run time)
+mkdir -p bindings/go/lib/linux_amd64                 # match your GOOS_GOARCH
+cp target/release/libwickra.so    bindings/go/lib/linux_amd64/    # Linux
+cp target/release/libwickra.dylib bindings/go/lib/darwin_arm64/   # macOS (arm64)
+cp target/release/wickra.dll      bindings/go/lib/windows_amd64/  # Windows
 ```

-On Linux and macOS the library path is baked in via rpath; on Windows the DLL
-must be discoverable at run time (next to the executable or on `PATH`).
-
 ## Quick start

 ```go
@@ -74,6 +88,17 @@ values — the equivalence is enforced by the test suite. Multi-output indicator
 Every indicator owns a native handle freed by `Close()`; a finalizer is wired as
 a backstop, but call `Close()` (e.g. with `defer`) to release memory promptly.

+## Benchmark
+
+`benchmarks/throughput.go` reports streaming and batch updates-per-second for
+`SMA`, `ATR` and `MACD`. It measures this binding's FFI overhead, not a
+cross-library ratio (the same Rust core runs under every binding) — see the
+repository [BENCHMARKS.md](https://github.com/wickra-lib/wickra/blob/main/BENCHMARKS.md) §3.
+
+```bash
+cd benchmarks && go run .
+```
+
 ## Documentation

 The full indicator catalogue, guides, quickstarts, and API reference live in the
@@ -0,0 +1,145 @@
+// Throughput benchmark for the Wickra Go bindings.
+//
+// Measures how many indicator updates per second the cgo binding sustains,
+// both per-tick (streaming Update) and bulk (Batch), over a synthetic OHLCV
+// series. It is the Go counterpart of the Node throughput.js and the Rust
+// criterion benches: it benchmarks Wickra's own O(1) streaming engine across
+// the Go<->C-ABI boundary (there is no comparable streaming TA library to
+// compare against), so the headline number is raw per-binding throughput /
+// FFI overhead, not a cross-library ratio.
+//
+// Three indicators are timed, chosen by FFI call-signature archetype rather
+// than algorithm: SMA (1-in -> 1-out), ATR (multi-in -> 1-out), and MACD
+// (1-in -> multi-out). Streaming is timed for all three; batch only for the
+// single-output SMA and ATR (multi-output batch is not exposed uniformly).
+//
+// Provision the C ABI library first (see bindings/go/README.md), then run:
+//
+//	cd bindings/go/benchmarks
+//	go run .                 # 200k bars (default)
+//	go run . -bars 1000000
+package main
+
+import (
+	"flag"
+	"fmt"
+	"math"
+	"sort"
+	"time"
+
+	wickra "github.com/wickra-lib/wickra/bindings/go"
+)
+
+func main() {
+	bars := flag.Int("bars", 200_000, "number of synthetic bars to feed")
+	flag.Parse()
+	n := *bars
+	if n < 1000 {
+		fmt.Println("-bars must be >= 1000")
+		return
+	}
+
+	// Deterministic synthetic OHLCV (no RNG, so runs are comparable).
+	open := make([]float64, n)
+	high := make([]float64, n)
+	low := make([]float64, n)
+	closeP := make([]float64, n)
+	volume := make([]float64, n)
+	timestamp := make([]int64, n)
+	for i := 0; i < n; i++ {
+		mid := 100 + math.Sin(float64(i)*0.001)*20 + float64(i)*1e-4
+		c := mid + math.Sin(float64(i)*0.05)*2
+		closeP[i] = c
+		open[i] = mid
+		high[i] = math.Max(c, mid) + 1.5
+		low[i] = math.Min(c, mid) - 1.5
+		volume[i] = 1000 + float64(i%97)*13
+		timestamp[i] = int64(i)
+	}
+
+	mups := func(d time.Duration) float64 {
+		return float64(n) / d.Seconds() / 1e6
+	}
+
+	// Median elapsed over a few repetitions, after one warmup pass.
+	timeFn := func(fn func()) time.Duration {
+		fn() // warmup
+		const reps = 3
+		samples := make([]time.Duration, reps)
+		for r := 0; r < reps; r++ {
+			t0 := time.Now()
+			fn()
+			samples[r] = time.Since(t0)
+		}
+		sort.Slice(samples, func(a, b int) bool { return samples[a] < samples[b] })
+		return samples[reps/2]
+	}
+
+	type indicator struct {
+		name   string
+		stream func()
+		batch  func() // nil -> streaming only
+	}
+
+	indicators := []indicator{
+		{
+			name: "SMA(20)",
+			stream: func() {
+				ind, _ := wickra.NewSma(20)
+				for i := 0; i < n; i++ {
+					ind.Update(closeP[i])
+				}
+				ind.Close()
+			},
+			batch: func() {
+				ind, _ := wickra.NewSma(20)
+				ind.Batch(closeP)
+				ind.Close()
+			},
+		},
+		{
+			name: "ATR(14)",
+			stream: func() {
+				ind, _ := wickra.NewAtr(14)
+				for i := 0; i < n; i++ {
+					ind.Update(open[i], high[i], low[i], closeP[i], volume[i], timestamp[i])
+				}
+				ind.Close()
+			},
+			batch: func() {
+				ind, _ := wickra.NewAtr(14)
+				ind.Batch(open, high, low, closeP, volume, timestamp)
+				ind.Close()
+			},
+		},
+		{
+			name: "MACD(12,26,9)",
+			stream: func() {
+				ind, _ := wickra.NewMacdIndicator(12, 26, 9)
+				for i := 0; i < n; i++ {
+					ind.Update(closeP[i])
+				}
+				ind.Close()
+			},
+			batch: nil, // multi-output: streaming only
+		},
+	}
+
+	fmt.Printf("Wickra Go throughput - %d bars (median of 3 runs)\n\n", n)
+	fmt.Printf("%-22s%20s%18s\n", "Indicator", "streaming (Mupd/s)", "batch (Mupd/s)")
+	fmt.Println("------------------------------------------------------------")
+
+	for _, ind := range indicators {
+		streamMups := fmt.Sprintf("%.1f", mups(timeFn(ind.stream)))
+		batchMups := "-"
+		if ind.batch != nil {
+			batchMups = fmt.Sprintf("%.1f", mups(timeFn(ind.batch)))
+		}
+		fmt.Printf("%-22s%20s%18s\n", ind.name, streamMups, batchMups)
+	}
+
+	fmt.Print("\nMupd/s = million indicator updates per second. Streaming is the per-tick\n",
+		"Update path crossing the Go<->C-ABI boundary once per value; batch is the\n",
+		"bulk slice path (one boundary crossing). Higher is better. Numbers are\n",
+		"machine-dependent - use them for relative comparison, not as a speed claim.\n")
+}
@@ -4,16 +4,21 @@
 // Each indicator is an opaque-handle type with a New<Indicator> constructor and
 // Update/Batch/Reset/Close methods. Handles are freed by Close and, as a
 // backstop, by a finalizer; call Close explicitly to release native memory
-// promptly. The binding links against the prebuilt Wickra C ABI library
-// (libwickra.so/.dylib or wickra.dll) staged under ./lib — see the package
-// README for how to provision it.
+// promptly. The binding links against the prebuilt Wickra C ABI library, staged
+// per platform under ./lib/<goos>_<goarch>/, with the C ABI header vendored
+// under ./include. For distribution the libraries are committed alongside the
+// source in the wickra-go module, so `go get` + `go build` works with no extra
+// steps — see the package README.
 package wickra

 /*
-#cgo CFLAGS: -I${SRCDIR}/../c/include
-#cgo linux LDFLAGS: -L${SRCDIR}/lib -lwickra -Wl,-rpath,${SRCDIR}/lib
-#cgo darwin LDFLAGS: -L${SRCDIR}/lib -lwickra -Wl,-rpath,${SRCDIR}/lib
-#cgo windows LDFLAGS: -L${SRCDIR}/lib -l:wickra.dll
+#cgo CFLAGS: -I${SRCDIR}/include
+#cgo linux,amd64 LDFLAGS: -L${SRCDIR}/lib/linux_amd64 -lwickra -Wl,-rpath,${SRCDIR}/lib/linux_amd64
+#cgo linux,arm64 LDFLAGS: -L${SRCDIR}/lib/linux_arm64 -lwickra -Wl,-rpath,${SRCDIR}/lib/linux_arm64
+#cgo darwin,amd64 LDFLAGS: -L${SRCDIR}/lib/darwin_amd64 -lwickra -Wl,-rpath,${SRCDIR}/lib/darwin_amd64
+#cgo darwin,arm64 LDFLAGS: -L${SRCDIR}/lib/darwin_arm64 -lwickra -Wl,-rpath,${SRCDIR}/lib/darwin_arm64
+#cgo windows,amd64 LDFLAGS: -L${SRCDIR}/lib/windows_amd64 -l:wickra.dll
+#cgo windows,arm64 LDFLAGS: -L${SRCDIR}/lib/windows_arm64 -l:wickra.dll
 #include "wickra.h"
 */
 import "C"
@@ -30,14 +30,14 @@ Maven:
 <dependency>
  <groupId>org.wickra</groupId>
  <artifactId>wickra</artifactId>
-  <version>0.7.9</version>
+  <version>0.8.3</version>
 </dependency>
 ```

 Gradle:

 ```kotlin
-implementation("org.wickra:wickra:0.7.9")
+implementation("org.wickra:wickra:0.8.3")
 ```

 The native library ships prebuilt per platform (Linux, macOS, Windows — x64 and
@@ -76,6 +76,19 @@ values — the equivalence is enforced by the test suite. Multi-output indicator
 indicator owns a native handle freed by a `Cleaner`; `close()` releases it
 eagerly (use try-with-resources).

+## Benchmark
+
+`benchmarks/` reports streaming and batch updates-per-second for `SMA`, `ATR`
+and `MACD`. It measures this binding's FFI overhead, not a cross-library ratio
+(the same Rust core runs under every binding) — see the repository
+[BENCHMARKS.md](https://github.com/wickra-lib/wickra/blob/main/BENCHMARKS.md) §3.
+
+```bash
+cargo build -p wickra-c --release
+mvn -q install -DskipTests
+mvn -q -f benchmarks exec:exec -Dexec.mainClass=org.wickra.benchmarks.Throughput
+```
+
 ## Documentation

 The full indicator catalogue, guides, quickstarts, and API reference live in
@@ -0,0 +1,57 @@
+<?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.benchmarks</groupId>
+  <artifactId>wickra-benchmarks</artifactId>
+  <version>0.8.2</version>
+  <packaging>jar</packaging>
+
+  <name>Wickra Java benchmarks</name>
+  <description>Throughput benchmark for the Wickra Java binding.</description>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <maven.compiler.release>22</maven.compiler.release>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.wickra</groupId>
+      <artifactId>wickra</artifactId>
+      <version>0.8.2</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.13.0</version>
+      </plugin>
+
+      <!--
+        Run the benchmark in a forked JVM with native access granted:
+          mvn exec:exec -Dexec.mainClass=org.wickra.benchmarks.Throughput
+        Requires the C ABI library and the installed binding; see Throughput.java.
+      -->
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>exec-maven-plugin</artifactId>
+        <version>3.2.0</version>
+        <configuration>
+          <executable>${java.home}/bin/java</executable>
+          <arguments>
+            <argument>--enable-native-access=ALL-UNNAMED</argument>
+            <argument>-classpath</argument>
+            <classpath/>
+            <argument>${exec.mainClass}</argument>
+          </arguments>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>
@@ -0,0 +1,149 @@
+package org.wickra.benchmarks;
+
+import java.util.Arrays;
+import java.util.Locale;
+import org.wickra.Atr;
+import org.wickra.MacdIndicator;
+import org.wickra.Sma;
+
+/**
+ * Throughput benchmark for the Wickra Java binding.
+ *
+ * <p>Measures how many indicator updates per second the binding sustains, both
+ * per-tick (streaming {@code update}) and bulk ({@code batch}), over a synthetic
+ * OHLCV series. It is the Java counterpart of the Node {@code throughput.js} and
+ * the Rust criterion benches: it benchmarks Wickra's own O(1) streaming engine
+ * across the Java FFM &lt;-&gt; C-ABI boundary (there is no comparable streaming
+ * TA library on Maven Central to compare against), so the headline number is raw
+ * per-binding throughput / FFI overhead, not a cross-library ratio.
+ *
+ * <p>Three indicators are timed, chosen by FFI call-signature archetype rather
+ * than algorithm: SMA (1-in -&gt; 1-out), ATR (multi-in -&gt; 1-out), and MACD
+ * (1-in -&gt; multi-out). Streaming is timed for all three; batch only for the
+ * single-output SMA and ATR (multi-output batch is not exposed uniformly).
+ *
+ * <p>Install the binding and build the C ABI library first, then run from the
+ * repo root:
+ *
+ * <pre>
+ *   cargo build -p wickra-c --release
+ *   mvn -q -f bindings/java install -DskipTests
+ *   mvn -q -f bindings/java/benchmarks exec:exec -Dexec.mainClass=org.wickra.benchmarks.Throughput
+ * </pre>
+ */
+public final class Throughput {
+    private Throughput() {}
+
+    public static void main(String[] args) {
+        int bars = 200_000;
+        for (int i = 0; i < args.length - 1; i++) {
+            if (args[i].equals("--bars")) {
+                try {
+                    int n = Integer.parseInt(args[i + 1]);
+                    if (n >= 1000) {
+                        bars = n;
+                    }
+                } catch (NumberFormatException ignored) {
+                    // keep default
+                }
+            }
+        }
+
+        // Deterministic synthetic OHLCV (no RNG, so runs are comparable).
+        double[] open = new double[bars];
+        double[] high = new double[bars];
+        double[] low = new double[bars];
+        double[] close = new double[bars];
+        double[] volume = new double[bars];
+        double[] timestamp = new double[bars];
+        for (int i = 0; i < bars; i++) {
+            double mid = 100 + Math.sin(i * 0.001) * 20 + i * 1e-4;
+            double c = mid + Math.sin(i * 0.05) * 2;
+            close[i] = c;
+            open[i] = mid;
+            high[i] = Math.max(c, mid) + 1.5;
+            low[i] = Math.min(c, mid) - 1.5;
+            volume[i] = 1000 + (i % 97) * 13;
+            timestamp[i] = i;
+        }
+
+        final int n = bars;
+
+        // SMA (scalar 1-in/1-out), ATR (multi-in/1-out), MACD (1-in/multi-out).
+        Indicator[] indicators = {
+            new Indicator("SMA(20)",
+                () -> {
+                    try (Sma ind = new Sma(20)) {
+                        for (int i = 0; i < n; i++) {
+                            ind.update(close[i]);
+                        }
+                    }
+                },
+                () -> {
+                    try (Sma ind = new Sma(20)) {
+                        ind.batch(close);
+                    }
+                }),
+            new Indicator("ATR(14)",
+                () -> {
+                    try (Atr ind = new Atr(14)) {
+                        for (int i = 0; i < n; i++) {
+                            ind.update(open[i], high[i], low[i], close[i], volume[i], (long) timestamp[i]);
+                        }
+                    }
+                },
+                () -> {
+                    try (Atr ind = new Atr(14)) {
+                        ind.batch(open, high, low, close, volume, timestamp);
+                    }
+                }),
+            new Indicator("MACD(12,26,9)",
+                () -> {
+                    try (MacdIndicator ind = new MacdIndicator(12, 26, 9)) {
+                        for (int i = 0; i < n; i++) {
+                            ind.update(close[i]);
+                        }
+                    }
+                },
+                null), // multi-output: streaming only
+        };
+
+        System.out.printf(Locale.ROOT, "Wickra Java throughput - %,d bars (median of 3 runs)%n%n", bars);
+        System.out.printf(Locale.ROOT, "%-22s%20s%18s%n", "Indicator", "streaming (Mupd/s)", "batch (Mupd/s)");
+        System.out.println("------------------------------------------------------------");
+
+        for (Indicator ind : indicators) {
+            String streamMups = String.format(Locale.ROOT, "%.1f", mups(bars, timeNs(ind.stream)));
+            String batchMups = ind.batch == null
+                ? "-"
+                : String.format(Locale.ROOT, "%.1f", mups(bars, timeNs(ind.batch)));
+            System.out.printf(Locale.ROOT, "%-22s%20s%18s%n", ind.name, streamMups, batchMups);
+        }
+
+        System.out.println(
+            "\nMupd/s = million indicator updates per second. Streaming is the per-tick\n"
+            + "update path crossing the Java FFM<->C-ABI boundary once per value; batch is\n"
+            + "the bulk array path (one boundary crossing). Higher is better. Numbers are\n"
+            + "machine-dependent - use them for relative comparison, not as a speed claim.");
+    }
+
+    private static double mups(int bars, double ns) {
+        return bars / (ns / 1e9) / 1e6;
+    }
+
+    // Median elapsed-ns over a few repetitions, after one warmup pass.
+    private static double timeNs(Runnable fn) {
+        fn.run(); // warmup (JIT + cache)
+        final int reps = 3;
+        double[] samples = new double[reps];
+        for (int r = 0; r < reps; r++) {
+            long t0 = System.nanoTime();
+            fn.run();
+            samples[r] = System.nanoTime() - t0;
+        }
+        Arrays.sort(samples);
+        return samples[reps / 2];
+    }
+
+    private record Indicator(String name, Runnable stream, Runnable batch) {}
+}
@@ -6,7 +6,7 @@

  <groupId>org.wickra</groupId>
  <artifactId>wickra</artifactId>
-  <version>0.7.9</version>
+  <version>0.8.3</version>
  <packaging>jar</packaging>

  <name>Wickra</name>
@@ -47,6 +47,18 @@ for (const price of liveFeed) {
 `batch(prices)` and feeding the same prices through `update()` produce
 identical values — the equivalence is enforced by the test suite.

+## Benchmark
+
+`benchmarks/throughput.js` reports streaming and batch updates-per-second for
+`SMA`, `ATR` and `MACD`. It measures this binding's FFI overhead, not a
+cross-library ratio (the same Rust core runs under every binding) — see the
+repository [BENCHMARKS.md](https://github.com/wickra-lib/wickra/blob/main/BENCHMARKS.md) §3.
+
+```bash
+npx napi build --platform --release
+node benchmarks/throughput.js
+```
+
 ## Documentation

 The full indicator catalogue, guides, quickstarts, and API reference live in
@@ -1,6 +1,6 @@
 {
  "name": "wickra-darwin-arm64",
-  "version": "0.7.9",
+  "version": "0.8.3",
  "description": "Native binding for wickra (macOS Apple Silicon). Installed automatically as an optional dependency of wickra on matching platforms.",
  "main": "wickra.darwin-arm64.node",
  "files": [
@@ -1,6 +1,6 @@
 {
  "name": "wickra-darwin-x64",
-  "version": "0.7.9",
+  "version": "0.8.3",
  "description": "Native binding for wickra (macOS Intel). Installed automatically as an optional dependency of wickra on matching platforms.",
  "main": "wickra.darwin-x64.node",
  "files": [
@@ -1,6 +1,6 @@
 {
  "name": "wickra-linux-arm64-gnu",
-  "version": "0.7.9",
+  "version": "0.8.3",
  "description": "Native binding for wickra (linux arm64 GNU). Installed automatically as an optional dependency of wickra on matching platforms.",
  "main": "wickra.linux-arm64-gnu.node",
  "files": [
@@ -1,6 +1,6 @@
 {
  "name": "wickra-linux-x64-gnu",
-  "version": "0.7.9",
+  "version": "0.8.3",
  "description": "Native binding for wickra (linux x64 GNU). Installed automatically as an optional dependency of wickra on matching platforms.",
  "main": "wickra.linux-x64-gnu.node",
  "files": [
@@ -1,6 +1,6 @@
 {
  "name": "wickra-win32-arm64-msvc",
-  "version": "0.7.9",
+  "version": "0.8.3",
  "description": "Native binding for wickra (Windows arm64 MSVC). Installed automatically as an optional dependency of wickra on matching platforms.",
  "main": "wickra.win32-arm64-msvc.node",
  "files": [
@@ -1,6 +1,6 @@
 {
  "name": "wickra-win32-x64-msvc",
-  "version": "0.7.9",
+  "version": "0.8.3",
  "description": "Native binding for wickra (Windows x64 MSVC). Installed automatically as an optional dependency of wickra on matching platforms.",
  "main": "wickra.win32-x64-msvc.node",
  "files": [
@@ -1,12 +1,12 @@
 {
  "name": "wickra",
-  "version": "0.7.9",
+  "version": "0.8.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "wickra",
-      "version": "0.7.9",
+      "version": "0.8.3",
      "license": "MIT OR Apache-2.0",
      "devDependencies": {
        "@napi-rs/cli": "^2.18.0"
@@ -15,12 +15,12 @@
        "node": ">= 18"
      },
      "optionalDependencies": {
-        "wickra-darwin-arm64": "0.7.9",
-        "wickra-darwin-x64": "0.7.9",
-        "wickra-linux-arm64-gnu": "0.7.9",
-        "wickra-linux-x64-gnu": "0.7.9",
-        "wickra-win32-arm64-msvc": "0.7.9",
-        "wickra-win32-x64-msvc": "0.7.9"
+        "wickra-darwin-arm64": "0.8.3",
+        "wickra-darwin-x64": "0.8.3",
+        "wickra-linux-arm64-gnu": "0.8.3",
+        "wickra-linux-x64-gnu": "0.8.3",
+        "wickra-win32-arm64-msvc": "0.8.3",
+        "wickra-win32-x64-msvc": "0.8.3"
      }
    },
    "node_modules/@napi-rs/cli": {
@@ -41,8 +41,8 @@
      }
    },
    "node_modules/wickra-darwin-arm64": {
-      "version": "0.7.9",
-      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.7.9.tgz",
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.8.3.tgz",
      "integrity": "sha512-4eZiBR/yGUdr4nzhEUFy2i69XgNx64iI2ax/LPamsThgylC0KpHOZKK19QzJ2d9KbK4C8nMjME5FLuR+4GNEwQ==",
      "cpu": [
        "arm64"
@@ -57,8 +57,8 @@
      }
    },
    "node_modules/wickra-darwin-x64": {
-      "version": "0.7.9",
-      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.7.9.tgz",
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.8.3.tgz",
      "integrity": "sha512-6hf8zI3QPjTFp4zCpmgUwDvNtu6jHqNUHKD5e55POo0CgA52HkpyxSPtVm8TGTIZDI7kPjlbOdBM8CJ76mmXwA==",
      "cpu": [
        "x64"
@@ -73,8 +73,8 @@
      }
    },
    "node_modules/wickra-linux-arm64-gnu": {
-      "version": "0.7.9",
-      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.7.9.tgz",
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.8.3.tgz",
      "integrity": "sha512-kSe6y0xBMSiqdPLXNjwop5WZdHtvdBNKSEBCwZ4hFq33p4apW25/wrlzv9/oDuyD4kuPabJEhCCnFOplh58CUg==",
      "cpu": [
        "arm64"
@@ -89,8 +89,8 @@
      }
    },
    "node_modules/wickra-linux-x64-gnu": {
-      "version": "0.7.9",
-      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.7.9.tgz",
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.8.3.tgz",
      "integrity": "sha512-tWBWS4qz7hxM4xnpFb59bhf6TaLwXq0Z3jEa/2l7r8PiHA94g8r8S53NRMiT+4yiL5hSWe/nUiC/YXdRrhEZ4g==",
      "cpu": [
        "x64"
@@ -105,8 +105,8 @@
      }
    },
    "node_modules/wickra-win32-arm64-msvc": {
-      "version": "0.7.9",
-      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.7.9.tgz",
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.8.3.tgz",
      "integrity": "sha512-EXIckHxAtF75PUGDKRzXyqMe9ldP0JjSdu68WFN6iJfp+McYrGu6h40TEJlQ/oUEIoPqiZB/xhVyo/el5Lg7zw==",
      "cpu": [
        "arm64"
@@ -121,8 +121,8 @@
      }
    },
    "node_modules/wickra-win32-x64-msvc": {
-      "version": "0.7.9",
-      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.7.9.tgz",
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.8.3.tgz",
      "integrity": "sha512-Yfsqq1Xwp6hdxMyLze411vNdo7BDwI6+lPSe7A9XdqyPecNDbtKwYLpsal2r8EHbNzqM+R8XnuRtUaEQS5VlUQ==",
      "cpu": [
        "x64"
@@ -1,6 +1,6 @@
 {
  "name": "wickra",
-  "version": "0.7.9",
+  "version": "0.8.3",
  "description": "Streaming-first technical indicators: incremental, fast, install-free. Node bindings powered by Rust.",
  "author": "kingchenc <support@wickra.org>",
  "main": "index.js",
@@ -47,12 +47,12 @@
    "node": ">= 18"
  },
  "optionalDependencies": {
-    "wickra-linux-x64-gnu": "0.7.9",
-    "wickra-linux-arm64-gnu": "0.7.9",
-    "wickra-darwin-x64": "0.7.9",
-    "wickra-darwin-arm64": "0.7.9",
-    "wickra-win32-x64-msvc": "0.7.9",
-    "wickra-win32-arm64-msvc": "0.7.9"
+    "wickra-linux-x64-gnu": "0.8.3",
+    "wickra-linux-arm64-gnu": "0.8.3",
+    "wickra-darwin-x64": "0.8.3",
+    "wickra-darwin-arm64": "0.8.3",
+    "wickra-win32-x64-msvc": "0.8.3",
+    "wickra-win32-arm64-msvc": "0.8.3"
  },
  "scripts": {
    "build": "napi build --platform --release",
@@ -46,6 +46,24 @@ for price in live_feed:
 `batch(prices)` and feeding the same prices through `update()` produce
 identical values — the equivalence is enforced by the test suite.

+## Benchmark
+
+Two benchmarks ship with the binding:
+
+- `benchmarks/throughput.py` — streaming and batch updates-per-second for `SMA`,
+  `ATR` and `MACD`. This is per-binding FFI overhead (the same Rust core runs
+  under every binding), not a cross-library ratio.
+- `benchmarks/compare_libraries.py` — the cross-library comparison against
+  TA-Lib, pandas-ta, tulipy and finta that backs the headline speedups.
+
+```bash
+maturin develop --release
+python -m benchmarks.throughput
+python -m benchmarks.compare_libraries   # cross-library; auto-detects installed peers
+```
+
+See the repository [BENCHMARKS.md](https://github.com/wickra-lib/wickra/blob/main/BENCHMARKS.md).
+
 ## Documentation

 The full indicator catalogue, guides, quickstarts, and API reference live in
@@ -0,0 +1,116 @@
+"""Throughput benchmark for the Wickra Python binding.
+
+Measures how many indicator updates per second the binding sustains, both
+per-tick (streaming ``update``) and bulk (``batch``), over a synthetic OHLCV
+series. It is the Python counterpart of the Node ``throughput.js`` and the Rust
+criterion benches: it benchmarks Wickra's own O(1) streaming engine across the
+Python<->Rust boundary, so the headline number is raw per-binding throughput /
+FFI overhead, not a cross-library ratio.
+
+For the cross-library comparison against TA-Lib, pandas-ta, tulipy and finta,
+see ``benchmarks/compare_libraries.py`` instead.
+
+Three indicators are timed, chosen by call-signature archetype rather than
+algorithm: SMA (1-in -> 1-out), ATR (multi-in -> 1-out) and MACD (1-in ->
+multi-out). Streaming is timed for all three; batch only for the single-output
+SMA and ATR (multi-output batch returns a 2-D array and is not compared here).
+
+Install the binding first (``maturin develop --release`` in bindings/python),
+then run from bindings/python::
+
+    python -m benchmarks.throughput                # 200k bars (default)
+    python -m benchmarks.throughput --bars 1000000
+"""
+
+from __future__ import annotations
+
+import argparse
+import time
+
+import numpy as np
+
+import wickra as ta
+
+
+def _time_ns(fn, reps: int = 3) -> float:
+    """Median elapsed-ns over a few repetitions, after one warmup pass."""
+    fn()  # warmup
+    samples = []
+    for _ in range(reps):
+        t0 = time.perf_counter_ns()
+        fn()
+        samples.append(time.perf_counter_ns() - t0)
+    samples.sort()
+    return samples[len(samples) // 2]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Wickra Python throughput benchmark")
+    parser.add_argument("--bars", type=int, default=200_000, help="number of synthetic bars")
+    args = parser.parse_args()
+    bars = args.bars if args.bars >= 1000 else 200_000
+
+    # Deterministic synthetic OHLCV (no RNG, so runs are comparable).
+    idx = np.arange(bars, dtype=np.float64)
+    mid = 100 + np.sin(idx * 0.001) * 20 + idx * 1e-4
+    close = mid + np.sin(idx * 0.05) * 2
+    high = np.maximum(close, mid) + 1.5
+    low = np.minimum(close, mid) - 1.5
+    open_ = mid
+    volume = 1000 + (idx % 97) * 13
+
+    close_list = close.tolist()
+    # ATR streams a 6-tuple (open, high, low, close, volume, timestamp) per tick.
+    candles = list(
+        zip(open_.tolist(), high.tolist(), low.tolist(), close_list, volume.tolist(), range(bars))
+    )
+
+    def mups(ns: float) -> float:
+        return bars / (ns / 1e9) / 1e6
+
+    def sma_stream() -> None:
+        ind = ta.SMA(20)
+        for value in close_list:
+            ind.update(value)
+
+    def sma_batch() -> None:
+        ta.SMA(20).batch(close)
+
+    def atr_stream() -> None:
+        ind = ta.ATR(14)
+        for candle in candles:
+            ind.update(candle)
+
+    def atr_batch() -> None:
+        ta.ATR(14).batch(high, low, close)
+
+    def macd_stream() -> None:
+        ind = ta.MACD(12, 26, 9)
+        for value in close_list:
+            ind.update(value)
+
+    # SMA (scalar 1-in/1-out), ATR (multi-in/1-out), MACD (1-in/multi-out).
+    indicators = [
+        ("SMA(20)", sma_stream, sma_batch),
+        ("ATR(14)", atr_stream, atr_batch),
+        ("MACD(12,26,9)", macd_stream, None),  # multi-output: streaming only
+    ]
+
+    print(f"Wickra Python throughput - {bars:,} bars (median of 3 runs)\n")
+    print(f"{'Indicator':<22}{'streaming (Mupd/s)':>20}{'batch (Mupd/s)':>18}")
+    print("-" * 60)
+    for name, stream, batch in indicators:
+        stream_mups = f"{mups(_time_ns(stream)):.1f}"
+        batch_mups = "-" if batch is None else f"{mups(_time_ns(batch)):.1f}"
+        print(f"{name:<22}{stream_mups:>20}{batch_mups:>18}")
+
+    print(
+        "\nMupd/s = million indicator updates per second. Streaming is the per-tick\n"
+        "`update` path crossing the Python<->Rust boundary once per value; batch is\n"
+        "the bulk numpy path (one boundary crossing). Higher is better. Numbers are\n"
+        "machine-dependent - use them for relative comparison, not as a speed claim."
+    )
+
+
+if __name__ == "__main__":
+    main()
@@ -4,7 +4,7 @@ build-backend = "maturin"

 [project]
 name = "wickra"
-version = "0.7.9"
+version = "0.8.3"
 description = "Streaming-first technical indicators: incremental, fast, install-free."
 readme = "README.md"
 license = "MIT OR Apache-2.0"
@@ -5,4 +5,9 @@
 ^src/wickra\.dll$
 ^src/wickra\.so$
 ^src/symbols\.rds$
+^src/wickra\.h$
+^src/libwickra\.(so|dylib)$
+^src/wickra-c\.tar\.gz$
+^src/wickra-c$
+^src/Makevars$
 ^\.gitignore$
@@ -1,7 +1,7 @@
 Package: wickra
 Type: Package
 Title: Streaming-First Technical Indicators
-Version: 0.7.9
+Version: 0.8.3
 Authors@R: person("Wickra contributors", role = c("aut", "cre"), email = "support@wickra.org")
 Description: R bindings for the Wickra technical-analysis library over its C ABI
    hub. Exposes 514 indicators, each an O(1) streaming state machine shared with
@@ -12,8 +12,10 @@ URL: https://github.com/wickra-lib/wickra, https://docs.wickra.org
 BugReports: https://github.com/wickra-lib/wickra/issues
 Encoding: UTF-8
 NeedsCompilation: yes
-SystemRequirements: the Wickra C ABI library (libwickra); set WICKRA_INCLUDE_DIR
-    and WICKRA_LIB_DIR when installing from source.
+SystemRequirements: the Wickra C ABI shared library, downloaded automatically at
+    install time from the matching GitHub release and bundled into the package.
+    Set WICKRA_INCLUDE_DIR and WICKRA_LIB_DIR to build against a locally built C
+    ABI instead (e.g. after `cargo build -p wickra-c --release`).
 Roxygen: list(markdown = TRUE)
 Suggests: testthat (>= 3.0.0)
 Config/testthat/edition: 3
@@ -59,6 +59,17 @@ indicators take the OHLCV fields plus a timestamp, e.g.
 `update(atr, open, high, low, close, volume, timestamp)`. The native handle is
 freed automatically when the object is garbage-collected.

+## Benchmark
+
+`benchmarks/throughput.R` reports streaming and batch updates-per-second for
+`SMA`, `ATR` and `MACD`. It measures this binding's FFI overhead, not a
+cross-library ratio (the same Rust core runs under every binding) — see the
+repository [BENCHMARKS.md](https://github.com/wickra-lib/wickra/blob/main/BENCHMARKS.md) §3.
+
+```bash
+Rscript benchmarks/throughput.R
+```
+
 ## Documentation

 The full indicator catalogue, guides, quickstarts, and API reference live in the
@@ -0,0 +1,119 @@
+#!/usr/bin/env Rscript
+#
+# Throughput benchmark for the Wickra R bindings.
+#
+# Measures how many indicator updates per second the R binding sustains, both
+# per-tick (streaming `update`) and bulk (`batch`), over a synthetic OHLCV
+# series. It is the R counterpart of the Node `throughput.js` and the Rust
+# criterion benches: it benchmarks Wickra's own O(1) streaming engine across
+# the R<->C-ABI boundary (there is no comparable streaming TA library on CRAN
+# to compare against), so the headline number is raw per-binding throughput /
+# FFI overhead, not a cross-library ratio.
+#
+# Three indicators are timed, chosen by FFI call-signature archetype rather
+# than algorithm: SMA (1-in -> 1-out), ATR (multi-in -> 1-out), and MACD
+# (1-in -> multi-out). Streaming is timed for all three; batch only for the
+# single-output SMA and ATR (multi-output batch is not exposed uniformly).
+#
+# Install the package first (it links the C ABI; see bindings/r/README.md),
+# then run:
+#
+#   Rscript bindings/r/benchmarks/throughput.R               # 200k bars (default)
+#   Rscript bindings/r/benchmarks/throughput.R --bars 1000000
+
+suppressMessages(library(wickra))
+
+parse_bars <- function() {
+  args <- commandArgs(trailingOnly = TRUE)
+  i <- match("--bars", args)
+  if (!is.na(i) && length(args) >= i + 1L) {
+    n <- suppressWarnings(as.integer(args[i + 1L]))
+    if (!is.na(n) && n >= 1000L) {
+      return(n)
+    }
+    stop("--bars must be an integer >= 1000")
+  }
+  200000L
+}
+
+bars <- parse_bars()
+
+# Deterministic synthetic OHLCV (no RNG, so runs are comparable).
+idx <- seq.int(0L, bars - 1L)
+mid <- 100 + sin(idx * 0.001) * 20 + idx * 1e-4
+close <- mid + sin(idx * 0.05) * 2
+high <- pmax(close, mid) + 1.5
+low <- pmin(close, mid) - 1.5
+open <- mid
+volume <- 1000 + (idx %% 97L) * 13
+# `numeric` (double), not integer: the candle batch path coerces the timestamp
+# column with REAL(), which rejects an integer vector.
+timestamp <- as.numeric(idx)
+
+# Median elapsed-ns over a few repetitions, after one warmup pass.
+time_ns <- function(fn, reps = 3L) {
+  fn() # warmup
+  samples <- numeric(reps)
+  for (r in seq_len(reps)) {
+    t0 <- Sys.time()
+    fn()
+    samples[r] <- as.numeric(Sys.time() - t0, units = "secs") * 1e9
+  }
+  median(samples)
+}
+
+mups_from_ns <- function(ns) bars / (ns / 1e9) / 1e6
+
+# SMA (scalar 1-in/1-out), ATR (multi-in/1-out), MACD (1-in/multi-out).
+indicators <- list(
+  list(
+    name = "SMA(20)",
+    stream = function() {
+      ind <- Sma(20)
+      for (i in seq_len(bars)) update(ind, close[i])
+    },
+    batch = function() {
+      batch(Sma(20), close)
+    }
+  ),
+  list(
+    name = "ATR(14)",
+    stream = function() {
+      ind <- Atr(14)
+      for (i in seq_len(bars)) {
+        update(ind, open[i], high[i], low[i], close[i], volume[i], timestamp[i])
+      }
+    },
+    batch = function() {
+      batch(Atr(14), open, high, low, close, volume, timestamp)
+    }
+  ),
+  list(
+    name = "MACD(12,26,9)",
+    stream = function() {
+      ind <- MacdIndicator(12, 26, 9)
+      for (i in seq_len(bars)) update(ind, close[i])
+    },
+    batch = NULL # multi-output: streaming only
+  )
+)
+
+cat(sprintf(
+  "Wickra R throughput - %s bars (median of 3 runs)\n\n",
+  format(bars, big.mark = ",")
+))
+cat(sprintf("%-22s%20s%18s\n", "Indicator", "streaming (Mupd/s)", "batch (Mupd/s)"))
+cat(strrep("-", 60), "\n", sep = "")
+
+for (ind in indicators) {
+  stream_mups <- sprintf("%.1f", mups_from_ns(time_ns(ind$stream)))
+  batch_mups <- if (is.null(ind$batch)) "-" else sprintf("%.1f", mups_from_ns(time_ns(ind$batch)))
+  cat(sprintf("%-22s%20s%18s\n", ind$name, stream_mups, batch_mups))
+}
+
+cat(paste0(
+  "\nMupd/s = million indicator updates per second. Streaming is the per-tick\n",
+  "`update` path crossing the R<->C-ABI boundary once per value; batch is the\n",
+  "bulk vector path (one boundary crossing). Higher is better. Numbers are\n",
+  "machine-dependent - use them for relative comparison, not as a speed claim.\n"
+))
@@ -0,0 +1,112 @@
+#!/bin/sh
+# Resolve the Wickra C ABI (header + shared library) for the Unix build.
+#
+# Self-contained by default: download the prebuilt wickra-c-<triple>.tar.gz
+# release asset that matches this package's version and stage the shared library
+# into src/ so the compiled wickra.so links against it and bundles it (via
+# install.libs.R), found post-install through an rpath ($ORIGIN on Linux,
+# @loader_path on macOS). Set WICKRA_INCLUDE_DIR + WICKRA_LIB_DIR to build
+# against a locally built C ABI instead (dev override; e.g.
+# `cargo build -p wickra-c --release`). Download/extract uses base R (always
+# present at build time), so there is no curl/wget system dependency.
+set -e
+
+inc=""
+lib=""
+
+# WebAssembly (r-universe / webR): there is no prebuilt wasm C ABI to download,
+# but the build image ships cargo (/usr/local/cargo/bin) and emscripten
+# (EMSDK on PATH), so build the C ABI staticlib from source for
+# wasm32-unknown-emscripten right here. Building it in the same image with the
+# same emscripten avoids any ABI/version mismatch a prebuilt lib would risk.
+# rayon (threads) is dropped via --no-default-features; the indicators are pure
+# computation, so the serial path is functionally identical.
+if [ "$(uname -s)" = "Emscripten" ]; then
+  version=$(sed -n 's/^Version:[[:space:]]*//p' DESCRIPTION)
+  echo "wickra: building C ABI from source for wasm32-unknown-emscripten (v${version})"
+  build=$(mktemp -d)
+  url="https://github.com/wickra-lib/wickra/archive/refs/tags/v${version}.tar.gz"
+  "${R_HOME}/bin/Rscript" -e "download.file('${url}', '${build}/src.tar.gz', mode = 'wb', quiet = TRUE)" \
+    || { echo "wickra: failed to download source ${url}"; exit 1; }
+  "${R_HOME}/bin/Rscript" -e "untar('${build}/src.tar.gz', exdir = '${build}')"
+  root="${build}/wickra-${version}"
+  rustup target add wasm32-unknown-emscripten 2>/dev/null || true
+  ( cd "${root}" && cargo build -p wickra-c --release \
+      --target wasm32-unknown-emscripten --no-default-features ) \
+    || { echo "wickra: cargo wasm build failed"; exit 1; }
+  cp "${root}/bindings/c/include/wickra.h" src/wickra.h
+  cp "${root}/target/wasm32-unknown-emscripten/release/libwickra.a" src/libwickra.a
+  rm -rf "${build}"
+  # The static archive is linked into the package object; no shared lib to
+  # bundle and no rpath needed.
+  sed "s|@WICKRA_RPATH@||" src/Makevars.in > src/Makevars
+  exit 0
+fi
+
+if [ -n "${WICKRA_INCLUDE_DIR}" ] && [ -n "${WICKRA_LIB_DIR}" ]; then
+  echo "wickra: using C ABI from WICKRA_INCLUDE_DIR / WICKRA_LIB_DIR (dev override)"
+  inc="${WICKRA_INCLUDE_DIR}"
+  lib="${WICKRA_LIB_DIR}"
+else
+  version=$(sed -n 's/^Version:[[:space:]]*//p' DESCRIPTION)
+  os=$(uname -s)
+  arch=$(uname -m)
+  case "${os}" in
+    Linux)
+      case "${arch}" in
+        x86_64) triple="x86_64-unknown-linux-gnu" ;;
+        aarch64 | arm64) triple="aarch64-unknown-linux-gnu" ;;
+        *) echo "wickra: unsupported Linux arch '${arch}' — set WICKRA_INCLUDE_DIR/WICKRA_LIB_DIR"; exit 1 ;;
+      esac
+      ;;
+    Darwin)
+      case "${arch}" in
+        x86_64) triple="x86_64-apple-darwin" ;;
+        arm64 | aarch64) triple="aarch64-apple-darwin" ;;
+        *) echo "wickra: unsupported macOS arch '${arch}' — set WICKRA_INCLUDE_DIR/WICKRA_LIB_DIR"; exit 1 ;;
+      esac
+      ;;
+    *)
+      echo "wickra: unsupported OS '${os}' — set WICKRA_INCLUDE_DIR/WICKRA_LIB_DIR"
+      exit 1
+      ;;
+  esac
+  url="https://github.com/wickra-lib/wickra/releases/download/v${version}/wickra-c-${triple}.tar.gz"
+  echo "wickra: downloading C ABI ${triple} for v${version}"
+  "${R_HOME}/bin/Rscript" -e "download.file('${url}', 'src/wickra-c.tar.gz', mode = 'wb', quiet = TRUE)" \
+    || { echo "wickra: failed to download ${url}"; exit 1; }
+  "${R_HOME}/bin/Rscript" -e "untar('src/wickra-c.tar.gz', exdir = 'src/wickra-c')"
+  inc="src/wickra-c/wickra-c-${triple}/include"
+  lib="src/wickra-c/wickra-c-${triple}/lib"
+fi
+
+# Stage the header and the platform shared library into src/ so the package
+# object links with -L. -lwickra and install.libs.R bundles the lib.
+cp "${inc}/wickra.h" src/wickra.h
+staged=""
+for f in libwickra.so libwickra.dylib; do
+  if [ -f "${lib}/${f}" ]; then
+    cp "${lib}/${f}" "src/${f}"
+    staged="${f}"
+  fi
+done
+if [ -z "${staged}" ]; then
+  echo "wickra: no libwickra.so/.dylib found under ${lib}"
+  exit 1
+fi
+
+# rpath so the bundled lib is found next to wickra.so after install.
+case "$(uname -s)" in
+  Darwin)
+    rpath="-Wl,-rpath,@loader_path"
+    # Normalise the dylib id to @rpath so @loader_path resolution applies.
+    install_name_tool -id "@rpath/${staged}" "src/${staged}" 2>/dev/null || true
+    ;;
+  *)
+    rpath="-Wl,-rpath,'\$\$ORIGIN'"
+    ;;
+esac
+
+sed "s|@WICKRA_RPATH@|${rpath}|" src/Makevars.in > src/Makevars
+echo "wickra: configured (bundled ${staged})"
+exit 0
@@ -4,9 +4,35 @@
 # itself). Stage a renamed copy, wickra_abi.dll, into src/ and build a mingw
 # import library that references it by that name (objdump + dlltool, both shipped
 # with Rtools — no gendef/pexports needed). install.libs.R then bundles the DLL.
+#
+# Self-contained by default: download the prebuilt wickra-c-<triple>.tar.gz
+# release asset matching this package's version. Set WICKRA_INCLUDE_DIR +
+# WICKRA_LIB_DIR to build against a locally built C ABI instead (dev override).
 set -e
-: "${WICKRA_LIB_DIR:?set WICKRA_LIB_DIR to the directory containing wickra.dll}"
-cp "${WICKRA_LIB_DIR}/wickra.dll" src/wickra_abi.dll
+
+if [ -n "${WICKRA_INCLUDE_DIR}" ] && [ -n "${WICKRA_LIB_DIR}" ]; then
+  echo "wickra: using C ABI from WICKRA_INCLUDE_DIR / WICKRA_LIB_DIR (dev override)"
+  inc="${WICKRA_INCLUDE_DIR}"
+  lib="${WICKRA_LIB_DIR}"
+else
+  version=$(sed -n 's/^Version:[[:space:]]*//p' DESCRIPTION)
+  arch=$(uname -m)
+  case "${arch}" in
+    x86_64) triple="x86_64-pc-windows-msvc" ;;
+    aarch64 | arm64) triple="aarch64-pc-windows-msvc" ;;
+    *) echo "wickra: unsupported Windows arch '${arch}' — set WICKRA_INCLUDE_DIR/WICKRA_LIB_DIR"; exit 1 ;;
+  esac
+  url="https://github.com/wickra-lib/wickra/releases/download/v${version}/wickra-c-${triple}.tar.gz"
+  echo "wickra: downloading C ABI ${triple} for v${version}"
+  "${R_HOME}/bin/Rscript" -e "download.file('${url}', 'src/wickra-c.tar.gz', mode = 'wb', quiet = TRUE)" \
+    || { echo "wickra: failed to download ${url}"; exit 1; }
+  "${R_HOME}/bin/Rscript" -e "untar('src/wickra-c.tar.gz', exdir = 'src/wickra-c')"
+  inc="src/wickra-c/wickra-c-${triple}/include"
+  lib="src/wickra-c/wickra-c-${triple}/lib"
+fi
+
+cp "${inc}/wickra.h" src/wickra.h
+cp "${lib}/wickra.dll" src/wickra_abi.dll
 {
  echo 'LIBRARY wickra_abi.dll'
  echo 'EXPORTS'
@@ -1,7 +1,13 @@
-# Build artifacts and the configure.win-generated C ABI import shims.
+# Build artifacts and the configure-staged C ABI header / library / downloads.
 *.o
 *.so
 *.dll
 *.dll.a
+*.dylib
+wickra.h
 wickra_abi.def
 symbols.rds
+wickra-c.tar.gz
+wickra-c/
+# configure generates Makevars from Makevars.in (Makevars.in + Makevars.win stay tracked).
+/Makevars
@@ -1,5 +0,0 @@
-# The Wickra C ABI header and library are not vendored; point the build at them
-# via WICKRA_INCLUDE_DIR (containing wickra.h) and WICKRA_LIB_DIR (containing
-# libwickra). Build the library first with: cargo build -p wickra-c --release.
-PKG_CPPFLAGS = -I$(WICKRA_INCLUDE_DIR)
-PKG_LIBS = -L$(WICKRA_LIB_DIR) -lwickra -Wl,-rpath,$(WICKRA_LIB_DIR)
@@ -0,0 +1,6 @@
+# Generated into src/Makevars by ../configure (the @WICKRA_RPATH@ token is
+# substituted per-OS: $ORIGIN on Linux, @loader_path on macOS). The C ABI header
+# (wickra.h) and shared library (libwickra.so/.dylib) are staged into src/ by
+# configure, so the package object links against the bundled lib.
+PKG_CPPFLAGS = -I.
+PKG_LIBS = -L. -lwickra @WICKRA_RPATH@
@@ -1,5 +1,5 @@
 # Link the import library built by configure.win (references wickra_abi.dll, not
-# the package's own wickra.dll). The C ABI header dir is passed via
-# WICKRA_INCLUDE_DIR at build time.
-PKG_CPPFLAGS = -I$(WICKRA_INCLUDE_DIR)
+# the package's own wickra.dll). The C ABI header (wickra.h) is staged into src/
+# by configure.win, so the include path is the source dir itself.
+PKG_CPPFLAGS = -I.
 PKG_LIBS = libwickra_abi.dll.a
@@ -1,7 +1,10 @@
-# Install the compiled package shared object plus, on Windows, the bundled
-# wickra_abi.dll (matched by the *.dll glob) so the loader can resolve the import
-# from the package's own libs directory (see .onLoad, which puts it on PATH).
-files <- Sys.glob(paste0("*", SHLIB_EXT))
+# Install the compiled package shared object plus the bundled C ABI library so
+# the package is self-contained: on Windows the wickra_abi.dll (matched by the
+# *.dll glob, loaded via PATH in .onLoad); on Linux the libwickra.so (matched by
+# the *.so SHLIB_EXT glob); on macOS the libwickra.dylib (added explicitly, since
+# R package objects use the .so extension there too). The Unix rpath baked by
+# configure ($ORIGIN / @loader_path) resolves it from this libs directory.
+files <- unique(c(Sys.glob(paste0("*", SHLIB_EXT)), Sys.glob("libwickra.dylib")))
 dest <- file.path(R_PACKAGE_DIR, paste0("libs", R_ARCH))
 dir.create(dest, recursive = TRUE, showWarnings = FALSE)
 file.copy(files, dest, overwrite = TRUE)
@@ -46,6 +46,18 @@ Constructors mirror the other bindings (`new SMA(20)`, `new MACD(12, 26, 9)`,
 `new BollingerBands(20, 2.0)`, …); `update()` returns the latest value or
 `null` while the indicator is still warming up.

+## Benchmark
+
+`benchmarks/throughput.mjs` reports streaming and batch updates-per-second for
+`SMA`, `ATR` and `MACD`. It measures this binding's FFI overhead, not a
+cross-library ratio (the same Rust core runs under every binding) — see the
+repository [BENCHMARKS.md](https://github.com/wickra-lib/wickra/blob/main/BENCHMARKS.md) §3.
+
+```bash
+wasm-pack build --target nodejs --out-dir pkg-node --release
+node benchmarks/throughput.mjs
+```
+
 ## Documentation

 The full indicator catalogue, guides, quickstarts, and API reference live in
@@ -0,0 +1,127 @@
+// Throughput benchmark for the Wickra WebAssembly bindings.
+//
+// Measures how many indicator updates per second the wasm binding sustains,
+// both per-tick (streaming `update`) and bulk (`batch`), over a synthetic
+// OHLCV series. It is the wasm counterpart of the Node `throughput.js` and the
+// Rust criterion benches: it benchmarks Wickra's own O(1) streaming engine
+// across the JS<->wasm boundary (there is no install-free TA library with a
+// comparable surface to compare against), so the headline number is raw
+// per-binding throughput / FFI overhead, not a cross-library ratio.
+//
+// Three indicators are timed, chosen by FFI call-signature archetype rather
+// than algorithm (the algorithm is identical to the Rust core; only the
+// boundary cost differs): SMA (1-in -> 1-out), ATR (multi-in -> 1-out), and
+// MACD (1-in -> multi-out). Streaming is timed for all three; batch only for
+// the single-output SMA and ATR (multi-output batch is not exposed uniformly).
+//
+// Build the nodejs-target package first (needs the wasm32-unknown-unknown
+// target, i.e. a rustup toolchain), then run:
+//
+//   cd bindings/wasm && wasm-pack build --target nodejs --out-dir pkg-node --release
+//   node benchmarks/throughput.mjs               # 200k bars (default)
+//   node benchmarks/throughput.mjs --bars 1000000
+
+import { createRequire } from 'node:module';
+import { hrtime } from 'node:process';
+
+const require = createRequire(import.meta.url);
+// wasm-pack --target nodejs emits a CommonJS module named after the crate.
+const wasm = require('../pkg-node/wickra_wasm.js');
+const { SMA, ATR, MACD } = wasm;
+
+function parseBars() {
+  const idx = process.argv.indexOf('--bars');
+  if (idx !== -1 && process.argv[idx + 1]) {
+    const n = Number(process.argv[idx + 1]);
+    if (Number.isFinite(n) && n >= 1000) return Math.floor(n);
+    console.error('--bars must be a number >= 1000');
+    process.exit(1);
+  }
+  return 200_000;
+}
+
+const BARS = parseBars();
+
+// Deterministic synthetic OHLCV (no RNG, so runs are comparable).
+const close = new Float64Array(BARS);
+const high = new Float64Array(BARS);
+const low = new Float64Array(BARS);
+for (let i = 0; i < BARS; i++) {
+  const mid = 100 + Math.sin(i * 0.001) * 20 + i * 1e-4;
+  close[i] = mid + Math.sin(i * 0.05) * 2;
+  high[i] = Math.max(close[i], mid) + 1.5;
+  low[i] = Math.min(close[i], mid) - 1.5;
+}
+
+// Median elapsed-ns over a few repetitions, after one warmup pass.
+function timeNs(fn, reps = 3) {
+  fn(); // warmup (JIT + cache)
+  const samples = [];
+  for (let r = 0; r < reps; r++) {
+    const t0 = hrtime.bigint();
+    fn();
+    samples.push(Number(hrtime.bigint() - t0));
+  }
+  samples.sort((a, b) => a - b);
+  return samples[Math.floor(samples.length / 2)];
+}
+
+function mupsFromNs(ns) {
+  return BARS / (ns / 1e9) / 1e6; // million updates per second
+}
+
+// SMA (scalar 1-in/1-out), ATR (multi-in/1-out), MACD (1-in/multi-out).
+const indicators = [
+  {
+    name: 'SMA(20)',
+    stream: () => {
+      const ind = new SMA(20);
+      for (let i = 0; i < BARS; i++) ind.update(close[i]);
+      ind.free();
+    },
+    batch: () => {
+      const ind = new SMA(20);
+      ind.batch(close);
+      ind.free();
+    },
+  },
+  {
+    name: 'ATR(14)',
+    stream: () => {
+      const ind = new ATR(14);
+      for (let i = 0; i < BARS; i++) ind.update(high[i], low[i], close[i]);
+      ind.free();
+    },
+    batch: () => {
+      const ind = new ATR(14);
+      ind.batch(high, low, close);
+      ind.free();
+    },
+  },
+  {
+    name: 'MACD(12,26,9)',
+    stream: () => {
+      const ind = new MACD(12, 26, 9);
+      for (let i = 0; i < BARS; i++) ind.update(close[i]);
+      ind.free();
+    },
+    batch: null, // multi-output: streaming only
+  },
+];
+
+console.log(`Wickra WASM throughput — ${BARS.toLocaleString('en-US')} bars (median of 3 runs)\n`);
+console.log(`${'Indicator'.padEnd(22)}${'streaming (Mupd/s)'.padStart(20)}${'batch (Mupd/s)'.padStart(18)}`);
+console.log('-'.repeat(60));
+
+for (const ind of indicators) {
+  const streamMups = mupsFromNs(timeNs(ind.stream)).toFixed(1);
+  const batchMups = ind.batch ? mupsFromNs(timeNs(ind.batch)).toFixed(1) : '—';
+  console.log(`${ind.name.padEnd(22)}${streamMups.padStart(20)}${batchMups.padStart(18)}`);
+}
+
+console.log(
+  '\nMupd/s = million indicator updates per second. Streaming is the per-tick\n' +
+    '`update` path crossing the JS<->wasm boundary once per value; batch is the\n' +
+    'bulk array path (one boundary crossing). Higher is better. Numbers are\n' +
+    'machine-dependent — use them for relative comparison, not as a speed claim.',
+);
@@ -64,6 +64,7 @@ endfunction()

 # Offline examples — built and run as ctests.
 add_wickra_example(smoke smoke.c TRUE)                 # links the boundary, asserts values
+add_wickra_example(archetypes archetypes.c TRUE)       # one indicator per FFI archetype
 add_wickra_example(streaming streaming.c TRUE)         # multi-indicator tick stream
 add_wickra_example(cpp_smoke smoke.cpp TRUE)           # C++ RAII wrapper (wickra.hpp)
 add_wickra_example(backtest backtest.c TRUE)           # indicator basket over a CSV
@@ -0,0 +1,161 @@
+/*
+ * Archetype coverage test for the Wickra C ABI.
+ *
+ * Exercises one indicator per FFI call-signature archetype through the real C
+ * boundary — scalar (+ batch == streaming), multi-output, alt-chart bars,
+ * market profile and array input — plus reset, invalid-parameter and NULL-safety
+ * behaviour. It is the C counterpart of the Go / R / Java archetype suites; the
+ * existing smoke test covers symbol/header/link, this one covers the data
+ * contracts. Run as a ctest (exit 0 on success).
+ */
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "wickra.h"
+
+static int failures = 0;
+
+#define CHECK(cond, msg)                          \
+    do {                                          \
+        if (!(cond)) {                            \
+            fprintf(stderr, "FAIL: %s\n", (msg)); \
+            failures += 1;                        \
+        }                                         \
+    } while (0)
+
+static int is_nan(double value) {
+    return value != value;
+}
+
+int main(void) {
+    /* 1. Scalar archetype: SMA known value over the FFI boundary. */
+    {
+        struct Sma *sma = wickra_sma_new(3);
+        CHECK(sma != NULL, "sma_new(3) returned NULL");
+        double last = NAN;
+        const double xs[] = {1.0, 2.0, 3.0, 4.0, 5.0};
+        for (size_t i = 0; i < 5; i++) {
+            last = wickra_sma_update(sma, xs[i]);
+        }
+        CHECK(fabs(last - 4.0) < 1e-9, "SMA(3) over [.. 3 4 5] should be 4");
+        wickra_sma_free(sma);
+    }
+
+    /* 2. Scalar batch must equal streaming. */
+    {
+        const double xs[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
+        const size_t n = 8;
+        struct Sma *stream = wickra_sma_new(3);
+        double want[8];
+        for (size_t i = 0; i < n; i++) {
+            want[i] = wickra_sma_update(stream, xs[i]);
+        }
+        wickra_sma_free(stream);
+
+        struct Sma *batched = wickra_sma_new(3);
+        double got[8];
+        wickra_sma_batch(batched, xs, got, n);
+        wickra_sma_free(batched);
+
+        int equal = 1;
+        for (size_t i = 0; i < n; i++) {
+            if (is_nan(want[i]) != is_nan(got[i])) {
+                equal = 0;
+            } else if (!is_nan(want[i]) && fabs(want[i] - got[i]) > 1e-9) {
+                equal = 0;
+            }
+        }
+        CHECK(equal, "SMA batch must equal streaming");
+    }
+
+    /* 3. Multi-output archetype: MACD writes a struct and returns a bool. */
+    {
+        struct MacdIndicator *macd = wickra_macd_indicator_new(3, 6, 3);
+        CHECK(macd != NULL, "macd_indicator_new returned NULL");
+        struct WickraMacdOutput out = {0};
+        int produced = 0;
+        for (int i = 0; i < 30; i++) {
+            if (wickra_macd_indicator_update(macd, 100.0 + (double)i, &out)) {
+                produced = 1;
+            }
+        }
+        CHECK(produced, "MACD produced no value after warmup");
+        CHECK(!is_nan(out.macd), "MACD value is NaN after warmup");
+        wickra_macd_indicator_free(macd);
+    }
+
+    /* 4. Alt-chart bars archetype: RangeBars writes 0..n bars per candle. */
+    {
+        struct RangeBars *bars = wickra_range_bars_new(2.0);
+        CHECK(bars != NULL, "range_bars_new returned NULL");
+        struct WickraRangeBar out[16];
+        size_t total = 0;
+        for (int i = 0; i < 15; i++) {
+            double price = 100.0 + (double)i;
+            total += wickra_range_bars_update(bars, price, price, price, price, 1.0,
+                                              (int64_t)i, out, 16);
+        }
+        CHECK(total > 0, "range bars produced no bars over a 15-point move");
+        wickra_range_bars_free(bars);
+    }
+
+    /* 5. Market-profile archetype: scalars + a caller-owned values buffer. */
+    {
+        struct VolumeProfile *profile = wickra_volume_profile_new(10, 24);
+        CHECK(profile != NULL, "volume_profile_new returned NULL");
+        struct WickraVolumeProfileOutputScalars scalars = {0};
+        double values[24];
+        intptr_t len = -1;
+        for (int i = 0; i < 20; i++) {
+            double price = 100.0 + (double)i;
+            len = wickra_volume_profile_update(profile, price, price + 1.0, price - 1.0,
+                                               price, 1000.0, (int64_t)i, &scalars,
+                                               values, 24);
+        }
+        CHECK(len > 0, "volume profile never produced a snapshot");
+        wickra_volume_profile_free(profile);
+    }
+
+    /* 6. Array-input archetype: a full order-book snapshot per side. */
+    {
+        struct OrderBookImbalanceFull *book = wickra_order_book_imbalance_full_new();
+        CHECK(book != NULL, "order_book_imbalance_full_new returned NULL");
+        const double bid_price[] = {99.9, 99.8, 99.7};
+        const double bid_size[] = {5.0, 3.0, 2.0};
+        const double ask_price[] = {100.1, 100.2, 100.3};
+        const double ask_size[] = {1.0, 1.0, 1.0};
+        double imbalance = wickra_order_book_imbalance_full_update(
+            book, bid_price, bid_size, 3, ask_price, ask_size, 3);
+        CHECK(!is_nan(imbalance), "order book imbalance returned NaN");
+        wickra_order_book_imbalance_full_free(book);
+    }
+
+    /* 7. Reset returns the indicator to its warmup state. */
+    {
+        struct Sma *sma = wickra_sma_new(3);
+        for (int i = 0; i < 3; i++) {
+            wickra_sma_update(sma, (double)(i + 1));
+        }
+        wickra_sma_reset(sma);
+        CHECK(is_nan(wickra_sma_update(sma, 10.0)), "SMA after reset must be NaN");
+        wickra_sma_free(sma);
+    }
+
+    /* 8. Invalid parameters return NULL; freeing NULL is a no-op. */
+    {
+        CHECK(wickra_sma_new(0) == NULL, "sma_new(0) should return NULL");
+        wickra_sma_free(NULL);
+    }
+
+    /* 9. A NULL handle update is a no-op returning NaN, never a crash. */
+    CHECK(is_nan(wickra_sma_update(NULL, 1.0)), "update(NULL) should return NaN");
+
+    if (failures == 0) {
+        printf("all archetypes passed\n");
+        return 0;
+    }
+    fprintf(stderr, "%d archetype check(s) failed\n", failures);
+    return 1;
+}
@@ -6,7 +6,7 @@

  <groupId>org.wickra.examples</groupId>
  <artifactId>wickra-examples</artifactId>
-  <version>0.7.9</version>
+  <version>0.8.3</version>
  <packaging>jar</packaging>

  <name>Wickra Java examples</name>
@@ -21,7 +21,7 @@
    <dependency>
      <groupId>org.wickra</groupId>
      <artifactId>wickra</artifactId>
-      <version>0.7.9</version>
+      <version>0.8.3</version>
    </dependency>
    <!-- Only the network examples (fetch_btcusdt) parse JSON. -->
    <dependency>
@@ -17,7 +17,7 @@
    },
    "../../bindings/node": {
      "name": "wickra",
-      "version": "0.7.9",
+      "version": "0.8.3",
      "license": "MIT OR Apache-2.0",
      "devDependencies": {
        "@napi-rs/cli": "^2.18.0"
@@ -26,12 +26,12 @@
        "node": ">= 18"
      },
      "optionalDependencies": {
-        "wickra-darwin-arm64": "0.7.9",
-        "wickra-darwin-x64": "0.7.9",
-        "wickra-linux-arm64-gnu": "0.7.9",
-        "wickra-linux-x64-gnu": "0.7.9",
-        "wickra-win32-arm64-msvc": "0.7.9",
-        "wickra-win32-x64-msvc": "0.7.9"
+        "wickra-darwin-arm64": "0.8.3",
+        "wickra-darwin-x64": "0.8.3",
+        "wickra-linux-arm64-gnu": "0.8.3",
+        "wickra-linux-x64-gnu": "0.8.3",
+        "wickra-win32-arm64-msvc": "0.8.3",
+        "wickra-win32-x64-msvc": "0.8.3"
      }
    },
    "node_modules/wickra": {
@@ -0,0 +1,131 @@
+//! Throughput benchmark for the Wickra Rust core — the zero-FFI baseline.
+//!
+//! Reports streaming (`update`) and batch updates-per-second over a synthetic
+//! OHLCV series, in the same format as every binding's `throughput` benchmark.
+//! Rust has no FFI boundary — it calls the core directly — so these numbers are
+//! the ceiling the per-binding benchmarks are measured against, and the value
+//! their `batch` paths converge towards. See the repository BENCHMARKS.md §3.
+//!
+//! For per-update latency and the cross-library comparison, use the criterion
+//! harnesses instead: `cargo bench -p wickra` and `cargo bench -p wickra-bench`.
+//!
+//! Run:
+//!   cargo run -p wickra-examples --release --bin throughput            # 200k bars
+//!   cargo run -p wickra-examples --release --bin throughput -- 1000000
+
+use std::time::Instant;
+
+use wickra::{Atr, Candle, Indicator, MacdIndicator, Sma};
+
+/// Median elapsed-ns over a few repetitions, after one warmup pass.
+fn time_ns(mut run: impl FnMut()) -> u128 {
+    run(); // warmup
+    let mut samples = [0u128; 3];
+    for sample in &mut samples {
+        let start = Instant::now();
+        run();
+        *sample = start.elapsed().as_nanos();
+    }
+    samples.sort_unstable();
+    samples[1]
+}
+
+fn main() {
+    let bars: usize = std::env::args()
+        .nth(1)
+        .and_then(|arg| arg.parse().ok())
+        .filter(|&n| n >= 1000)
+        .unwrap_or(200_000);
+
+    // Deterministic synthetic OHLCV (no RNG, so runs are comparable).
+    let mut open = Vec::with_capacity(bars);
+    let mut high = Vec::with_capacity(bars);
+    let mut low = Vec::with_capacity(bars);
+    let mut close = Vec::with_capacity(bars);
+    let mut volume = Vec::with_capacity(bars);
+    for i in 0..bars {
+        let mid = 100.0 + (i as f64 * 0.001).sin() * 20.0 + i as f64 * 1e-4;
+        let c = mid + (i as f64 * 0.05).sin() * 2.0;
+        close.push(c);
+        open.push(mid);
+        high.push(c.max(mid) + 1.5);
+        low.push(c.min(mid) - 1.5);
+        volume.push(1000.0 + (i % 97) as f64 * 13.0);
+    }
+    // ATR streams a Candle per tick; build them once, outside the timed loop.
+    let candles: Vec<Candle> = (0..bars)
+        .map(|i| {
+            Candle::new(
+                open[i],
+                high[i],
+                low[i],
+                close[i],
+                volume[i],
+                i64::try_from(i).unwrap(),
+            )
+            .unwrap()
+        })
+        .collect();
+
+    let mups = |ns: u128| bars as f64 / (ns as f64 / 1e9) / 1e6;
+
+    // SMA (scalar 1-in/1-out), ATR (multi-in/1-out), MACD (1-in/multi-out).
+    let sma_stream = time_ns(|| {
+        let mut ind = Sma::new(20).unwrap();
+        for &price in &close {
+            ind.update(price);
+        }
+    });
+    let sma_batch = time_ns(|| {
+        let mut ind = Sma::new(20).unwrap();
+        ind.batch_nan(&close);
+    });
+    let atr_stream = time_ns(|| {
+        let mut ind = Atr::new(14).unwrap();
+        for &candle in &candles {
+            ind.update(candle);
+        }
+    });
+    let atr_batch = time_ns(|| {
+        let mut ind = Atr::new(14).unwrap();
+        ind.batch_atr(&high, &low, &close);
+    });
+    let macd_stream = time_ns(|| {
+        let mut ind = MacdIndicator::new(12, 26, 9).unwrap();
+        for &price in &close {
+            ind.update(price);
+        }
+    });
+
+    println!("Wickra Rust core throughput - {bars} bars (median of 3 runs)\n");
+    println!(
+        "{:<22}{:>20}{:>18}",
+        "Indicator", "streaming (Mupd/s)", "batch (Mupd/s)"
+    );
+    println!("{}", "-".repeat(60));
+    println!(
+        "{:<22}{:>20.1}{:>18.1}",
+        "SMA(20)",
+        mups(sma_stream),
+        mups(sma_batch)
+    );
+    println!(
+        "{:<22}{:>20.1}{:>18.1}",
+        "ATR(14)",
+        mups(atr_stream),
+        mups(atr_batch)
+    );
+    println!(
+        "{:<22}{:>20.1}{:>18}",
+        "MACD(12,26,9)",
+        mups(macd_stream),
+        "-"
+    );
+
+    println!(
+        "\nMupd/s = million indicator updates per second. This is the Rust core with\n\
+         no FFI boundary, so it is the ceiling for the per-binding benchmarks and\n\
+         the value their batch paths converge towards. Numbers are machine-dependent\n\
+         - use them for relative comparison, not as a speed claim."
+    );
+}
Author	SHA1	Message	Date
kingchenc	3ee3fb67ec	release: bump 0.8.2 -> 0.8.3 (#249 ) Version bump 0.8.2 → 0.8.3, releasing the per-binding throughput benchmark work (merged in #246). Bumped via `ScriptHelpers/bump_version.py` across all manual touchpoints — `Cargo.toml`, `pyproject.toml`, the Node `package.json` + 6 platform packages + both lockfiles, the Java `pom.xml`s + README, the C# `.csproj`, the R `DESCRIPTION` — plus `Cargo.lock` (via `cargo build`) and the `CHANGELOG.md` `[0.8.3]` section and compare URLs. CHANGELOG `[0.8.3]`: - Per-binding throughput benchmarks for all 9 targets (BENCHMARKS.md §3). - C ABI archetype test (`examples/c/archetypes.c`). `cargo fmt`, `cargo test --workspace --all-features` (all green) and `cargo clippy --workspace --all-targets --all-features -D warnings` pass. The docs/webpage version strings are bumped by `sync-about.yml` on the `v*` tag — not touched here.	2026-06-10 03:55:39 +02:00
kingchenc	3ebcb3f758	Per-binding throughput benchmarks + test-coverage gaps (#246 ) Adds a `throughput` benchmark to every target and closes two small test-coverage documentation/QA gaps. One PR, no merge of binding code beyond the additive benchmarks and one C test. ## 1. Per-binding throughput benchmarks (all 9 targets) Each benchmark feeds a deterministic synthetic OHLCV series through three indicators chosen by FFI call-signature archetype (not algorithm — the same Rust core runs underneath all bindings): - `SMA(20)` — 1-in → 1-out (baseline boundary cost) - `ATR(14)` — multi-in → 1-out (input marshalling) - `MACD(12,26,9)` — 1-in → multi-out (output marshalling) Streaming is timed for all three; batch for the single-output SMA and ATR (median of 3 runs, after a warmup pass). New: Python (PyO3), WASM, C (CMake), C# (Stopwatch), Go, Java (FFM), R, and the Rust core baseline (`examples/rust/.../throughput.rs`, no FFI — the ceiling the bindings are measured against and the value their batch paths converge towards). Node already had `throughput.js`. Not a speed claim: there is no comparable streaming TA library for C, C#, Go, Java, R or WASM to compare against, so these are raw per-binding throughput numbers documenting each language's FFI overhead — see BENCHMARKS.md §3. The "Wickra is fast" claim still lives in §1/§2 (Rust core + the Python/Rust cross-library runs). ## 2. README `## Testing`: C# and C bullets The section listed every layer except C# and C, even though both have suites. Adds the two missing bullets. ## 3. C archetype ctest `examples/c/archetypes.c` drives one indicator per FFI archetype through the real C boundary (scalar + batch==streaming, multi-output, bars, profile, array input) plus reset, invalid-parameter and NULL-safety — the C counterpart of the Go/R/Java archetype suites. Runs on three OSes via the existing CMake/ctest. ## Notes - Benchmarks are not CI-gated (manual-run scripts, like the existing `throughput.js`); no `ci.yml`/`release.yml` changes. - Docs: BENCHMARKS.md §3, a `## Benchmark` section in every binding README, a CHANGELOG entry. - Verified locally by running: Rust, Python, C, C#, Go, Java (real numbers); the C archetype ctest with `-Wall -Wextra -Wpedantic -Werror`. WASM and R are API-correct and syntax-checked but need their own toolchains to run.	2026-06-10 03:46:38 +02:00
kingchenc	b31a9a3624	release: bump 0.8.1 -> 0.8.2 (#245 ) Patch release shipping the R WebAssembly build fix (#244): `bindings/r/configure` builds the C ABI from source for `wasm32-unknown-emscripten`, so r-universe's webR build stops failing. Also carries the shared Go badge in `bindings/go/README.md`. Version bumped across all manual touchpoints via `bump_version.py` (incl. DESCRIPTION + csproj, which had drifted before).	2026-06-10 01:57:10 +02:00
kingchenc	6433c9b3de	bindings/r: build the C ABI from source for the WebAssembly target (#244 ) ## Problem r-universe builds every package to WebAssembly (webR) in addition to the native platforms, calling `./configure --host=wasm32-unknown-emscripten`. `bindings/r/configure` only knew Linux/macOS/Windows and exited with `unsupported OS 'Emscripten'`, so the WASM job was the single red check on an otherwise fully-published r-universe build (all native platforms + deploy are green; the package installs fine everywhere). ## Fix The r-universe wasm build image ships cargo (`/usr/local/cargo/bin`) and emscripten (`EMSDK` on PATH). So instead of needing a prebuilt wasm lib (which would risk an emscripten ABI/version mismatch), `configure` now detects the Emscripten host and builds the C ABI staticlib from source for `wasm32-unknown-emscripten` in-place — compiled with the image's own emscripten, so the ABI always matches. The static `libwickra.a` is linked into the package object (no shared lib, no rpath). `wickra-core`'s rayon batch needs threads (absent on wasm), so the wasm build drops it via `--no-default-features`. `wickra-c` now takes `wickra-core` as a direct path dep with `default-features = false` plus a default `parallel` feature that re-enables it for native builds (a member-level `default-features = false` is ignored when inheriting a workspace dep — that was the trap). ## Validated locally - `cargo build -p wickra-c` (default) → rayon present, builds. - `cargo build -p wickra-c --no-default-features` (the wasm feature path) → rayon gone, builds. - `cargo build --workspace`, clippy, fmt all clean; `configure` passes `sh -n`. ## Cannot be validated locally No Rust/emscripten wasm toolchain here. The wasm build only runs in r-universe, and `configure` downloads the matching `v${version}` source tag — so this takes effect from the first release that includes it (the tagged source must contain the feature toggle). Open risks: whether the image has the `wasm32-unknown-emscripten` Rust target pre-installed (configure runs `rustup target add` best-effort) and the wasm build time. Worth one r-universe rebuild to confirm. Not merging — review first.	2026-06-10 01:44:48 +02:00
kingchenc	447bbc8220	bindings/csharp: sync the static csproj version to 0.8.1 (#243 ) The static `<Version>` in `bindings/csharp/Wickra/Wickra.csproj` had drifted to 0.7.9 — it was missed in the 0.8.0/0.8.1 bumps (wrongly assumed to be purely tag-injected). The published NuGet package was correct (the release packs with `-p:Version=`), but the static field lagged. Resync to 0.8.1; bump_version.py now covers it.	2026-06-10 01:08:37 +02:00
kingchenc	c9ef2fc037	bindings/r: bump DESCRIPTION version to 0.8.1 (#242 ) The R package DESCRIPTION was missed in the 0.8.0/0.8.1 version bumps (it stayed at 0.7.9), so r-universe published wickra 0.7.9 while everything else is 0.8.1. Resync it; r-universe rebuilds from the main HEAD on its next ~hourly sync.	2026-06-10 00:47:13 +02:00
kingchenc	49c2872ad4	sync-about: sync the version for every registry row (#241 ) The published-versions table sync only matched crates.io/PyPI/npm rows, so the NuGet, Maven Central, Go and r-universe rows added to the docs would stay stale on each release. Extend the regex to all seven registries and match the registry name whether plain or wrapped in a markdown link.	2026-06-10 00:26:49 +02:00
kingchenc	0c4bbaf314	release: bump 0.8.0 -> 0.8.1 (#240 ) Patch release shipping the wickra-go mirror license fix (#239). The release-time Go mirror now includes the dual MIT OR Apache-2.0 license files, so the next published Go module version resolves with a redistributable license on pkg.go.dev. No code changes; all other packages are republished unchanged at 0.8.1.	2026-06-10 00:22:29 +02:00
kingchenc	99ad2ab107	release.yml: ship the dual license in the wickra-go mirror (#239 ) The go-mirror job copied the source, header, README and libraries into wickra-go but not the license, so pkg.go.dev reports `License: None detected` (not redistributable). Copy the root `LICENSE-MIT` and `LICENSE-APACHE` into the assembled module. Takes effect on the next release; the already-published `v0.8.0` tag is immutable on the Go proxy and keeps its current state.	2026-06-10 00:20:34 +02:00
kingchenc	8e225a5872	docs: add Maven Central, Go and r-universe badges to the README (#238 ) Adds the three remaining package badges to the README badge row — Maven Central (`org.wickra:wickra`), the Go module (`wickra-go`) and the r-universe R package — mirroring the org profile badge row. They are served from the `.github` badge snapshots like the existing badges.	2026-06-10 00:12:52 +02:00
kingchenc	87bb008aa1	release: bump 0.7.9 -> 0.8.0 + Go module mirror (#237 ) Bumps the workspace from 0.7.9 to 0.8.0 and adds the release-time mirror of the Go module to a standalone `wickra-go` repository. ## release.yml: `go-mirror` job Adds a `go-mirror` job (independent of `github-release`, `needs: c-abi-build`) that on every `v` tag: - assembles the standalone Go module from `bindings/go` (single-package source + the vendored `include/wickra.h`), - stages the six prebuilt C ABI libraries from the `c-abi-build` artifacts under `lib/<goos>_<goarch>/` (committed in the mirror, unlike the in-repo `lib/.gitignore`), - rewrites `go.mod` to `module github.com/wickra-lib/wickra-go`, - commits and tags the result in `wickra-lib/wickra-go` using the `WICKRA_GO_MIRROR_TOKEN` fine-grained PAT. This makes `go get github.com/wickra-lib/wickra-go` build with no extra steps, closing the gap where the in-repo `bindings/go` module only built inside a full repository checkout. The mirror is a derived artifact, so its bot commit is intentionally unsigned. ## Version bump 0.7.9 -> 0.8.0 Patch never reaches double digits (`0.7.9` -> `0.8.0`). Touchpoints: `Cargo.toml` (+ `Cargo.lock` via build), `bindings/python/pyproject.toml`, `bindings/node/package.json` + 6 platform `npm//package.json` + both `package-lock.json` files, `bindings/java/pom.xml` + `examples/java/pom.xml` + Maven/Gradle snippets in `bindings/java/README.md`, and `CHANGELOG.md`. The C# `Wickra.csproj` (version set per tag) and `bindings/c` (inherits the workspace version) are intentionally untouched. Tagging `v0.8.0` (which triggers the publish + the new mirror) stays gated on explicit confirmation.	2026-06-09 23:50:48 +02:00
kingchenc	b06ce2678a	Restructure the Go binding for self-contained distribution (#236 ) ## Problem Plain `go get` + `go build` of the Go binding never worked as a dependency: - cgo `CFLAGS` pointed at `${SRCDIR}/../c/include` — the parent dir is outside the Go module, so a proxy-fetched module has no header. - the library under `./lib` was git-ignored and never shipped; the README told users to `cargo build` it from the workspace, which only works inside a clone, not from the read-only module cache. cgo has no build hook and Go has no registry, so the only way a consumer's `go get`+build can find the lib is for it to be committed inside the module the consumer pulls. Per the design decision, that module is a separate `wickra-go` repo (keeps this repo free of committed binaries), populated by the release pipeline — this PR is the in-repo restructure that makes that possible. ## Changes - Vendor the header at `bindings/go/include/wickra.h` (committed copy of `bindings/c/include/wickra.h`); `CFLAGS` → `-I${SRCDIR}/include`. A CI drift check fails if the copy goes stale. - Per-platform libraries: cgo `LDFLAGS` become per `GOOS`/`GOARCH`, linking `${SRCDIR}/lib/<goos>_<goarch>/`. - CI stages the host library into `lib/<goos>_<goarch>/` (`RUNNER_OS`/`RUNNER_ARCH` — note `macos-latest` is arm64) and exports `WICKRA_GO_LIBDIR` for the Windows PATH; libraries stay git-ignored here. - README: install via the `wickra-go` module + a contributor build section. ## Validation - Local windows/amd64: `gofmt` clean, `go vet`, `go build`, `go test` all green against the staged library + vendored header. - Linux/macOS arches → the 3-OS `Go on …` CI job. Follow-up (Stage 2, separate): create `wickra-lib/wickra-go` + a `release.yml` mirror job (source + 6 platform libs → `lib/<goos>_<goarch>/`, commit + tag), and point the docs at the new import path. Part of the self-contained gap (`todo-11`).	2026-06-09 23:06:16 +02:00
kingchenc	5b7523265c	Make the R binding self-contained (fetch the C ABI at install time) (#235 ) ## Problem The R package built only inside the dev/CI workspace. `src/Makevars` and `configure.win` hard-required `WICKRA_INCLUDE_DIR` / `WICKRA_LIB_DIR` pointing at a pre-built `libwickra` (`configure.win` literally `: "${WICKRA_LIB_DIR:?...}"`), and there was no Unix `configure`. So r-universe and any plain `install.packages` / `install_github` failed — R had no working end-user install path. ## Fix Fetch the prebuilt `wickra-c-<triple>.tar.gz` release asset matching the package version at install time and bundle the library into the package (same outcome as the C# / Java bindings, which bundle per-platform native libs): - New POSIX `configure` (the Unix hook R lacked): detect OS/arch → triple, download + `untar` via base R (no curl/wget system dep), stage `wickra.h` + `libwickra.{so,dylib}` into `src/`, generate `src/Makevars` from `Makevars.in` with an rpath (`$ORIGIN` Linux, `@loader_path` + `install_name_tool` macOS) so the bundled lib resolves post-install. - `configure.win`: drop the hard `WICKRA_LIB_DIR` requirement; download the Windows triple when unset, then keep the existing `wickra_abi.dll` rename + `objdump`/`dlltool` import-lib dance (sourcing the dll/header from the asset). - `install.libs.R` also bundles `libwickra.dylib` (macOS); the `.so`/`.dll` globs already covered Linux/Windows. - `WICKRA_INCLUDE_DIR`/`WICKRA_LIB_DIR` stay as an optional dev override. - CI (3 OS) keeps building against the locally built C ABI (version-independent — avoids the chicken-egg of downloading the in-flight version) but no longer exports `LD_LIBRARY_PATH`/`DYLD_LIBRARY_PATH`, so it now verifies the bundled rpath — the real self-contained path users and r-universe get. `Makevars` is now generated from `Makevars.in`; `SystemRequirements` + ignore/attributes files updated. ## Validation - The Windows `objdump`/`dlltool` import-lib dance was smoke-tested locally against the real v0.7.9 asset (2412 `wickra_` exports → import lib built). - Linux/macOS rpath bundling can't be tested on this Windows host → the 3-OS `r` CI job is the gate (now without the loader-path mask). - Follow-up (separate, after release): set up `wickra-lib/wickra-lib.r-universe.dev` (`packages.json` → `bindings/r`). Closes the R half of the self-contained-distribution gap (`todo-10`).	2026-06-09 22:11:50 +02:00