release: bump 0.9.8 -> 0.9.9 (#351)

* release: bump 0.9.8 -> 0.9.9

* ci(lychee): exclude the CHANGELOG version-compare links

The CHANGELOG compare URLs point at the release tag created *after* the bump is
merged; ci.yml runs on push/PR (never on the tag), so the tag never exists when
lychee runs and 'compare/vX...vY' / 'compare/vY...HEAD' 404. Excluded by the same
pattern mechanism already used for the crates.io / npm package URLs — one pattern
covers every future version, no per-release change needed.

.editorconfig

@@ -0,0 +1,34 @@
+# EditorConfig: https://editorconfig.org
+# Keeps indentation and line-endings consistent across IDEs.
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+
+# Rust + Python + most config files use 4-space indents.
+[*.{rs,py,toml}]
+indent_size = 4
+
+# JS / TS / JSON / YAML / Markdown use 2-space indents per ecosystem conventions.
+[*.{js,ts,jsx,tsx,json,yml,yaml,md}]
+indent_size = 2
+
+# Markdown allows trailing whitespace as a hard line break — keep it intact.
+[*.md]
+trim_trailing_whitespace = false
+
+# Makefiles must use tabs.
+[Makefile]
+indent_style = tab
+
+# Generated files are not authored by humans; leave them alone.
+[bindings/node/index.{js,d.ts}]
+indent_style = unset
+indent_size = unset
+trim_trailing_whitespace = unset
+insert_final_newline = unset

.gitattributes

@@ -0,0 +1,41 @@
+# Shell scripts must keep LF line endings so they run on Linux/macOS CI and
+# local shells regardless of the committer's platform autocrlf setting.
+*.sh text eol=lf
+
+# The cbindgen-generated C header is committed; pin it to LF so its CI drift
+# check (regenerate + `git diff`) never trips on a CRLF normalization.
+bindings/c/include/wickra.h text eol=lf
+
+# C# sources (including the generated binding) are pinned to LF so the committed
+# files stay stable regardless of the committer's autocrlf setting.
+*.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. 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.
+*.java text eol=lf
+
+# R binding: `R CMD check` requires LF in sources, Makevars and shell scripts.
+*.R text eol=lf
+*.Rd text eol=lf
+bindings/r/configure text eol=lf
+bindings/r/configure.win 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
+
+# Golden fixtures are replayed byte-for-byte by every binding's parity test. Pin
+# them to LF so a Windows `core.autocrlf=true` checkout doesn't rewrite them as
+# CRLF — which silently broke the Node reader (`Number('inf\r')` is NaN, and a
+# blank "no-bar" row gained a stray `\r`), failing only on Windows runners. The
+# tolerant readers (Python `splitlines`/`float`) hid the same hazard.
+testdata/golden/** text eol=lf
+

.github/CODEOWNERS

@@ -0,0 +1,6 @@
+# Code owners for Wickra.
+#
+# The owner listed here is requested for review automatically on every pull
+# request. See https://docs.github.com/articles/about-code-owners.
+
+*       @wickra-lib

.github/FUNDING.yml

@@ -0,0 +1,5 @@
+# Funding sources surfaced on the repository "Sponsor" button.
+# Each platform's value is the username/handle on that platform.
+# Leave a key empty (e.g. patreon:) to skip a platform.
+
+github: [kingchenc]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,39 @@
+---
+name: Bug report
+about: Report incorrect behaviour in Wickra
+title: "[Bug] "
+labels: bug
+assignees: ""
+---
+
+## Description
+
+<!-- A clear description of what is wrong. -->
+
+## Reproduction
+
+<!-- Minimal code that reproduces the problem. -->
+
+```rust
+// or python / javascript
+```
+
+## Expected behaviour
+
+<!-- What you expected to happen, ideally with a reference value
+     (TA-Lib, pandas-ta, hand-computed). -->
+
+## Actual behaviour
+
+<!-- What happened instead. -->
+
+## Environment
+
+- Wickra version:
+- Language / binding: <!-- Rust crate / Python / Node.js / WASM / C / C++ / C# / Go / Java / R -->
+- OS and architecture:
+- Rust / Python / Node.js / .NET version (If relevant):
+
+## Additional context
+
+<!-- Logs, screenshots, anything else. -->

.github/ISSUE_TEMPLATE/bug_report_detailed.md

@@ -0,0 +1,61 @@
+---
+name: Bug report (Detailed)
+about: Long-form bug report with environment matrix, minimal reproducer, and expected-vs-actual sections.
+title: "[Bug] <short description>"
+labels: ["bug", "triage"]
+assignees: []
+---
+
+## Summary
+
+<!-- One or two sentences. What did you expect, what happened instead? -->
+
+## Affected binding
+
+- [ ] Rust crate (`wickra`)
+- [ ] Python (`pip install wickra`)
+- [ ] Node.js (`npm install wickra`)
+- [ ] WASM
+- [ ] C ABI (`bindings/c`)
+- [ ] C# (`Wickra` on NuGet)
+- [ ] Go (`bindings/go`)
+- [ ] Java (`org.wickra:wickra` on Maven Central)
+- [ ] R (`bindings/r`)
+- [ ] Docs / examples only
+
+## Environment
+
+| Field                | Value                                  |
+| -------------------- | -------------------------------------- |
+| Wickra version       | `e.g. 0.4.2`                           |
+| Binding version      | `e.g. python 0.4.2 / node 0.4.2`       |
+| OS / arch            | `e.g. Windows 11 x86_64, Linux glibc`  |
+| Rust toolchain       | `rustc --version` (If building from source) |
+| Python / Node.js / .NET version | `python --version` / `node --version` / `dotnet --version` |
+
+## Minimal reproducer
+
+<!--
+Paste the smallest possible code snippet that triggers the bug.
+If the input data matters, attach a CSV/JSON or paste a few rows inline.
+-->
+
+```python
+# or rust / js
+import wickra as ta
+...
+```
+
+## Actual output
+
+```
+<paste stack trace, panic, wrong values, etc.>
+```
+
+## Expected output
+
+<!-- What should the indicator / API have returned? Reference a paper, TA-Lib, or another implementation if possible. -->
+
+## Additional context
+
+<!-- Logs, screenshots, links to related issues, anything else useful. -->

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Security vulnerability
+    url: https://github.com/wickra-lib/wickra/security/advisories/new
+    about: Report security issues privately — do not open a public issue.
+  - name: Question or discussion
+    url: https://github.com/wickra-lib/wickra/discussions
+    about: Ask usage questions and discuss ideas here.

.github/ISSUE_TEMPLATE/documentation.md

@@ -0,0 +1,33 @@
+---
+name: Documentation issue
+about: Something in the README, rustdoc, examples, or guides is wrong, missing, or confusing.
+title: "[Docs] <short description>"
+labels: ["documentation", "good first issue"]
+assignees: []
+---
+
+## Where
+
+<!-- Link or path. e.g. README.md#streaming-vs-batch, docs/guide/ema.md, rustdoc for `wickra::Ema::update`. -->
+
+## What's wrong / missing
+
+<!--
+- [ ] Incorrect information
+- [ ] Outdated for current API
+- [ ] Missing example
+- [ ] Unclear wording
+- [ ] Broken link / broken code block
+- [ ] Other
+-->
+
+## Suggested change
+
+<!--
+Paste the corrected wording, a clearer example, or a sketch of the
+section you'd like to see. PRs welcome.
+-->
+
+## Additional context
+
+<!-- Quote of the confusing passage, screenshot, etc. -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,36 @@
+---
+name: Feature request
+about: Suggest a new indicator or capability for Wickra
+title: "[Feature] "
+labels: enhancement
+assignees: ""
+---
+
+## Problem
+
+<!-- What are you trying to do that Wickra cannot do today? -->
+
+## Proposed solution
+
+<!-- For a new indicator: its name, formula, and the standard parameters.
+     Link a reference implementation (TA-Lib, pandas-ta) if one exists. -->
+
+## Alternatives considered
+
+<!-- Other approaches and why they fall short. -->
+
+## Scope
+
+- [ ] Affects the Rust core
+- [ ] Should be exposed in the Python binding
+- [ ] Should be exposed in the Node binding
+- [ ] Should be exposed in the WASM binding
+- [ ] Should be exposed in the C ABI
+- [ ] Should be exposed in the C# binding
+- [ ] Should be exposed in the Go binding
+- [ ] Should be exposed in the Java binding
+- [ ] Should be exposed in the R binding
+
+## Additional context
+
+<!-- Anything else that helps. -->

.github/ISSUE_TEMPLATE/feature_request_detailed.md

@@ -0,0 +1,55 @@
+---
+name: Feature request (Detailed)
+about: Long-form proposal with API sketch, scope checkboxes, prior-art links, and contribution intent.
+title: "[Feat] <short description>"
+labels: ["enhancement", "triage"]
+assignees: []
+---
+
+## Problem / motivation
+
+<!--
+What are you trying to do that Wickra doesn't support today?
+Describe the user-facing pain point, not the implementation.
+-->
+
+## Proposed solution
+
+<!--
+Sketch the API or behavior you'd like. A short code snippet of how
+you'd want to call it is worth a thousand words.
+-->
+
+```python
+import wickra as ta
+
+# proposed API
+ind = ta.SuperTrend(period=10, multiplier=3.0)
+ind.update(close, high, low)
+```
+
+## Scope
+
+- [ ] New indicator
+- [ ] New method on an existing indicator
+- [ ] New binding / platform target
+- [ ] Performance improvement
+- [ ] Ergonomics / API cleanup
+- [ ] Other (Explain below)
+
+## Reference / prior art
+
+<!--
+Link the paper, book chapter, TA-Lib function, TradingView Pine source,
+or other implementations you'd like Wickra to match.
+-->
+
+## Alternatives considered
+
+<!-- What workarounds exist today? Why aren't they enough? -->
+
+## Willingness to contribute
+
+- [ ] I'd like to implement this myself with guidance
+- [ ] I can help review / test
+- [ ] Requesting only — no bandwidth to implement

.github/ISSUE_TEMPLATE/performance_regression.md

@@ -0,0 +1,54 @@
+---
+name: Performance regression
+about: Report a measurable slowdown, memory blowup, or throughput drop.
+title: "[Perf] <indicator / API> regressed in <version>"
+labels: ["performance", "regression", "triage"]
+assignees: []
+---
+
+## Summary
+
+<!-- Which code path got slower, by how much, and since when? -->
+
+## Affected code path
+
+- Indicator / API: `e.g. EMA.update`
+- Binding: `Rust / Python / Node.js / WASM / C / C++ / C# / Go / Java / R`
+- Hot loop or one-shot call?
+
+## Versions compared
+
+| Version  | Throughput / latency / memory | Notes |
+| -------- | ----------------------------- | ----- |
+| `0.4.1`  | `e.g. 12.3 ns/iter`           | baseline (Good) |
+| `0.4.2`  | `e.g. 38.7 ns/iter`           | regressed |
+
+## Benchmark / reproducer
+
+<!--
+Paste the criterion / pytest-benchmark / hyperfine command and its output.
+For one-off measurements, include the timing snippet inline.
+-->
+
+```bash
+cargo bench --bench ema -- --save-baseline new
+```
+
+```
+ema/update              time:   [38.5 ns 38.7 ns 38.9 ns]
+                        change: [+213.4% +214.8% +216.1%] (p = 0.00 < 0.05)
+                        Performance has regressed.
+```
+
+## Hardware / environment
+
+| Field        | Value                                  |
+| ------------ | -------------------------------------- |
+| CPU          | `e.g. Ryzen 9 9950X, AVX2 + AVX512`    |
+| OS / arch    | `e.g. Linux 6.8 x86_64`                |
+| Toolchain    | `rustc 1.x.y`                          |
+| Build flags  | `RUSTFLAGS=...`, `--release`, profile  |
+
+## Suspected cause
+
+<!-- Optional. Link the commit / PR if you've bisected it. -->

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,36 @@
+---
+name: Question / usage help
+about: Ask how to do something with Wickra. For open-ended discussion prefer GitHub Discussions.
+title: "[Question] <short description>"
+labels: ["question"]
+assignees: []
+---
+
+> [!NOTE]
+> If this is open-ended ("which indicator should I use for X?") please
+> use **Discussions** instead — issues are for actionable items.
+
+## What are you trying to do?
+
+<!-- The end goal, not the API call. -->
+
+## What have you tried?
+
+<!--
+Code, docs you've read, search terms that didn't help.
+Show that you've spent a few minutes before asking.
+-->
+
+```python
+import wickra as ta
+...
+```
+
+## What's confusing or blocking you?
+
+<!-- Specific question. "Why does X return NaN for the first N points?" beats "doesn't work". -->
+
+## Environment (Only if relevant)
+
+- Wickra version: `e.g. 0.4.2`
+- Binding: `Rust / Python / Node.js / WASM / C / C++ / C# / Go / Java / R`

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,34 @@
+<!-- Thanks for contributing to Wickra. Please fill in the sections below. -->
+
+## Summary
+
+<!-- What does this PR change, and why? -->
+
+## Related issue
+
+<!-- e.g. Closes #123 -->
+
+## Type of change
+
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Indicator addition / change
+- [ ] Documentation
+- [ ] CI / build / tooling
+
+## Checklist
+
+- [ ] `cargo fmt --all --check` is clean.
+- [ ] `cargo clippy --workspace --all-targets -- -D warnings` is clean.
+- [ ] `cargo test --workspace` passes.
+- [ ] New behaviour has tests; bug fixes have a regression test.
+- [ ] Public API changes are mirrored in the Python / Node.js / WASM bindings, and the C ABI + C# + Go + Java + R bindings are regenerated
+      and their type stubs (If applicable).
+- [ ] The relevant page on the [documentation site](https://docs.wickra.org)
+      and the `README.md` are updated (If applicable). Docs edits go to a
+      separate repository: `https://github.com/wickra-lib/wickra-docs`.
+- [ ] An entry was added under `## [Unreleased]` in `CHANGELOG.md`.
+
+## Notes for reviewers
+
+<!-- Anything that needs extra attention, trade-offs, follow-ups. -->

.github/PULL_REQUEST_TEMPLATE/detailed.md

@@ -0,0 +1,72 @@
+<!--
+Thanks for contributing to Wickra!
+Please fill in the sections below. Delete any that don't apply.
+-->
+
+## Summary
+
+<!-- 1–3 sentences: what does this PR change and why? -->
+
+## Type of change
+
+- [ ] Bug fix (Non-breaking change which fixes an issue)
+- [ ] New feature (Non-breaking change which adds functionality)
+- [ ] Breaking change (Fix or feature that changes existing public API)
+- [ ] Performance improvement
+- [ ] Refactor (No functional change)
+- [ ] Documentation only
+- [ ] CI / build / tooling
+
+## Affected surfaces
+
+- [ ] Rust crate (`crates/wickra`)
+- [ ] Python binding (`bindings/python`)
+- [ ] Node.js binding (`bindings/node`)
+- [ ] WASM binding (`bindings/wasm`)
+- [ ] C ABI (`bindings/c`)
+- [ ] C# binding (`bindings/csharp`)
+- [ ] Go binding (`bindings/go`)
+- [ ] Java binding (`bindings/java`)
+- [ ] R binding (`bindings/r`)
+- [ ] Examples / docs
+
+## Linked issues
+
+<!-- "Closes #123", "Refs #456". One per line. -->
+
+Closes #
+
+## How was this tested?
+
+<!--
+- Unit tests added / updated under `crates/*/tests/` or `bindings/*/tests/`
+- Property / fuzz tests touched? (Under `fuzz/`)
+- Manual repro steps, if applicable
+- Benchmarks run (Paste before/after if perf-sensitive)
+-->
+
+## Numerical correctness (If you touched an indicator)
+
+- [ ] Output matches an existing reference (TA-Lib, paper, prior Wickra release) within documented tolerance
+- [ ] Streaming `update()` matches batch / `from_slice` output on the same input
+- [ ] Edge cases covered: empty input, single point, NaN, leading warm-up window
+
+## Performance impact (If applicable)
+
+| Benchmark | Before | After | Δ |
+| --------- | ------ | ----- | - |
+|           |        |       |   |
+
+## Checklist
+
+- [ ] `cargo fmt --all` and `cargo clippy --all-targets -- -D warnings` are clean
+- [ ] `cargo test --workspace` passes locally
+- [ ] Binding tests run (If a binding changed)
+- [ ] Public API changes are reflected in `CHANGELOG.md`
+- [ ] Public API changes are reflected in rustdoc / README / examples
+- [ ] No `todo*.md` or other local-only notes are staged
+- [ ] License header / `LICENSE` reference unchanged (MIT OR Apache-2.0)
+
+## Notes for reviewers
+
+<!-- Anything reviewers should look at first, known follow-ups, deliberately out-of-scope items. -->

.github/actions/setup-rust/action.yml

@@ -0,0 +1,46 @@
+name: Setup Rust toolchain (with retry)
+description: >
+  Install a Rust toolchain via dtolnay/rust-toolchain, retrying once after a
+  short pause on the transient rustup CDN failure (a corrupt channel manifest /
+  checksum mismatch on `channel-rust-<channel>.toml`) that rustup itself does
+  not retry — the same hardening already applied to setup-node / setup-go.
+
+inputs:
+  toolchain:
+    description: Rust toolchain (channel or version) to install.
+    required: false
+    default: stable
+  components:
+    description: Comma-separated list of rustup components (e.g. "rustfmt, clippy").
+    required: false
+    default: ""
+  targets:
+    description: Comma-separated list of rustup targets (e.g. "wasm32-unknown-unknown").
+    required: false
+    default: ""
+
+runs:
+  using: composite
+  steps:
+    - id: first
+      uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
+      continue-on-error: true
+      with:
+        toolchain: ${{ inputs.toolchain }}
+        components: ${{ inputs.components }}
+        targets: ${{ inputs.targets }}
+
+    - name: Wait before retrying the toolchain install
+      if: steps.first.outcome == 'failure'
+      shell: bash
+      run: |
+        echo "::warning::rustup toolchain install failed (likely a CDN flake / corrupt channel manifest); retrying in 30s"
+        sleep 30
+
+    - name: Retry the Rust toolchain install
+      if: steps.first.outcome == 'failure'
+      uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
+      with:
+        toolchain: ${{ inputs.toolchain }}
+        components: ${{ inputs.components }}
+        targets: ${{ inputs.targets }}

.github/dependabot.yml

@@ -0,0 +1,156 @@
+version: 2
+updates:
+  # Rust workspace (root Cargo.toml + all member crates).
+  - package-ecosystem: cargo
+    directory: "/"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "deps(cargo)"
+    # ureq is intentionally pinned to 2.x. ureq 3 unconditionally pulls
+    # webpki-root-certs (CDLA-Permissive-2.0); the native-tls / OS-trust-store
+    # setup in wickra-data deliberately avoids that licence. Block the major
+    # bump (2.x patch/minor still flow through).
+    ignore:
+      - dependency-name: "ureq"
+        update-types: ["version-update:semver-major"]
+    groups:
+      # napi-rs (napi / napi-derive / napi-build) is a coordinated major
+      # migration that must move with @napi-rs/cli on the npm side — keep it in
+      # its own PR rather than bundled with unrelated crate bumps.
+      napi:
+        patterns: ["napi", "napi-derive", "napi-build"]
+      cargo:
+        patterns: ["*"]
+        exclude-patterns: ["napi", "napi-derive", "napi-build"]
+
+  # Node binding npm dependencies.
+  - package-ecosystem: npm
+    directory: "/bindings/node"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "deps(npm)"
+    groups:
+      node-binding:
+        patterns: ["*"]
+
+  # Python binding pip dependencies.
+  - package-ecosystem: pip
+    directory: "/bindings/python"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "deps(pip)"
+    groups:
+      python-binding:
+        patterns: ["*"]
+
+  # Hash-pinned CI/bench Python tooling under .github/requirements/. Each
+  # <name>.in is the loose source; the matching hash-locked <name>.txt is the
+  # output regenerated by scripts/update-lockfiles.sh (uv). Dependabot keeps the
+  # pins fresh; ci-dev-py39.in caps numpy <2.1 so 3.9 stays installable. Any
+  # bump that breaks a matrix row surfaces in the PR's CI run.
+  - package-ecosystem: pip
+    directory: "/.github/requirements"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "deps(ci-pip)"
+    groups:
+      ci-pip:
+        patterns: ["*"]
+
+  # GitHub Actions — keeps the SHA-pinned actions current (Dependabot reads
+  # the version comment after each pinned SHA and bumps both together).
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "deps(actions)"
+    groups:
+      github-actions:
+        patterns: ["*"]
+
+  # Java binding + examples (Maven). Tracks the C-ABI binding's build plugins
+  # (e.g. central-publishing-maven-plugin) and the examples' jackson dependency,
+  # which had no Dependabot coverage before — a stale publishing plugin slipped
+  # through unnoticed until an OSV scan flagged it.
+  - package-ecosystem: maven
+    directories:
+      - "/bindings/java"
+      - "/bindings/java/benchmarks"
+      - "/examples/java"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "deps(maven)"
+    groups:
+      maven:
+        patterns: ["*"]
+
+  # C# binding (NuGet). The published Wickra.csproj is a thin C-ABI wrapper with
+  # no external packages, but the test and benchmark projects pull xunit,
+  # Microsoft.NET.Test.Sdk and BenchmarkDotNet.
+  - package-ecosystem: nuget
+    directories:
+      - "/bindings/csharp/Wickra.Tests"
+      - "/bindings/csharp/benchmarks"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "deps(nuget)"
+    groups:
+      nuget:
+        patterns: ["*"]
+
+  # Node examples (npm) — separate from the binding's own package.json.
+  - package-ecosystem: npm
+    directory: "/examples/node"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "deps(npm)"
+    groups:
+      node-examples:
+        patterns: ["*"]
+
+  # Go examples (Go modules). The binding's own go.mod has no external deps;
+  # the examples pull coder/websocket.
+  - package-ecosystem: gomod
+    directory: "/examples/go"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "deps(gomod)"
+    groups:
+      go-examples:
+        patterns: ["*"]

.github/requirements/bench.in

@@ -0,0 +1,11 @@
+# Python deps + peer TA libraries for the bench.yml cross-library benchmark.
+# Loose source spec — the pinned, hash-locked output is generated from this:
+#   bench.txt  (Python 3.11)  via scripts/update-lockfiles.sh
+# bench.yml runs on a single Python version (3.11), so one output suffices.
+maturin
+numpy
+pandas
+TA-Lib
+tulipy
+talipp
+finta

.github/requirements/bench.txt

@@ -0,0 +1,247 @@
+# This file was autogenerated by uv via the following command:
+#    ./scripts/update-lockfiles.sh
+build==1.5.0 \
+    --hash=sha256:13f3eecb844759ab66efec90ca17639bbf14dc06cb2fdf37a9010322d9c50a6f \
+    --hash=sha256:302c22c3ba2a0fd5f3911918651341ebb3896176cbdec15bd421f80b1afc7647
+    # via ta-lib
+colorama==0.4.6 \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6
+    # via build
+finta==1.3 \
+    --hash=sha256:b94b94df311c18bf5402eb2fe8fd2db5e1bdaff08baf58a7367d05c7abdd10d3 \
+    --hash=sha256:f2fa0673748f4be8f57e57cf6d5c00a4d44bc6071ea69dbb9a1d329d045cbba2
+    # via -r .github/requirements/bench.in
+maturin==1.13.3 \
+    --hash=sha256:0ef257e692cc756c87af5bea95ddfe7d3ac49d3376a7a87f728d63f06e7b6f8b \
+    --hash=sha256:1cc0a110b224ca90406b668a3e3c1f5a515062e59e26292f6dbaf5fd4909c6f3 \
+    --hash=sha256:2389fe92d017cea9d94e521fa0175314a4c52f79a1057b901fbc9f8686ef7d0b \
+    --hash=sha256:3cc13929ca82aefa4adbf0f2c35419369796213c6fb0eb24e914945f50ef5d8c \
+    --hash=sha256:3db93337ed97e60ffc878aa8b493cd7ae44d3a5e1a37256db3a4491f57565018 \
+    --hash=sha256:4667ef609ab446c1b5e0bfe4f9fb99699ab6d8548433f8d1a684256e0b67217f \
+    --hash=sha256:49fd6ab08da28098ccf37afca24cdba72376ba9c1eedf9dd25ff82ed771961ff \
+    --hash=sha256:4cd478e6e4c56251e48ed079b8efd55b30bc5c09cf695a1bdafaeb582ee735a0 \
+    --hash=sha256:53b08bd075649ce96513ad9abf241a43cb685ed6e9e7790f8dbc2d66e95d8323 \
+    --hash=sha256:771e1e9e71a278e56db01552e0d1acfd1464259f9575b6e72842f893cd299079 \
+    --hash=sha256:a2675e25f313034ae6f57388cf14818f87d8961c4a96795287f3e155f59beb11 \
+    --hash=sha256:b6741d7bf4af97da937528fd1e523c6ab54f53d9a21870fa735d6e67fd88e273 \
+    --hash=sha256:c00ea6428dea17bf616fe93770837634454b28c2de1a876e42ef8036c616079a \
+    --hash=sha256:def4a435ea9d2ee93b18ba579dc8c9cf898889a66f312cd379b5e374ec3e3ad6
+    # via -r .github/requirements/bench.in
+numpy==2.4.6 \
+    --hash=sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1 \
+    --hash=sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4 \
+    --hash=sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f \
+    --hash=sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079 \
+    --hash=sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096 \
+    --hash=sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47 \
+    --hash=sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66 \
+    --hash=sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d \
+    --hash=sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1 \
+    --hash=sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e \
+    --hash=sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147 \
+    --hash=sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd \
+    --hash=sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75 \
+    --hash=sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063 \
+    --hash=sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73 \
+    --hash=sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab \
+    --hash=sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4 \
+    --hash=sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41 \
+    --hash=sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402 \
+    --hash=sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698 \
+    --hash=sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7 \
+    --hash=sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8 \
+    --hash=sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b \
+    --hash=sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8 \
+    --hash=sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0 \
+    --hash=sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662 \
+    --hash=sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91 \
+    --hash=sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0 \
+    --hash=sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f \
+    --hash=sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3 \
+    --hash=sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f \
+    --hash=sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67 \
+    --hash=sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6 \
+    --hash=sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997 \
+    --hash=sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b \
+    --hash=sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e \
+    --hash=sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538 \
+    --hash=sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627 \
+    --hash=sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93 \
+    --hash=sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02 \
+    --hash=sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853 \
+    --hash=sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c \
+    --hash=sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43 \
+    --hash=sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd \
+    --hash=sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8 \
+    --hash=sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089 \
+    --hash=sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778 \
+    --hash=sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1 \
+    --hash=sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb \
+    --hash=sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261 \
+    --hash=sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb \
+    --hash=sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a \
+    --hash=sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8 \
+    --hash=sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359 \
+    --hash=sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5 \
+    --hash=sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7 \
+    --hash=sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751 \
+    --hash=sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8 \
+    --hash=sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605 \
+    --hash=sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e \
+    --hash=sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45 \
+    --hash=sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2 \
+    --hash=sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895 \
+    --hash=sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe \
+    --hash=sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb \
+    --hash=sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a \
+    --hash=sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577 \
+    --hash=sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d \
+    --hash=sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a \
+    --hash=sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda \
+    --hash=sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6 \
+    --hash=sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20
+    # via
+    #   -r .github/requirements/bench.in
+    #   finta
+    #   pandas
+    #   ta-lib
+    #   tulipy
+packaging==26.2 \
+    --hash=sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e \
+    --hash=sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661
+    # via build
+pandas==3.0.3 \
+    --hash=sha256:0383c72c75cdcca61a9e116e611143902dbfd08bff356829c2f6d1cf40a9ca8c \
+    --hash=sha256:05f1f1752b8533ea03f7f39a9c15b1a058d067bb48f4748948e7a8691e0510f2 \
+    --hash=sha256:08d789b41f87e0905880e293cedf6197ce71fe67cc081358b1e148a491b9bd13 \
+    --hash=sha256:0d589105b3c14645af1738ff279b2995102d8f7a03b0a66dc8d95550eb513e04 \
+    --hash=sha256:13fc1e853d9e04743d11ba75a985ccbc2a317fe07d8af61e445a6fd24dacd6a6 \
+    --hash=sha256:14da8316da4d0c5a77618425996bfb1248ca87fc2c1486e6fde4652bd18b5824 \
+    --hash=sha256:1928e07221f82db493cd4af1e23c1bfca524a19a4699887975bff68f49a72bfb \
+    --hash=sha256:261e308dfb22448384b7580cf719d2f998fe2966c92893c3e77d14008af1f066 \
+    --hash=sha256:275c14e0fce14a2ec20eee474aecd305478ea3c1e6f6a9d8fe219a165542717e \
+    --hash=sha256:335f62418ed562cfc3c49e9e196375c28b729dcef8543abf4f9438e381bf3c76 \
+    --hash=sha256:3650109c0f22879df8bd6179ab9ee3d7f1d1d4e7e0094a3f0032d9f51e2e64ac \
+    --hash=sha256:39436b377d56d2a2e52d0395bdbee171f01068e99af5250509aceeb929f765c7 \
+    --hash=sha256:3c20a521bbb85902f79f7270c80a59e1b5452d96d170c034f207181870f97ac5 \
+    --hash=sha256:3e91cec1879ada0624fc3dc9953c5cbd60208e59c0db28f540c5d6d47502422f \
+    --hash=sha256:455f6f8139d4282188f526868dbc3c828470e88a3d9d59a891bd46a455f21b98 \
+    --hash=sha256:46997386d528eb40376ecd6b033cf4a8a1e5282580f68f43de875b78cba2199d \
+    --hash=sha256:4db8c527972a821cf5286b40ccc57642a39bc62e62022b42f99f8a67fca8c3a1 \
+    --hash=sha256:4e15135e2ee5df1063313e2425ceef8ac0f4ae775893815b0923651b806a5639 \
+    --hash=sha256:51b1fe551acb77dac643c6fda86084d8d446c10fe64b06a9cc29c4cc8540e7f2 \
+    --hash=sha256:557409bc4178e70ee8d9ddb494798e51ebf6ea59330f6be22c51bab2a7db6c49 \
+    --hash=sha256:5cc09a68b3120e0f54870dede8287a7bb1fa463907e4fcec1ea77cab6179bf7a \
+    --hash=sha256:60ae316d3fd75d1858d450d0db0103ea2be3e7d4a95ec2f064f7e2ae63f7b028 \
+    --hash=sha256:6674ab18ad8c57802867264b00e15e7bb904700cdd9046e3b2fa1fce237439ea \
+    --hash=sha256:67b3b64c11910cfa29f4e94a14d3bff9ee693b6fc76055e7cad549cee0aec5fa \
+    --hash=sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc \
+    --hash=sha256:6dc0b3fd2169c9157deed50b4d519553a3655c8c6a96027136d654592be973a9 \
+    --hash=sha256:7e65d5407dc0b394f509699650e4a2ec01c0514f21850f453fa60f3be79a5dbf \
+    --hash=sha256:819959dab7bbd0049c15623fbac4e29a191b9528160a61fb1032242d8ced2d9c \
+    --hash=sha256:8a1e45c80cceb3b4a21bc5939d52e8cbd8d9b7305309219d59e9754d9ce09e27 \
+    --hash=sha256:9c39be2d709d01fa972a0cabc522389fceca4f3969332ba25a7d6c5802cf976a \
+    --hash=sha256:9d71c63ae4ebdbf70209742096f1fc46a83a0613c99d4b23766cced9ff8cd62a \
+    --hash=sha256:a2d2dff8a04f3917b55ab3910c32990f8ddf7eceba114947838cefa976a68977 \
+    --hash=sha256:a4eeb6830daf35a71cc09649bd823e2b542dac246cdee9614c6e4bd65028cd6a \
+    --hash=sha256:a55066a0505dae0ba2b50a46637db34b46f9094c65c5d4800794ef6335010938 \
+    --hash=sha256:a82d532a3351d435432cd913edbccaf8b8e01d4dd0e5ced5a8d2e8ecd94c7e44 \
+    --hash=sha256:b168fc218fd80a6cbdbdbc1a97ddc7889ed057d7eb45f50d866ceab5f39904c4 \
+    --hash=sha256:b2c95f8bfc1ee412bf482605d7bfd30c12d1d26bd59fdd91efeef1d4718decb1 \
+    --hash=sha256:ba7e08b9ac1d54569cd1e256e3668975ed624d6826f7b68df0342b012007bddb \
+    --hash=sha256:bab900348131a7db1f69a7309ef141fd5680f1487094193bcbbb61791573bf8f \
+    --hash=sha256:bd3a518890b400d32f9023722dc9a9a5c969f00b415419a3c06c043f09bb5d7d \
+    --hash=sha256:c7be265b62cef88e253a941e4698604973736dcfe242fdb5198f0f7bc473cdcc \
+    --hash=sha256:d26cbe1fcfc12e8fd900e2454163e466b2d3af84f7c75481df7683ffc073d870 \
+    --hash=sha256:d4be06d68f9ddcfc645b87534911da79a8fbffc7573c80e0edcf42a5020624d8 \
+    --hash=sha256:d72828c20c6d6e83e1e22a6a3b47b326b71664112fa9705dcbccfd7a39b62085 \
+    --hash=sha256:dd1a5d1def6a46002e964510bdc67c368aa0951df5d1d9f8365336f5a1f490cd \
+    --hash=sha256:e3a2ec42c98ffa2565a67e08e218d06d72576d758d90facb7c00805194d8f360 \
+    --hash=sha256:f8894dc474d648fe7b6ff0ca9b0bd73950d19952bc1a6534540762c5d79d305c \
+    --hash=sha256:fed2ff7fd9779120e388e285fc029bd5cf9490cdd2e4166a9ee22c0e49a9ab09
+    # via
+    #   -r .github/requirements/bench.in
+    #   finta
+pyproject-hooks==1.2.0 \
+    --hash=sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8 \
+    --hash=sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913
+    # via build
+python-dateutil==2.9.0.post0 \
+    --hash=sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3 \
+    --hash=sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427
+    # via pandas
+six==1.17.0 \
+    --hash=sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274 \
+    --hash=sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81
+    # via python-dateutil
+ta-lib==0.6.8 \
+    --hash=sha256:02388054c059945e5f02625f5075bac20a1803573cb43e7d096091027511961f \
+    --hash=sha256:094677b279a59c3f01c3aca8a889fda3523fd641a3805f69a2d642121b72e55e \
+    --hash=sha256:0a08a29690a922ba92a6cf42902a8a93c6fbda4cfed62c3c5b0471560ef60135 \
+    --hash=sha256:0ccd478ff5735831bf2a61d653466bfda8afadc26ad58ca6b1edb9e7521cc674 \
+    --hash=sha256:0e371d14b49e70caa973a234c8823341dd446f5c5d7acc826868bb42b272bdc0 \
+    --hash=sha256:11a373c9308eae3bac2d56d37017f9ab63968cc074a8b95be879aae3d13133aa \
+    --hash=sha256:128ec92e6a0e9ff7a38edef80e3b74f15bb2ed1c531d5d3252c8dca22677651b \
+    --hash=sha256:1fb4028437201e19014e4e374272b739867c8a3eb655da46675ef4c2ff14b616 \
+    --hash=sha256:282e49c766b5952dd8796f77d7ed3ae412cdd88e31f845b1fbbb86ac6cb7bebf \
+    --hash=sha256:2b369cabb48485fbf444beb3f5a878075367b99c2c86db2f796afeabebc749e0 \
+    --hash=sha256:2bf714333788bf5175f2512b86d2ed129e89ae6f6c2923e8a297a1e3395e13b5 \
+    --hash=sha256:30de46b55873b51be945a09edf486afcc190dc47eff9fb5d2b12c9f7e3d743da \
+    --hash=sha256:34e3b12407ddf99f6627435aa8a165f094339bb7dc33de92e1d7472e9f237304 \
+    --hash=sha256:36b2a516fce57309840f5ef3fa2fd0c4449293fc72536a0400d2e1e26b414da8 \
+    --hash=sha256:3a9195299df9d7d2a6e9d16bebd6b706b0ea99e4b871864c4b034c2577e21a77 \
+    --hash=sha256:3c32fc0f546ceecc47dd45f33d72ab4a1e341b80d9081c2d77b100add5d49104 \
+    --hash=sha256:3d7333e907bff3e3997e54f89733ffa8d619842a3e1cd962bca34bdc11944c28 \
+    --hash=sha256:4795e93d130c9b7fb661f0cead49752ae6a980437df74b99d5918026c212443e \
+    --hash=sha256:490e19a45cd3cdd6dfe6b46019f7ffe1103500750b41b51996a870e7c1c5f066 \
+    --hash=sha256:4aa0fe08383f3e5fc7d2f8cf9b42ac778f4d53fd75bcd2799a858225954eab89 \
+    --hash=sha256:559326d8f3d904cd4aa61f6a392d5626f35eec6a9f6cc83bcddb0abf88c40516 \
+    --hash=sha256:5929c83bd8cb7572d1c17ffdbf0eac235bf3c4d53cde1950cf89d944eaf97525 \
+    --hash=sha256:5bfd21b6acb32e20d4e279c34405a34e63da345be4b2b6eabd683e1a88857406 \
+    --hash=sha256:613cf06313331f49dd7b85a5a24fbddb1156c9723b6921a231906241726e5aee \
+    --hash=sha256:66a8e1c1e899d15a2f7510e43527fba22d895e7f6058d027db3e3837d88a69de \
+    --hash=sha256:691a62926ba09f2653ec0908554b3635497efb7751c5d46b916cd1ebbb1d3c25 \
+    --hash=sha256:6c1fd18e45c39d5a4be4b0d6a20c141e43fe46daeb1b2e2f304ebae7015ab6e6 \
+    --hash=sha256:6c6a1e8f98de92e817491b50aa4d01d69a1b41a4ed3173747e8f16f0d4cf81cc \
+    --hash=sha256:6cf029b886cfb28a2701503b7c602b811f2daa45276bd6459b0c71e051deb497 \
+    --hash=sha256:71506116eac0d3e3598d6325b4b818c3a0f6acb3222b24d30ad726e8c4bf7ea8 \
+    --hash=sha256:7993164e8e9f78ec31d38c47850ca6ba5451788b5b49a8a2dbb3322b36b5693b \
+    --hash=sha256:7a5cc6bf60791d8274edfdfe2dd7cec3f00f656dcc92e2b0a9af06c8b18ce6a6 \
+    --hash=sha256:87c1cc1057d903b78a8257a7c5f497db6fd5284f5080392bd57b66031d7389a3 \
+    --hash=sha256:98376c75bd6c103c74396953084a5e0798ffe476aecbfcc51ec6d100a685ac38 \
+    --hash=sha256:a395524b0fafa10446d11e11acb4742e919523de58aac03b791f26d7a783bcf0 \
+    --hash=sha256:a5100a4be91b7d4b7c8fe16a3600bd0951e10205eb1066b6873afd3996b51ee4 \
+    --hash=sha256:a63a52221f8c73f82f4e00493351d987f594931198589287aee96f8da673cfd5 \
+    --hash=sha256:a89734a7bcb2ea3b6fd600a74d6fbcdb8d3fa3f7917dbd978e039710b5509c9c \
+    --hash=sha256:b165f5e6de1ccc964e863bd2035807a4d3bad3e0481f9db2dc52034d6ad4f9de \
+    --hash=sha256:b3845e4c2fa32963fb7f384ebbaa2761b0e6b96145239bf80e956d4aff4b071c \
+    --hash=sha256:b3b017d9103e7a7372a146773be32b184ff7330bd708d40b1f56f06a686756ed \
+    --hash=sha256:b6c6e4858d8c3f88e19b7aa94b6a7619108f0bee51da9fa67b0785a8b59955f9 \
+    --hash=sha256:bfad1202fb1f9140e3810cc607058395f59032d9128cc0d716900c78bea5f337 \
+    --hash=sha256:c01809fb602e2fefc8cbfb3b603bb59d2a2eaee8708410896d48a835ba00e7c5 \
+    --hash=sha256:cce8de9d48289927ed18aaa420740efd52b2cd9289da32e3799afbb3a02822e8 \
+    --hash=sha256:ce2bc1ea01200b6d8130ab917296d05d77a1a571ec6c1ee25cfca6d55cd5db4a \
+    --hash=sha256:d4601e2a8b46ffbf540601a4926fd6cc5aae8a13b36fdd467f1040f01f9edaed \
+    --hash=sha256:d556d1c256b3700b60b6b061664a667b2e49d599c2772d46a9f2348f2dc4ab5c \
+    --hash=sha256:ddf7453acd03b966624ebefdb38169b5bbbeea1a1a58c90b095667247f9de327 \
+    --hash=sha256:e781eeb65b2007af553389c8a7fb7bc53cb856118b0fcffb2c26b0f49561c686 \
+    --hash=sha256:e920c272cd9e70a6b10eae9203cc96845da142e1dd4482de9343dda3738a9862 \
+    --hash=sha256:f5b6174bf4bf9152e368561dff410203c6921e4dd2afbcda3283a95957158112 \
+    --hash=sha256:f69bd42fd2515060af69b120668213121264bb7976b113954b6f9db327727c65 \
+    --hash=sha256:f823d0f6b04a6797fbe253bcf91666e71a6b63c290683819650c68b2468ebe64 \
+    --hash=sha256:fa7e9f2e80a9535f9692e113d02b4268b5f88675a730d1b0ef0abeb74c9a4e80
+    # via -r .github/requirements/bench.in
+talipp==2.7.0 \
+    --hash=sha256:567f59ad74366cb59a14a00d350f35fd9d22e6924d6228bad581e6dcf1de2205 \
+    --hash=sha256:f749f22b9ad615605e71faf26457bb7f5e3fe16f04d3287f4ca54fd16bc3d4eb
+    # via -r .github/requirements/bench.in
+tulipy==0.4.0 \
+    --hash=sha256:540704956b5b940a5f6306aa393a37536a6d7c3cbc07efe47512f3496e5203ab \
+    --hash=sha256:95542e40537afdd345d875baf37485eac993c6a819d00c51432e9de8df21eba8 \
+    --hash=sha256:fbc31727ef7657c93ad910bfdce65fecc6aaa7a5e961fe00240718e7a3fc79d8
+    # via -r .github/requirements/bench.in
+tzdata==2026.2 \
+    --hash=sha256:9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10 \
+    --hash=sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7
+    # via pandas

.github/requirements/ci-dev-py3.in

@@ -0,0 +1,7 @@
+# Python 3.10+ dev/test tooling for the ci.yml binding test job
+# (covers the 3.11 / 3.12 / 3.13 matrix rows). Locked output: ci-dev-py3.txt
+# Refresh via scripts/update-lockfiles.sh.
+maturin
+pytest
+numpy
+hypothesis

.github/requirements/ci-dev-py3.txt

@@ -0,0 +1,124 @@
+# This file was autogenerated by uv via the following command:
+#    ./scripts/update-lockfiles.sh
+colorama==0.4.6 \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6
+    # via pytest
+hypothesis==6.155.1 \
+    --hash=sha256:07c102031612b98d7c1be15ca3608c43e1234d9d07e3a190a53fa01536700196 \
+    --hash=sha256:2753f469df3ba3c483b08e0c37dbcbc41d8316ebb921abcc07493ee9c8a7d187
+    # via -r .github/requirements/ci-dev-py3.in
+iniconfig==2.3.0 \
+    --hash=sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730 \
+    --hash=sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12
+    # via pytest
+maturin==1.13.3 \
+    --hash=sha256:0ef257e692cc756c87af5bea95ddfe7d3ac49d3376a7a87f728d63f06e7b6f8b \
+    --hash=sha256:1cc0a110b224ca90406b668a3e3c1f5a515062e59e26292f6dbaf5fd4909c6f3 \
+    --hash=sha256:2389fe92d017cea9d94e521fa0175314a4c52f79a1057b901fbc9f8686ef7d0b \
+    --hash=sha256:3cc13929ca82aefa4adbf0f2c35419369796213c6fb0eb24e914945f50ef5d8c \
+    --hash=sha256:3db93337ed97e60ffc878aa8b493cd7ae44d3a5e1a37256db3a4491f57565018 \
+    --hash=sha256:4667ef609ab446c1b5e0bfe4f9fb99699ab6d8548433f8d1a684256e0b67217f \
+    --hash=sha256:49fd6ab08da28098ccf37afca24cdba72376ba9c1eedf9dd25ff82ed771961ff \
+    --hash=sha256:4cd478e6e4c56251e48ed079b8efd55b30bc5c09cf695a1bdafaeb582ee735a0 \
+    --hash=sha256:53b08bd075649ce96513ad9abf241a43cb685ed6e9e7790f8dbc2d66e95d8323 \
+    --hash=sha256:771e1e9e71a278e56db01552e0d1acfd1464259f9575b6e72842f893cd299079 \
+    --hash=sha256:a2675e25f313034ae6f57388cf14818f87d8961c4a96795287f3e155f59beb11 \
+    --hash=sha256:b6741d7bf4af97da937528fd1e523c6ab54f53d9a21870fa735d6e67fd88e273 \
+    --hash=sha256:c00ea6428dea17bf616fe93770837634454b28c2de1a876e42ef8036c616079a \
+    --hash=sha256:def4a435ea9d2ee93b18ba579dc8c9cf898889a66f312cd379b5e374ec3e3ad6
+    # via -r .github/requirements/ci-dev-py3.in
+numpy==2.4.6 \
+    --hash=sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1 \
+    --hash=sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4 \
+    --hash=sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f \
+    --hash=sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079 \
+    --hash=sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096 \
+    --hash=sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47 \
+    --hash=sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66 \
+    --hash=sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d \
+    --hash=sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1 \
+    --hash=sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e \
+    --hash=sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147 \
+    --hash=sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd \
+    --hash=sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75 \
+    --hash=sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063 \
+    --hash=sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73 \
+    --hash=sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab \
+    --hash=sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4 \
+    --hash=sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41 \
+    --hash=sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402 \
+    --hash=sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698 \
+    --hash=sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7 \
+    --hash=sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8 \
+    --hash=sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b \
+    --hash=sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8 \
+    --hash=sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0 \
+    --hash=sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662 \
+    --hash=sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91 \
+    --hash=sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0 \
+    --hash=sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f \
+    --hash=sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3 \
+    --hash=sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f \
+    --hash=sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67 \
+    --hash=sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6 \
+    --hash=sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997 \
+    --hash=sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b \
+    --hash=sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e \
+    --hash=sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538 \
+    --hash=sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627 \
+    --hash=sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93 \
+    --hash=sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02 \
+    --hash=sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853 \
+    --hash=sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c \
+    --hash=sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43 \
+    --hash=sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd \
+    --hash=sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8 \
+    --hash=sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089 \
+    --hash=sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778 \
+    --hash=sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1 \
+    --hash=sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb \
+    --hash=sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261 \
+    --hash=sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb \
+    --hash=sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a \
+    --hash=sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8 \
+    --hash=sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359 \
+    --hash=sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5 \
+    --hash=sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7 \
+    --hash=sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751 \
+    --hash=sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8 \
+    --hash=sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605 \
+    --hash=sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e \
+    --hash=sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45 \
+    --hash=sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2 \
+    --hash=sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895 \
+    --hash=sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe \
+    --hash=sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb \
+    --hash=sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a \
+    --hash=sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577 \
+    --hash=sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d \
+    --hash=sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a \
+    --hash=sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda \
+    --hash=sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6 \
+    --hash=sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20
+    # via -r .github/requirements/ci-dev-py3.in
+packaging==26.2 \
+    --hash=sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e \
+    --hash=sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661
+    # via pytest
+pluggy==1.6.0 \
+    --hash=sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3 \
+    --hash=sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746
+    # via pytest
+pygments==2.20.0 \
+    --hash=sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f \
+    --hash=sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176
+    # via pytest
+pytest==9.0.3 \
+    --hash=sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9 \
+    --hash=sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c
+    # via -r .github/requirements/ci-dev-py3.in
+sortedcontainers==2.4.0 \
+    --hash=sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88 \
+    --hash=sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0
+    # via hypothesis

.github/requirements/ci-dev-py39.in

@@ -0,0 +1,8 @@
+# Python 3.9 dev/test tooling for the ci.yml binding test job.
+# numpy is capped <2.1 because that is the last series shipping cp39 wheels
+# (>=2.1 dropped Python 3.9). Locked output: ci-dev-py39.txt
+# Refresh via scripts/update-lockfiles.sh.
+maturin
+pytest
+numpy<2.1
+hypothesis

.github/requirements/ci-dev-py39.txt

@@ -0,0 +1,162 @@
+# This file was autogenerated by uv via the following command:
+#    ./scripts/update-lockfiles.sh
+attrs==26.1.0 \
+    --hash=sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309 \
+    --hash=sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32
+    # via hypothesis
+colorama==0.4.6 \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6
+    # via pytest
+exceptiongroup==1.3.1 \
+    --hash=sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219 \
+    --hash=sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598
+    # via
+    #   hypothesis
+    #   pytest
+hypothesis==6.141.1 \
+    --hash=sha256:8ef356e1e18fbeaa8015aab3c805303b7fe4b868e5b506e87ad83c0bf951f46f \
+    --hash=sha256:a5b3c39c16d98b7b4c3c5c8d4262e511e3b2255e6814ced8023af49087ad60b3
+    # via -r .github/requirements/ci-dev-py39.in
+iniconfig==2.1.0 \
+    --hash=sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7 \
+    --hash=sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760
+    # via pytest
+maturin==1.13.3 \
+    --hash=sha256:0ef257e692cc756c87af5bea95ddfe7d3ac49d3376a7a87f728d63f06e7b6f8b \
+    --hash=sha256:1cc0a110b224ca90406b668a3e3c1f5a515062e59e26292f6dbaf5fd4909c6f3 \
+    --hash=sha256:2389fe92d017cea9d94e521fa0175314a4c52f79a1057b901fbc9f8686ef7d0b \
+    --hash=sha256:3cc13929ca82aefa4adbf0f2c35419369796213c6fb0eb24e914945f50ef5d8c \
+    --hash=sha256:3db93337ed97e60ffc878aa8b493cd7ae44d3a5e1a37256db3a4491f57565018 \
+    --hash=sha256:4667ef609ab446c1b5e0bfe4f9fb99699ab6d8548433f8d1a684256e0b67217f \
+    --hash=sha256:49fd6ab08da28098ccf37afca24cdba72376ba9c1eedf9dd25ff82ed771961ff \
+    --hash=sha256:4cd478e6e4c56251e48ed079b8efd55b30bc5c09cf695a1bdafaeb582ee735a0 \
+    --hash=sha256:53b08bd075649ce96513ad9abf241a43cb685ed6e9e7790f8dbc2d66e95d8323 \
+    --hash=sha256:771e1e9e71a278e56db01552e0d1acfd1464259f9575b6e72842f893cd299079 \
+    --hash=sha256:a2675e25f313034ae6f57388cf14818f87d8961c4a96795287f3e155f59beb11 \
+    --hash=sha256:b6741d7bf4af97da937528fd1e523c6ab54f53d9a21870fa735d6e67fd88e273 \
+    --hash=sha256:c00ea6428dea17bf616fe93770837634454b28c2de1a876e42ef8036c616079a \
+    --hash=sha256:def4a435ea9d2ee93b18ba579dc8c9cf898889a66f312cd379b5e374ec3e3ad6
+    # via -r .github/requirements/ci-dev-py39.in
+numpy==2.0.2 \
+    --hash=sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a \
+    --hash=sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195 \
+    --hash=sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951 \
+    --hash=sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1 \
+    --hash=sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c \
+    --hash=sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc \
+    --hash=sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b \
+    --hash=sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd \
+    --hash=sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4 \
+    --hash=sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd \
+    --hash=sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318 \
+    --hash=sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448 \
+    --hash=sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece \
+    --hash=sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d \
+    --hash=sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5 \
+    --hash=sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8 \
+    --hash=sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57 \
+    --hash=sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78 \
+    --hash=sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66 \
+    --hash=sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a \
+    --hash=sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e \
+    --hash=sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c \
+    --hash=sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa \
+    --hash=sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d \
+    --hash=sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c \
+    --hash=sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729 \
+    --hash=sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97 \
+    --hash=sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c \
+    --hash=sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9 \
+    --hash=sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669 \
+    --hash=sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4 \
+    --hash=sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73 \
+    --hash=sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385 \
+    --hash=sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8 \
+    --hash=sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c \
+    --hash=sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b \
+    --hash=sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692 \
+    --hash=sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15 \
+    --hash=sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131 \
+    --hash=sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a \
+    --hash=sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326 \
+    --hash=sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b \
+    --hash=sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded \
+    --hash=sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04 \
+    --hash=sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd
+    # via -r .github/requirements/ci-dev-py39.in
+packaging==26.2 \
+    --hash=sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e \
+    --hash=sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661
+    # via pytest
+pluggy==1.6.0 \
+    --hash=sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3 \
+    --hash=sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746
+    # via pytest
+pygments==2.20.0 \
+    --hash=sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f \
+    --hash=sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176
+    # via pytest
+pytest==8.4.2 \
+    --hash=sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01 \
+    --hash=sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79
+    # via -r .github/requirements/ci-dev-py39.in
+sortedcontainers==2.4.0 \
+    --hash=sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88 \
+    --hash=sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0
+    # via hypothesis
+tomli==2.4.1 \
+    --hash=sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853 \
+    --hash=sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe \
+    --hash=sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5 \
+    --hash=sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d \
+    --hash=sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd \
+    --hash=sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26 \
+    --hash=sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54 \
+    --hash=sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6 \
+    --hash=sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c \
+    --hash=sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a \
+    --hash=sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd \
+    --hash=sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f \
+    --hash=sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5 \
+    --hash=sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9 \
+    --hash=sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662 \
+    --hash=sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9 \
+    --hash=sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1 \
+    --hash=sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585 \
+    --hash=sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e \
+    --hash=sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c \
+    --hash=sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41 \
+    --hash=sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f \
+    --hash=sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085 \
+    --hash=sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15 \
+    --hash=sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7 \
+    --hash=sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c \
+    --hash=sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36 \
+    --hash=sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076 \
+    --hash=sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac \
+    --hash=sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8 \
+    --hash=sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232 \
+    --hash=sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece \
+    --hash=sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a \
+    --hash=sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897 \
+    --hash=sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d \
+    --hash=sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4 \
+    --hash=sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917 \
+    --hash=sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396 \
+    --hash=sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a \
+    --hash=sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc \
+    --hash=sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba \
+    --hash=sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f \
+    --hash=sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257 \
+    --hash=sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30 \
+    --hash=sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf \
+    --hash=sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9 \
+    --hash=sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049
+    # via
+    #   maturin
+    #   pytest
+typing-extensions==4.15.0 \
+    --hash=sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466 \
+    --hash=sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548
+    # via exceptiongroup

.github/scripts/sync-metadata.py

@@ -0,0 +1,113 @@
+"""Audit that no file in the repo contains the pre-migration org slug or
+maintainer email. Driven by `repo-metadata.toml` at the repo root.
+
+This is the read-only side of the metadata pipeline. It does not patch any
+files — it just fails CI when drift sneaks in. Pair with a future
+`--write` mode (auto-fix + signed commit on main) once the migration has
+settled.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+METADATA_PATH = REPO_ROOT / "repo-metadata.toml"
+
+
+def load_metadata() -> dict:
+    with METADATA_PATH.open("rb") as f:
+        return tomllib.load(f)
+
+
+def is_allowlisted(rel_path: str, allowlist: list[str]) -> bool:
+    norm = rel_path.replace(os.sep, "/")
+    for entry in allowlist:
+        entry_norm = entry.replace(os.sep, "/")
+        if entry_norm.endswith("/"):
+            if norm.startswith(entry_norm):
+                return True
+        else:
+            if norm == entry_norm:
+                return True
+    return False
+
+
+def tracked_files() -> list[str]:
+    """List git-tracked files relative to the repo root."""
+    out = subprocess.run(
+        ["git", "ls-files"],
+        cwd=REPO_ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return [line for line in out.stdout.splitlines() if line]
+
+
+def scan(forbidden: list[str], allowlist: list[str]) -> list[tuple[str, int, str, str]]:
+    """Return a list of (rel_path, line_no, needle, line_text) findings.
+
+    Only git-tracked files are scanned, so local-only ghost-ignored files
+    (`.claude/`, drafts) never trigger false positives.
+    """
+    findings: list[tuple[str, int, str, str]] = []
+    for rel_path in tracked_files():
+        if is_allowlisted(rel_path, allowlist):
+            continue
+        abs_path = REPO_ROOT / rel_path
+        if not abs_path.is_file():
+            continue
+        try:
+            lines = abs_path.read_text(encoding="utf-8", errors="replace").splitlines()
+        except (OSError, UnicodeDecodeError):
+            continue
+        for lineno, line in enumerate(lines, start=1):
+            for needle in forbidden:
+                if needle in line:
+                    findings.append((rel_path, lineno, needle, line.strip()))
+    return findings
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--check", action="store_true", help="audit-only (default)")
+    args = parser.parse_args()
+    _ = args  # currently only --check is supported
+
+    meta = load_metadata()
+    audit = meta.get("audit", {})
+    forbidden: list[str] = list(audit.get("forbidden", []))
+    allowlist: list[str] = list(audit.get("allowlist", []))
+
+    if not forbidden:
+        print("repo-metadata.toml [audit].forbidden is empty — nothing to scan.")
+        return 0
+
+    findings = scan(forbidden, allowlist)
+    if findings:
+        print(f"sync-metadata: {len(findings)} forbidden-substring hits:", file=sys.stderr)
+        for rel_path, lineno, needle, text in findings:
+            print(f"  {rel_path}:{lineno}: matched {needle!r}", file=sys.stderr)
+            print(f"      {text}", file=sys.stderr)
+        print(
+            "\nUpdate the offending lines to use the values from repo-metadata.toml,",
+            "or add the path to [audit].allowlist if the reference is intentional",
+            "(e.g. historical CHANGELOG entries).",
+            file=sys.stderr,
+        )
+        return 1
+
+    org = meta["repo"]["org"]
+    email = meta["maintainer"]["email"]
+    print(f"sync-metadata: clean. org={org!r} email={email!r}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/workflows/bench.yml

@@ -0,0 +1,145 @@
+name: Cross-library benchmark
+
+# Audit finding R10: previously the cross-library benchmark ran on every push
+# and every pull-request to `main`, adding 5–10 minutes of build + bench time
+# per CI run with no consumer of the resulting artefact. The benchmark is now
+# scheduled (nightly at 03:00 UTC) and on-demand via `workflow_dispatch`. The
+# CI pipeline proper (.github/workflows/ci.yml) still verifies build / tests /
+# lints on every push and pull-request.
+on:
+  schedule:
+    # Nightly at 03:00 UTC. Pick a slot well away from common European /
+    # American working-hours pushes to keep this off the critical path.
+    - cron: "0 3 * * *"
+  workflow_dispatch:
+    inputs:
+      size:
+        description: "Number of bars per indicator (default 20000)"
+        required: false
+        default: "20000"
+      iterations:
+        description: "Batch iterations per indicator (default 10)"
+        required: false
+        default: "10"
+
+# Least-privilege default for the auto-injected GITHUB_TOKEN. The single job
+# only builds and uploads an artifact (upload-artifact uses the artifact
+# storage API, not the contents scope), so it never needs repo write (OpenSSF
+# Scorecard: Token-Permissions).
+permissions:
+  contents: read
+
+env:
+  CARGO_TERM_COLOR: always
+  # Network-flake resilience: retry transient registry/DNS failures at the tool
+  # level so a blip fetching crates.io / PyPI inside any build step (cargo,
+  # maturin, pip) retries automatically instead of failing the job. Cargo treats
+  # "couldn't resolve host" / connect / timeout as spurious and retries with
+  # backoff; 10 attempts ride out a transient DNS blip on a runner.
+  CARGO_NET_RETRY: "10"
+  CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+  npm_config_fetch_retries: "5"
+  npm_config_fetch_retry_maxtimeout: "120000"
+  PIP_RETRIES: "5"
+  PIP_DEFAULT_TIMEOUT: "120"
+
+jobs:
+  cross-library-bench:
+    name: Cross-library benchmark report
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - uses: ./.github/actions/setup-rust
+
+      - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
+
+      - name: Set up Python
+        id: setup_python
+        continue-on-error: true
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.11"
+          cache: pip
+          cache-dependency-path: .github/requirements/bench.txt
+
+      - name: Wait before Python retry
+        if: steps.setup_python.outcome == 'failure'
+        shell: bash
+        run: |
+          echo "::warning::setup-python failed (likely CDN flake), waiting 30s before retry..."
+          sleep 30
+
+      - name: Set up Python (retry)
+        if: steps.setup_python.outcome == 'failure'
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.11"
+          cache: pip
+          cache-dependency-path: .github/requirements/bench.txt
+
+      - name: Install Python deps + peer libs
+        run: |
+          python -m pip install --upgrade pip
+          # Hash-locked deps (OpenSSF Scorecard PinnedDependencies). bench.yml
+          # runs on a single Python version (3.11), so one lock file suffices.
+          python -m pip install --require-hashes -r .github/requirements/bench.txt
+
+      - name: Build Wickra wheel
+        working-directory: bindings/python
+        run: maturin build --release --out dist
+
+      - name: Install Wickra wheel
+        working-directory: bindings/python
+        run: python -m pip install --find-links dist --force-reinstall wickra
+
+      - name: Run cross-library benchmark
+        working-directory: bindings/python
+        # workflow_dispatch inputs are untrusted; pass them through the
+        # environment and quote them rather than interpolating into the shell
+        # command (OpenSSF Scorecard: Dangerous-Workflow).
+        env:
+          BENCH_SIZE: ${{ github.event.inputs.size || '20000' }}
+          BENCH_ITERATIONS: ${{ github.event.inputs.iterations || '10' }}
+        run: |
+          python -m benchmarks.compare_libraries \
+            --size "$BENCH_SIZE" \
+            --iterations "$BENCH_ITERATIONS" \
+            --streaming-window 5000 --streaming-iterations 2 \
+            | tee benchmark.txt
+
+      - name: Upload report
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: cross-library-bench
+          path: bindings/python/benchmark.txt
+
+  rust-cross-bench:
+    name: Rust cross-library benchmark report
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - uses: ./.github/actions/setup-rust
+
+      - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
+
+      # Wickra vs the other Rust TA crates (kand, ta-rs, yata) on an identical
+      # candle series — the like-for-like engine comparison with no binding
+      # overhead. Streaming + batch, in crates/wickra-bench/benches/cross_lib.rs.
+      - name: Run Rust cross-library benchmark
+        run: cargo bench -p wickra-bench --bench cross_lib | tee rust_cross_bench.txt
+
+      - name: Upload Rust report
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: rust-cross-bench
+          path: rust_cross_bench.txt

.github/workflows/codeql.yml

@@ -0,0 +1,56 @@
+name: CodeQL
+
+# Static analysis security testing (findings P13.x). Analyses the Rust core and
+# the Python / JavaScript binding surfaces with GitHub's CodeQL engine. Results
+# appear under Security → Code scanning. `build-mode: none` analyses source
+# directly — no compilation step — for every language here.
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: '31 3 * * 0' # Sundays 03:31 UTC
+
+# Least-privilege default for the auto-injected GITHUB_TOKEN. The analyze job
+# raises exactly the scopes CodeQL needs (security-events: write to upload
+# results) in its own job-level block below; this top-level read-only default
+# covers any future job (OpenSSF Scorecard: Token-Permissions).
+permissions:
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write # upload CodeQL results to code-scanning
+      packages: read
+      actions: read
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - language: rust
+            build-mode: none
+          - language: python
+            build-mode: none
+          - language: javascript-typescript
+            build-mode: none
+    steps:
+      - name: Checkout
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+        with:
+          languages: ${{ matrix.language }}
+          build-mode: ${{ matrix.build-mode }}
+
+      - name: Perform CodeQL analysis
+        uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+        with:
+          category: "/language:${{ matrix.language }}"

.github/workflows/links.yml

@@ -0,0 +1,28 @@
+name: Link check
+
+# External link rot is non-deterministic (third-party sites go down, rate-limit,
+# or move), so the authoritative check runs on a weekly schedule and on demand
+# rather than gating PRs or releases. ci.yml additionally runs a non-blocking
+# lychee job on PRs for an early heads-up (continue-on-error), and release.yml is
+# deliberately NOT gated on it — a transient external outage must never block an
+# irreversible publish.
+on:
+  schedule:
+    - cron: "0 6 * * 1" # Mondays 06:00 UTC
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  links:
+    name: External links (lychee)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+      - uses: lycheeverse/lychee-action@8646ba30535128ac92d33dfc9133794bfdd9b411 # v2
+        with:
+          args: --config lychee.toml --no-progress --root-dir "${{ github.workspace }}" "*.md" "bindings/*/README.md"
+          fail: true

.github/workflows/scorecard.yml

@@ -0,0 +1,56 @@
+name: OpenSSF Scorecard
+
+# Supply-chain / security-posture analysis (findings P13.1). Runs on a weekly
+# schedule, on branch-protection changes, and on push to main. `publish_results`
+# uploads the score to the public OpenSSF API so the README badge resolves, and
+# the SARIF is surfaced under the repo's Security → Code scanning tab.
+on:
+  branch_protection_rule:
+  schedule:
+    - cron: '27 7 * * 2' # Tuesdays 07:27 UTC
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+# Read-only by default; the analysis job widens to exactly what it needs.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write # upload the SARIF result to code-scanning
+      id-token: write # OIDC token to publish results to the OpenSSF API
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Run Scorecard analysis
+        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # The default GITHUB_TOKEN cannot read classic branch-protection
+          # rules, so the Branch-Protection check fails with an internal error
+          # and scores -1. A read-only fine-grained PAT (Administration: read,
+          # Contents: read, Metadata: read) supplied as SCORECARD_TOKEN lets the
+          # check read the protection settings. See
+          # https://github.com/ossf/scorecard-action/blob/main/docs/authentication/fine-grained-auth-token.md
+          repo_token: ${{ secrets.SCORECARD_TOKEN }}
+          # Publish to the public OpenSSF endpoint that backs the README badge.
+          publish_results: true
+
+      - name: Upload SARIF artifact
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      - name: Upload SARIF to code-scanning
+        uses: github/codeql-action/upload-sarif@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+        with:
+          sarif_file: results.sarif

.github/workflows/sync-about.yml

@@ -0,0 +1,474 @@
+name: Sync indicator count
+
+# Indicator count appears in four places that must stay in sync with
+# the number of public indicator types exported from
+# crates/wickra-core/src/lib.rs (the `pub use indicators::{ ... }` block,
+# minus the `FAMILIES` constant and any `*Output` companion structs):
+#
+#   1. README.md prose                       — synced on PR branches (this workflow)
+#   2. GitHub repo "About" description       — synced on push to main / v* tag
+#   3. Docs site: index.md / overview.md / Indicators-Overview.md
+#      (wickra-lib/wickra-docs) — synced on push to main / v* tag*
+#   4. Marketing site count (wickra-lib/webpage: index.md / about.md /
+#      .vitepress/config.ts) — push to main / v* tag*
+#   5. org profile README count (wickra-lib/.github, profile/README.md)
+#                                            — synced on push to main / v* tag*
+#   6. org description ("… N indicators, install-free.")
+#                                            — synced on push to main / v* tag*
+#   7. docs site published version (wickra-lib/wickra-docs: the
+#      "Published versions" table in overview.md + the Rust quickstart prose)
+#                                            — synced on v* tag only*
+#   8. Marketing site version (wickra-lib/webpage: api/*.md "Latest" lines, the
+#      nav version label, and the wickra-wasm dep) — synced on v* tag only*
+#   9. Wiki pointer page count (wickra-lib/wickra.wiki, Home.md — the wiki was
+#      collapsed to a single page that points at docs.wickra.org but still names
+#      the count) — synced on push to main / v* tag*
+#
+#   *Surfaces 3 + 7 need the ABOUT_SYNC_TOKEN to have write on
+#   wickra-lib/wickra-docs, surfaces 4 + 8 on wickra-lib/webpage; surfaces 5 + 6
+#   need write on wickra-lib/.github and admin:org for the org-description PATCH;
+#   surface 9 needs write on wickra-lib/wickra (the wiki rides on the parent
+#   repo's permission).
+#   Until that scope is granted these steps emit a ::warning:: and soft-skip —
+#   they never fail the run. The repo "About" homepage URL is also enforced in
+#   step 2 (constant value, no extra scope); it points at docs.wickra.org.
+#
+#   Note: surface 7 carries the release *version*, not the indicator count, so
+#   it is driven by the v* tag (which is the version) rather than the count.
+#
+# We count public types (not `mod xxx;` lines) because some modules export
+# more than one indicator — e.g. `vwap.rs` exposes both `Vwap` and
+# `RollingVwap`, so the mod-count under-reports by one. lib.rs is the
+# single source of truth for what the bindings reach.
+#
+# Design: on PRs this workflow is a READ-ONLY check. The indicator wiring
+# bumps both README.md and docs/README.md inside the author's code commit, so
+# the counter is already correct by the time CI runs. If it is not, the check
+# below fails loud and asks the author to re-run the wiring — it never pushes a
+# fix-up commit.
+#
+# (An earlier version pushed a GITHUB_TOKEN "sync indicator count" commit to
+# the PR head. Because GITHUB_TOKEN pushes trigger no workflows, that commit
+# moved the PR head onto a commit with no CI run, which hid the Codecov patch
+# status — keyed to the PR head sha — from the PR. Keeping the counter in the
+# code commit avoids that entirely.)
+on:
+  push:
+    branches: [main]
+    tags: ['v*']
+  pull_request:
+    types: [opened, synchronize, reopened]
+  workflow_dispatch:
+
+# Least-privilege default for the auto-injected GITHUB_TOKEN. The `contents:
+# write` the workflow needs — to push the counter fix-up commit to the PR head
+# branch — is raised at the job level below, not here, so the top-level default
+# stays read-only (OpenSSF Scorecard: Token-Permissions). The wider About /
+# docs / webpage / org writes still go through the fine-grained PAT
+# (ABOUT_SYNC_TOKEN), which the `permissions:` key does not govern at all.
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    # This workflow never writes to wickra-lib/wickra with GITHUB_TOKEN: the PR
+    # flow is a read-only check, and the main/tag flow writes only to other
+    # repos (About metadata, docs, webpage, wiki, org) through the fine-grained
+    # ABOUT_SYNC_TOKEN PAT. So GITHUB_TOKEN stays read-only (OpenSSF Scorecard:
+    # Token-Permissions).
+    permissions:
+      contents: read
+      pull-requests: read
+    steps:
+      # On PRs we check out the PR *head* commit (the author's code, not the
+      # merge ref) so the counter check validates exactly what will land. On
+      # push events we check out the default ref. No push is made, so a shallow
+      # checkout is enough.
+      #
+      # Check out by head SHA, not head ref (branch name): a fast `gh pr merge
+      # --squash --delete-branch` deletes the head branch the moment the PR
+      # merges, often before this queued read-only check reaches its checkout.
+      # Fetching the now-gone `refs/heads/<branch>` then fails the run (exit 1).
+      # The head SHA stays reachable via `refs/pull/N/head` after the branch is
+      # gone, so the checkout — and the run — survives an instant merge.
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          fetch-depth: 1
+          ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.ref }}
+          repository: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name || github.repository }}
+
+      - name: Count indicators
+        id: count
+        run: |
+          # Parse the `pub use indicators::{ ... }` block from lib.rs, strip
+          # the FAMILIES constant and any `*Output` companion structs, count
+          # the remaining identifiers. Pure-shell so the workflow doesn't
+          # require a python runtime.
+          n=$(sed -n '/^pub use indicators::{/,/^};/p' crates/wickra-core/src/lib.rs \
+            | tr ',{}' '\n' \
+            | sed 's/[[:space:]]//g' \
+            | grep -E '^[A-Z][A-Za-z0-9_]*$' \
+            | grep -vE '^FAMILIES$|Output$' \
+            | sort -u | wc -l)
+          echo "count=$n" >> "$GITHUB_OUTPUT"
+          echo "Indicator count: $n"
+
+      # ----- PR flow ---------------------------------------------------
+
+      - name: Check README counter (PR, read-only)
+        if: github.event_name == 'pull_request'
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          ok=true
+          if ! grep -qE "^${n} streaming-first indicators" README.md; then
+            echo "::error::README.md does not say '${n} streaming-first indicators' — lib.rs exports ${n}. Re-run the indicator wiring (it bumps README.md), then push again."
+            ok=false
+          fi
+          if ! grep -qE "\*\*${n} indicators\*\*" docs/README.md; then
+            echo "::error::docs/README.md does not say '**${n} indicators**' — lib.rs exports ${n}. Re-run the indicator wiring (it bumps docs/README.md), then push again."
+            ok=false
+          fi
+          if [ "$ok" = "true" ]; then
+            echo "README.md + docs/README.md counter already at ${n}; nothing to do."
+          else
+            exit 1
+          fi
+
+      # ----- main / tag flow ------------------------------------------
+      #
+      # After a PR squash-merges, this workflow runs again on the push to main.
+      # README.md / docs/README.md are already correct (the indicator wiring
+      # bumped them in the merged code commit); the only outward syncs left are
+      # the GitHub About description (repo metadata, not a commit) and the docs /
+      # webpage / wiki / org repos (separate repos, no main history pollution).
+      # The wickra repo's own README is not touched on main any more.
+
+      - name: Update GitHub About (description + homepage)
+        if: github.event_name != 'pull_request'
+        env:
+          GH_TOKEN: ${{ secrets.ABOUT_SYNC_TOKEN }}
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          # Canonical homepage — the docs site (P8.3). This is enforced on every
+          # run, so it must only point at docs.wickra.org once that domain is
+          # actually live (Cloudflare Pages, P8.1); merging this PR is therefore
+          # gated on the domain resolving, otherwise the About link would 404.
+          homepage="https://docs.wickra.org"
+          desc="Streaming-first technical indicators with a Rust core and Python, Node.js, WebAssembly, C ABI, .NET, Go, Java, and R bindings. ${n} indicators, O(1) per-tick updates, no system dependencies. Drop-in TA-Lib replacement."
+          # Enforce the homepage unconditionally — it is a constant, so this both
+          # corrects the stale kingchenc URL and self-heals any future drift.
+          # Same Administration-write permission as --description (no extra scope).
+          gh repo edit --homepage "$homepage"
+          current=$(gh repo view --json description -q .description)
+          if [ "$current" = "$desc" ]; then
+            echo "About description unchanged; homepage enforced."
+          else
+            gh repo edit --description "$desc"
+            echo "About description + homepage updated."
+          fi
+
+      # Counter sync target moved from the retired GitHub wiki to the docs site
+      # repo (wickra-lib/wickra-docs). The count appears in index.md (hero),
+      # overview.md prose, and Indicators-Overview.md prose. Soft-skips like the
+      # org steps so a token/scope gap never fails the run. Uses its own clone
+      # dir (docs-count) so it cannot collide with the tag-only version step
+      # below, which clones the same repo into `docs`.
+      - name: Sync docs indicator count (wickra-docs)
+        if: github.event_name != 'pull_request'
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.ABOUT_SYNC_TOKEN }}
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          if ! git clone "https://x-access-token:${GH_TOKEN}@github.com/wickra-lib/wickra-docs.git" docs-count 2>/dev/null; then
+            echo "::warning::cannot clone wickra-lib/wickra-docs — ABOUT_SYNC_TOKEN likely lacks write on that repo (findings P10.0a). Skipping docs count sync."
+            exit 0
+          fi
+          cd docs-count
+          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" index.md overview.md Indicators-Overview.md .vitepress/config.ts
+          if git diff --quiet; then
+            echo "Docs indicator count unchanged."
+            exit 0
+          fi
+          git config user.name "wickra-bot"
+          git config user.email "wickra-bot@users.noreply.github.com"
+          git add index.md overview.md Indicators-Overview.md .vitepress/config.ts
+          git commit -m "chore: sync indicator count to ${n}"
+          if ! git push 2>/dev/null; then
+            echo "::warning::push to wickra-lib/wickra-docs failed — ABOUT_SYNC_TOKEN likely lacks write (findings P10.0a)."
+          else
+            echo "Docs indicator count synced to ${n}."
+          fi
+
+      # The GitHub wiki (wickra-lib/wickra.wiki) was collapsed to a single
+      # Home.md pointer page that sends visitors to docs.wickra.org, but that
+      # page still names the count ("… for all N indicators"), so keep it in
+      # sync here too. Mirrors the docs/webpage count steps: own clone dir
+      # (wiki-count) and the same soft-skip contract. Wiki write rides on the
+      # parent repo's permission, so the PAT needs write on wickra-lib/wickra;
+      # the wiki has no signing gate, so a plain wickra-bot commit is fine.
+      - name: Sync wiki pointer indicator count (wickra.wiki)
+        if: github.event_name != 'pull_request'
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.ABOUT_SYNC_TOKEN }}
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          if ! git clone "https://x-access-token:${GH_TOKEN}@github.com/wickra-lib/wickra.wiki.git" wiki-count 2>/dev/null; then
+            echo "::warning::cannot clone wickra-lib/wickra.wiki — ABOUT_SYNC_TOKEN likely lacks write on the wiki. Skipping wiki count sync."
+            exit 0
+          fi
+          cd wiki-count
+          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" Home.md
+          if git diff --quiet; then
+            echo "Wiki pointer indicator count unchanged."
+            exit 0
+          fi
+          git config user.name "wickra-bot"
+          git config user.email "wickra-bot@users.noreply.github.com"
+          git add Home.md
+          git commit -m "chore: sync indicator count to ${n}"
+          if ! git push 2>/dev/null; then
+            echo "::warning::push to wickra-lib/wickra.wiki failed — ABOUT_SYNC_TOKEN likely lacks write on the wiki."
+          else
+            echo "Wiki pointer indicator count synced to ${n}."
+          fi
+
+      # ----- org-profile sync (soft-skip until PAT scope lands) -------
+      #
+      # These two steps keep the org page (github.com/wickra-lib) in sync
+      # with the same count. They need ABOUT_SYNC_TOKEN scope the main-repo
+      # syncs do not: write on wickra-lib/.github, and admin:org for the org
+      # description PATCH. Both are written to soft-skip with a ::warning::
+      # (never fail the run) so this workflow stays green before the scope is
+      # granted — once it is, they start syncing with no further code change.
+
+      - name: Sync org profile README count
+        if: github.event_name != 'pull_request'
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.ABOUT_SYNC_TOKEN }}
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          if ! git clone "https://x-access-token:${GH_TOKEN}@github.com/wickra-lib/.github.git" orgprofile 2>/dev/null; then
+            echo "::warning::cannot clone wickra-lib/.github — ABOUT_SYNC_TOKEN likely lacks write on that repo (findings P10.0a). Skipping org profile sync."
+            exit 0
+          fi
+          cd orgprofile
+          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" profile/README.md
+          if git diff --quiet; then
+            echo "Org profile README count unchanged."
+            exit 0
+          fi
+          git config user.name "wickra-bot"
+          git config user.email "wickra-bot@users.noreply.github.com"
+          git add profile/README.md
+          git commit -m "chore: sync indicator count to ${n}"
+          if ! git push 2>/dev/null; then
+            echo "::warning::push to wickra-lib/.github failed — ABOUT_SYNC_TOKEN likely lacks write (findings P10.0a)."
+          else
+            echo "Org profile README synced to ${n}."
+          fi
+
+      - name: Sync org description
+        if: github.event_name != 'pull_request'
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.ABOUT_SYNC_TOKEN }}
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          org="wickra-lib"
+          # Reading the org description is public; the PATCH needs admin:org.
+          current=$(gh api "orgs/${org}" --jq '.description // ""' 2>/dev/null || true)
+          if [ -z "$current" ]; then
+            echo "::warning::could not read org description (network/PAT?). Skipping."
+            exit 0
+          fi
+          updated=$(printf '%s' "$current" | sed -E "s/[0-9]+ indicators/${n} indicators/")
+          if [ "$current" = "$updated" ]; then
+            echo "Org description count unchanged."
+            exit 0
+          fi
+          if gh api -X PATCH "orgs/${org}" -f description="$updated" >/dev/null 2>&1; then
+            echo "Org description synced to ${n}."
+          else
+            echo "::warning::org description PATCH failed — ABOUT_SYNC_TOKEN likely lacks admin:org (findings P10.0b)."
+          fi
+
+      # ----- docs version sync (tag-only, soft-skip until PAT scope lands) -----
+      #
+      # Surface 7: the docs site (wickra-lib/wickra-docs) carries the published
+      # version in the "Published versions" table (overview.md) and the Rust
+      # quickstart prose. Unlike the indicator count these change only on a
+      # release, so this step runs on v* tag pushes only and takes the version
+      # straight from the tag. It needs ABOUT_SYNC_TOKEN to have write on
+      # wickra-lib/wickra-docs (findings P10.0a). Until that scope is granted it
+      # soft-skips with a ::warning:: and never fails the run; once granted, every
+      # release self-heals the docs version with no code change (replaces the old
+      # manual P0.5 post-release wiki bump).
+      - name: Sync docs version (wickra-docs)
+        if: startsWith(github.ref, 'refs/tags/v')
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.ABOUT_SYNC_TOKEN }}
+        run: |
+          version="${GITHUB_REF#refs/tags/v}"
+          if ! printf '%s' "$version" | grep -qE '^[0-9]+\.[0-9]+\.[0-9]+$'; then
+            echo "::warning::tag '${GITHUB_REF}' is not a plain vMAJOR.MINOR.PATCH release; skipping docs version sync."
+            exit 0
+          fi
+          # Clone into `docs-ver`, NOT `docs`: on a tag push this job checks out
+          # the wickra repo at the workspace root, which already contains a
+          # top-level `docs/` directory, so `git clone … docs` fails with
+          # "destination path 'docs' already exists" — silently, because of the
+          # 2>/dev/null below — and the version sync never runs (this is exactly
+          # why v0.4.0 did not bump the docs table). `docs-ver` mirrors the
+          # `docs-count` dir used by the count step above and collides with
+          # nothing in the repo.
+          if ! git clone "https://x-access-token:${GH_TOKEN}@github.com/wickra-lib/wickra-docs.git" docs-ver 2>/dev/null; then
+            echo "::warning::cannot clone wickra-lib/wickra-docs — ABOUT_SYNC_TOKEN likely lacks write on that repo (findings P10.0a). Skipping docs version sync."
+            exit 0
+          fi
+          cd docs-ver
+          # 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
+          # Quickstart-Java is the only quickstart whose install block pins a
+          # version (the Maven `<version>` tag and the `org.wickra:wickra:<v>`
+          # Gradle coordinate). Java publishes on every release, so it tracks the
+          # same ${version}.
+          sed -i -E "s|<version>[0-9]+\.[0-9]+\.[0-9]+</version>|<version>${version}</version>|" Quickstart-Java.md
+          sed -i -E "s|(org\.wickra:wickra:)[0-9]+\.[0-9]+\.[0-9]+|\1${version}|" Quickstart-Java.md
+          if git diff --quiet; then
+            echo "Docs version already at ${version}."
+            exit 0
+          fi
+          git config user.name "wickra-bot"
+          git config user.email "wickra-bot@users.noreply.github.com"
+          git add overview.md Quickstart-Rust.md Quickstart-Java.md
+          git commit -m "chore: sync published version to ${version}"
+          if ! git push 2>/dev/null; then
+            echo "::warning::push to wickra-lib/wickra-docs failed — ABOUT_SYNC_TOKEN likely lacks write (findings P10.0a)."
+          else
+            echo "Docs version synced to ${version}."
+          fi
+
+      # ----- webpage (marketing site) self-update (findings P12.1) ------------
+      #
+      # The marketing site (wickra-lib/webpage) carries the same indicator count
+      # and published version as the docs. Mirrors the docs steps above: the
+      # count syncs on push-to-main + tag, the version syncs on v* tags only.
+      # Distinct clone dirs (webpage-count / webpage-ver) avoid any collision on
+      # a tag run. Soft-skips with a ::warning:: if the token can't reach the
+      # repo, so the run never fails.
+      - name: Sync webpage indicator count (wickra-lib/webpage)
+        if: github.event_name != 'pull_request'
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.ABOUT_SYNC_TOKEN }}
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          if ! git clone "https://x-access-token:${GH_TOKEN}@github.com/wickra-lib/webpage.git" webpage-count 2>/dev/null; then
+            echo "::warning::cannot clone wickra-lib/webpage — ABOUT_SYNC_TOKEN likely lacks write on that repo (findings P10.0a). Skipping webpage count sync."
+            exit 0
+          fi
+          cd webpage-count
+          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" index.md about.md .vitepress/config.ts
+          if git diff --quiet; then
+            echo "Webpage indicator count unchanged."
+            exit 0
+          fi
+          git config user.name "wickra-bot"
+          git config user.email "wickra-bot@users.noreply.github.com"
+          git add index.md about.md .vitepress/config.ts
+          git commit -m "chore: sync indicator count to ${n}"
+          if ! git push 2>/dev/null; then
+            echo "::warning::push to wickra-lib/webpage failed — ABOUT_SYNC_TOKEN likely lacks write (findings P10.0a)."
+          else
+            echo "Webpage indicator count synced to ${n}."
+          fi
+
+      - name: Sync webpage version (wickra-lib/webpage)
+        if: startsWith(github.ref, 'refs/tags/v')
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.ABOUT_SYNC_TOKEN }}
+        run: |
+          version="${GITHUB_REF#refs/tags/v}"
+          if ! printf '%s' "$version" | grep -qE '^[0-9]+\.[0-9]+\.[0-9]+$'; then
+            echo "::warning::tag '${GITHUB_REF}' is not a plain vMAJOR.MINOR.PATCH release; skipping webpage version sync."
+            exit 0
+          fi
+          # The webpage pins wickra-wasm to the released version in package.json,
+          # and its Cloudflare Pages build runs `npm clean-install`. release.yml
+          # publishes wickra-wasm to npm in parallel on this same tag and finishes
+          # minutes later, so committing the bump immediately would point the site
+          # at a version npm cannot resolve yet (ETARGET) and break the build —
+          # exactly what happened on v0.4.0. Wait until wickra-wasm@$version is
+          # actually live on npm before committing; if it never appears (the wasm
+          # publish failed), skip rather than push a build-breaking commit.
+          echo "Waiting for wickra-wasm@${version} on npm before bumping the webpage..."
+          attempts=0
+          until npm view "wickra-wasm@${version}" version >/dev/null 2>&1; do
+            attempts=$((attempts + 1))
+            if [ "$attempts" -ge 30 ]; then
+              echo "::warning::wickra-wasm@${version} not on npm after ~15 min; skipping webpage version sync to avoid a broken Cloudflare build."
+              exit 0
+            fi
+            echo "  not on npm yet (attempt ${attempts}/30); waiting 30s..."
+            sleep 30
+          done
+          echo "wickra-wasm@${version} is live on npm; proceeding with the webpage version bump."
+          if ! git clone "https://x-access-token:${GH_TOKEN}@github.com/wickra-lib/webpage.git" webpage-ver 2>/dev/null; then
+            echo "::warning::cannot clone wickra-lib/webpage — ABOUT_SYNC_TOKEN likely lacks write (findings P10.0a). Skipping webpage version sync."
+            exit 0
+          fi
+          cd webpage-ver
+          # api/*.md "Latest" lines, the nav version label, and the wickra-wasm
+          # dep pin. The '.' anchors match the backtick / quote / caret without a
+          # literal in this shell string; historical "Since X.Y.Z" prose has no
+          # such anchor and is never matched.
+          sed -i -E "s/(Latest:\*\* \[.wickra(-wasm)? )[0-9]+\.[0-9]+\.[0-9]+/\1${version}/" api/*.md
+          sed -i -E "s/(text: .v)[0-9]+\.[0-9]+\.[0-9]+/\1${version}/" .vitepress/config.ts
+          sed -i -E "s/(.wickra-wasm.: .\^)[0-9]+\.[0-9]+\.[0-9]+/\1${version}/" package.json
+          # Java is the only target whose install snippet pins a version: the
+          # Maven `<version>` tag in the api/java.md dependency block and the
+          # home-page install tab in index.md, plus any `org.wickra:wickra:<v>`
+          # Gradle coordinate. Java publishes on every release, so it tracks the
+          # same ${version} as the rest. (Other languages' api/*.md carry a
+          # "Latest:" line handled above; Java uses the XML snippet instead.)
+          sed -i -E "s|<version>[0-9]+\.[0-9]+\.[0-9]+</version>|<version>${version}</version>|" api/java.md index.md
+          sed -i -E "s|(org\.wickra:wickra:)[0-9]+\.[0-9]+\.[0-9]+|\1${version}|" api/java.md index.md
+          # Keep package-lock.json in sync with the package.json bump. The site's
+          # Cloudflare build runs `npm clean-install` (npm ci), which hard-fails
+          # with EUSAGE if the lockfile still pins the previous wickra-wasm —
+          # editing package.json alone is not enough. The npm-wait above already
+          # proved wickra-wasm@$version is resolvable, so --package-lock-only
+          # regenerates the lock (version + resolved + integrity) without fetching
+          # node_modules. Guard it: if the regen fails, skip the whole commit so we
+          # never push a package.json/lock mismatch that would break the build.
+          if ! npm install --package-lock-only --no-audit --no-fund; then
+            echo "::warning::could not regenerate package-lock.json for wickra-wasm@${version}; skipping webpage version sync to avoid a lockfile-drift build break."
+            exit 0
+          fi
+          if git diff --quiet; then
+            echo "Webpage version already at ${version}."
+            exit 0
+          fi
+          git config user.name "wickra-bot"
+          git config user.email "wickra-bot@users.noreply.github.com"
+          git add api/*.md index.md .vitepress/config.ts package.json package-lock.json
+          git commit -m "chore: sync published version to ${version}"
+          if ! git push 2>/dev/null; then
+            echo "::warning::push to wickra-lib/webpage failed — ABOUT_SYNC_TOKEN likely lacks write (findings P10.0a)."
+          else
+            echo "Webpage version synced to ${version}."
+          fi

.github/workflows/sync-metadata.yml

@@ -0,0 +1,24 @@
+name: sync-metadata
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  audit:
+    name: metadata audit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.12"
+      - name: Audit repo-metadata.toml drift
+        run: python .github/scripts/sync-metadata.py --check

.github/workflows/zizmor.yml

@@ -0,0 +1,40 @@
+name: zizmor
+
+# Static analysis of the GitHub Actions workflows themselves — the surface the
+# CodeQL pass does not cover. zizmor flags template injection, overly broad
+# GITHUB_TOKEN permissions, unpinned actions, cache poisoning, and dangerous
+# triggers. Findings appear under Security -> Code scanning alongside CodeQL.
+#
+# Report-only: with `advanced-security: true` the action runs zizmor in SARIF
+# mode, which exits 0 regardless of findings, so this job never blocks CI —
+# triage happens in the Security tab. Switch to gating later (e.g. a
+# `min-severity` input) once the existing findings are triaged.
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: '17 4 * * 1' # Mondays 04:17 UTC
+
+# Least-privilege default for the auto-injected GITHUB_TOKEN; the job raises
+# exactly the scopes it needs below (matches codeql.yml's pattern).
+permissions:
+  contents: read
+
+jobs:
+  zizmor:
+    name: Audit workflows
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write # upload SARIF to code-scanning
+      contents: read # checkout
+      actions: read # online audits resolve referenced actions
+    steps:
+      - name: Checkout
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Run zizmor
+        uses: zizmorcore/zizmor-action@5f14fd08f7cf1cb1609c1e344975f152c7ee938d # v0.5.6

.github/zizmor.yml

@@ -0,0 +1,49 @@
+# zizmor configuration — https://docs.zizmor.sh/configuration/
+#
+# cache-poisoning (release.yml):
+#   The release pipeline restores build caches (Swatinem/rust-cache for the Rust
+#   compilation, actions/setup-node) as a deliberate, accepted optimisation.
+#   zizmor flags these under cache-poisoning because release.yml publishes
+#   artifacts to crates.io / PyPI / npm, so a poisoned cache could in theory
+#   reach a released build. Our caches are maintainer-controlled and the
+#   restore speedup is kept on purpose; we accept this risk rather than running
+#   cache-free release builds. (Six of the eight hits are actions/setup-node,
+#   which zizmor reports at "Low" confidence.)
+#
+# artipacked (sync-about.yml):
+#   The sync-about job checks out with persisted credentials on purpose: it
+#   pushes the indicator-count fix-up back to the PR head branch (git commit +
+#   git push), which needs the token in the runner's git config. It uploads no
+#   artifacts, so the persisted token is never packaged or leaked; accept it.
+#
+# template-injection (sync-about.yml):
+#   False positive. Every flagged expansion is steps.count.outputs.count, the
+#   indicator count produced by an internal `grep -c` over lib.rs. It is not
+#   attacker-controllable, so there is nothing to inject.
+#
+# use-trusted-publishing (release.yml):
+#   Informational suggestion to use OIDC trusted publishing for PyPI / npm
+#   instead of long-lived tokens. A worthwhile migration, but it reconfigures
+#   the live publish pipeline on the registry side; tracked separately rather
+#   than blocking on it here.
+#
+# superfluous-actions (release.yml):
+#   The GitHub release step uses softprops/action-gh-release. The runner ships
+#   `gh`, so this is replaceable by a script step, but the action is stable and
+#   battle-tested; we keep it deliberately.
+rules:
+  cache-poisoning:
+    ignore:
+      - release.yml
+  artipacked:
+    ignore:
+      - sync-about.yml
+  template-injection:
+    ignore:
+      - sync-about.yml
+  use-trusted-publishing:
+    ignore:
+      - release.yml
+  superfluous-actions:
+    ignore:
+      - release.yml

.gitignore

@@ -42,14 +42,20 @@ tarpaulin-report.html
 *.local.toml
 
 # Node binding artifacts
-bindings/node/node_modules/
+**/node_modules/
 bindings/node/*.node
-bindings/node/index.d.ts
 bindings/node/npm-debug.log*
-package-lock.json
+# index.js + index.d.ts are generated by `napi build` but committed (a matched
+# pair) so consumers and the repo get TypeScript types; CONTRIBUTING requires
+# regenerating both when a binding's public API changes.
+# package-lock.json is committed for the tracked Node packages — bindings/node/
+# and examples/node/ — so contributors get reproducible npm installs. There is
+# no top-level npm package, and the ghost-ignored site/ keeps its lockfile local.
+# See CONTRIBUTING.md "Lockfile policy" for the full per-component breakdown.
 
 # WASM build output
 bindings/wasm/pkg/
+bindings/wasm/pkg-node/
 
 # Python venv
 .venv/

ARCHITECTURE.md

@@ -0,0 +1,338 @@
+# Architecture
+
+A walkthrough of how Wickra is organised internally — written for new
+contributors who want to know **where the code lives, why it's split that
+way, and which invariants they must not break**. Pair it with [`CONTRIBUTING.md`](CONTRIBUTING.md)
+for the day-to-day workflow.
+
+## Workspace layout
+
+Wickra is a Cargo workspace of three Rust crates plus four binding crates.
+The split is deliberate: every concern that one user might want to disable
+or replace lives behind a separate crate boundary.
+
+```
+┌────────────────────────────────────────────────────────────────────┐
+│                            wickra (facade)                         │
+│              re-exports wickra-core::* + wickra-data::*            │
+└──────────────┬──────────────────────────────────┬──────────────────┘
+               │                                  │
+   ┌───────────▼──────────┐            ┌──────────▼─────────┐
+   │    wickra-core       │            │    wickra-data     │
+   │   indicator engine   │            │  i/o + aggregation │
+   │   • 514 indicators   │            │  • CSV reader      │
+   │   • Indicator trait  │            │  • Tick aggregator │
+   │   • BatchExt impl    │            │  • Resampler       │
+   │   • OHLCV / Candle   │            │  • Live feeds      │
+   │   no I/O, no deps    │            │  optional features │
+   └──────────────────────┘            └────────────────────┘
+                ▲
+                │  every binding wraps the same core
+   ┌────────────┼────────────┬────────────────┐
+   │            │            │                │
+┌──▼───────┐ ┌──▼───────┐ ┌──▼───────────┐ ┌──▼──────────────────┐
+│  Python  │ │ Node.js  │ │     WASM     │ │  C ABI (cbindgen)   │
+│  (PyO3)  │ │ (napi-rs)│ │(wasm-bindgen)│ │   cdylib + header   │
+└──────────┘ └──────────┘ └──────────────┘ └─────────┬───────────┘
+                                                     │  linked by
+                                          ┌──────────▼──────────┐
+                                          │  C · C++ · C# · Go  │
+                                          │     · Java · R      │
+                                          └─────────────────────┘
+```
+
+Python, Node.js and WASM are *native* Rust bindings (PyO3 / napi-rs /
+wasm-bindgen). The C ABI is the *hub* every other C-capable language links
+against: it builds to a `cdylib`/`staticlib` plus a generated `wickra.h`, and
+downstream languages link that one artifact rather than each re-wrapping the
+core. C and C++ link it directly; the **C#** binding (`bindings/csharp`,
+on NuGet), the **Go** binding (`bindings/go`, cgo), the **R** binding
+(`bindings/r`, `.Call`) and the **Java** binding (`bindings/java`, the Java FFM
+API / Panama, on Maven Central) are all generated from `wickra.h`.
+
+| Crate | Path | What it owns | Public deps |
+|---|---|---|---|
+| `wickra-core` | `crates/wickra-core` | every indicator, the `Indicator` trait, `BatchExt`, `Candle`/`Tick` types, `Error` | `thiserror`, `rayon` (parallel batch) |
+| `wickra` | `crates/wickra` | thin facade — re-exports everything user-facing from `wickra-core` and `wickra-data` | both internal crates |
+| `wickra-data` | `crates/wickra-data` | CSV reader, tick aggregator, resampler, live exchange feeds (feature-gated) | `tokio`, `tokio-tungstenite` (live), `serde_json` |
+| `wickra-python` | `bindings/python` | `_wickra` PyO3 module + Python package | `pyo3`, `numpy`, depends on `wickra-core` |
+| `wickra-node` | `bindings/node` | NAPI-RS native binding | `napi`, depends on `wickra-core` |
+| `wickra-wasm` | `bindings/wasm` | WASM binding | `wasm-bindgen`, depends on `wickra-core` |
+| `wickra-c` | `bindings/c` | C ABI hub — `cdylib`/`staticlib` + generated `wickra.h` (cbindgen) | depends on `wickra-core` |
+| `wickra-examples` | `examples/rust` | runnable binary examples | depends on `wickra`, `wickra-data` |
+
+The `fuzz/` directory is **excluded** from the workspace (it has its own
+`Cargo.toml`) because the libfuzzer-sys harness requires a nightly
+toolchain, which would otherwise infect the stable workspace lints.
+
+## The `Indicator` trait
+
+Every indicator in Wickra implements one trait, defined in
+`crates/wickra-core/src/traits.rs`:
+
+```rust
+pub trait Indicator {
+    type Input;
+    type Output;
+
+    fn update(&mut self, input: Self::Input) -> Option<Self::Output>;
+    fn reset(&mut self);
+    fn warmup_period(&self) -> usize;
+    fn is_ready(&self) -> bool;
+    fn name(&self) -> &'static str;
+}
+```
+
+Four design choices that are non-negotiable:
+
+1. **Streaming-first.** `update` is the only computation entry point. Each
+   call must be O(1) amortised — no replays over history, no `clone`s of
+   the input window unless absolutely necessary.
+2. **`Option<Output>` warmup.** A new indicator returns `None` until it has
+   ingested `warmup_period()` inputs. After that it returns `Some(value)`
+   on every call. The `None` → `Some` transition happens exactly once per
+   `reset()`.
+3. **Reset is mandatory.** Calling `reset()` returns the indicator to the
+   state of a newly constructed one. Tests verify this for every indicator.
+4. **No interior mutability across `update` calls.** Indicators may hold
+   `VecDeque` / array state, but no `Cell`/`RefCell`/`Mutex` should be
+   needed — `&mut self` is the only mutation channel.
+
+### Batch is free
+
+`BatchExt` is a blanket impl over `Indicator`:
+
+```rust
+impl<I: Indicator> BatchExt for I {
+    fn batch<'a>(&mut self, input: &'a [I::Input]) -> Vec<Option<I::Output>>
+    where I::Input: Copy
+    {
+        input.iter().map(|x| self.update(*x)).collect()
+    }
+    fn batch_parallel(...)  // rayon-based for multi-asset processing
+}
+```
+
+Consequence: **every indicator gets batch and parallel-batch for free** as
+soon as `Indicator` is implemented. Tests verify `batch == streaming`
+equivalence on every indicator — this is the `batch_equals_streaming` test
+that appears in every indicator module.
+
+## Indicator-module convention
+
+Each indicator lives in its own file under
+`crates/wickra-core/src/indicators/`. Naming: snake-case of the struct,
+e.g. `Sma` → `sma.rs`, `MacdIndicator` → `macd.rs`.
+
+Layout inside an indicator file is uniform:
+
+```rust
+//! Doc-comment with the formula and one-line summary.
+
+use std::collections::VecDeque;
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Public struct + rustdoc with mathematical definition + a runnable example.
+#[derive(Debug, Clone)]
+pub struct Foo { /* state fields */ }
+
+impl Foo {
+    /// Constructor with parameter validation.
+    pub fn new(period: usize, ...) -> Result<Self> { ... }
+    /// Const accessors for configured params.
+    pub const fn period(&self) -> usize { ... }
+}
+
+impl Indicator for Foo {
+    type Input = f64;        // or (f64, f64), or Candle
+    type Output = f64;       // or FooOutput { ... }
+    fn update(...) -> ... { ... }
+    fn reset(...) { ... }
+    fn warmup_period(...) -> usize { ... }
+    fn is_ready(...) -> bool { ... }
+    fn name(...) -> &'static str { "Foo" }
+}
+
+#[cfg(test)]
+mod tests {
+    // mandatory tests (every indicator):
+    // - rejects_invalid_params
+    // - accessors_and_metadata
+    // - reference_value (vs TA-Lib / pandas-ta / hand-calculated)
+    // - ignores_non_finite_input
+    // - reset_clears_state
+    // - batch_equals_streaming
+    // plus indicator-specific edge cases
+}
+```
+
+The `FAMILIES` constant in `mod.rs` (introduced in PR #60) is the
+machine-readable index of which family every indicator belongs to. It is
+the canonical taxonomy; README and Wiki tables should be derived from it.
+
+## Input types
+
+| Input | Used for | Examples |
+|---|---|---|
+| `f64` | Scalar inputs — usually a price or a return | SMA, EMA, RSI, ROC |
+| `Candle` | OHLCV bar — `{open, high, low, close, volume, timestamp}` | ATR, Bollinger, Ichimoku, all candlestick patterns |
+| `(f64, f64)` | Two-series indicators — `(asset, benchmark)` or `(x, y)` | PearsonCorrelation, Beta, Alpha, TreynorRatio |
+
+The `Candle` type lives in `wickra-core::ohlcv` and is the binding
+contract across bindings — Python's `Candle` namedtuple, Node's
+`Candle` object, and WASM's `Candle` JS class all map 1:1.
+
+## Output types
+
+Most indicators emit `f64`. Multi-output indicators emit a dedicated
+struct in the same module, named `FooOutput`:
+
+```rust
+pub struct BollingerOutput {
+    pub upper: f64,
+    pub middle: f64,
+    pub lower: f64,
+}
+```
+
+Bindings flatten these into matrix outputs (NumPy 2-D array for Python,
+typed object arrays for Node/WASM).
+
+## Numerical-stability notes
+
+A handful of indicators need care beyond naive accumulation:
+
+- **Rolling variance is running-sum, not Welford.** The sliding-window
+  variance family — `StdDev`, `Variance`, `ZScore`, `Bollinger` — keeps
+  running `Σx` and `Σx²` over the window and reports `var = Σx²/n − mean²`,
+  clamping to zero the tiny negative values floating-point cancellation can
+  produce. `Bollinger` periodically reseeds its `Σx²` from the live window
+  so error cannot accumulate over a long stream. Welford's online algorithm
+  (an incremental `M2` accumulator) does **not** transfer cleanly to a
+  sliding window — removing the oldest point from `M2` is numerically
+  unstable — so it is used only where the statistic is *not* a fixed
+  window: `IntradayVolatilityProfile` and `SeasonalZScore` accumulate
+  per-bucket variance that way.
+- **Logarithm bases** matter for some indicators (Hurst, MFI). Wickra
+  uses natural log everywhere unless the reference math explicitly
+  requires `log10` or `log2` — and then it documents the choice in the
+  rustdoc.
+- **NaN / infinity guards.** Every indicator's `update` rejects
+  non-finite input early (returns `None` without state mutation). Tests
+  cover this with `ignores_non_finite_input`.
+
+## Cross-crate flow
+
+A typical full-stack call sequence for a Python live-trading example:
+
+```
+[ Python: live_binance.py ]
+        │
+        ▼
+[ binance.AsyncClient WebSocket ] ──── wickra_data live feed ───┐
+                                                                 │
+                                              ┌──────────────────┘
+                                              ▼
+                                  [ Candle struct conversion ]
+                                              │
+                                              ▼
+                                  [ PyRsi.update(close)       ]
+                                              │
+              wraps                           │
+                                              ▼
+                              [ wickra_core::Rsi::update(f64) ]   <-- the only place math runs
+                                              │
+                                              ▼
+                                  [ Option<f64> -> Py<PyFloat> ]
+                                              │
+                                              ▼
+                                       [ Python user code ]
+```
+
+The same call sequence happens identically for Node (via NAPI),
+WASM (via wasm-bindgen → JS), and Rust (no FFI overhead, just direct
+calls).
+
+## What lives where — the navigation cheat sheet
+
+| You want to … | Look in |
+|---|---|
+| add a new indicator | `crates/wickra-core/src/indicators/<name>.rs` + add to `mod.rs` + add to `FAMILIES` + re-export in `lib.rs` |
+| change the `Indicator` trait surface | `crates/wickra-core/src/traits.rs` — this affects every indicator, treat as breaking |
+| add a new Candle field | `crates/wickra-core/src/ohlcv.rs` — also propagates to every binding's `Candle` mapping |
+| add a new exchange / data source | `crates/wickra-data/src/live/<exchange>.rs`, feature-gated under `live-<exchange>` |
+| expose a new binding | new crate under `bindings/` + macro-driven boilerplate in `bindings/<lang>/src/lib.rs` |
+| change benchmark coverage | `crates/wickra/benches/indicators.rs` |
+| add a new fuzz target | `fuzz/fuzz_targets/<name>.rs` + register in `fuzz/Cargo.toml` |
+| change CI matrix | `.github/workflows/ci.yml` |
+| change release pipeline | `.github/workflows/release.yml` (irreversible on `v*` tag — test on a throwaway tag first) |
+
+## What is **deliberately** not in this repo
+
+- **Backtest framework.** Wickra is an indicator library, not a backtester.
+  Strategy + PnL + fills logic is for the user (see `examples/` for
+  illustrative scripts).
+- **Multi-exchange aggregation.** Binance is the demo feed; full
+  exchange-agnostic aggregation is `ccxt`'s job. Wickra's
+  `wickra-data::live` is intentionally minimal.
+- **Order-book / L2 data.** Wickra works on OHLCV bars and ticks, not
+  full depth. Tick-data variants (cumulative delta, single print) are on
+  the roadmap but require new input types.
+- **Charting / visualization.** Out of scope for the Rust core. The
+  WASM examples include a `lightweight-charts` integration as a
+  starting point, but no charting code lives in the published packages.
+- **GPU / SIMD optimisation.** Indicators are O(1) per update — the
+  bottleneck is not vector throughput. SIMD would only help large-batch
+  workloads, which already saturate memory bandwidth via the cache-
+  friendly `VecDeque` window.
+
+## Performance characteristics
+
+Every indicator is amortised O(1) per `update`. The constant factor
+varies:
+
+| Class | Indicators | Per-`update` cost (approx) |
+|---|---|---|
+| Simple rolling | SMA, EMA, WMA, Mom | 1-2 floating-point ops |
+| Recursive smoothers | KAMA, FRAMA, VIDYA, JMA | 5-15 ops |
+| Window-sort | OmegaRatio, percentile-based VaR | O(period · log period) per update |
+| Multi-buffer DSP | MAMA, HilbertDominantCycle, EmpiricalModeDecomposition | 30-80 ops |
+| Multi-component | MacdIndicator, TtmSqueeze, Alligator | sum of components |
+
+Benchmarks against real BTCUSDT 1-minute data live in
+`crates/wickra/benches/indicators.rs`. Cross-library comparison vs
+TA-Lib / pandas-ta / talipp / finta lives in
+`bindings/python/benchmarks/compare_libraries.py`.
+
+## Stability commitments
+
+- **MSRV.** Workspace: Rust 1.86. Node binding: 1.88 (NAPI-RS pins it).
+- **`Indicator` trait surface.** Breaking changes here are major-version
+  events. Adding a new method with a default impl is minor.
+- **Indicator removal.** Once an indicator ships in a release, it stays
+  callable. Renames go through a deprecation period of at least one
+  minor version.
+- **Output structs.** Adding a field to a `FooOutput` is non-breaking
+  because the binding contracts go through serde and accept extra keys.
+
+## Open questions / known sharp edges
+
+These are documented for contributors so you don't waste time
+re-discovering them.
+
+- **`Rvi`** (Relative Vigor Index) and `RviVolatility` (Relative
+  Volatility Index) are different indicators with the same short
+  acronym — make sure you import the right one.
+- **Fuzz coverage of pair indicators** uses `indicator_update_pair.rs`,
+  which is small because pair indicators are simpler — but coverage
+  should grow as more pair indicators land.
+- **`FAMILIES` (from PR #60) is hand-maintained.** Adding a new
+  indicator requires a separate entry in `FAMILIES`. The
+  `total_count_matches_expected` test will fail if you forget.
+- **WASM is covered by `wasm-bindgen-test`.** `bindings/wasm/src/lib.rs`
+  carries 21 in-crate tests (run under `wasm-pack test` in CI), in
+  addition to the manual browser examples.
+
+For the high-level project goals see [`ROADMAP.md`](ROADMAP.md); for
+day-to-day contribution mechanics see [`CONTRIBUTING.md`](CONTRIBUTING.md).

BENCHMARKS.md

@@ -0,0 +1,208 @@
+# Benchmarks
+
+Read these as **relative** speedups on identical input — absolute µs depend on
+CPU, memory clock and OS scheduler, not a universal contract. **Streaming is the
+headline**: it is where Wickra's design pays off and where the gap is measured in
+orders of magnitude, not percent. The batch numbers come second and are shown
+honestly — the leanest crates edge Wickra out on the simple recurrences, and that
+is a deliberate trade for warmup/NaN semantics, not a ceiling.
+
+- **Reproduced on:** Windows 11 Pro 26200, AMD Ryzen 9 9950X, 64 GB DDR5,
+  Rust 1.92 (release: `lto = "fat"`, `codegen-units = 1`), Python 3.12.
+- **Reproduce yourself:**
+  - Rust core vs Rust crates: `cargo bench -p wickra-bench`
+  - Python vs Python libs: `pip install -e bindings/python[bench]` then
+    `python -m benchmarks.compare_libraries` (auto-detects installed peers).
+
+## 1. Streaming — the structural win
+
+Live trading feeds one tick at a time. Wickra updates every indicator in **O(1)**;
+batch-only libraries (TA-Lib, tulipy, finta, pandas-ta) have no incremental API
+and must recompute the whole history on every tick. Only `talipp` (Python) and
+`ta-rs` / `yata` (Rust) carry real per-tick state. This is the gap the library
+was built to expose.
+
+**Python — per-tick latency** (seed 5 000 bars, then feed ticks one at a time):
+
+| Indicator        | **★ Wickra** | talipp           | TA-Lib (recompute)    |
+|------------------|------------------:|------------------|-----------------------|
+| SMA(20)          | **0.089 µs ★**    | 0.96 µs (11×)    | 422 µs (4 700×)       |
+| EMA(20)          | **0.111 µs ★**    | 1.19 µs (11×)    | 430 µs (3 900×)       |
+| RSI(14)          | **0.061 µs ★**    | 0.95 µs (16×)    | 298 µs (4 900×)       |
+| MACD(12, 26, 9)  | **0.079 µs ★**    | 3.30 µs (42×)    | 327 µs (4 100×)       |
+| Bollinger(20, 2) | **0.089 µs ★**    | 4.97 µs (56×)    | 296 µs (3 300×)       |
+
+Against the only other incremental Python peer Wickra is **11–56× faster**;
+against the recompute-on-every-tick libraries it is **2 800–19 000× faster**
+(`finta` RSI hits 19 000×). tulipy / pandas-ta land in the same recompute band
+as TA-Lib.
+
+**Rust — per-tick latency** (whole 50 000-bar series, lower = faster):
+
+| Indicator        | **★ Wickra** | kand | ta-rs | yata |
+|------------------|------------------:|-----:|------:|-----:|
+| SMA(20)          | 50                | 38   | 47    | 38   |
+| EMA(20)          | 154               | 69   | 56    | 69   |
+| RSI(14)          | 164               | 216  | 74    | —    |
+| MACD(12, 26, 9)  | 275               | 143  | 66    | —    |
+| Bollinger(20, 2) | **128 ★**         | 248  | 168   | —    |
+| ATR(14)          | 152               | 166  | 61    | —    |
+
+`ta-rs` hands back a bare `f64` from the first tick with no warmup and no
+validation; it leads several rows by giving those guarantees up. Against `kand`,
+Wickra wins streaming RSI, Bollinger and ATR. `yata` exposes only SMA/EMA as
+raw-value methods, so its other rows are omitted rather than faked.
+
+## 2. Batch — competitive, not the headline
+
+Whole series in one call. Here hand-tuned C (`tulipy`, TA-Lib) and the leanest
+Rust crate (`kand`) win the simple recurrences — Wickra trades a few µs per pass
+for the `None`-warmup, NaN-safety and bit-exact `batch == streaming` guarantees
+none of them keep. It still wins several rows outright and beats the rest of the
+field everywhere.
+
+**Python** (20 000-bar pass, µs/op, lower = faster):
+
+| Indicator        | Wickra   | TA-Lib   | tulipy   | pandas-ta | finta    |
+|------------------|---------:|---------:|---------:|----------:|---------:|
+| SMA(20)          | 22.2     | **15.6** | 15.9     | 32.7      | 290.1    |
+| EMA(20)          | 30.5     | **30.4** | 30.9     | 46.7      | 198.5    |
+| RSI(14)          | 52.3     | 72.0     | **34.2** | 88.8      | 812.3    |
+| MACD(12, 26, 9)  | 129.8    | 111.1    | **38.4** | 286.8     | 716.7    |
+| Bollinger(20, 2) | 87.2     | 74.6     | **37.9** | 474.3     | 1255.5   |
+| ATR(14)          | 74.7     | 87.3     | **35.5** | —         | 3496.4   |
+
+Wickra beats pandas-ta and finta on every row and TA-Lib on RSI and ATR;
+tulipy's SIMD C (and TA-Lib on SMA/EMA) lead the remaining rows.
+
+**Rust** (50 000-bar pass, µs, lower = faster). Only Wickra and `kand` expose a
+batch API; `ta-rs` and `yata` are streaming-only:
+
+| Indicator        | **★ Wickra** | kand   |
+|------------------|------------------:|-------:|
+| SMA(20)          | 53                | **41** |
+| EMA(20)          | 111               | **71** |
+| RSI(14)          | **221 ★**         | 259    |
+| MACD(12, 26, 9)  | 533               | **327** |
+| Bollinger(20, 2) | **404 ★**         | 460    |
+| ATR(14)          | **122 ★**         | 169    |
+
+Run the suite yourself:
+
+```bash
+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++, C#, Go, Java,
+R or WASM 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 crosses once.** A `batch` call crosses the boundary a single time and the
+  Rust core computes the whole series internally, so batch throughput stays high for
+  most bindings — the exceptions are the ones that copy or box the result array on
+  the way out (Node's JS `Array`, Python's stdlib `array.array` now that NumPy is
+  optional).
+- **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)   |                380 |            498 |
+| C / C++              |                365 |            358 |
+| C#                   |                348 |            259 |
+| Python               |                 31 |             46 |
+| Java                 |                 38 |            173 |
+| Go                   |                 23 |            394 |
+| WASM                 |                 21 |            169 |
+| Node.js              |                 16 |              9 |
+| R                    |                0.1 |            279 |
+
+Streaming spans more than three orders of magnitude — the raw C ABI (365) sits
+just under the FFI-free Rust ceiling (380), while R's per-call interpreter overhead
+(0.1) makes streaming ~2800× slower than its own batch. Batch stays high for the
+bindings that hand back a contiguous buffer (slices, typed arrays); the two low
+outliers are Node — whose napi `batch` boxes every element into a JS `Array` — and
+Python, which now copies into a stdlib `array.array` since NumPy became optional.
+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# (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)
+```
+
+## 4. Data layer — native I/O throughput
+
+Wickra ships its own data layer — a CSV candle reader, a tick-to-candle
+aggregator, and a timeframe resampler — so loading and reshaping market data
+needs **no third-party package** (`pandas`, `csv-parse`, manual bucketing,
+`pandas.resample`, …) in any of the ten languages. These run on the same Rust
+core as the indicators, so every binding reaches these speeds minus the FFI
+boundary characterised in section 3 (a `read` / `push` / `flush` call crosses the
+boundary once per batch, like `batch`, so bindings land close to the core).
+
+Rust core, 50 000 real BTCUSDT one-minute candles
+(`examples/data/btcusdt-1m.csv`), median of 100 samples, on the reference machine
+(Windows 11, AMD Ryzen 9 9950X):
+
+| Operation                          | Throughput          | Per element |
+|------------------------------------|--------------------:|------------:|
+| CSV parse (`CandleReader`)         |   3.0 M candles/s   |      329 ns |
+| Tick aggregate → 1m (`TickAggregator`) |  44 M ticks/s   |     22.6 ns |
+| Resample 1m → 5m (`Resampler`)     | 234 M candles/s     |      4.3 ns |
+
+Reading and validating a 50 000-row CSV into typed candles takes ~16 ms;
+aggregating 50 000 ticks into one-minute bars ~1.1 ms; resampling 50 000
+one-minute candles to five-minute bars ~0.2 ms. CSV parsing is the floor because
+it does the most per row (UTF-8 scan, field split, six `f64` parses, finiteness
+checks); aggregation and resampling are pure arithmetic over already-typed
+candles.
+
+The live and historical Binance feeds (`BinanceFeed`, `fetch_binance_klines`) are
+network-bound — their throughput is set by the exchange and the socket, not by
+Wickra — so they are not micro-benchmarked here; the relevant Wickra cost is the
+per-event parse, which is the same arithmetic measured above.
+
+Run it with:
+
+```bash
+cargo bench -p wickra --bench data_layer
+```

CITATION.cff

@@ -0,0 +1,31 @@
+cff-version: 1.2.0
+title: Wickra
+message: >-
+  If you use Wickra in academic work, please cite it using the metadata
+  below.
+type: software
+authors:
+  - alias: kingchenc
+    email: support@wickra.org
+repository-code: "https://github.com/wickra-lib/wickra"
+url: "https://wickra.org"
+abstract: >-
+  Wickra is a streaming-first technical-analysis library implemented in
+  Rust with bindings for Python, Node.js and WebAssembly. Each indicator
+  is a state machine that updates in constant time per new input, so
+  identical code paths serve live-trading workloads and historical
+  back-testing. The library covers 214 indicators across 16 families
+  (moving averages, momentum, volatility, volume, statistics, Ehlers
+  digital-signal-processing cycles, pivots, DeMark, Ichimoku, candlestick
+  patterns, market profile, and risk/performance metrics).
+keywords:
+  - technical-analysis
+  - technical-indicators
+  - streaming
+  - algorithmic-trading
+  - quantitative-finance
+  - rust
+  - time-series
+license:
+  - MIT
+  - Apache-2.0

CODE_OF_CONDUCT.md

@@ -0,0 +1,47 @@
+# Code of Conduct
+
+## Our pledge
+
+We as members, contributors, and maintainers pledge to make participation in
+the Wickra project a respectful and welcoming experience for everyone,
+regardless of background or identity.
+
+## Our standards
+
+Behaviour that helps build a positive community includes:
+
+- Showing empathy and kindness toward others.
+- Respecting differing opinions, viewpoints, and experiences.
+- Giving and gracefully accepting constructive feedback.
+- Taking responsibility for mistakes and learning from them.
+- Focusing on what is best for the project and the community.
+
+Behaviour that is not acceptable includes:
+
+- Personal attacks, insults, or derogatory comments.
+- Harassment of any kind, public or private.
+- Publishing others' private information without explicit permission.
+- Other conduct that would reasonably be considered inappropriate in a
+  professional setting.
+
+## Scope
+
+This Code of Conduct applies in all project spaces — the repository, issues,
+pull requests, and discussions — and when an individual is representing the
+project in public spaces.
+
+## Enforcement
+
+Instances of unacceptable behaviour may be reported to the project maintainer
+at **support@wickra.org**. All reports will be reviewed and investigated
+promptly and fairly, and the maintainer will respect the privacy and security
+of the reporter.
+
+Maintainers may take any action they deem appropriate, including warnings,
+temporary bans, or permanent removal from the project, for behaviour that
+violates this Code of Conduct.
+
+## Attribution
+
+This Code of Conduct is adapted from the
+[Contributor Covenant](https://www.contributor-covenant.org), version 2.1.

CONTRIBUTING.md

@@ -0,0 +1,168 @@
+# Contributing to Wickra
+
+Thanks for your interest in improving Wickra. This document explains how to
+build the project, the standards a change must meet, and how to get it merged.
+
+## License of contributions
+
+Wickra is dual-licensed under the [MIT](LICENSE-MIT) and
+[Apache-2.0](LICENSE-APACHE) licenses; users may choose either. Unless you
+explicitly state otherwise, any contribution you intentionally submit for
+inclusion in the work, as defined in the Apache-2.0 license, shall be dual
+licensed as above, without any additional terms or conditions.
+
+## Project layout
+
+| Path | Contents |
+| --- | --- |
+| `crates/wickra-core` | The indicator engine — every indicator lives here. |
+| `crates/wickra` | Thin umbrella crate re-exporting `wickra-core`. |
+| `crates/wickra-data` | CSV reader, tick aggregator, resampler, Binance feed. |
+| `bindings/python` | PyO3 bindings (`wickra` on PyPI). |
+| `bindings/node` | napi-rs bindings (`wickra` on npm). |
+| `bindings/wasm` | wasm-bindgen bindings (`wickra-wasm` on npm). |
+| `bindings/c` | C ABI — `cdylib` + `staticlib` + generated `include/wickra.h`. The hub for C / C++ and any C-capable language. |
+| `bindings/csharp` | C# binding over the C ABI (`Wickra` on NuGet) — `[LibraryImport]` P/Invoke generated from `wickra.h`. |
+| `bindings/go` | Go binding over the C ABI via cgo (module tag `bindings/go/vX.Y.Z`) — wrappers generated from `wickra.h`. |
+| `bindings/r` | R binding over the C ABI via `.Call` (R package) — C glue + R wrappers generated from `wickra.h`. |
+| `bindings/java` | Java binding over the C ABI via the FFM API (Panama, Maven Central) — wrappers generated from `wickra.h`. |
+| `examples/` | Runnable examples. |
+| `docs/` | Pointer to the documentation site (docs.wickra.org); the docs live in the `wickra-lib/wickra-docs` repo. |
+
+## Building and testing
+
+### Rust
+
+```bash
+cargo fmt --all --check
+cargo clippy --workspace --all-targets -- -D warnings
+cargo test --workspace
+cargo test -p wickra-data --features live-binance
+```
+
+The minimum supported Rust version is **1.86** for the workspace crates and
+**1.88** for `bindings/node`; the `msrv` CI job enforces both. These floors are
+not chosen freely — they are the lowest versions our dependencies allow
+(criterion 0.8.2, the bench dev-dependency, requires 1.86; napi-build 2.3.2
+requires 1.88). We keep the MSRV at that dependency-forced floor on purpose so
+the library builds for the widest possible audience; please don't raise it
+without a dependency that actually requires it.
+
+### Python
+
+```bash
+cd bindings/python
+python -m maturin build --release --out dist
+python -m pip install --force-reinstall --no-deps dist/wickra-*.whl
+python -m pytest -q
+```
+
+### Node
+
+```bash
+cd bindings/node
+npm install
+npx napi build --platform --release
+node --test __tests__/
+```
+
+### WASM
+
+```bash
+wasm-pack build bindings/wasm --target web --release --features panic-hook
+wasm-pack test --node bindings/wasm
+```
+
+## Lockfile policy
+
+| Component | Lockfile | Tracked? | Why |
+| --- | --- | --- | --- |
+| Workspace (Rust) | `Cargo.lock` | **yes** | The workspace ships binaries (examples, fuzz harness) and CI builds, so the dependency graph is pinned for reproducible builds. |
+| `bindings/node` | `package-lock.json` | **yes** | Reproducible `npm install` for the native binding. |
+| `examples/node` | `package-lock.json` | **yes** | Same — the runnable Node examples link the binding via a `file:` dependency. |
+| `bindings/python` | — | n/a (no lockfile) | The published package pins only `numpy>=1.22` at runtime; its native code is pinned through the workspace `Cargo.lock`. The CI/bench dev tooling it installs is hash-locked separately — see the `.github/requirements` row. |
+| `.github/requirements` | `*.txt` (hash-pinned) | **yes** | CI/bench Python tooling, locked with `uv pip compile --generate-hashes` (OpenSSF Scorecard PinnedDependencies). `ci-dev` is split per Python version — `ci-dev-py39.txt` and `ci-dev-py3.txt` — because numpy ships no single release with wheels for both cp39 and cp313; `bench.txt` covers the single-version bench job. |
+| `fuzz` | `fuzz/Cargo.lock` | **no** (ignored) | `fuzz/` is a detached crate; `cargo-fuzz init` generates `fuzz/.gitignore` which ignores its `Cargo.lock`. The fuzz smoke job resolves dependencies fresh, so the lock is not needed for reproducibility here. |
+| `site` (marketing) | `package-lock.json` | **no** (ghost-ignored) | The VitePress site is a local-only project excluded via `.git/info/exclude`; its lockfile stays local. |
+
+When adding a new committed Node package, commit its `package-lock.json` too and
+remove any matching ignore rule. Do **not** add a top-level `package-lock.json` —
+the repository root is not an npm package.
+
+To refresh every committed lockfile in the workspace — `Cargo.lock`,
+`fuzz/Cargo.lock`, the Node binding lock, and the hash-pinned Python
+requirements — run `./scripts/update-lockfiles.sh`. It uses `uv` for the Python
+locks (and bootstraps it on Linux/macOS if absent) so each target Python
+version's hashed transitive closure can be regenerated without that interpreter
+installed. Dependabot also keeps the `.github/requirements` pins current.
+
+## Standards for a change
+
+- **Formatting & lints.** `cargo fmt` must leave the tree unchanged and
+  `cargo clippy ... -D warnings` must be clean. CI gates both.
+- **Tests.** New behaviour needs tests; bug fixes need a regression test.
+- **Indicator correctness.** A new or changed indicator must have a
+  reference-value test against a known-good source (TA-Lib, pandas-ta, or a
+  hand-computed value) and a `reset` test.
+- **Streaming parity.** An indicator's `batch` output must equal the sequence
+  of `update` calls.
+- **Bindings.** A change to a public indicator API must be mirrored across the
+  Python, Node.js, and WASM bindings, including their type stubs / `.d.ts`. The C ABI
+  (`bindings/c`) is generated from the core, so regenerate it from the core and
+  commit `src/lib.rs` + `include/wickra.h`. The C# binding (`bindings/csharp`) is
+  generated from `wickra.h`, so regenerate and commit its `Generated/*.g.cs` too.
+  The Go binding (`bindings/go`) is likewise generated from `wickra.h`, so
+  regenerate and commit `indicators_gen.go` (`gofmt`-clean). The R binding
+  (`bindings/r`) is generated from `wickra.h` too, so regenerate and commit
+  `src/wickra.c` + `R/indicators.R`. The Java binding (`bindings/java`) is
+  generated from `wickra.h` as well, so regenerate and commit its
+  `src/main/java/org/wickra/*.java`.
+- **Docs.** Update the relevant page on the
+  [documentation site](https://docs.wickra.org) and the
+  `README.md` when behaviour or the public API changes. The docs live in
+  a separate git repository: `https://github.com/wickra-lib/wickra-docs`.
+- **Changelog.** Add an entry under `## [Unreleased]` in `CHANGELOG.md`.
+
+## Commit and pull-request workflow
+
+1. Branch off `main`.
+2. Keep commits focused — one logical change per commit, with an imperative
+   subject line and a body explaining *why*.
+3. Open a pull request against `main` and fill in the template.
+4. CI must be green before review.
+
+## Reporting bugs and proposing features
+
+Use the issue templates under
+[`.github/ISSUE_TEMPLATE`](.github/ISSUE_TEMPLATE). For security-sensitive
+reports, follow [`SECURITY.md`](SECURITY.md) instead of opening a public issue.
+
+## Developer Certificate of Origin (DCO)
+
+All contributions to Wickra are made under the [Developer Certificate of
+Origin (DCO) 1.1](DCO). By signing off on your commits you certify that you
+wrote the patch, or otherwise have the right to submit it under the project's
+`MIT OR Apache-2.0` license.
+
+Sign off every commit by adding a `Signed-off-by` trailer with your real name
+and email — Git adds it automatically with the `-s` flag:
+
+```bash
+git commit -s -m "your message"
+```
+
+This produces a trailer of the form:
+
+```
+Signed-off-by: Your Name <you@example.com>
+```
+
+The name and email must match the commit author. Commits without a valid
+sign-off line cannot be merged. To sign off a commit you already made, amend it
+with `git commit -s --amend`, or sign off a range with an interactive rebase.
+
+## Governance
+
+Wickra's decision-making and maintainership are described in
+[`GOVERNANCE.md`](GOVERNANCE.md); the current maintainers are listed in
+[`MAINTAINERS.md`](MAINTAINERS.md).

Cargo.toml

@@ -7,23 +7,27 @@ members = [
     "bindings/python",
     "bindings/wasm",
     "bindings/node",
+    "bindings/c",
+    "examples/rust",
+    "crates/wickra-bench",
 ]
-exclude = []
+exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.1.3"
-authors = ["Wickra Contributors"]
+version = "0.9.9"
+authors = ["kingchenc <support@wickra.org>"]
 edition = "2021"
-rust-version = "1.75"
-license = "PolyForm-Noncommercial-1.0.0"
-repository = "https://github.com/kingchenc/wickra"
-homepage = "https://github.com/kingchenc/wickra"
+rust-version = "1.86"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/wickra-lib/wickra"
+homepage = "https://github.com/wickra-lib/wickra"
 readme = "README.md"
 keywords = ["finance", "trading", "indicators", "technical-analysis", "ta"]
 categories = ["finance", "mathematics", "science"]
 
 [workspace.dependencies]
-wickra-core = { path = "crates/wickra-core", version = "0.1.3" }
+wickra-core = { path = "crates/wickra-core", version = "0.9.9" }
+wickra-data = { path = "crates/wickra-data", version = "0.9.9" }
 
 thiserror = "2"
 rayon = "1.10"
@@ -31,11 +35,11 @@ rayon = "1.10"
 # Testing
 proptest = "1.5"
 approx = "0.5"
-criterion = { version = "0.5", features = ["html_reports"] }
+criterion = { version = "0.8", features = ["html_reports"] }
 
 # Python binding
-pyo3 = { version = "0.22", features = ["extension-module", "abi3-py39"] }
-numpy = "0.22"
+pyo3 = { version = "0.29", features = ["extension-module", "abi3-py39"] }
+numpy = "0.29"
 
 [workspace.lints.rust]
 unsafe_code = "forbid"

DCO

@@ -0,0 +1,34 @@
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.

GOVERNANCE.md

@@ -0,0 +1,71 @@
+# Governance
+
+Wickra is an open-source project maintained under a **single-maintainer
+("BDFL") model**. This document describes how decisions are made and how the
+project is run, so contributors know what to expect.
+
+## Roles
+
+- **Maintainer.** The maintainer (see [`MAINTAINERS.md`](MAINTAINERS.md)) is
+  responsible for the project's direction, reviews and merges changes, cuts
+  releases, and has final say on all technical and project decisions.
+- **Contributors.** Anyone who proposes changes via pull requests, files
+  issues, improves documentation, or otherwise participates. Contributors do
+  not need any special status to take part.
+
+## Decision-making
+
+- Day-to-day technical decisions (APIs, indicator implementations, refactors)
+  are made by the maintainer, informed by discussion on issues and pull
+  requests.
+- Proposals are raised as GitHub issues or pull requests. Significant or
+  breaking changes should be opened as an issue first to agree on the approach
+  before implementation.
+- The maintainer aims to act transparently: rationale for non-trivial decisions
+  is recorded in the relevant issue, pull request, or commit message.
+
+## Contribution flow
+
+All changes — including the maintainer's own — go through pull requests so that
+CI (tests, linting, static analysis) runs against them, and so the change
+history is reviewable. Contribution requirements are documented in
+[`CONTRIBUTING.md`](CONTRIBUTING.md), including the Developer Certificate of
+Origin sign-off that every commit must carry.
+
+## Becoming a maintainer
+
+The project currently has one maintainer. Maintainership may be extended to
+contributors who have demonstrated sustained, high-quality involvement, at the
+current maintainer's discretion. If the project grows to multiple maintainers,
+this document will be updated to describe shared decision-making.
+
+## Continuity and succession
+
+The project is designed to survive the loss of any single individual, so that
+issues can be triaged, proposed changes accepted, and releases published within
+one week of confirmed loss of the maintainer:
+
+- **Credentials.** All credentials required to operate the project — the
+  `wickra-lib` GitHub organization, the publishing tokens for crates.io, PyPI
+  and npm, and the `wickra.org` domain registrar — are stored in a password
+  manager. A trusted contact (a family member) holds **emergency access** to
+  that password manager and can obtain these credentials if the maintainer can
+  no longer continue.
+- **Continuity actions.** With that access, the trusted contact (or a delegate
+  they appoint) can create and close issues, accept pull requests, and publish
+  releases through the existing CI/CD workflows.
+- **Account recovery.** The maintainer's GitHub account has recovery configured,
+  and ownership of the `wickra-lib` organization can be transferred to a new
+  maintainer.
+- **Legal rights.** Legal rights to the project name and DNS are covered by the
+  maintainer's estate arrangements.
+
+## Code of conduct
+
+All participants are expected to follow the
+[Code of Conduct](CODE_OF_CONDUCT.md).
+
+## Changes to this document
+
+This governance model may evolve as the project grows. Changes are made via
+pull request and take effect once merged.

LICENSE

@@ -1,136 +0,0 @@
-# PolyForm Noncommercial License 1.0.0
-
-<https://polyformproject.org/licenses/noncommercial/1.0.0>
-
-## Acceptance
-
-In order to get any license under these terms, you must agree
-to them as both strict obligations and conditions to all
-your licenses.
-
-## Copyright License
-
-The licensor grants you a copyright license for the
-software to do everything you might do with the software
-that would otherwise infringe the licensor's copyright
-in it for any permitted purpose. However, you may
-only distribute the software according to [Distribution
-License](#distribution-license) and make changes or new works
-based on the software according to [Changes and New Works
-License](#changes-and-new-works-license).
-
-## Distribution License
-
-The licensor grants you an additional copyright license
-to distribute copies of the software. Your license to
-distribute covers distributing the software with changes
-and new works permitted by [Changes and New Works
-License](#changes-and-new-works-license).
-
-## Notices
-
-You must ensure that anyone who gets a copy of any part of
-the software from you also gets a copy of these terms or the
-URL for them above, as well as copies of any plain-text lines
-beginning with `Required Notice:` that the licensor provided
-with the software. For example:
-
-> Required Notice: Copyright 2026 kingchenc (https://github.com/kingchenc/wickra)
-
-## Changes and New Works License
-
-The licensor grants you an additional copyright license
-to make changes and new works based on the software for any
-permitted purpose.
-
-## Patent License
-
-The licensor grants you a patent license for the software that
-covers patent claims the licensor can license, or becomes able
-to license, that you would infringe by using the software.
-
-## Noncommercial Purposes
-
-Any noncommercial purpose is a permitted purpose.
-
-## Personal Uses
-
-Personal use for research, experiment, and testing for
-the benefit of public knowledge, personal study, private
-entertainment, hobby projects, amateur pursuits, or religious
-observance, without any anticipated commercial application,
-is use for a permitted purpose.
-
-## Noncommercial Organizations
-
-Use by any charitable organization, educational institution,
-public research organization, public safety or health
-organization, environmental protection organization, or
-government institution is use for a permitted purpose regardless
-of the source of funding or obligations resulting from the
-funding.
-
-## Fair Use
-
-You may have "fair use" rights for the software under the
-law. These terms do not limit them.
-
-## No Other Rights
-
-These terms do not allow you to sublicense or transfer any of
-your licenses to anyone else, or prevent the licensor from
-granting licenses to anyone else.  These terms do not imply
-any other licenses.
-
-## Patent Defense
-
-If you make any written claim that the software infringes or
-contributes to infringement of any patent, your patent license
-for the software granted under these terms ends immediately. If
-your company makes such a claim, your patent license ends
-immediately for work on behalf of your company.
-
-## Violations
-
-The first time you are notified in writing that you have
-violated any of these terms, or done anything with the software
-not covered by your licenses, your licenses can nonetheless
-continue if you come into full compliance with these terms,
-and take practical steps to correct past violations, within 32
-days of receiving notice.  Otherwise, all your licenses end
-immediately.
-
-## No Liability
-
-***As far as the law allows, the software comes as is, without
-any warranty or condition, and the licensor will not be liable
-to you for any damages arising out of these terms or the use
-or nature of the software, under any kind of legal claim.***
-
-## Definitions
-
-The **licensor** is the individual or entity offering these
-terms, and the **software** is the software the licensor makes
-available under these terms.
-
-**You** refers to the individual or entity agreeing to these
-terms.
-
-**Your company** is any legal entity, sole proprietorship,
-or other kind of organization that you work for, plus all
-organizations that have control over, are under the control
-of, or are under common control with that organization.
-**Control** means ownership of substantially all the assets
-of an entity, or the power to direct its management and
-policies by vote, contract, or otherwise.  Control can be
-direct or indirect.
-
-**Your licenses** are all the licenses granted to you for the
-software under these terms.
-
-**Use** means anything you do with the software requiring one
-of your licenses.
-
----
-
-Required Notice: Copyright 2026 kingchenc (https://github.com/kingchenc/wickra)

LICENSE-APACHE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 kingchenc and the Wickra contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kingchenc and the Wickra contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSES/Apache-2.0.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 kingchenc and the Wickra contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

LICENSES/MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kingchenc and the Wickra contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MAINTAINERS.md

@@ -0,0 +1,17 @@
+# Maintainers
+
+This file lists the current maintainers of Wickra. See
+[`GOVERNANCE.md`](GOVERNANCE.md) for what the role entails and how the project
+is run.
+
+| Maintainer | GitHub | Areas |
+| --- | --- | --- |
+| kingchenc | [@kingchenc](https://github.com/kingchenc) | All (core, bindings, CI/release, docs) |
+
+## Contacting the maintainers
+
+- General questions and support: see [`SUPPORT.md`](SUPPORT.md).
+- Bug reports and feature requests: open an issue using the
+  [issue templates](.github/ISSUE_TEMPLATE).
+- Security reports: follow [`SECURITY.md`](SECURITY.md) — do **not** open a
+  public issue.

README.md

@@ -1,26 +1,46 @@
-# Wickra
+<p align="center">
+  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=514" alt="Wickra — streaming-first technical indicators" width="100%"></a>
+</p>
 
-[![CI](https://github.com/kingchenc/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/kingchenc/wickra/actions/workflows/ci.yml)
-[![crates.io](https://img.shields.io/crates/v/wickra.svg?logo=rust&color=orange)](https://crates.io/crates/wickra)
-[![PyPI](https://img.shields.io/pypi/v/wickra.svg?logo=pypi&color=blue)](https://pypi.org/project/wickra/)
-[![npm](https://img.shields.io/npm/v/wickra.svg?logo=npm&color=red)](https://www.npmjs.com/package/wickra)
-[![License: PolyForm-NC](https://img.shields.io/badge/license-PolyForm--NC--1.0.0-purple)](LICENSE)
+[![CI](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/ci.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![CodeQL](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/codeql.svg)](https://github.com/wickra-lib/wickra/actions/workflows/codeql.yml)
+[![codecov](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/codecov.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![GitHub release](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/release.svg)](https://github.com/wickra-lib/wickra/releases/latest)
+[![crates.io](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/crates.svg)](https://crates.io/crates/wickra)
+[![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)
+[![Build provenance](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/provenance.svg)](https://github.com/wickra-lib/wickra/attestations)
+[![Docs](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/docs.svg)](https://docs.wickra.org)
+[![Live demo](https://img.shields.io/badge/live%20demo-live.wickra.org-3b82f6)](https://live.wickra.org)
+[![Verified across 10 languages](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/verified.svg)](https://docs.wickra.org/FAQ#do-all-the-language-bindings-compute-the-same-values)
 
-**Streaming-first technical indicators. Install with `pip install wickra` — no system dependencies.**
+---
+
+**Streaming-first technical indicators. Install with `pip install wickra` — no system dependencies, zero third-party packages.**
+
+> **▶ Live demo:** all 514 indicators over real Binance market data, computed live in your browser — **[live.wickra.org](https://live.wickra.org)** · zero backend, powered by `wickra-wasm`.
 
 Wickra is a multi-language technical-analysis library with a Rust core and
-bindings for Python, Node.js, and WebAssembly. Every indicator is a state
-machine that updates in O(1) per new data point, so live trading bots and
+native bindings for Python, Node.js and WASM, plus a C ABI that C, C++,
+C#, Go, Java, R and any other C-capable language links against. Every indicator is a
+state machine that updates in O(1) per new data point, so live trading bots and
 historical backtests share the exact same implementation.
 
 ```python
-import numpy as np
-import wickra as ta
+import wickra as ta                     # zero third-party deps — not even NumPy
 
 # Batch: classic TA-Lib-style usage
-prices = np.linspace(100, 200, 1000)
+prices = [100.0 + i * 0.1 for i in range(1000)]
 rsi = ta.RSI(14)
-values = rsi.batch(prices)              # numpy array, NaN during warmup
+values = rsi.batch(prices)              # array.array('d'), NaN during warmup
+                                        # np.asarray(values) wraps it zero-copy if you use NumPy
 
 # Streaming: same indicator, fed tick by tick
 rsi = ta.RSI(14)
@@ -30,95 +50,223 @@ for price in live_feed:
         print("overbought")
 ```
 
+## Documentation
+
+Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**:
+
+- **Quickstarts** — [Rust](https://docs.wickra.org/Quickstart-Rust),
+  [Python](https://docs.wickra.org/Quickstart-Python),
+  [Node](https://docs.wickra.org/Quickstart-Node),
+  [WASM](https://docs.wickra.org/Quickstart-WASM),
+  [C](https://docs.wickra.org/Quickstart-C),
+  [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
+  [indicators overview](https://docs.wickra.org/Indicators-Overview).
+- **Reference** — [warmup periods](https://docs.wickra.org/Warmup-Periods),
+  [streaming vs batch](https://docs.wickra.org/Streaming-vs-Batch),
+  [indicator chaining](https://docs.wickra.org/Indicator-Chaining), the
+  [data layer](https://docs.wickra.org/Data-Layer).
+- **Guides** — [Cookbook](https://docs.wickra.org/Cookbook),
+  [TA-Lib migration](https://docs.wickra.org/TA-Lib-Migration),
+  [FAQ](https://docs.wickra.org/FAQ).
+
+## Why Wickra
+
+Most TA libraries are fast, *or* multi-language, *or* broad. Wickra refuses to
+pick. It's the streaming-first engine built for the workload the others treat as
+an afterthought — **live, tick-by-tick data** — without giving up the breadth of
+a full batch library, and without making you reimplement your indicators four
+times to get there.
+
+- **The biggest streaming-native catalogue, period.** 514 indicators across 24
+  families — candlesticks, harmonic & chart patterns, market profile, market
+  breadth, Renko/Kagi/Point&Figure bars, Ehlers DSP cycles, risk/performance
+  metrics — every single one updating in **O(1) per tick**. TA-Lib ships ~150 and
+  none of them stream.
+- **One Rust core, five first-class targets.** Native **Rust · Python · Node.js ·
+  WASM** plus a **C ABI** for C, C++, C#, Go, Java, R and any other C-capable language —
+  identical math, identical results, zero per-language reimplementation and zero
+  GIL bottleneck.
+- **Correct by construction, not by hope.** Every `update` validates its input,
+  runs a real warmup, and returns an `Option` so a single bad tick can't silently
+  poison state. `batch == streaming` is **bit-exact, fuzzed and 100 %-line-covered
+  for all 514 indicators**.
+- **Identical across every language — proven, not promised.** All 514 indicators
+  are replayed through **all 10 languages** (Rust · Python · Node.js · WASM · C ·
+  C++ · C# · Go · Java · R) and checked **bit-for-bit against the Rust reference**
+  via shared golden fixtures in CI. The math is verifiably the same everywhere —
+  this very check caught and fixed two real cross-language marshalling bugs.
+- **Orders of magnitude faster where it counts.** In streaming Wickra is **11–56×**
+  faster than the only other incremental peer and **thousands of times** faster
+  than recompute-on-every-tick libraries. On batch it wins several rows outright
+  and trades the simple recurrences (SMA, EMA, MACD) for its guarantees — and
+  the losses are shown, not hidden.
+- **Install in one line, anywhere.** `pip install wickra` / `npm install wickra` —
+  precompiled wheels and binaries, **no C toolchain, none of TA-Lib's setup pain**.
+  macOS · Linux · Windows.
+- **Batteries included — zero third-party deps, in every language.** A full native
+  data layer ships in the box: a CSV candle reader, a tick-to-candle aggregator, a
+  timeframe resampler, a live Binance WebSocket feed and a historical Binance REST
+  fetcher — in **all 10 languages**. Loading a CSV, rolling ticks into candles,
+  resampling and streaming live data needs **no foreign package** — no pandas, no
+  `csv-parse`, no `ws`/`websockets`, no `jackson`, no `jsonlite`, not even NumPy.
+  `pip install wickra` / `npm install wickra` / `go get` / … pulls **nothing else**.
+- **Truly permissive.** **MIT OR Apache-2.0** — drop it straight into commercial
+  and closed-source work.
+
+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.js · WASM · C · 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    |
+| TA-Lib           | yes (C deps)| no          | many bindings               |      ~150  | barely |
+| pandas-ta        | clean       | no          | Python                      |      ~130  | slow   |
+| finta            | clean       | no          | Python                      |       ~80  | stale  |
+| talipp           | clean       | yes         | Python                      |       ~40  | yes    |
+
+Broad, multi-language, streaming-native **and** honest about its trade-offs — at
+the same time. That's the combination no one else ships.
+
 ## Why Wickra exists
 
-The Python TA ecosystem has plenty of libraries — TA-Lib, pandas-ta, finta,
-talipp, tulipy — and every one of them shares the same blind spot:
+Wickra started as a personal itch. The existing TA libraries never quite fit the
+projects I was building, so I decided to build one from the ground up — partly to
+learn, partly because I genuinely enjoy taking something that already exists and
+trying to do it differently (and, ideally, better). It's open source because the
+useful version of that itch is the one other people can build on too.
 
-| Library            | Install pain    | Streaming | Multi-language | Active |
-|--------------------|-----------------|-----------|----------------|--------|
-| TA-Lib (Python)    | yes (C deps)    | no        | no             | barely |
-| pandas-ta          | clean           | no        | no             | slow   |
-| finta              | clean           | no        | no             | stale  |
-| ta-lib-python      | yes (C deps)    | no        | no             | barely |
-| talipp             | clean           | yes       | no             | yes    |
-| Tulip Indicators   | yes (C deps)    | no        | partial        | stale  |
-| ooples (C#)        | clean           | no        | C# only        | yes    |
-| **Wickra**         | **clean**       | **yes**   | **Python+Node+WASM+Rust** | **yes** |
+## Benchmarks
 
-Wickra is the only library that combines all of: clean install, streaming,
-multi-language reach, and active maintenance.
+Wickra updates every indicator in **O(1)** per tick. In **streaming** — the
+workload it is built for — it is **11–56× faster** than the only other incremental
+peer and **thousands of times** faster than recompute-on-every-tick libraries.
+**Batch** is competitive: it wins several rows outright and trades a few µs
+elsewhere for `None`-warmup, NaN-safety and bit-exact `batch == streaming`.
 
-## Benchmark: how much faster is "streaming-first"?
+Full tables (Rust + Python, streaming + batch) and how to reproduce them live in
+**[BENCHMARKS.md](BENCHMARKS.md)**.
 
-Reproduced on this machine with `python -m benchmarks.compare_libraries`.
-Lower µs/op = faster. Wickra wins every batch category outright, and the
-streaming gap widens linearly with how much history a batch-only library has
-to recompute on every tick.
+### Pick your language with eyes open — per-binding throughput
 
-### Batch — single full pass over a 5 000-bar series
+Every binding calls the **same** Rust core, so this is **not** a speed claim — it
+is the raw cost of crossing each language's FFI boundary (`SMA(20)`, 200 000 bars,
+Ryzen 9 9950X, million updates/sec). **Batch stays high for most bindings;
+streaming is where the boundary shows** — so if you stream tick-by-tick, the table
+tells you which binding keeps up and which to avoid for hot loops.
 
-Reading the table: each cell shows that library's runtime, plus how many times
-slower it is than Wickra in parentheses. **★** marks the winner per row.
+| Language        | streaming (Mupd/s) | batch (Mupd/s) |
+|-----------------|-------------------:|---------------:|
+| Rust (no FFI)   |                380 |            498 |
+| C / C++         |                365 |            358 |
+| C#              |                348 |            259 |
+| Python          |                 31 |             46 |
+| Java            |                 38 |            173 |
+| Go              |                 23 |            394 |
+| WASM            |                 21 |            169 |
+| Node.js         |                 16 |              9 |
+| R               |                0.1 |            279 |
 
-| Indicator           | Wickra              | finta                  | talipp                       |
-|---------------------|---------------------|------------------------|------------------------------|
-| SMA(20)             | **26.0 µs ★**       | 295.3 µs (11.4× slower) | 1 812.8 µs (69.7× slower)   |
-| EMA(20)             | **16.8 µs ★**       | 205.5 µs (12.2× slower) | 2 534.4 µs (150.9× slower)  |
-| RSI(14)             | **31.2 µs ★**       | 714.1 µs (22.9× slower) | 3 751.7 µs (120.2× slower)  |
-| MACD(12, 26, 9)     | **30.8 µs ★**       | 359.5 µs (11.7× slower) | 11 642.2 µs (378.0× slower) |
-| Bollinger(20, 2.0)  | **26.7 µs ★**       | 690.6 µs (25.9× slower) | 27 482.4 µs (1 030.1× slower) |
-| ATR(14)             | **40.6 µs ★**       | 1 120.3 µs (27.6× slower) | 3 760.2 µs (92.7× slower) |
+All ten share one verified implementation (see the verification badge above), so
+the *numbers* differ but the *values* are bit-for-bit identical. Methodology and
+the per-indicator breakdown are in [BENCHMARKS.md](BENCHMARKS.md#3-per-binding-throughput--the-cost-of-the-boundary).
 
-### Streaming — per-tick latency after seeding with 2 000 historical bars
+## Indicators
 
-A batch-only library has to re-run its full indicator over the entire history on
-every new tick; Wickra updates state in O(1).
-
-| Indicator | Wickra (per tick)   | talipp (per tick)         |
-|-----------|---------------------|---------------------------|
-| RSI(14)   | **0.07 µs ★**       | 1.16 µs (17.5× slower)    |
-
-> TA-Lib and pandas-ta are not included here because both fail to install
-> cleanly on Windows without C build tooling — which is precisely the install
-> pain Wickra was built to remove. The benchmark script auto-detects every
-> peer library it can find and runs them on the same inputs as Wickra; install
-> them in your environment to see those rows light up too.
-
-Run the suite yourself:
-
-```bash
-pip install -e bindings/python[bench]
-python -m benchmarks.compare_libraries
-```
-
-## Indicators in 0.1.0
-
-25 streaming-first indicators across four families. Every one passes the
+514 streaming-first indicators across twenty-four families. Every one passes the
 `batch == streaming` equivalence test, reference-value tests, and reset
-semantics tests.
+semantics tests — and is replayed through **all 10 languages** and checked
+bit-for-bit against the Rust reference (golden fixtures, in CI). Each has a
+per-indicator deep dive (formula, parameters, warmup) at
+[docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
 
-| Family      | Indicators |
-|-------------|-----------|
-| Trend       | SMA, EMA, WMA, DEMA, TEMA, HMA, KAMA |
-| Momentum    | RSI (Wilder), MACD, Stochastic, CCI, ROC, Williams %R, ADX (+DI/-DI), MFI, TRIX, Awesome Oscillator, Aroon |
-| Volatility  | Bollinger Bands, ATR, Keltner Channels, Donchian Channels, Parabolic SAR |
-| Volume      | OBV, VWAP (cumulative + rolling) |
+| Family | Indicators |
+|--------|-----------|
+| Moving Averages      | SMA, EMA, WMA, DEMA, TEMA, HMA, KAMA, SMMA, TRIMA, ZLEMA, T3, VWMA, ALMA, McGinley Dynamic, FRAMA, VIDYA, JMA, Alligator, EVWMA, SWMA, GMA, EHMA, Median MA, Adaptive Laguerre, GD, Holt-Winters |
+| Momentum Oscillators | RSI (Wilder), Anchored RSI, Stochastic, CCI, ROC, Williams %R, MFI, Awesome Oscillator, MOM, CMO, TSI, PMO, StochRSI, Ultimate Oscillator, RVI, PGO, KST, SMI, Laguerre RSI, Connors RSI, Inertia, ROC Percentage (ROCP), ROC Ratio (ROCR), ROC Ratio 100 (ROCR100), Disparity Index, Fisher RSI, RSX, Dynamic Momentum Index, Stochastic CCI, RMI, Derivative Oscillator, Elder Ray, Intraday Momentum Index, QQE |
+| Trend & Directional  | MACD, MACD Fixed (MACDFIX), MACD Extended (MACDEXT), ADX (+DI/-DI), ADXR, Aroon, TRIX, Aroon Oscillator, Vortex, Random Walk Index, Trend Intensity Index, Wave Trend Oscillator, Mass Index, Choppiness Index, Vertical Horizontal Filter, Plus DM, Minus DM, Plus DI, Minus DI, DX, TTM Trend, Trend Strength Index, Qstick, Polarized Fractal Efficiency, Wave PM, Gator Oscillator, Kase Permission Stochastic |
+| Price Oscillators    | PPO, DPO, Coppock, Accelerator Oscillator, Balance of Power, APO, AO Histogram, CFO, Zero-Lag MACD, Elder Impulse, STC, TSF Oscillator, MACD Histogram, PPO Histogram |
+| Volatility & Bands   | ATR, Bollinger Bands, Keltner Channels, Donchian Channels, NATR, StdDev, Ulcer Index, Historical Volatility, Bollinger Bandwidth, %B, True Range, Chaikin Volatility, RVI (Relative Volatility Index), Parkinson Volatility, Garman-Klass Volatility, Rogers-Satchell Volatility, Yang-Zhang Volatility, Volatility Cone |
+| Bands & Channels     | MA Envelope, Acceleration Bands, STARC Bands, ATR Bands, Hurst Channel, LinReg Channel, Standard Error Bands, Double Bollinger Bands, TTM Squeeze, Fractal Chaos Bands, VWAP StdDev Bands, Quartile Bands, Bomar Bands, Median Channel, Projection Bands, Projection Oscillator |
+| Trailing Stops       | Parabolic SAR, Parabolic SAR Extended (SAREXT), SuperTrend, Chandelier Exit, Chande Kroll Stop, ATR Trailing Stop, HiLo Activator, Volty Stop, Yo-Yo Exit, Donchian Channel Stop, Percentage Trailing Stop, Step Trailing Stop, Renko Trailing Stop, Kase DevStop, Elder SafeZone, ATR Ratchet, NRTR, Time-Based Stop, Modified MA Stop |
+| Volume               | OBV, VWAP (cumulative + rolling), ADL, Volume-Price Trend, Chaikin Money Flow, Chaikin Oscillator, Force Index, Ease of Movement, Klinger Volume Oscillator, Volume Oscillator, NVI, PVI, Williams A/D Oscillator, Anchored VWAP, Demand Index, TSV, VZO, Market Facilitation Index, Volume RSI, Williams Accumulation/Distribution, Twiggs Money Flow, Trade Volume Index, Intraday Intensity, Better Volume, Volume-Weighted MACD |
+| Price Statistics     | Typical Price, Median Price, Weighted Close, Linear Regression, Linear Regression Slope, Z-Score, Linear Regression Angle, Variance, Coefficient of Variation, Skewness, Kurtosis, Standard Error, Detrended StdDev, R², Median Absolute Deviation, Autocorrelation, Hurst Exponent, Pearson Correlation, Beta, Pairwise Beta, Pair Spread Z-Score, Lead-Lag Cross-Correlation, Cointegration, Relative Strength A-vs-B, Spearman Correlation, Mid Price, Mid Point, Average Price, Linear Regression Intercept, Time Series Forecast, Rolling Correlation, Rolling Covariance, OU Half-Life, Spread Hurst, Distance SSD, Beta-Neutral Spread, Variance Ratio, Granger Causality, Kalman Hedge Ratio, Spread Bollinger Bands, Spread AR(1) Coefficient, Jarque-Bera, Rolling Min-Max Scaler, Shannon Entropy, Sample Entropy, Kendall Tau |
+| Ehlers / Cycle (DSP) | MAMA, FAMA, Fisher Transform, Inverse Fisher Transform, SuperSmoother, Hilbert Dominant Cycle, Hilbert Phasor, Hilbert DC Phase, Hilbert Trend Mode, Sine Wave, Decycler, Decycler Oscillator, Roofing Filter, Center of Gravity, Cybernetic Cycle, Adaptive Cycle, Empirical Mode Decomposition, Ehlers Stochastic, Instantaneous Trendline, Highpass Filter, Reflex, Trendflex, Correlation Trend Indicator, Adaptive RSI, Universal Oscillator, Adaptive CCI, Bandpass Filter, Even Better Sinewave, Autocorrelation Periodogram |
+| Pivots & S/R         | Classic Pivots, Fibonacci Pivots, Camarilla, Woodie Pivots, DeMark Pivots, Williams Fractals, ZigZag, Central Pivot Range, Murrey Math Lines, Andrews Pitchfork, Volume-Weighted Support/Resistance, Pivot Reversal |
+| DeMark               | TD Setup, TD Sequential, TD DeMarker, TD REI, TD Pressure, TD Combo, TD Countdown, TD Lines, TD Range Projection, TD Differential, TD Open, TD Risk Level, TD Camouflage, TD Clop, TD Clopwin, TD Propulsion, TD Trap, TD D-Wave, TD Moving Averages |
+| Ichimoku & Charts    | Ichimoku Kinko Hyo (Tenkan, Kijun, Senkou A/B, Chikou), Heikin-Ashi, Heikin-Ashi Oscillator, Three Line Break, Smoothed Heikin-Ashi, Equivolume, CandleVolume |
+| Alt-Chart Bars       | Renko (box-size bricks), Kagi (reversal-amount lines), Point & Figure (X/O columns), Range, Tick, Volume, Dollar, Imbalance, Run, Three-Line Break |
+| Candlestick Patterns | Doji, Hammer, Inverted Hammer, Hanging Man, Shooting Star, Engulfing, Harami, Morning/Evening Star, Three White Soldiers/Black Crows, Piercing Line/Dark Cloud Cover, Marubozu, Tweezer, Spinning Top, Three Inside Up/Down, Three Outside Up/Down, Two Crows, Upside Gap Two Crows, Identical Three Crows, Three Line Strike, Three Stars in the South, Abandoned Baby, Advance Block, Belt-hold, Breakaway, Counterattack, Doji Star, Dragonfly Doji, Gravestone Doji, Long-Legged Doji, Rickshaw Man, Evening Doji Star, Morning Doji Star, Gap Side-by-Side White, High-Wave, Hikkake, Modified Hikkake, Homing Pigeon, On-Neck, In-Neck, Thrusting, Separating Lines, Kicking, Kicking by Length, Ladder Bottom, Mat Hold, Matching Low, Long Line, Short Line, Rising Three Methods, Falling Three Methods, Upside Gap Three Methods, Downside Gap Three Methods, Stalled Pattern, Stick Sandwich, Takuri, Closing Marubozu, Opening Marubozu, Tasuki Gap, Unique Three River, Concealing Baby Swallow, Tristar, Harami Cross, Tower Top/Bottom, Dumpling Top, New Price Lines, Frying Pan Bottom |
+| Chart Patterns       | Double Top / Bottom, Triple Top / Bottom, Head and Shoulders, Triangle (asc/desc/sym), Wedge (rising/falling), Flag / Pennant, Rectangle / Range, Cup and Handle |
+| Harmonic Patterns    | AB=CD, Gartley, Butterfly, Bat, Crab, Shark, Cypher, Three Drives |
+| Fibonacci            | Fibonacci Retracement, Fibonacci Extension, Fibonacci Projection, Auto-Fibonacci, Golden Pocket, Fibonacci Confluence, Fibonacci Fan, Fibonacci Arcs, Fibonacci Channel, Fibonacci Time Zones |
+| Microstructure       | Order-Book Imbalance (Top-1 / Top-N / Full), Microprice, Quoted Spread, Depth Slope, Signed Volume, Cumulative Volume Delta, Trade Imbalance, Effective Spread, Realized Spread, Kyle's Lambda, Footprint, Order Flow Imbalance, VPIN, Amihud Illiquidity, Roll Measure, Trade-Sign Autocorrelation, Hasbrouck Information Share |
+| Derivatives          | Funding Rate, Funding Rate Mean, Funding Rate Z-Score, Funding Basis, Open-Interest Delta, OI / Price Divergence, OI-Weighted Price, Long/Short Ratio, Taker Buy/Sell Ratio, Liquidation Features, Term-Structure Basis, Calendar Spread, Estimated Leverage Ratio, OI-to-Volume Ratio, Perpetual Premium Index, Funding-Implied APR, Open-Interest Momentum |
+| Market Profile       | Value Area (POC / VAH / VAL), Volume Profile (histogram), TPO Profile, Initial Balance, Opening Range, Naked POC, Single Prints, Profile Shape, High/Low Volume Nodes, Composite Profile |
+| Market Breadth       | Advance/Decline Line, Advance/Decline Ratio, Advance/Decline Volume Line, McClellan Oscillator, McClellan Summation Index, TRIN / Arms Index, Breadth Thrust, New Highs - New Lows, High-Low Index, Percent Above Moving Average, Up/Down Volume Ratio, Bullish Percent Index, Cumulative Volume Index, Absolute Breadth Index, TICK Index |
+| Risk / Performance   | Sharpe Ratio, Sortino Ratio, Calmar Ratio, Omega Ratio, Max Drawdown, Average Drawdown, Drawdown Duration, Pain Index, Value at Risk, Conditional Value at Risk (CVaR), Profit Factor, Gain/Loss Ratio, Recovery Factor, Kelly Criterion, Treynor Ratio, Information Ratio, Alpha (Jensen) |
+| Seasonality & Session | Session VWAP, Session High/Low, Session Range, Average Daily Range, Overnight Gap, Overnight/Intraday Return, Turn-of-Month, Seasonal Z-Score, Time-of-Day Return Profile, Day-of-Week Profile, Intraday Volatility Profile, Volume-by-Time Profile |
 
-Adding a new indicator means implementing one trait in Rust; all four bindings
-inherit it automatically.
+Every candlestick pattern emits a signed per-bar value — `+1.0` bullish,
+`−1.0` bearish, `0.0` none — so the family drops straight into a feature matrix
+as one column each. `Doji` is direction-less by default (`+1.0` / `0.0`);
+construct it in signed mode (`Doji::new().signed()`, `Doji(signed=True)`,
+`new Doji(true)`) for a dragonfly / gravestone `±1` reading.
+
+Adding a new indicator means implementing one trait in Rust; every binding
+inherits it automatically (the C ABI — and the C#, Go, Java and R bindings generated from
+it — regenerate from the core).
 
 ## Languages
 
 | Binding           | Install                                       | Example |
 |-------------------|-----------------------------------------------|---------|
 | Python (PyO3)     | `pip install wickra`                          | `examples/python/backtest.py` |
-| Node.js (napi-rs) | `npm install wickra`                          | `bindings/node/__tests__/smoke.test.js` |
-| Browser / WASM    | `npm install wickra-wasm`                     | `bindings/wasm/examples/index.html` |
-| Rust              | `cargo add wickra`                            | `crates/wickra/examples/backtest.rs` |
+| Node.js (napi-rs) | `npm install wickra`                          | `examples/node/backtest.js` |
+| Browser / WASM    | `npm install wickra-wasm`                     | `examples/wasm/index.html` |
+| Rust              | `cargo add wickra`                            | `examples/rust/src/bin/backtest.rs` |
+| C / C++ (C ABI)   | header + library, see [`bindings/c`](bindings/c) | `examples/c/streaming.c` |
+| C# (C ABI) | `dotnet add package Wickra`, see [`bindings/csharp`](bindings/csharp) | `examples/csharp/streaming` |
+| Go (cgo, C ABI)   | `go get github.com/wickra-lib/wickra/bindings/go`, see [`bindings/go`](bindings/go) | `examples/go/streaming` |
+| Java (FFM, C ABI)  | Maven Central `org.wickra:wickra`, see [`bindings/java`](bindings/java) | `examples/java` (`Streaming`) |
+| R (`.Call`, C ABI) | `R CMD INSTALL bindings/r`, see [`bindings/r`](bindings/r) | `examples/r/streaming.R` |
 
-The wickra-core crate is `unsafe`-forbidden, so every binding inherits a
-memory-safe implementation.
+Each binding ships several runnable examples (streaming, backtest, live feed);
+[`examples/README.md`](examples/README.md) is the full cross-language index.
+
+The wickra-core crate is `unsafe`-forbidden, so the native bindings are
+memory-safe end to end. The C ABI runs the same safe core; only its thin FFI
+boundary uses `unsafe`, and the caller owns handle lifetimes (`_new` / `_free`).
+
+## Requirements
+
+The minimum supported version per language. Prebuilt packages (Rust, Python,
+Node.js, WASM, C#) need only the runtime; the C-ABI bindings that compile on
+install — Go (cgo) and R (`.Call`) — also need a C compiler, and Java runs with
+`--enable-native-access=ALL-UNNAMED`.
+
+| Language    | Package                              | Minimum supported          |
+|-------------|--------------------------------------|----------------------------|
+| Rust        | crates.io · `wickra`                 | 1.86 (MSRV)                |
+| Python      | PyPI · `wickra` (abi3 wheel)         | 3.9 (tested through 3.13)  |
+| Node.js     | npm · `wickra` (N-API 8)             | 20 (tested on 22 · 24 LTS) |
+| WASM        | npm · `wickra-wasm`                  | any modern JS engine       |
+| C           | `wickra.h` + library (releases)      | C99 compiler               |
+| C++         | `wickra.hpp` over the C ABI          | C++14 compiler             |
+| C#          | NuGet · `Wickra`                     | .NET 8 (`net8.0`)          |
+| Go          | module · `wickra-lib/wickra-go`      | Go 1.23 (cgo)              |
+| Java        | Maven Central · `org.wickra:wickra`  | Java 22 (FFM / Panama)     |
+| R           | source package                       | R ≥ 2.10 (Rtools on Win.)  |
+
+Full per-language detail (runtime vs. build-from-source) is on the
+[Requirements page](https://docs.wickra.org/Requirements) in the docs.
 
 ## Rust API
 
@@ -143,12 +291,17 @@ chain.update(price);
 
 ## Live data sources
 
-`wickra-data` (separate crate, opt-in) ships:
+Wickra ships a complete, **native data layer** — exposed in **all 10 languages**,
+pulling **zero third-party packages** (no pandas / `csv-parse` / `ws` / `jackson`
+/ `jsonlite`). In Rust it lives in the `wickra-data` crate; every binding exposes
+the same building blocks:
 
-- A streaming OHLCV **CSV reader**.
-- A **tick-to-candle aggregator** with arbitrary timeframes.
-- A **candle resampler** for multi-timeframe analysis (1m → 5m → 1h on the fly).
-- A **Binance Spot WebSocket** kline adapter (feature `live-binance`).
+- A streaming OHLCV **CSV reader** (`CandleReader`).
+- A **tick-to-candle aggregator** with arbitrary timeframes (`TickAggregator`).
+- A **candle resampler** for multi-timeframe analysis (1m → 5m → 1h on the fly, `Resampler`).
+- A live **Binance Spot WebSocket** kline feed (`BinanceFeed`, feature `live-binance`).
+- A historical **Binance REST** kline fetcher (`fetch_binance_klines`) — native
+  HTTP + JSON, no third-party client.
 
 ```rust
 use wickra::{Indicator, Rsi};
@@ -165,35 +318,55 @@ while let Some(event) = stream.next_event().await? {
 }
 ```
 
-A Python live-trading example using the public `websockets` package lives at
-`examples/python/live_trading.py`.
+Native live-feed and historical-fetch examples — using `wickra.BinanceFeed` and
+`wickra.fetch_binance_klines`, **with no third-party HTTP/WebSocket client** — live
+under `examples/python/` (and the matching directory for every other language).
 
 ## Project layout
 
 ```
 wickra/
 ├── crates/
-│   ├── wickra-core/         core engine + all 25 indicators
-│   ├── wickra/              top-level facade crate (publishes on crates.io)
-│   └── wickra-data/         CSV reader, tick aggregator, live exchange feeds
+│   ├── wickra-core/         core engine + all 514 indicators
+│   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
+│   ├── wickra-data/         CSV reader, tick aggregator, live exchange feeds
+│   └── wickra-bench/        internal cross-library benchmark harness (not published)
 ├── bindings/
 │   ├── python/              PyO3 + maturin (publishes on PyPI)
 │   ├── node/                napi-rs (publishes on npm)
-│   └── wasm/                wasm-bindgen (browsers, bundlers, Node)
-├── examples/
-│   └── python/              backtest, live trading, parallel assets, multi-tf
-│   (Rust examples live inside their crate at crates/<name>/examples/)
-├── benches/                 cargo bench targets
+│   ├── wasm/                wasm-bindgen (browsers, bundlers, Node)
+│   ├── c/                   C ABI (cdylib + staticlib) + generated include/wickra.h
+│   ├── csharp/              C# binding over the C ABI (publishes on NuGet)
+│   ├── go/                  Go binding over the C ABI via cgo (module tag)
+│   ├── r/                   R binding over the C ABI via .Call (R package)
+│   └── java/                Java binding over the C ABI via the FFM API (Maven Central)
+├── examples/                examples/README.md indexes every language
+│   ├── data/                real BTCUSDT OHLCV datasets, one per timeframe
+│   ├── rust/                Rust workspace member (`wickra-examples`)
+│   ├── python/              backtest, live Binance feed, parallel assets, multi-tf
+│   ├── node/                streaming, backtest, live Binance feed (load `wickra`)
+│   ├── wasm/                browser demo for `wickra-wasm`
+│   ├── c/                   C smoke + streaming, C++ RAII wrapper
+│   ├── csharp/              streaming, backtest, strategies (load `Wickra`)
+│   ├── go/                  streaming, backtest, strategies (cgo binding)
+│   ├── r/                   streaming, backtest, strategies (.Call binding)
+│   └── java/                streaming, backtest, strategies (FFM binding)
 └── .github/workflows/       CI and release pipelines
 ```
 
+Wickra's own regression benchmarks live in `crates/wickra/benches/`; the
+cross-library comparison against kand, ta-rs and yata lives in the internal
+`crates/wickra-bench/` crate. Runnable Rust examples live in the workspace member
+crate at `examples/rust/`. There is no top-level `benches/` directory.
+
 ## Building everything from source
 
 ```bash
 # Rust core + tests
 cargo test --workspace
 cargo clippy --workspace --all-targets -- -D warnings
-cargo bench -p wickra
+cargo bench -p wickra           # Wickra's own regression benchmarks
+cargo bench -p wickra-bench     # cross-library comparison (kand, ta-rs, yata)
 
 # Python binding (requires Rust toolchain + maturin)
 cd bindings/python
@@ -205,22 +378,72 @@ wasm-pack build bindings/wasm --target web --release --features panic-hook
 
 # Node binding (requires @napi-rs/cli)
 cd bindings/node && npm install && npm run build && npm test
+
+# C ABI (cdylib + staticlib + generated header)
+cargo build -p wickra-c --release
+cmake -S examples/c -B examples/c/build -DWICKRA_LIB_DIR="$PWD/target/release"
+cmake --build examples/c/build && ctest --test-dir examples/c/build --output-on-failure
+
+# C# binding (requires the .NET 8 SDK; links the C ABI above)
+dotnet test bindings/csharp/Wickra.Tests/Wickra.Tests.csproj
+
+# Go binding (requires a C compiler for cgo; links the C ABI above)
+cp target/release/libwickra.so bindings/go/lib/   # .dylib on macOS, wickra.dll on Windows
+cd bindings/go && go test ./...
+
+# R binding (requires a C toolchain / Rtools; links the C ABI above)
+WICKRA_INCLUDE_DIR="$PWD/bindings/c/include" WICKRA_LIB_DIR="$PWD/target/release" \
+  R CMD INSTALL bindings/r
+
+# Java binding (requires JDK 22+ and Maven; links the C ABI above)
+mvn -f bindings/java test
 ```
 
-## Test counts
+## Testing
 
-- `wickra-core`: 171 unit tests + 2 doctests, including textbook-value tests
-  for Wilder RSI, Bollinger Bands, MACD, ATR, and Stochastic.
-- `wickra-data`: 11 unit tests + 1 doctest, covers CSV decoding, the tick
-  aggregator, the resampler, and the Binance payload parser.
-- `bindings/python`: 56 pytest tests covering smoke checks, streaming==batch
-  equivalence, reference values, lifecycle, and dict/tuple candle inputs.
-- `bindings/node`: 7 Node test-runner cases via `node --test`.
+Every layer is covered; run the suites with the commands in
+[Building everything from source](#building-everything-from-source).
+
+- `wickra-core`: unit tests per indicator — textbook reference values
+  (Wilder RSI, Bollinger Bands, MACD, ATR, Stochastic), `batch == streaming`
+  equivalence, `reset` semantics, NaN/Inf handling, and property tests. A
+  catalogue-wide property harness (`tests/invariants.rs`) additionally asserts
+  `batch == streaming`, `reset == fresh`, and non-finite-input rejection for
+  **every** indicator and bar-builder.
+- `wickra-data`: unit tests for CSV decoding, the tick aggregator, the
+  resampler, and the Binance payload parser.
+- `bindings/python`: pytest covering smoke checks, streaming/batch
+  equivalence, reference values, lifecycle, input validation, and
+  dict/tuple candle inputs.
+- `bindings/node`: `node --test` cases for batch, streaming, and reference
+  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
+  (scalar/batch, multi-output, bars, profile, array input), reset, and validation.
+- `bindings/java`: JUnit cases covering one indicator per FFI archetype
+  (scalar/batch, multi-output, bars, profile, array input) plus batch equivalence.
+
+On top of those per-binding tests, **all 10 languages** (Rust, Python, Node.js,
+WASM, C, C++, C#, Go, Java, R) replay a shared, language-neutral golden fixture
+(`testdata/golden/*.csv`, generated by
+`cargo run -p wickra-examples --bin gen_golden`) and assert **bit-for-bit parity
+with the Rust reference for every one of the 514 indicators** across every
+archetype (scalar, multi-output, pairwise, derivatives-tick, cross-section,
+order-book, trade, profile, alt-chart bars, footprint). This catches FFI wiring
+bugs the math-only core tests cannot see — it has already found and fixed real
+cross-language marshalling bugs in the Java and R bindings.
 
 ## Contributing
 
 Contributions are very welcome — issues, bug reports, ideas, and pull requests
-all land in the same place: <https://github.com/kingchenc/wickra>.
+all land in the same place: <https://github.com/wickra-lib/wickra>.
 
 A short orientation for first-time contributors:
 
@@ -243,28 +466,52 @@ shape together before you invest the time.
 
 ## License
 
-Licensed under the **PolyForm Noncommercial License 1.0.0**. See [LICENSE](LICENSE).
+Licensed under either of
 
-In plain English: use it, fork it, modify it, redistribute it, file issues, send
-pull requests — all welcome. Personal projects, research, education, non-profits,
-government, hobby trading bots: all fine. The one thing that's not allowed is
-commercial sale of the software or of services built around it. If you want to
-use Wickra commercially, get in touch about a license.
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
+
+at your option. Use it, fork it, modify it, redistribute it — commercially or
+not — file issues, send pull requests; all welcome.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
+
+## Disclaimer
+
+Wickra is an indicator toolkit, not a trading system. Values it computes are
+deterministic transforms of the input data — they are not financial advice and
+they do not predict the market. Any use of this library in a production
+trading context is at your own risk.
+
+The library is provided **as is**, without warranty of any kind; see
+[LICENSE](LICENSE) for the full terms.
 
 ---
 
 <p align="center">
-  <a href="https://github.com/kingchenc/wickra/stargazers">
-    <img alt="GitHub stars" src="https://img.shields.io/github/stars/kingchenc/wickra?style=for-the-badge&logo=github&logoColor=white&color=ffd866">
+  <a href="https://github.com/wickra-lib/wickra/stargazers">
+    <img alt="GitHub stars" src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/stars.svg">
   </a>
-  <a href="https://github.com/kingchenc/wickra/network/members">
-    <img alt="GitHub forks" src="https://img.shields.io/github/forks/kingchenc/wickra?style=for-the-badge&logo=github&logoColor=white&color=78dce8">
+  <a href="https://github.com/wickra-lib/wickra/network/members">
+    <img alt="GitHub forks" src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/forks.svg">
   </a>
-  <a href="https://github.com/kingchenc/wickra/issues">
-    <img alt="GitHub issues" src="https://img.shields.io/github/issues/kingchenc/wickra?style=for-the-badge&logo=github&logoColor=white&color=ff6188">
+  <a href="https://github.com/wickra-lib/wickra/issues">
+    <img alt="GitHub issues" src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/issues.svg">
   </a>
 </p>
 
 <p align="center">
   If Wickra saved you time, the cheapest way to say thanks is to ⭐ the repo.
 </p>
+
+<p align="center">
+  <a href="https://star-history.com/#wickra-lib/wickra&Date">
+    <img alt="Wickra star history" width="640"
+         src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/star-history.svg">
+  </a>
+</p>

ROADMAP.md

@@ -0,0 +1,37 @@
+# Roadmap
+
+This roadmap describes the project's direction at a high level. It is
+intentionally non-binding: priorities shift with feedback and available time,
+and the authoritative, up-to-date view of planned work is the
+[issue tracker](https://github.com/wickra-lib/wickra/issues). Shipped changes
+are recorded in [`CHANGELOG.md`](CHANGELOG.md).
+
+## Status
+
+Wickra is **pre-1.0**. The public API is largely stable but may still change in
+minor releases; breaking changes are called out in the changelog.
+
+## Themes
+
+- **Indicator coverage.** Continue broadening the indicator catalogue across
+  families (trend, momentum, volatility, volume, statistics, market profile,
+  and more), each with the same streaming/batch parity and test guarantees.
+- **API stabilization toward 1.0.** Settle the public `Indicator` and
+  `BarBuilder` traits and the binding surfaces, then commit to semantic
+  versioning stability for a 1.0 release.
+- **Performance.** Keep per-tick updates O(1) and maintain the benchmark suite;
+  investigate further allocation and cache improvements.
+- **Bindings parity.** Keep the Python, Node.js and WASM bindings — plus
+  the C ABI and the C#, Go, Java and R bindings generated from it — in lockstep with the
+  Rust core, including type stubs and platform coverage.
+- **Documentation.** Maintain a deep-dive page per indicator on
+  <https://docs.wickra.org>, plus quickstarts and cookbook material.
+- **Project health.** Maintain test coverage, static and dynamic analysis,
+  signed releases, and supply-chain monitoring.
+
+## How to influence the roadmap
+
+Open or comment on an issue, or start with the
+[feature-request template](.github/ISSUE_TEMPLATE/feature_request.md).
+Well-scoped proposals and pull requests are the most effective way to move an
+item forward.

SECURITY.md

@@ -0,0 +1,143 @@
+# Security Policy
+
+## Supported versions
+
+Wickra is pre-1.0. Security fixes are applied to the latest released `0.9.9`
+version only; please upgrade to the newest release before reporting an issue.
+
+| Version | Supported |
+| --- | --- |
+| 0.9.9 (latest) | :white_check_mark: |
+| < 0.9.9 | :x: |
+
+## Reporting a vulnerability
+
+**Do not open a public issue for a security vulnerability.**
+
+Report it privately through one of:
+
+- GitHub's [private vulnerability reporting](https://github.com/wickra-lib/wickra/security/advisories/new)
+  ("Report a vulnerability" under the repository's *Security* tab), or
+- email to **support@wickra.org** with a subject line starting with
+  `[wickra security]`.
+
+Please include:
+
+- the affected version(s) and platform / language binding,
+- a description of the issue and its impact,
+- steps to reproduce, ideally a minimal proof of concept.
+
+## What to expect
+
+- An acknowledgement within **5 working days**.
+- An assessment and, if confirmed, a planned fix with a target release.
+- Coordinated disclosure: we will agree on a disclosure date with you and
+  credit you in the release notes unless you prefer to stay anonymous.
+
+## Scope
+
+In scope: the published crates (`wickra-core`, `wickra-data`, `wickra`), the
+PyPI/npm packages, and the build/release workflows in `.github/workflows/`.
+
+Out of scope: vulnerabilities in third-party dependencies (report those
+upstream; we track them via Dependabot and `cargo-deny`).
+
+## Security assurance case
+
+This is a short, evidence-backed argument for why Wickra can be used safely.
+
+**Security requirements.** Wickra is a computational library: it ingests
+numeric market data and produces indicator values. It stores no user
+credentials, authenticates no external users, and implements no cryptography of
+its own. The requirements are therefore: (1) memory safety and freedom from
+undefined behaviour, (2) robust handling of untrusted/degenerate numeric input
+without panics or unbounded resource use, (3) integrity of the published
+artifacts, and (4) a healthy dependency supply chain.
+
+**How the requirements are met.**
+
+- *Memory safety* — the core and all bindings are written in Rust. The crates
+  forbid or minimise `unsafe`, so the compiler guarantees memory and thread
+  safety for the indicator logic. The one exception is the C ABI
+  ([`bindings/c`](bindings/c)), whose thin FFI shim is necessarily `unsafe`
+  because it dereferences caller-supplied pointers; it adds no indicator logic,
+  validates every handle for NULL, and never lets a panic cross the boundary, so
+  the safe core's guarantees still cover all computation.
+- *Input robustness* — every indicator validates its parameters and rejects
+  non-finite inputs at construction; behaviour on edge cases (flat markets,
+  warmup, reset) is pinned by unit tests, and the public update paths are
+  exercised by coverage-guided fuzzing (`cargo-fuzz` / libFuzzer) in CI.
+- *Static and dynamic analysis* — every push and pull request runs Clippy
+  (`clippy::pedantic`, warnings-as-errors), CodeQL, fuzzing, and the full test
+  suite, with 100% line coverage on the core crate tracked by Codecov.
+- *Artifact integrity* — releases are built in CI, commits and tags are signed,
+  the `main` branch requires signed commits, and release artifacts carry build
+  provenance attestations.
+- *Supply chain* — dependencies are pinned and monitored with Dependabot and
+  audited with `cargo-deny` (license + advisory checks) on every change.
+
+**Residual risk.** The optional `live-binance` feature opens a TLS WebSocket to
+an exchange using the platform TLS library; transport security therefore
+depends on that library, not on Wickra. Wickra is not a trading system and is
+provided "as is" — see the disclaimers in `README.md` and the licenses.
+
+## Secrets management
+
+The project stores **no** secrets or credentials in the version control system.
+Secrets required by automation (publishing tokens, the about-sync PAT) are kept
+exclusively as **GitHub Actions encrypted secrets** and referenced via the
+`secrets.*` context; they are never written to the repository, logs, or build
+artifacts. GitHub **secret scanning with push protection** is enabled to block
+accidental commits of credentials. Secrets follow least privilege (the narrowest
+scope that works) and are rotated when a holder changes or on suspected
+exposure.
+
+## Verifying releases
+
+Released artifacts can be verified for integrity and authenticity:
+
+- **Build provenance.** Release assets carry GitHub build provenance
+  attestations. Verify a downloaded asset with the GitHub CLI:
+  `gh attestation verify <file> --repo wickra-lib/wickra`.
+- **Signed tags.** Each release corresponds to a signed git tag (`vX.Y.Z`);
+  the tag signature identifies the maintainer who authorised the release.
+- **Registry integrity.** Packages are distributed over HTTPS from crates.io,
+  PyPI and npm, which serve package checksums that package managers verify on
+  install.
+
+The release is published only by the maintainer through the tag-triggered
+release workflow, so a verified tag signature establishes the expected
+publisher identity.
+
+## Support timeline and end of support
+
+Wickra is **pre-1.0**: only the **latest released `0.y.z`** version receives
+security fixes. When a newer release is published, the previous version
+**immediately reaches end of support** and will not receive further fixes;
+users should upgrade to the latest release. The supported-versions table above
+is authoritative. After the `1.0.0` release this policy will be revised to
+support a defined window of releases.
+
+## Remediation policy (dependencies and code scanning)
+
+- **Severity threshold.** Vulnerabilities of **medium severity or higher** in
+  the project's own code or its dependencies are remediated promptly and before
+  the next release; lower-severity findings are addressed on a best-effort
+  basis.
+- **Automated enforcement (SCA).** Every change is evaluated by `cargo-deny`
+  (RUSTSEC advisories + license policy) and Dependabot; a known-vulnerable
+  dependency fails CI and **blocks the change** until resolved or explicitly
+  waived with justification.
+- **Automated enforcement (SAST).** Every change is evaluated by CodeQL and
+  Clippy (`-D warnings`); findings **block the change** in CI until fixed.
+- **Pre-release gate.** A release is not cut while an unresolved medium-or-higher
+  SCA/SAST finding is outstanding.
+
+## Vulnerability exploitability (VEX)
+
+Advisories reported by `cargo-deny`/Dependabot for third-party dependencies that
+do **not** affect Wickra (e.g. the vulnerable code path is not reachable, or the
+affected feature is not enabled) are triaged and recorded — with the
+not-affected justification — in the `cargo-deny` configuration (`deny.toml`) and
+the relevant pull request, rather than forcing an unnecessary dependency bump.
+This serves as the project's exploitability (VEX) record.

SUPPORT.md

@@ -0,0 +1,37 @@
+# Support
+
+Thanks for using Wickra! Here is where to get help, depending on what you need.
+
+## Documentation first
+
+Most questions are answered in the documentation:
+
+- **Docs site:** <https://docs.wickra.org> — quickstarts for Rust, Python,
+  Node.js, WASM, C, C++, C#, Go, Java and R, a per-indicator reference, warmup periods, the
+  data layer, and an FAQ.
+- **README:** <https://github.com/wickra-lib/wickra#readme> — installation and a
+  quick overview.
+- **API docs (Rust):** <https://docs.rs/wickra/latest/wickra/>.
+
+## Questions and help
+
+- Ask a question with the
+  [question issue template](.github/ISSUE_TEMPLATE/question.md).
+- Browse [existing issues](https://github.com/wickra-lib/wickra/issues) — your
+  question may already be answered.
+
+## Bugs and feature requests
+
+- **Bugs:** use the bug-report issue template.
+- **Feature requests / new indicators:** use the feature-request template.
+
+## Security issues
+
+Please do **not** report security vulnerabilities through public issues. Follow
+the process in [`SECURITY.md`](SECURITY.md) (private GitHub advisory or email).
+
+## Support expectations
+
+Wickra is maintained by a single maintainer on a best-effort basis. Issues are
+triaged and acknowledged as time allows; there is no commercial support or SLA.
+Clear, reproducible reports get help fastest.

THREAT_MODEL.md

@@ -0,0 +1,57 @@
+# Threat model
+
+This document describes Wickra's attack surface and the threats considered,
+together with their mitigations. It complements the security assurance case in
+[`SECURITY.md`](SECURITY.md). Wickra is a computational technical-analysis
+library (a Rust core with Python, Node.js and WASM bindings plus a C ABI
+and the C#, Go, Java and R bindings built on it),
+not a network service or trading system; the attack surface is correspondingly
+small.
+
+## Assets
+
+- **Integrity of computed indicator values** — consumers may use them in
+  automated decisions, so silently wrong output is the primary concern.
+- **Availability of the calling process** — a library must not crash or hang
+  its host on malformed input.
+- **Integrity of published artifacts** — the crates, wheels and npm packages
+  users install.
+- **The build and release pipeline** and its secrets (publishing tokens).
+
+## Actors / trust boundaries
+
+- **Library consumer** (trusted) — calls the API with numeric data. Data may
+  originate from untrusted sources (e.g. a market feed), so *input values* are
+  treated as untrusted even though the caller is trusted.
+- **Optional live feed** — with the `live-binance` feature, data crosses a
+  network boundary from an exchange over TLS.
+- **Contributors** (semi-trusted) — propose changes via pull requests.
+- **Supply chain** — upstream dependencies and the CI/CD platform.
+
+## Threats and mitigations
+
+| Threat | Mitigation |
+| --- | --- |
+| Memory-safety exploit (buffer overflow, UAF) via crafted input | Pure safe Rust; `unsafe` is forbidden/minimised, so the compiler precludes these classes. |
+| Misuse of the C ABI FFI boundary (invalid/dangling handle, undersized batch buffer) | The C ABI (`bindings/c`) is the sole `unsafe` surface. Its shim adds no logic, NULL-checks every handle (returning `NaN`/no-op), writes only into caller-sized buffers, and is built with `panic = "abort"` so a panic terminates the process deterministically instead of unwinding across the FFI boundary (which would be undefined behaviour). A caller passing a non-NULL but dangling pointer is undefined behaviour by C's own contract — out of scope, the same as any C library. |
+| Denial of service via malformed/degenerate input (NaN, infinities, extreme magnitudes) | Indicators reject non-finite inputs and validate parameters at construction; update paths are exercised by coverage-guided fuzzing and unit tests for edge cases. |
+| Silently incorrect results | 100% line coverage on the core crate; reference-value tests against known-good sources; streaming/batch parity tests. |
+| Integer overflow / panics | `clippy::pedantic` with `-D warnings`; debug assertions and overflow checks enabled in test/fuzz builds. |
+| Adversary-in-the-middle on the optional live feed | Connection uses TLS via the platform library; transport security is delegated to that reviewed implementation. |
+| Compromised dependency (supply chain) | Dependencies pinned (`Cargo.lock`, hash-locked CI requirements), monitored by Dependabot, audited by `cargo-deny` (advisories + licenses) on every change. |
+| Malicious or accidental change to `main` | Branch protection requires signed commits and blocks force-push and deletion; all changes flow through pull requests with required CI; static analysis (CodeQL, Clippy) and fuzzing run on every change. |
+| Compromised CI / leaked secrets | Workflows use least-privilege `permissions:`; secrets live only as encrypted GitHub Actions secrets; secret scanning with push protection is enabled; workflows are linted by `zizmor`. |
+| Tampered release artifact | Releases are built in CI, tags are signed, and assets carry build provenance attestations (verifiable with `gh attestation verify`). |
+
+## Out of scope
+
+- Wickra implements no authentication, authorization or cryptography of its own,
+  stores no user data, and exposes no network listener; those threat classes do
+  not apply.
+- Vulnerabilities in third-party dependencies that do not affect Wickra are
+  tracked as exploitability (VEX) records (see [`SECURITY.md`](SECURITY.md)).
+
+## Maintenance
+
+This threat model is reviewed when the architecture changes materially (for
+example, a new input family, a new network feature, or a new release channel).

bindings/c/Cargo.toml

@@ -0,0 +1,72 @@
+[package]
+name = "wickra-c"
+description = "C ABI (cdylib + staticlib) for the Wickra streaming-first technical indicators library — the hub every C-capable language (C, C++, Go, C#, Java, R) links against."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+readme = "README.md"
+keywords.workspace = true
+categories.workspace = true
+publish = false
+
+[lib]
+name = "wickra"
+crate-type = ["cdylib", "staticlib"]
+
+# The C ABI inherently needs `unsafe` (raw pointers across the FFI boundary,
+# `#[export_name]` symbol control). The workspace forbids `unsafe_code`, so this
+# crate cannot inherit `workspace = true`; it mirrors every workspace lint and
+# only relaxes `unsafe_code` to `allow` (parity with how the proc-macro bindings
+# emit their unsafe). The Rust core stays `unsafe`-forbidden — this is the one
+# crate where the boundary lives.
+[lints.rust]
+unsafe_code = "allow"
+missing_debug_implementations = "warn"
+unreachable_pub = "warn"
+unused_must_use = "deny"
+
+[lints.clippy]
+all = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+module_name_repetitions = "allow"
+must_use_candidate = "allow"
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+cast_precision_loss = "allow"
+cast_possible_truncation = "allow"
+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.
+#
+# `live-binance` is on by default too so the published C ABI ships the native
+# Binance kline feed (tokio + TLS WebSocket) — the six C-ABI languages with no
+# native WebSocket (C, C++, Go, R, plus Node/Python via their own bindings) get
+# it without a third-party client. The wasm build drops it via
+# --no-default-features (a browser has no raw TCP/TLS sockets; WASM users use the
+# host `WebSocket`), exactly like rayon.
+default = ["parallel", "live-binance"]
+parallel = ["wickra-core/parallel"]
+live-binance = ["wickra-data/live-binance", "dep:tokio"]
+
+[dependencies]
+# 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 }
+wickra-data = { path = "../../crates/wickra-data" }
+# Only pulled in by `live-binance`: a single-thread runtime drives the async
+# Binance feed behind the blocking C-ABI poll. The feed's own I/O features come
+# transitively from wickra-data; this just needs the runtime + timeout.
+tokio = { version = "1", features = ["rt", "net", "time"], optional = true }

bindings/c/README.md

@@ -0,0 +1,109 @@
+<p align="center">
+  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=514" alt="Wickra — streaming-first technical indicators" width="100%"></a>
+</p>
+
+[![CI](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/ci.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/codecov.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![GitHub release](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/release.svg)](https://github.com/wickra-lib/wickra/releases/latest)
+[![License: MIT OR Apache-2.0](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/license.svg)](https://github.com/wickra-lib/wickra#license)
+
+# Wickra — C / C++
+
+---
+
+> **▶ Live demo:** all 514 indicators over real Binance market data, computed live in your browser — **[live.wickra.org](https://live.wickra.org)** · zero backend, powered by `wickra-wasm`.
+
+**Streaming-first technical indicators for C and C++. A prebuilt shared/static
+library plus a generated `wickra.h` — no system dependencies.**
+
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js and WASM, plus a C ABI for C, C++, C#, Go, Java, R and any
+other C-capable language. Every indicator is an O(1)
+streaming state machine, so live trading bots and historical backtests share
+the exact same implementation. This package is the **C ABI hub**: it compiles the
+core to a C-compatible shared/static library plus a generated header, so any
+C-capable language (C, C++, C#, Go, Java, R) links against one artifact instead
+of re-wrapping every indicator natively.
+
+## Install
+
+Grab the prebuilt header + library for your platform from the
+[GitHub releases](https://github.com/wickra-lib/wickra/releases) — each archive
+has `wickra.h`, the optional `wickra.hpp` C++ wrapper, and the shared/static
+library — or build from source:
+
+```bash
+cargo build -p wickra-c --release
+# -> target/release/libwickra.{so,dylib} or wickra.dll (+ import lib) + a staticlib
+```
+
+Then compile against the header and link the library
+(`cc app.c -I include -L lib -lwickra -lm -o app`).
+
+## Quick start
+
+```c
+#include "wickra.h"
+
+struct Rsi *rsi = wickra_rsi_new(14);              /* NULL on invalid params */
+for (size_t i = 0; i < n; ++i) {
+    double v = wickra_rsi_update(rsi, prices[i]);  /* NaN during warmup       */
+    if (v == v && v > 70.0)                        /* v == v is the NaN check */
+        printf("overbought\n");
+}
+wickra_rsi_free(rsi);                              /* exactly once per _new   */
+```
+
+Every indicator is an opaque handle with the same five functions —
+`_new` / `_update` / `_batch` / `_reset` / `_free`. `update` is O(1); there is no
+RAII across the C boundary, so each `_new` needs exactly one `_free`, and every
+function is NULL-safe (a NULL handle yields `NaN` or a no-op, never a crash).
+Multi-output indicators (MACD, Bollinger, ADX, …) take a pointer to a `#[repr(C)]`
+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
+the main repository and documentation site:
+
+- **Repository & full indicator list:** <https://github.com/wickra-lib/wickra>
+- **Docs** (C quickstart, cookbook, TA-Lib migration): <https://docs.wickra.org/Quickstart-C>
+- **Runnable examples:** [`examples/c/`](https://github.com/wickra-lib/wickra/tree/main/examples/c)
+
+Wickra ships native bindings for Python, Node.js, WASM and Rust, plus this
+C ABI hub that any C-capable language (C, C++, C#, Go, Java, R) links against —
+all exposing the same indicators from the shared Rust core.
+
+## Security
+
+Found a security issue? **Please don't open a public issue.** Report it privately
+via the affected repository's *Security* tab (*"Report a vulnerability"*) or email
+**support@wickra.org** with a subject line starting `[wickra security]`. Full
+policy: <https://github.com/wickra-lib/wickra/blob/main/SECURITY.md>.
+
+## Disclaimer
+
+Wickra is an indicator toolkit, not a trading system. The values it computes
+are deterministic transforms of the input data — they are not financial advice
+and do not predict the market. Any use in a live trading context is at your own
+risk. The library is provided **as is**, without warranty of any kind.
+
+## License
+
+Licensed under either of [Apache-2.0](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.

bindings/c/benchmarks/CMakeLists.txt

@@ -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()

bindings/c/benchmarks/throughput.c

@@ -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;
+}

bindings/c/cbindgen.toml

@@ -0,0 +1,20 @@
+language = "C"
+header = "/* Wickra C ABI — generated by cbindgen. Do not edit by hand. */"
+include_guard = "WICKRA_H"
+pragma_once = true
+# Wrap the declarations in `extern "C"` under __cplusplus so the header is usable
+# from C++ (the optional wickra.hpp RAII layer and any C++ consumer).
+cpp_compat = true
+tab_width = 4
+# Off: cbindgen copies the Rust struct/fn doc comments verbatim, and some core
+# indicator docs contain markdown (e.g. `**1/8**/**7/8**`) whose `*/` would close
+# the C block comment early and break the header. Usage docs live in the crate
+# README and examples; the header is a pure declaration contract.
+documentation = false
+
+[parse]
+# Parse wickra-core too so the opaque indicator handle types (Sma, Ema, …) are
+# discovered and emitted as forward-declared opaque structs. Their fields are
+# never exposed — only `T *` handles cross the boundary.
+parse_deps = true
+include = ["wickra-core", "wickra-data"]

bindings/c/include/wickra.hpp

@@ -0,0 +1,66 @@
+// Optional C++ convenience layer over the Wickra C ABI (`wickra.h`).
+//
+// The C ABI hands out raw handles that must be released exactly once with the
+// matching `wickra_<ind>_free`. `wickra::Handle` wraps that in a move-only RAII
+// owner so the free happens automatically at scope exit:
+//
+//     #include "wickra.hpp"
+//
+//     wickra::Handle<Sma, wickra_sma_free> sma(wickra_sma_new(14));
+//     if (sma) {
+//         double v = wickra_sma_update(sma.get(), 42.0);  // NaN during warmup
+//     }
+//     // sma is freed here
+//
+// This is header-only and adds no runtime cost beyond the C calls themselves.
+
+#ifndef WICKRA_HPP
+#define WICKRA_HPP
+
+#include "wickra.h"
+
+#include <utility>
+
+namespace wickra {
+
+/// Move-only RAII owner of a Wickra handle. `T` is the opaque indicator type and
+/// `Free` its `wickra_<ind>_free` function.
+template <typename T, void (*Free)(T *)>
+class Handle {
+public:
+    explicit Handle(T *ptr) noexcept : ptr_(ptr) {}
+
+    ~Handle() {
+        if (ptr_ != nullptr) {
+            Free(ptr_);
+        }
+    }
+
+    Handle(const Handle &) = delete;
+    Handle &operator=(const Handle &) = delete;
+
+    Handle(Handle &&other) noexcept : ptr_(std::exchange(other.ptr_, nullptr)) {}
+
+    Handle &operator=(Handle &&other) noexcept {
+        if (this != &other) {
+            if (ptr_ != nullptr) {
+                Free(ptr_);
+            }
+            ptr_ = std::exchange(other.ptr_, nullptr);
+        }
+        return *this;
+    }
+
+    /// The raw handle, for passing to the `wickra_<ind>_*` functions.
+    T *get() const noexcept { return ptr_; }
+
+    /// True if the handle is non-null (construction succeeded).
+    explicit operator bool() const noexcept { return ptr_ != nullptr; }
+
+private:
+    T *ptr_;
+};
+
+}  // namespace wickra
+
+#endif  // WICKRA_HPP

bindings/csharp/.gitignore

@@ -0,0 +1,12 @@
+# .NET build output
+bin/
+obj/
+*.user
+
+# NuGet packaging output
+*.nupkg
+*.snupkg
+
+# Native libraries staged for packaging (produced by the release pipeline from
+# the wickra-c-<triple>.tar.gz assets; never committed to source).
+Wickra/runtimes/

bindings/csharp/README.md

@@ -0,0 +1,105 @@
+<p align="center">
+  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=514" alt="Wickra — streaming-first technical indicators" width="100%"></a>
+</p>
+
+[![CI](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/ci.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/codecov.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![NuGet](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/nuget.svg)](https://www.nuget.org/packages/Wickra)
+[![License: MIT OR Apache-2.0](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/license.svg)](https://github.com/wickra-lib/wickra#license)
+
+# Wickra — C#
+
+---
+
+> **▶ Live demo:** all 514 indicators over real Binance market data, computed live in your browser — **[live.wickra.org](https://live.wickra.org)** · zero backend, powered by `wickra-wasm`.
+
+**Streaming-first technical indicators for C#. `dotnet add package Wickra` —
+prebuilt native library, no system dependencies.**
+
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js and WASM, plus a C ABI for C, C++, C#, Go, Java, R and any
+other C-capable language. Every indicator is an O(1)
+streaming state machine, so live trading bots and historical backtests share
+the exact same implementation. This package is the C# binding; it consumes the
+C ABI hub through `[LibraryImport]` P/Invoke and exposes all 514 streaming-first
+indicators as idiomatic `IDisposable` classes.
+
+## Install
+
+```bash
+dotnet add package Wickra
+```
+
+The native library ships prebuilt per platform (Linux, macOS, Windows — x64 and
+arm64) under `runtimes/<rid>/native/`, selected automatically. There is nothing
+to compile. Targets .NET 8 and later.
+
+## Quick start
+
+```csharp
+using Wickra;
+
+// Batch: run an indicator over a whole series (NaN at warmup positions).
+var prices = Enumerable.Range(0, 1000).Select(i => 100.0 + i * 0.1).ToArray();
+using var sma = new Sma(20);
+double[] values = sma.Batch(prices);
+
+// Streaming: the same indicator, fed tick by tick in O(1).
+using var rsi = new Rsi(14);
+foreach (var price in liveFeed)
+{
+    var value = rsi.Update(price); // NaN during warmup, no recomputation
+    if (double.IsFinite(value) && value > 70)
+    {
+        Console.WriteLine("overbought");
+    }
+}
+```
+
+`Batch(prices)` and feeding the same prices through `Update()` produce identical
+values — the equivalence is enforced by the test suite. Multi-output indicators
+(MACD, Bollinger, ADX, …) return a 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
+the main repository and documentation site:
+
+- **Repository & full indicator list:** <https://github.com/wickra-lib/wickra>
+- **Docs** (quickstarts, cookbook, TA-Lib migration): <https://docs.wickra.org>
+- **Runnable examples:** [`examples/csharp/`](https://github.com/wickra-lib/wickra/tree/main/examples/csharp)
+
+Wickra ships native bindings for Python, Node.js, WASM and Rust, plus a
+C ABI hub that any C-capable language (C, C++, C#, Go, Java, R) links against —
+all exposing the same indicators from the shared, `unsafe`-forbidden Rust core.
+
+## Security
+
+Found a security issue? **Please don't open a public issue.** Report it privately
+via the affected repository's *Security* tab (*"Report a vulnerability"*) or email
+**support@wickra.org** with a subject line starting `[wickra security]`. Full
+policy: <https://github.com/wickra-lib/wickra/blob/main/SECURITY.md>.
+
+## Disclaimer
+
+Wickra is an indicator toolkit, not a trading system. The values it computes
+are deterministic transforms of the input data — they are not financial advice
+and do not predict the market. Any use in a live trading context is at your own
+risk. The library is provided **as is**, without warranty of any kind.
+
+## License
+
+Licensed under either of [Apache-2.0](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.

bindings/csharp/Wickra.Tests/ArchetypeTests.cs

@@ -0,0 +1,159 @@
+using Wickra;
+using Xunit;
+
+namespace Wickra.Tests;
+
+/// <summary>
+/// One representative per FFI archetype, exercising every marshalling path the
+/// generator produces (scalar, candle, pairwise, multi-output, bars, profile,
+/// values-profile, array-input). Garbage marshalling surfaces as NaN, wild
+/// values, or crashes — so finite/sane assertions are the real check.
+/// </summary>
+public class ArchetypeTests
+{
+    private static (double open, double high, double low, double close, double volume, long ts) Candle(int i)
+    {
+        var close = 100.0 + 10.0 * Math.Sin(i * 0.3);
+        var open = 100.0 + 10.0 * Math.Sin((i - 1) * 0.3);
+        var high = Math.Max(open, close) + 1.0;
+        var low = Math.Min(open, close) - 1.0;
+        return (open, high, low, close, 1_000.0, i * 60_000L);
+    }
+
+    [Fact]
+    public void Scalar_Ema_IsFiniteAfterWarmup()
+    {
+        using var ema = new Ema(3);
+        double last = double.NaN;
+        for (var i = 1; i <= 10; i++)
+        {
+            last = ema.Update(i);
+        }
+
+        Assert.True(double.IsFinite(last));
+        Assert.InRange(last, 1.0, 10.0);
+    }
+
+    [Fact]
+    public void Query_WarmupPeriodAndIsReady()
+    {
+        using var sma = new Sma(3);
+        Assert.Equal(3, sma.WarmupPeriod());
+        Assert.False(sma.IsReady());
+        sma.Update(1.0);
+        sma.Update(2.0);
+        Assert.False(sma.IsReady());
+        sma.Update(3.0);
+        Assert.True(sma.IsReady());
+        sma.Reset();
+        Assert.False(sma.IsReady());
+    }
+
+    [Fact]
+    public void Candle_Atr_IsFinitePositive()
+    {
+        using var atr = new Atr(3);
+        double last = double.NaN;
+        for (var i = 0; i < 20; i++)
+        {
+            var (o, h, l, c, v, ts) = Candle(i);
+            last = atr.Update(o, h, l, c, v, ts);
+        }
+
+        Assert.True(double.IsFinite(last));
+        Assert.True(last > 0.0);
+    }
+
+    [Fact]
+    public void Pairwise_Beta_IsFinite()
+    {
+        using var beta = new Beta(5);
+        double last = double.NaN;
+        for (var i = 0; i < 30; i++)
+        {
+            var market = 100.0 + 10.0 * Math.Sin(i * 0.5);
+            var asset = 50.0 + 6.0 * Math.Sin(i * 0.5 + 0.2);
+            last = beta.Update(market, asset);
+        }
+
+        Assert.True(double.IsFinite(last));
+    }
+
+    [Fact]
+    public void MultiOutput_Adx_ReturnsFiniteStruct()
+    {
+        using var adx = new Adx(5);
+        AdxOutput? result = null;
+        for (var i = 0; i < 60; i++)
+        {
+            var (o, h, l, c, v, ts) = Candle(i);
+            result = adx.Update(o, h, l, c, v, ts);
+        }
+
+        Assert.NotNull(result);
+        Assert.True(double.IsFinite(result!.Value.Adx));
+        Assert.True(double.IsFinite(result.Value.PlusDi));
+        Assert.True(double.IsFinite(result.Value.MinusDi));
+    }
+
+    [Fact]
+    public void Bars_DollarBars_EmitsBars()
+    {
+        using var bars = new DollarBars(5_000.0);
+        var total = 0;
+        for (var i = 0; i < 200; i++)
+        {
+            var (o, h, l, c, v, ts) = Candle(i);
+            total += bars.Update(o, h, l, c, v, ts).Length;
+        }
+
+        Assert.True(total > 0);
+    }
+
+    [Fact]
+    public void Profile_VolumeProfile_ReturnsValues()
+    {
+        using var profile = new VolumeProfile(20, 8);
+        VolumeProfileOutputScalars? result = null;
+        for (var i = 0; i < 60; i++)
+        {
+            var (o, h, l, c, v, ts) = Candle(i);
+            result = profile.Update(o, h, l, c, v, ts);
+        }
+
+        Assert.NotNull(result);
+        Assert.NotNull(result!.Value.Values);
+        Assert.True(result.Value.PriceLow <= result.Value.PriceHigh);
+    }
+
+    [Fact]
+    public void ProfileValues_DayOfWeekProfile_NoCrash()
+    {
+        using var profile = new DayOfWeekProfile(0);
+        double[]? result = null;
+        for (var i = 0; i < 60; i++)
+        {
+            var close = 100.0 + 5.0 * Math.Sin(i * 0.2);
+            // one day apart so the day-of-week buckets fill
+            result = profile.Update(close, close + 1, close - 1, close, 1_000.0, i * 86_400_000L);
+        }
+
+        if (result is not null)
+        {
+            Assert.All(result, v => Assert.True(double.IsFinite(v)));
+        }
+    }
+
+    [Fact]
+    public void ArrayInput_DepthSlope_IsFinite()
+    {
+        using var slope = new DepthSlope();
+        ReadOnlySpan<double> bidPrice = stackalloc double[] { 99.0, 98.0, 97.0 };
+        ReadOnlySpan<double> bidSize = stackalloc double[] { 10.0, 20.0, 30.0 };
+        ReadOnlySpan<double> askPrice = stackalloc double[] { 101.0, 102.0, 103.0 };
+        ReadOnlySpan<double> askSize = stackalloc double[] { 12.0, 22.0, 32.0 };
+
+        var result = slope.Update(bidPrice, bidSize, askPrice, askSize);
+        Assert.True(double.IsFinite(result));
+    }
+}

bindings/csharp/Wickra.Tests/BinanceFeedTests.cs

@@ -0,0 +1,53 @@
+using System;
+using Wickra;
+using Xunit;
+
+// The live Binance feed's connect → read → reconnect pipeline is covered
+// deterministically by the Rust mock-WS-server tests in wickra-data. Here we
+// only assert the binding's error paths, which need no network.
+public class BinanceFeedTests
+{
+    [Fact]
+    public void RejectsUnknownInterval()
+    {
+        Assert.Throws<ArgumentException>(() =>
+            new BinanceFeed("BTCUSDT", (BinanceInterval)99));
+    }
+
+    [Fact]
+    public void RejectsEmptySymbols()
+    {
+        Assert.Throws<ArgumentException>(() =>
+            new BinanceFeed("", BinanceInterval.OneMinute));
+    }
+
+    [Fact]
+    public void RejectsUnreachableEndpoint()
+    {
+        Assert.Throws<ArgumentException>(() =>
+            new BinanceFeed("BTCUSDT", BinanceInterval.OneMinute, "ws://127.0.0.1:1"));
+    }
+
+    // The REST fetcher's parse/HTTP success path is covered by the Rust
+    // mock-HTTP-server tests; here we only assert the binding's error paths.
+    [Fact]
+    public void FetchKlinesRejectsUnknownInterval()
+    {
+        Assert.Throws<ArgumentException>(() =>
+            BinanceFeed.FetchKlines("BTCUSDT", (BinanceInterval)99, 1));
+    }
+
+    [Fact]
+    public void FetchKlinesRejectsZeroLimit()
+    {
+        Assert.Throws<ArgumentException>(() =>
+            BinanceFeed.FetchKlines("BTCUSDT", BinanceInterval.OneHour, 0));
+    }
+
+    [Fact]
+    public void FetchKlinesSurfacesUnreachableEndpoint()
+    {
+        Assert.Throws<ArgumentException>(() =>
+            BinanceFeed.FetchKlines("BTCUSDT", BinanceInterval.OneHour, 1, baseUrl: "http://127.0.0.1:1"));
+    }
+}

bindings/csharp/Wickra.Tests/DataLayerTests.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using Wickra;
+using Xunit;
+
+// Cross-language data-layer parity: replay the shared golden tick stream through
+// the TickAggregator and check the candles against the Rust reference, with and
+// without gap filling.
+public class DataLayerTests
+{
+    private static string GoldenDir([System.Runtime.CompilerServices.CallerFilePath] string file = "") =>
+        Path.GetFullPath(Path.Combine(Path.GetDirectoryName(file)!, "..", "..", "..", "testdata", "golden"));
+
+    private static double[][] Read(string name)
+    {
+        var lines = File.ReadAllLines(Path.Combine(GoldenDir(), name + ".csv"));
+        var rows = new List<double[]>();
+        for (var i = 1; i < lines.Length; i++)
+        {
+            if (lines[i].Length == 0)
+            {
+                continue;
+            }
+            rows.Add(Array.ConvertAll(lines[i].Split(','), s => double.Parse(s, CultureInfo.InvariantCulture)));
+        }
+        return rows.ToArray();
+    }
+
+    [Fact]
+    public void ResamplerMatchesGolden()
+    {
+        var input = Read("input"); // open,high,low,close,volume (timestamp = row index)
+        using var r = new Resampler(5);
+        var got = new List<double[]>();
+        for (var i = 0; i < input.Length; i++)
+        {
+            var c = r.Update(input[i][0], input[i][1], input[i][2], input[i][3], input[i][4], i);
+            if (c.HasValue)
+            {
+                got.Add(new[] { c.Value.Open, c.Value.High, c.Value.Low, c.Value.Close, c.Value.Volume, (double)c.Value.Timestamp });
+            }
+        }
+        var f = r.Flush();
+        if (f.HasValue)
+        {
+            got.Add(new[] { f.Value.Open, f.Value.High, f.Value.Low, f.Value.Close, f.Value.Volume, (double)f.Value.Timestamp });
+        }
+        var want = Read("data_resampled");
+        Assert.Equal(want.Length, got.Count);
+        for (var i = 0; i < got.Count; i++)
+        {
+            for (var j = 0; j < 6; j++)
+            {
+                var tol = 1e-9 * Math.Max(1, Math.Abs(want[i][j]));
+                Assert.True(Math.Abs(got[i][j] - want[i][j]) <= tol, $"resample row {i} col {j}: {got[i][j]} vs {want[i][j]}");
+            }
+        }
+    }
+
+    [Fact]
+    public void CandleReaderMatchesGolden()
+    {
+        var csv = File.ReadAllText(Path.Combine(GoldenDir(), "data_csv.csv"));
+        using var reader = new CandleReader(csv);
+        var candles = reader.Read();
+        var want = Read("data_csv_candles");
+        Assert.Equal(want.Length, candles.Length);
+        for (var i = 0; i < candles.Length; i++)
+        {
+            var c = candles[i];
+            var got = new[] { c.Open, c.High, c.Low, c.Close, c.Volume, (double)c.Timestamp };
+            for (var j = 0; j < 6; j++)
+            {
+                var tol = 1e-9 * Math.Max(1, Math.Abs(want[i][j]));
+                Assert.True(Math.Abs(got[j] - want[i][j]) <= tol, $"candle reader row {i} col {j}: {got[j]} vs {want[i][j]}");
+            }
+        }
+    }
+
+    [Theory]
+    [InlineData(false, "data_candles")]
+    [InlineData(true, "data_candles_gap")]
+    public void TickAggregatorMatchesGolden(bool gapFill, string fixture)
+    {
+        var ticks = Read("data_ticks");
+        using var agg = new TickAggregator(1000, gapFill);
+        var got = new List<double[]>();
+        foreach (var t in ticks)
+        {
+            foreach (var c in agg.Push(t[0], t[1], (long)t[2]))
+            {
+                got.Add(new[] { c.Open, c.High, c.Low, c.Close, c.Volume, (double)c.Timestamp });
+            }
+        }
+        var want = Read(fixture);
+        Assert.Equal(want.Length, got.Count);
+        for (var i = 0; i < got.Count; i++)
+        {
+            for (var j = 0; j < 6; j++)
+            {
+                var tol = 1e-9 * Math.Max(1, Math.Abs(want[i][j]));
+                Assert.True(
+                    Math.Abs(got[i][j] - want[i][j]) <= tol,
+                    $"{fixture} row {i} col {j}: {got[i][j]} vs {want[i][j]}");
+            }
+        }
+    }
+}

bindings/csharp/Wickra.Tests/GoldenTests.cs

@@ -0,0 +1,216 @@
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using Wickra;
+using Xunit;
+
+namespace Wickra.Tests;
+
+/// <summary>
+/// Golden-fixture parity: replay the shared <c>testdata/golden</c> input series
+/// through the C# FFI and assert every value matches the Rust reference output.
+/// Where the archetype tests only check finiteness, this pins exact values, so a
+/// wiring bug (swapped parameter, wrong multi-output field) is caught.
+/// Fixtures are generated by <c>cargo run -p wickra-examples --bin gen_golden</c>.
+/// </summary>
+public class GoldenTests
+{
+    private const double Tol = 1e-6;
+
+    private static string GoldenDir([CallerFilePath] string file = "") =>
+        Path.GetFullPath(Path.Combine(Path.GetDirectoryName(file)!, "..", "..", "..", "testdata", "golden"));
+
+    private static List<string[]> ReadCsv(string name)
+    {
+        var path = Path.Combine(GoldenDir(), name + ".csv");
+        return File.ReadAllLines(path)
+            .Skip(1) // header
+            .Where(l => l.Length > 0)
+            .Select(l => l.Split(','))
+            .ToList();
+    }
+
+    private static double[][] Input()
+    {
+        return ReadCsv("input")
+            .Select(r => r.Select(c => double.Parse(c, CultureInfo.InvariantCulture)).ToArray())
+            .ToArray();
+    }
+
+    private static double Cell(string s) =>
+        s == "nan" ? double.NaN : double.Parse(s, CultureInfo.InvariantCulture);
+
+    private static void AssertClose(double got, double want, int row, string field)
+    {
+        if (double.IsNaN(want))
+        {
+            Assert.True(double.IsNaN(got), $"row {row} {field}: expected warmup/NaN, got {got}");
+            return;
+        }
+        var tol = Tol * Math.Max(1.0, Math.Abs(want));
+        Assert.True(Math.Abs(got - want) <= tol, $"row {row} {field}: got {got}, want {want}");
+    }
+
+    // --- scalar (close-driven) ------------------------------------------------
+
+    [Theory]
+    [InlineData("sma")]
+    [InlineData("ema")]
+    [InlineData("rsi")]
+    public void Scalar_MatchesGolden(string name)
+    {
+        var input = Input();
+        var expected = ReadCsv(name);
+        using var ind = (IDisposable)(name switch
+        {
+            "sma" => new Sma(14),
+            "ema" => new Ema(14),
+            "rsi" => new Rsi(14),
+            _ => throw new ArgumentOutOfRangeException(nameof(name)),
+        });
+        for (var i = 0; i < input.Length; i++)
+        {
+            var close = input[i][3];
+            double got = ind switch
+            {
+                Sma s => s.Update(close),
+                Ema e => e.Update(close),
+                Rsi r => r.Update(close),
+                _ => double.NaN,
+            };
+            AssertClose(got, Cell(expected[i][0]), i, name);
+        }
+    }
+
+    // --- candle, single output ------------------------------------------------
+
+    [Fact]
+    public void Candle_Atr_MatchesGolden()
+    {
+        var input = Input();
+        var expected = ReadCsv("atr");
+        using var atr = new Atr(14);
+        for (var i = 0; i < input.Length; i++)
+        {
+            var (o, h, l, c, v) = (input[i][0], input[i][1], input[i][2], input[i][3], input[i][4]);
+            AssertClose(atr.Update(o, h, l, c, v, i), Cell(expected[i][0]), i, "atr");
+        }
+    }
+
+    // --- pairwise -------------------------------------------------------------
+
+    [Fact]
+    public void Pairwise_Beta_MatchesGolden()
+    {
+        var input = Input();
+        var expected = ReadCsv("beta");
+        using var beta = new Beta(20);
+        for (var i = 0; i < input.Length; i++)
+        {
+            // generator fed (close, open)
+            AssertClose(beta.Update(input[i][3], input[i][0]), Cell(expected[i][0]), i, "beta");
+        }
+    }
+
+    // --- scalar multi-output: MACD -------------------------------------------
+
+    [Fact]
+    public void MultiOutput_Macd_MatchesGolden()
+    {
+        var input = Input();
+        var expected = ReadCsv("macd");
+        using var macd = new MacdIndicator(12, 26, 9);
+        for (var i = 0; i < input.Length; i++)
+        {
+            MacdOutput? got = macd.Update(input[i][3]);
+            var e = expected[i];
+            if (e[0] == "nan")
+            {
+                Assert.Null(got);
+                continue;
+            }
+            Assert.NotNull(got);
+            AssertClose(got!.Value.Macd, Cell(e[0]), i, "macd.macd");
+            AssertClose(got.Value.Signal, Cell(e[1]), i, "macd.signal");
+            AssertClose(got.Value.Histogram, Cell(e[2]), i, "macd.histogram");
+        }
+    }
+
+    // --- candle multi-output: ADX --------------------------------------------
+
+    [Fact]
+    public void MultiOutput_Adx_MatchesGolden()
+    {
+        var input = Input();
+        var expected = ReadCsv("adx");
+        using var adx = new Adx(14);
+        for (var i = 0; i < input.Length; i++)
+        {
+            var (o, h, l, c, v) = (input[i][0], input[i][1], input[i][2], input[i][3], input[i][4]);
+            AdxOutput? got = adx.Update(o, h, l, c, v, i);
+            var e = expected[i];
+            if (e[0] == "nan")
+            {
+                Assert.Null(got);
+                continue;
+            }
+            Assert.NotNull(got);
+            AssertClose(got!.Value.PlusDi, Cell(e[0]), i, "adx.plus_di");
+            AssertClose(got.Value.MinusDi, Cell(e[1]), i, "adx.minus_di");
+            AssertClose(got.Value.Adx, Cell(e[2]), i, "adx.adx");
+        }
+    }
+
+    // --- the four de-duplicated indicators ------------------------------------
+
+    [Fact]
+    public void Candle_AdOscillator_MatchesGolden()
+    {
+        var input = Input();
+        var expected = ReadCsv("ad_oscillator");
+        using var ad = new AdOscillator();
+        for (var i = 0; i < input.Length; i++)
+        {
+            var (o, h, l, c, v) = (input[i][0], input[i][1], input[i][2], input[i][3], input[i][4]);
+            AssertClose(ad.Update(o, h, l, c, v, i), Cell(expected[i][0]), i, "ad_oscillator");
+        }
+    }
+
+    [Fact]
+    public void Candle_IntradayIntensity_MatchesGolden()
+    {
+        var input = Input();
+        var expected = ReadCsv("intraday_intensity");
+        using var ii = new IntradayIntensity();
+        for (var i = 0; i < input.Length; i++)
+        {
+            var (o, h, l, c, v) = (input[i][0], input[i][1], input[i][2], input[i][3], input[i][4]);
+            AssertClose(ii.Update(o, h, l, c, v, i), Cell(expected[i][0]), i, "intraday_intensity");
+        }
+    }
+
+    [Fact]
+    public void Candle_AwesomeOscillatorHistogram_MatchesGolden()
+    {
+        var input = Input();
+        var expected = ReadCsv("awesome_oscillator_histogram");
+        using var aoh = new AwesomeOscillatorHistogram(5, 34, 1);
+        for (var i = 0; i < input.Length; i++)
+        {
+            var (o, h, l, c, v) = (input[i][0], input[i][1], input[i][2], input[i][3], input[i][4]);
+            AssertClose(aoh.Update(o, h, l, c, v, i), Cell(expected[i][0]), i, "awesome_oscillator_histogram");
+        }
+    }
+
+    [Fact]
+    public void Scalar_AverageDrawdown_MatchesGolden()
+    {
+        var input = Input();
+        var expected = ReadCsv("average_drawdown");
+        using var avg = new AverageDrawdown(20);
+        for (var i = 0; i < input.Length; i++)
+        {
+            // generator fed the close column as the equity-curve sample.
+            AssertClose(avg.Update(input[i][3]), Cell(expected[i][0]), i, "average_drawdown");
+        }
+    }
+}

bindings/csharp/Wickra.Tests/SmaTests.cs

@@ -0,0 +1,51 @@
+using Wickra;
+using Xunit;
+
+namespace Wickra.Tests;
+
+public class SmaTests
+{
+    [Fact]
+    public void StreamingMatchesReference()
+    {
+        using var sma = new Sma(3);
+        Assert.True(double.IsNaN(sma.Update(1)));
+        Assert.True(double.IsNaN(sma.Update(2)));
+        Assert.Equal(2.0, sma.Update(3), 9);
+        Assert.Equal(3.0, sma.Update(4), 9);
+        Assert.Equal(4.0, sma.Update(5), 9);
+    }
+
+    [Fact]
+    public void BatchMatchesStreaming()
+    {
+        using var sma = new Sma(3);
+        var output = sma.Batch(new double[] { 1, 2, 3, 4, 5 });
+
+        Assert.True(double.IsNaN(output[0]));
+        Assert.True(double.IsNaN(output[1]));
+        Assert.Equal(2.0, output[2], 9);
+        Assert.Equal(3.0, output[3], 9);
+        Assert.Equal(4.0, output[4], 9);
+    }
+
+    [Fact]
+    public void ResetClearsState()
+    {
+        using var sma = new Sma(3);
+        sma.Update(1);
+        sma.Update(2);
+        sma.Update(3);
+        sma.Reset();
+        Assert.True(double.IsNaN(sma.Update(10)));
+    }
+
+    [Fact]
+    public void ZeroPeriodThrows()
+    {
+        // Zero is rejected by the native constructor (returns NULL) -> ArgumentException;
+        // a negative period is caught earlier by the wrapper guard.
+        Assert.Throws<ArgumentException>(() => new Sma(0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Sma(-1));
+    }
+}

bindings/csharp/Wickra.Tests/Wickra.Tests.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.6.0" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Wickra\Wickra.csproj" />
+  </ItemGroup>
+
+</Project>

bindings/csharp/Wickra/Wickra.csproj

@@ -0,0 +1,59 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <RootNamespace>Wickra</RootNamespace>
+    <AssemblyName>Wickra</AssemblyName>
+
+    <!-- NuGet package metadata -->
+    <PackageId>Wickra</PackageId>
+    <Version>0.9.9</Version>
+    <Authors>kingchenc</Authors>
+    <Description>High-performance streaming technical-analysis indicators (514 indicators) for .NET, backed by the native Rust core via the Wickra C ABI.</Description>
+    <PackageLicenseExpression>MIT OR Apache-2.0</PackageLicenseExpression>
+    <PackageProjectUrl>https://github.com/wickra-lib/wickra</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/wickra-lib/wickra</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <PackageTags>technical-analysis;indicators;trading;finance;streaming;ffi;native</PackageTags>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageIcon>icon.png</PackageIcon>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <!-- A managed package carrying per-RID native assets; not built per-RID itself. -->
+    <IncludeBuildOutput>true</IncludeBuildOutput>
+    <!-- NU5128: managed package carrying only per-RID native assets.
+         CS1591: generated members are self-descriptive; hand-written API is documented. -->
+    <NoWarn>$(NoWarn);NU5128;CS1591</NoWarn>
+  </PropertyGroup>
+
+  <!--
+    Supported native runtime identifiers. The release pipeline builds the C ABI
+    per target triple and stages the libraries under
+    Wickra/runtimes/<rid>/native/ before `dotnet pack`:
+      win-x64   win-arm64   linux-x64   linux-arm64   osx-x64   osx-arm64
+  -->
+  <PropertyGroup>
+    <WickraRuntimeIdentifiers>win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</WickraRuntimeIdentifiers>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\README.md" Pack="true" PackagePath="\" />
+    <None Include="..\icon.png" Pack="true" PackagePath="\" />
+  </ItemGroup>
+
+  <!--
+    Native libraries are packed under runtimes/<rid>/native/ by the release pipeline,
+    which unpacks the wickra-c-<triple>.tar.gz assets into the matching RID folders.
+    For local development and tests the natives are resolved from the cargo target dir
+    via WickraNative's DllImportResolver.
+  -->
+  <ItemGroup>
+    <None Include="runtimes/**/native/*" Pack="true" PackagePath="runtimes" Condition="Exists('runtimes')" />
+  </ItemGroup>
+
+</Project>

bindings/csharp/Wickra/WickraHandle.cs

@@ -0,0 +1,26 @@
+using Microsoft.Win32.SafeHandles;
+
+namespace Wickra;
+
+/// <summary>
+/// Owns an opaque native indicator handle and releases it via the indicator's
+/// <c>_free</c> function. One generic handle type backs every indicator; the
+/// correct free routine is captured at construction time.
+/// </summary>
+internal sealed class WickraHandle : SafeHandleZeroOrMinusOneIsInvalid
+{
+    private readonly Action<nint> _free;
+
+    internal WickraHandle(nint handle, Action<nint> free)
+        : base(ownsHandle: true)
+    {
+        _free = free;
+        SetHandle(handle);
+    }
+
+    protected override bool ReleaseHandle()
+    {
+        _free(handle);
+        return true;
+    }
+}

bindings/csharp/Wickra/WickraNative.cs

@@ -0,0 +1,94 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Wickra;
+
+/// <summary>
+/// Native library resolution for the Wickra C ABI.
+/// </summary>
+/// <remarks>
+/// When consumed as a NuGet package the native library ships under
+/// <c>runtimes/&lt;rid&gt;/native/</c> and the default runtime resolver finds it
+/// automatically. For local development (project reference against a cargo build)
+/// the resolver additionally walks up the directory tree to locate
+/// <c>target/release</c> or <c>target/debug</c>. Every candidate is validated to
+/// actually export the Wickra ABI before it is accepted, so an unrelated library
+/// of the same name cannot shadow the real one.
+/// </remarks>
+internal static class WickraNative
+{
+    /// <summary>The library name passed to <c>[LibraryImport]</c>.</summary>
+    internal const string LibraryName = "wickra";
+
+    // Any exported symbol works as a fingerprint; sma_new exists in every build.
+    private const string SentinelSymbol = "wickra_sma_new";
+
+    // CA2255 warns against [ModuleInitializer] in libraries, but registering the
+    // native-library resolver before any P/Invoke runs is exactly the advanced
+    // scenario the attribute exists for: a static constructor would run too late
+    // (only on first access to this type), letting the default resolver fail first.
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Usage", "CA2255:The 'ModuleInitializer' attribute should not be used in libraries",
+        Justification = "The DllImport resolver must be registered before the first P/Invoke; a static constructor would run too late.")]
+    [ModuleInitializer]
+    internal static void Register()
+    {
+        NativeLibrary.SetDllImportResolver(typeof(WickraNative).Assembly, Resolve);
+    }
+
+    private static nint Resolve(string libraryName, System.Reflection.Assembly assembly, DllImportSearchPath? searchPath)
+    {
+        if (libraryName != LibraryName)
+        {
+            return nint.Zero;
+        }
+
+        // 1. Default resolution (NuGet runtimes/ layout, app-local copies). Accept
+        //    only if it is genuinely the Wickra ABI; otherwise discard and fall through.
+        if (NativeLibrary.TryLoad(libraryName, assembly, searchPath, out var handle))
+        {
+            if (Exports(handle))
+            {
+                return handle;
+            }
+
+            NativeLibrary.Free(handle);
+        }
+
+        // 2. Development fallback: locate the cargo build output.
+        var fileName = NativeFileName();
+        var dir = AppContext.BaseDirectory;
+        for (var i = 0; i < 16 && dir is not null; i++)
+        {
+            foreach (var profile in new[] { "release", "debug" })
+            {
+                var candidate = Path.Combine(dir, "target", profile, fileName);
+                if (File.Exists(candidate) && NativeLibrary.TryLoad(candidate, out var devHandle))
+                {
+                    if (Exports(devHandle))
+                    {
+                        return devHandle;
+                    }
+
+                    NativeLibrary.Free(devHandle);
+                }
+            }
+
+            dir = Path.GetDirectoryName(dir.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
+        }
+
+        return nint.Zero;
+    }
+
+    private static bool Exports(nint handle) => NativeLibrary.TryGetExport(handle, SentinelSymbol, out _);
+
+    private static string NativeFileName()
+    {
+        if (OperatingSystem.IsWindows())
+        {
+            return "wickra.dll";
+        }
+
+        return OperatingSystem.IsMacOS() ? "libwickra.dylib" : "libwickra.so";
+    }
+}

bindings/csharp/benchmarks/Benchmarks.csproj

@@ -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>

bindings/csharp/benchmarks/Program.cs

@@ -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.");

bindings/csharp/gen_golden_test.py

@@ -0,0 +1,304 @@
+"""Generate Wickra.Tests/GoldenAllTests.g.cs: a value-parity test that replays
+the shared golden input through every one of the 514 C# indicators and checks
+output bit-for-bit against the Rust reference fixtures g_<Canonical>.csv.
+
+Run from repo root:  python bindings/csharp/gen_golden_test.py
+"""
+import glob
+import json
+import os
+import re
+
+ROOT = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+G = os.path.join(ROOT, "testdata", "golden")
+GEN = open(os.path.join(ROOT, "bindings", "csharp", "Wickra", "Generated", "Indicators.g.cs"), encoding="utf-8").read()
+
+# Canonical core Indicator::name() per indicator, shared across every binding.
+NAMES = json.load(open(os.path.join(G, "names.json")))
+
+# C# constructor parameter types per class.
+ctor_types = {}
+cur = None
+for line in GEN.splitlines():
+    m = re.match(r"public sealed class (\w+)", line)
+    if m:
+        cur = m.group(1)
+        continue
+    if cur:
+        cm = re.match(r"\s*public %s\(([^)]*)\)" % re.escape(cur), line)
+        if cm:
+            ps = cm.group(1).strip()
+            types = [p.strip().rsplit(" ", 1)[0].strip() for p in ps.split(",")] if ps else []
+            ctor_types[cur] = types
+            cur = None
+
+# Unified archetype + params, keyed by canonical (== C# class name).
+spec = {}
+for e in json.load(open(os.path.join(G, "scalar_manifest.json"))):
+    arch = {"f64": "scalar_f64", "Candle": "scalar_candle", "(f64, f64)": "pairwise"}[e["input"]]
+    spec[e["canonical"]] = {"arch": arch, "params": e["params"]}
+for e in json.load(open(os.path.join(G, "multi_manifest.json"))):
+    arch = {"f64": "multi_f64", "Candle": "multi_candle", "(f64, f64)": "multi_pairwise"}[e["input"]]
+    spec[e["canonical"]] = {"arch": arch, "params": e["params"], "n": e["n"]}
+ex = json.load(open(os.path.join(G, "exotic_manifest.json")))
+for e in ex["deriv"]:
+    spec[e["canonical"]] = {"arch": "deriv_multi" if "n" in e else "deriv", "params": e["params"], "n": e.get("n")}
+for e in ex["cross"]:
+    spec[e["canonical"]] = {"arch": "cross", "params": e["params"]}
+for e in ex["trade"]:
+    spec[e["canonical"]] = {"arch": "trade", "params": e["params"]}
+for e in ex["trademid"]:
+    spec[e["canonical"]] = {"arch": "trademid", "params": e["params"]}
+for e in ex["ob"]:
+    spec[e["canonical"]] = {"arch": "ob", "params": e["params"]}
+for e in json.load(open(os.path.join(G, "profile_manifest.json"))):
+    spec[e["canonical"]] = {"arch": "profile_" + e["kind"], "params": e["params"], "width": e["width"]}
+for e in json.load(open(os.path.join(G, "bars_manifest.json"))):
+    arch = "footprint" if e["canonical"] == "Footprint" else "bars_" + e["feed"]
+    spec[e["canonical"]] = {"arch": arch, "params": e["params"]}
+
+canons = sorted(os.path.basename(f)[2:-4] for f in glob.glob(os.path.join(G, "g_*.csv")))
+
+
+def lit(value, cstype):
+    if cstype == "int":
+        return str(int(round(value)))
+    if cstype == "uint":
+        return f"{int(round(value))}u"
+    if cstype == "byte":
+        return f"(byte){int(round(value))}"
+    f = float(value)
+    s = repr(f)
+    return s if ("." in s or "e" in s or "E" in s) else s + ".0"
+
+
+def ctor_call(canon):
+    types = ctor_types.get(canon, [])
+    vals = spec[canon]["params"]
+    args = ", ".join(lit(v, t) for v, t in zip(vals, types))
+    return f"new Wickra.{canon}({args})"
+
+
+def block(canon):
+    s = spec[canon]
+    a = s["arch"]
+    L = [f"    [Fact]", f"    public void Golden_{canon}()", "    {"]
+    L.append(f"        using var ind = {ctor_call(canon)};")
+    L.append(f"        Assert.Equal({json.dumps(NAMES[canon])}, ind.Name());")
+    L.append("        var got = new List<double[]>();")
+    L.append("        for (var i = 0; i < Rows.Length; i++)")
+    L.append("        {")
+    L.append("            var r = Rows[i];")
+    if a == "scalar_f64":
+        L.append("            got.Add(new[] { ind.Update(r[3]) });")
+    elif a == "pairwise":
+        L.append("            got.Add(new[] { ind.Update(r[3], r[0]) });")
+    elif a == "scalar_candle":
+        L.append("            got.Add(new[] { ind.Update(r[0], r[1], r[2], r[3], r[4], i) });")
+    elif a == "trade":
+        L.append("            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i) });")
+    elif a == "trademid":
+        L.append("            got.Add(new[] { ind.Update(r[3], r[4], r[3] >= r[0], i, (r[1] + r[2]) / 2) });")
+    elif a == "ob":
+        L.append("            var (bp, bs, ap, asz) = ObLists(r);")
+        L.append("            got.Add(new[] { ind.Update(bp, bs, ap, asz) });")
+    elif a == "deriv":
+        L.append("            var d = DerivFields(r);")
+        L.append("            got.Add(new[] { ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i) });")
+    elif a == "deriv_multi":
+        L.append("            var d = DerivFields(r);")
+        L.append("            got.Add(FlattenNullable(ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], i), %d));" % s["n"])
+    elif a == "cross":
+        L.append("            var (ch, vo, nh, nl, am, ob) = CrossLists(r);")
+        L.append("            got.Add(new[] { ind.Update(ch, vo, nh, nl, am, ob, i) });")
+    elif a == "multi_f64":
+        L.append("            got.Add(FlattenNullable(ind.Update(r[3]), %d));" % s["n"])
+    elif a == "multi_pairwise":
+        L.append("            got.Add(FlattenNullable(ind.Update(r[3], r[0]), %d));" % s["n"])
+    elif a == "multi_candle":
+        L.append("            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), %d));" % s["n"])
+    elif a == "profile_bins":
+        L.append("            var bins = ind.Update(r[0], r[1], r[2], r[3], r[4], i);")
+        L.append("            got.Add(bins ?? NanRow(%d));" % s["width"])
+    elif a == "profile_pricebins":
+        L.append("            got.Add(FlattenNullable(ind.Update(r[0], r[1], r[2], r[3], r[4], i), %d));" % s["width"])
+    elif a == "bars_close":
+        L.append("            got.Add(FlattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0)));")
+    elif a == "bars_candle4":
+        L.append("            got.Add(FlattenBars(ind.Update(r[0], r[1], r[2], r[3], 1.0, 0)));")
+    elif a == "bars_candle5":
+        L.append("            got.Add(FlattenBars(ind.Update(r[0], r[1], r[2], r[3], r[4], 0)));")
+    elif a == "footprint":
+        L.append("            got.Add(FlattenBars(ind.Update(r[3], r[4], r[3] >= r[0], i)));")
+    else:
+        raise SystemExit("arch " + a)
+    L.append("        }")
+    L.append(f'        Compare("{canon}", got);')
+    L.append("    }")
+    return "\n".join(L)
+
+
+HEADER = '''// <auto-generated>
+// Generated by gen_golden_test.py. DO NOT EDIT.
+//
+// Value-parity for every one of the 514 C# indicators: the shared golden input
+// is replayed through each one and checked bit-for-bit against the Rust
+// reference fixtures testdata/golden/g_<Canonical>.csv. Multi-output, profile
+// and bar shapes are flattened by reflection so one comparator covers all
+// archetypes. Regenerate with: python bindings/csharp/gen_golden_test.py
+// </auto-generated>
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using Xunit;
+
+namespace Wickra.Tests;
+
+public class GoldenAllTests
+{
+    private const double Tol = 1e-6;
+
+    private static readonly double[][] Rows = LoadInput();
+
+    private static string GoldenDir([System.Runtime.CompilerServices.CallerFilePath] string file = "") =>
+        Path.GetFullPath(Path.Combine(Path.GetDirectoryName(file)!, "..", "..", "..", "testdata", "golden"));
+
+    private static double Cell(string s) =>
+        s == "nan" ? double.NaN
+        : s == "inf" ? double.PositiveInfinity
+        : s == "-inf" ? double.NegativeInfinity
+        : double.Parse(s, CultureInfo.InvariantCulture);
+
+    private static double[][] LoadInput()
+    {
+        var lines = File.ReadAllLines(Path.Combine(GoldenDir(), "input.csv"));
+        return lines.Skip(1).Where(l => l.Length > 0)
+            .Select(l => l.Split(',').Select(x => double.Parse(x, CultureInfo.InvariantCulture)).ToArray())
+            .ToArray();
+    }
+
+    // Keep blank lines (a candle on which no bar closed) so rows stay aligned.
+    private static double[]?[] ReadFixture(string name)
+    {
+        var lines = File.ReadAllLines(Path.Combine(GoldenDir(), "g_" + name + ".csv"));
+        return lines.Skip(1).Select(l => l.Length == 0 ? Array.Empty<double>() : l.Split(',').Select(Cell).ToArray()).ToArray();
+    }
+
+    private static double[] NanRow(int n)
+    {
+        var r = new double[n];
+        for (var i = 0; i < n; i++) r[i] = double.NaN;
+        return r;
+    }
+
+    private static double[] FlattenStruct(object o)
+    {
+        var props = o.GetType()
+            .GetProperties(BindingFlags.Public | BindingFlags.Instance)
+            .OrderBy(p => p.MetadataToken);
+        var list = new List<double>();
+        foreach (var p in props)
+        {
+            var v = p.GetValue(o);
+            switch (v)
+            {
+                case double d: list.Add(d); break;
+                case float f: list.Add(f); break;
+                case long l: list.Add(l); break;
+                case int n: list.Add(n); break;
+                case double[] arr: list.AddRange(arr); break;
+            }
+        }
+        return list.ToArray();
+    }
+
+    private static double[] FlattenNullable<T>(T? value, int width) where T : struct =>
+        value.HasValue ? FlattenStruct(value.Value) : NanRow(width);
+
+    private static double[] FlattenBars<T>(T[] bars)
+    {
+        var list = new List<double>();
+        foreach (var bar in bars) list.AddRange(FlattenStruct(bar!));
+        return list.ToArray();
+    }
+
+    private static double[] DerivFields(double[] r)
+    {
+        double o = r[0], h = r[1], l = r[2], c = r[3], v = r[4];
+        return new[]
+        {
+            (c - o) / c * 0.01, c, c - 0.5, c + 1.0, v * 10.0, v * 0.6, v * 0.4,
+            v * 0.55, v * 0.45, h - c, c - l,
+        };
+    }
+
+    private static (double[], double[], bool[], bool[], bool[], bool[]) CrossLists(double[] r)
+    {
+        double o = r[0], c = r[3], v = r[4];
+        var change = new double[5];
+        var volume = new double[5];
+        var nh = new bool[5];
+        var nl = new bool[5];
+        var am = new bool[5];
+        var ob = new bool[5];
+        for (var j = 0; j < 5; j++)
+        {
+            change[j] = (c - o) + j;
+            volume[j] = v + j * 10.0;
+            nh[j] = j % 2 == 0;
+            nl[j] = j % 3 == 0;
+            am[j] = j % 2 == 0;
+            ob[j] = j % 3 == 0;
+        }
+        return (change, volume, nh, nl, am, ob);
+    }
+
+    private static (double[], double[], double[], double[]) ObLists(double[] r)
+    {
+        double c = r[3], v = r[4];
+        var bp = new double[5];
+        var bs = new double[5];
+        var ap = new double[5];
+        var asz = new double[5];
+        for (var k = 0; k < 5; k++)
+        {
+            var kf = k + 1;
+            bp[k] = c - 0.1 * kf;
+            bs[k] = v / kf;
+            ap[k] = c + 0.1 * kf;
+            asz[k] = v * 0.9 / kf;
+        }
+        return (bp, bs, ap, asz);
+    }
+
+    private static void Compare(string name, List<double[]> got)
+    {
+        var exp = ReadFixture(name);
+        Assert.True(exp.Length == got.Count, $"{name}: {exp.Length} fixture rows vs {got.Count} computed");
+        for (var i = 0; i < exp.Length; i++)
+        {
+            var want = exp[i]!;
+            var g = got[i];
+            Assert.True(want.Length == g.Length, $"{name} row {i}: arity {g.Length} vs {want.Length}");
+            for (var k = 0; k < want.Length; k++)
+            {
+                var w = want[k];
+                if (double.IsNaN(w)) { Assert.True(double.IsNaN(g[k]), $"{name} row {i} col {k}: want NaN got {g[k]}"); continue; }
+                if (double.IsInfinity(w)) { Assert.True(double.IsInfinity(g[k]) && Math.Sign(g[k]) == Math.Sign(w), $"{name} row {i} col {k}: want {w} got {g[k]}"); continue; }
+                var tol = Tol * Math.Max(1.0, Math.Abs(w));
+                Assert.True(Math.Abs(g[k] - w) <= tol, $"{name} row {i} col {k}: got {g[k]} want {w}");
+            }
+        }
+    }
+'''
+
+out = [HEADER]
+for canon in canons:
+    out.append(block(canon))
+out.append("}")
+open(os.path.join(ROOT, "bindings", "csharp", "Wickra.Tests", "GoldenAllTests.g.cs"), "w", encoding="utf-8").write("\n".join(out) + "\n")
+print("generated GoldenAllTests.g.cs with", len(canons), "indicators")

bindings/go/README.md

@@ -0,0 +1,140 @@
+<p align="center">
+  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=514" alt="Wickra — streaming-first technical indicators" width="100%"></a>
+</p>
+
+[![CI](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/ci.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/codecov.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![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://raw.githubusercontent.com/wickra-lib/.github/main/profile/badges/license.svg)](https://github.com/wickra-lib/wickra#license)
+
+# Wickra — Go
+
+---
+
+> **▶ Live demo:** all 514 indicators over real Binance market data, computed live in your browser — **[live.wickra.org](https://live.wickra.org)** · zero backend, powered by `wickra-wasm`.
+
+**Streaming-first technical indicators for Go, over the Wickra C ABI hub via cgo.**
+
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js and WASM, plus a C ABI for C, C++, C#, Go, Java, R and
+any other C-capable language. Every indicator is an O(1) streaming state machine,
+so live trading bots and historical backtests share the exact same
+implementation. This package is the Go binding; it consumes the C ABI hub through
+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-go
+```
+
+```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
+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
+```
+
+## Quick start
+
+```go
+package main
+
+import (
+	"fmt"
+
+	wickra "github.com/wickra-lib/wickra/bindings/go"
+)
+
+func main() {
+	// Batch: run an indicator over a whole series (NaN at warmup positions).
+	prices := make([]float64, 1000)
+	for i := range prices {
+		prices[i] = 100.0 + float64(i)*0.1
+	}
+	sma, _ := wickra.NewSma(20)
+	defer sma.Close()
+	values := sma.Batch(prices)
+
+	// Streaming: the same indicator, fed tick by tick in O(1).
+	rsi, _ := wickra.NewRsi(14)
+	defer rsi.Close()
+	for _, price := range prices {
+		value := rsi.Update(price) // NaN during warmup, no recomputation
+		if value > 70 {
+			fmt.Println("overbought")
+		}
+	}
+	_ = values
+}
+```
+
+`Batch(prices)` and feeding the same prices through `Update()` produce identical
+values — the equivalence is enforced by the test suite. Multi-output indicators
+(MACD, Bollinger, ADX, …) return `(Output, bool)`, with `false` while warming up.
+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
+main repository and documentation site:
+
+- **Repository & full indicator list:** <https://github.com/wickra-lib/wickra>
+- **Docs** (quickstarts, cookbook, TA-Lib migration): <https://docs.wickra.org>
+- **Runnable examples:** [`examples/go/`](https://github.com/wickra-lib/wickra/tree/main/examples/go)
+
+Wickra ships native bindings for Python, Node.js, WASM and Rust, plus a
+C ABI hub that any C-capable language (C, C++, C#, Go, Java, R) links against —
+all exposing the same indicators from the shared, `unsafe`-forbidden Rust core.
+
+## Security
+
+Found a security issue? **Please don't open a public issue.** Report it privately
+via the affected repository's *Security* tab (*"Report a vulnerability"*) or email
+**support@wickra.org** with a subject line starting `[wickra security]`. Full
+policy: <https://github.com/wickra-lib/wickra/blob/main/SECURITY.md>.
+
+## Disclaimer
+
+Wickra is an indicator toolkit, not a trading system. The values it computes are
+deterministic transforms of the input data — they are not financial advice and
+do not predict the market. Any use in a live trading context is at your own risk.
+The library is provided **as is**, without warranty of any kind.
+
+## License
+
+Licensed under either of [Apache-2.0](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.

bindings/go/benchmarks/throughput.go

@@ -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")
+}

bindings/go/binance_test.go

@@ -0,0 +1,35 @@
+package wickra
+
+import "testing"
+
+// The live Binance feed's connect → read → reconnect pipeline is covered
+// deterministically by the Rust mock-WS-server tests in wickra-data. Here we
+// only assert the binding's error paths, which need no network: a bad interval,
+// an empty symbol list, and an unreachable endpoint must all surface as an
+// error rather than a usable handle.
+func TestBinanceFeedRejectsBadParams(t *testing.T) {
+	if _, err := NewBinanceFeed("BTCUSDT", BinanceInterval(99), ""); err == nil {
+		t.Fatal("expected an error for an unknown interval code")
+	}
+	if _, err := NewBinanceFeed("", OneMinute, ""); err == nil {
+		t.Fatal("expected an error for an empty symbol list")
+	}
+	if _, err := NewBinanceFeed("BTCUSDT", OneMinute, "ws://127.0.0.1:1"); err == nil {
+		t.Fatal("expected an error connecting to an unreachable endpoint")
+	}
+}
+
+// The REST fetcher's parse/HTTP success path is covered by the Rust
+// mock-HTTP-server tests in wickra-data; here we only assert the binding's
+// error paths, which need no reachable network.
+func TestFetchBinanceKlinesRejectsBadParams(t *testing.T) {
+	if _, err := FetchBinanceKlines("BTCUSDT", BinanceInterval(99), 1, -1, -1, ""); err == nil {
+		t.Fatal("expected an error for an unknown interval code")
+	}
+	if _, err := FetchBinanceKlines("BTCUSDT", OneHour, 0, -1, -1, ""); err == nil {
+		t.Fatal("expected an error for a zero limit")
+	}
+	if _, err := FetchBinanceKlines("BTCUSDT", OneHour, 1, -1, -1, "http://127.0.0.1:1"); err == nil {
+		t.Fatal("expected an error connecting to an unreachable endpoint")
+	}
+}

bindings/go/data_layer_test.go

@@ -0,0 +1,119 @@
+package wickra
+
+import (
+	"math"
+	"os"
+	"strconv"
+	"testing"
+)
+
+// Cross-language data-layer parity: replay the shared golden tick stream through
+// the TickAggregator and assert the candles match the Rust reference, with and
+// without gap filling. Fixtures are generated by
+// `cargo run -p wickra-examples --bin gen_golden`.
+
+func dataParseF(t *testing.T, s string) float64 {
+	t.Helper()
+	v, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		t.Fatalf("parse %q: %v", s, err)
+	}
+	return v
+}
+
+func TestResamplerGolden(t *testing.T) {
+	input := readGolden(t, "input") // open,high,low,close,volume (timestamp = row index)
+	r, err := NewResampler(5)
+	if err != nil {
+		t.Fatalf("new: %v", err)
+	}
+	var got [][6]float64
+	for i, row := range input {
+		o, h, l, c, v := dataParseF(t, row[0]), dataParseF(t, row[1]), dataParseF(t, row[2]), dataParseF(t, row[3]), dataParseF(t, row[4])
+		if k, ok := r.Update(o, h, l, c, v, int64(i)); ok {
+			got = append(got, [6]float64{k.Open, k.High, k.Low, k.Close, k.Volume, float64(k.Timestamp)})
+		}
+	}
+	if k, ok := r.Flush(); ok {
+		got = append(got, [6]float64{k.Open, k.High, k.Low, k.Close, k.Volume, float64(k.Timestamp)})
+	}
+	r.Close()
+	want := readGolden(t, "data_resampled")
+	if len(got) != len(want) {
+		t.Fatalf("resample: %d candles vs %d", len(got), len(want))
+	}
+	for i := range got {
+		for j := 0; j < 6; j++ {
+			w := dataParseF(t, want[i][j])
+			if math.Abs(got[i][j]-w) > 1e-9*math.Max(1, math.Abs(w)) {
+				t.Errorf("resample row %d col %d: %v vs %v", i, j, got[i][j], w)
+			}
+		}
+	}
+}
+
+func TestCandleReaderGolden(t *testing.T) {
+	csv, err := os.ReadFile("../../testdata/golden/data_csv.csv")
+	if err != nil {
+		t.Fatalf("read data_csv.csv: %v", err)
+	}
+	r, err := NewCandleReader(string(csv))
+	if err != nil {
+		t.Fatalf("new: %v", err)
+	}
+	defer r.Close()
+	candles := r.Read()
+	got := make([][6]float64, len(candles))
+	for i, c := range candles {
+		got[i] = [6]float64{c.Open, c.High, c.Low, c.Close, c.Volume, float64(c.Timestamp)}
+	}
+	want := readGolden(t, "data_csv_candles")
+	if len(got) != len(want) {
+		t.Fatalf("candle reader: %d candles vs %d", len(got), len(want))
+	}
+	for i := range got {
+		for j := 0; j < 6; j++ {
+			w := dataParseF(t, want[i][j])
+			if math.Abs(got[i][j]-w) > 1e-9*math.Max(1, math.Abs(w)) {
+				t.Errorf("candle reader row %d col %d: %v vs %v", i, j, got[i][j], w)
+			}
+		}
+	}
+}
+
+func TestTickAggregatorGolden(t *testing.T) {
+	ticks := readGolden(t, "data_ticks")
+	cases := []struct {
+		gap     bool
+		fixture string
+	}{
+		{false, "data_candles"},
+		{true, "data_candles_gap"},
+	}
+	for _, c := range cases {
+		agg, err := NewTickAggregator(1000, c.gap)
+		if err != nil {
+			t.Fatalf("new: %v", err)
+		}
+		var got [][6]float64
+		for _, r := range ticks {
+			price, size, ts := dataParseF(t, r[0]), dataParseF(t, r[1]), int64(dataParseF(t, r[2]))
+			for _, k := range agg.Push(price, size, ts) {
+				got = append(got, [6]float64{k.Open, k.High, k.Low, k.Close, k.Volume, float64(k.Timestamp)})
+			}
+		}
+		agg.Close()
+		want := readGolden(t, c.fixture)
+		if len(got) != len(want) {
+			t.Fatalf("%s: %d candles vs %d", c.fixture, len(got), len(want))
+		}
+		for i := range got {
+			for j := 0; j < 6; j++ {
+				w := dataParseF(t, want[i][j])
+				if math.Abs(got[i][j]-w) > 1e-9*math.Max(1, math.Abs(w)) {
+					t.Errorf("%s row %d col %d: %v vs %v", c.fixture, i, j, got[i][j], w)
+				}
+			}
+		}
+	}
+}

bindings/go/gen_golden_test.py

@@ -0,0 +1,343 @@
+"""Generate golden_all_test.go: a value-parity test that replays the shared
+golden input through every one of the 514 Go indicators and checks output
+bit-for-bit against the Rust-generated g_<Canonical>.csv fixtures.
+
+Run from repo root:  python bindings/go/gen_golden_test.py
+"""
+import glob
+import json
+import os
+import re
+
+ROOT = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+G = os.path.join(ROOT, "testdata", "golden")
+GEN = open(os.path.join(ROOT, "bindings", "go", "indicators_gen.go"), encoding="utf-8").read()
+
+# Canonical core Indicator::name() per indicator, shared across every binding.
+NAMES = json.load(open(os.path.join(G, "names.json")))
+
+# Go constructor parameter types, keyed by canonical (== Go type name).
+ctor_types = {}
+for m in re.finditer(r"func New(\w+)\(([^)]*)\)\s*\(\*\w+, error\)", GEN):
+    name, ps = m.group(1), m.group(2).strip()
+    types = []
+    if ps:
+        for p in ps.split(","):
+            p = p.strip()
+            _, _, ty = p.partition(" ")
+            types.append(ty.strip())
+    ctor_types[name] = types
+
+# Unified archetype + params, keyed by canonical.
+spec = {}  # canon -> dict(arch, params, width?, n?)
+scal = json.load(open(os.path.join(G, "scalar_manifest.json")))
+for e in scal:
+    inp = e["input"]
+    arch = {"f64": "scalar_f64", "Candle": "scalar_candle", "(f64, f64)": "pairwise"}[inp]
+    spec[e["canonical"]] = {"arch": arch, "params": e["params"]}
+for e in json.load(open(os.path.join(G, "multi_manifest.json"))):
+    inp = e["input"]
+    arch = {"f64": "multi_f64", "Candle": "multi_candle", "(f64, f64)": "multi_pairwise"}[inp]
+    spec[e["canonical"]] = {"arch": arch, "params": e["params"], "n": e["n"]}
+ex = json.load(open(os.path.join(G, "exotic_manifest.json")))
+for e in ex["deriv"]:
+    spec[e["canonical"]] = {"arch": "deriv_multi" if "n" in e else "deriv", "params": e["params"], "n": e.get("n")}
+for e in ex["cross"]:
+    spec[e["canonical"]] = {"arch": "cross", "params": e["params"]}
+for e in ex["trade"]:
+    spec[e["canonical"]] = {"arch": "trade", "params": e["params"]}
+for e in ex["trademid"]:
+    spec[e["canonical"]] = {"arch": "trademid", "params": e["params"]}
+for e in ex["ob"]:
+    spec[e["canonical"]] = {"arch": "ob", "params": e["params"]}
+for e in json.load(open(os.path.join(G, "profile_manifest.json"))):
+    spec[e["canonical"]] = {"arch": "profile_" + e["kind"], "params": e["params"], "width": e["width"]}
+for e in json.load(open(os.path.join(G, "bars_manifest.json"))):
+    arch = "footprint" if e["canonical"] == "Footprint" else "bars_" + e["feed"]
+    spec[e["canonical"]] = {"arch": arch, "params": e["params"]}
+
+canons = sorted(os.path.basename(f)[2:-4] for f in glob.glob(os.path.join(G, "g_*.csv")))
+
+
+def go_param(value, gotype):
+    intlike = gotype in ("int", "int32", "int64", "uint", "uintptr", "usize")
+    if intlike:
+        return str(int(round(value)))
+    # float64
+    return repr(float(value)) if "." in repr(float(value)) or "e" in repr(float(value)) else f"{float(value)}"
+
+
+def ctor_call(canon):
+    types = ctor_types.get(canon, [])
+    vals = spec[canon]["params"]
+    args = ", ".join(go_param(v, t) for v, t in zip(vals, types))
+    return f"New{canon}({args})"
+
+
+# Update-call expression + output handling per archetype.
+def block(canon):
+    s = spec[canon]
+    a = s["arch"]
+    ctor = ctor_call(canon)
+    lines = [f'\tt.Run("{canon}", func(t *testing.T) {{']
+    lines.append(f"\t\tind, err := {ctor}")
+    lines.append('\t\tif err != nil {')
+    lines.append(f'\t\t\tt.Fatalf("new {canon}: %v", err)')
+    lines.append("\t\t}")
+    lines.append(f'\t\tif n := ind.Name(); n != {json.dumps(NAMES[canon])} {{')
+    lines.append(f'\t\t\tt.Errorf("name: got %q want %q", n, {json.dumps(NAMES[canon])})')
+    lines.append("\t\t}")
+    lines.append("\t\tgot := make([][]float64, len(rows))")
+    lines.append("\t\tfor i, r := range rows {")
+    if a == "scalar_f64":
+        upd = "ind.Update(r[3])"
+        lines.append(f"\t\t\tgot[i] = []float64{{{upd}}}")
+    elif a == "pairwise":
+        lines.append("\t\t\tgot[i] = []float64{ind.Update(r[3], r[0])}")
+    elif a == "scalar_candle":
+        lines.append("\t\t\tgot[i] = []float64{ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))}")
+    elif a == "trade":
+        lines.append("\t\t\tgot[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i))}")
+    elif a == "trademid":
+        lines.append("\t\t\tgot[i] = []float64{ind.Update(r[3], r[4], r[3] >= r[0], int64(i), (r[1]+r[2])/2)}")
+    elif a == "ob":
+        lines.append("\t\t\tbp, bs, ap, as_ := obLists(r)")
+        lines.append("\t\t\tgot[i] = []float64{ind.Update(bp, bs, ap, as_)}")
+    elif a == "deriv":
+        lines.append("\t\t\td := derivFields(r)")
+        lines.append("\t\t\tgot[i] = []float64{ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))}")
+    elif a == "deriv_multi":
+        lines.append("\t\t\td := derivFields(r)")
+        lines.append("\t\t\tout, ok := ind.Update(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], int64(i))")
+        lines.append(f"\t\t\tgot[i] = reflectRow(out, ok, {s['n']})")
+    elif a == "cross":
+        lines.append("\t\t\tch, vo, nh, nl, am, ob_ := crossLists(r)")
+        lines.append("\t\t\tgot[i] = []float64{ind.Update(ch, vo, nh, nl, am, ob_, int64(i))}")
+    elif a in ("multi_f64",):
+        lines.append("\t\t\tout, ok := ind.Update(r[3])")
+        lines.append(f"\t\t\tgot[i] = reflectRow(out, ok, {s['n']})")
+    elif a == "multi_pairwise":
+        lines.append("\t\t\tout, ok := ind.Update(r[3], r[0])")
+        lines.append(f"\t\t\tgot[i] = reflectRow(out, ok, {s['n']})")
+    elif a == "multi_candle":
+        lines.append("\t\t\tout, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))")
+        lines.append(f"\t\t\tgot[i] = reflectRow(out, ok, {s['n']})")
+    elif a == "profile_bins":
+        lines.append("\t\t\tbins, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))")
+        lines.append(f"\t\t\tif ok {{ got[i] = bins }} else {{ got[i] = nanRow({s['width']}) }}")
+    elif a == "profile_pricebins":
+        lines.append("\t\t\tout, ok := ind.Update(r[0], r[1], r[2], r[3], r[4], int64(i))")
+        lines.append(f"\t\t\tgot[i] = reflectRow(out, ok, {s['width']})")
+    elif a == "bars_close":
+        lines.append("\t\t\tgot[i] = flattenBars(ind.Update(r[3], r[3], r[3], r[3], 1.0, 0))")
+    elif a == "bars_candle4":
+        lines.append("\t\t\tgot[i] = flattenBars(ind.Update(r[0], r[1], r[2], r[3], 1.0, 0))")
+    elif a == "bars_candle5":
+        lines.append("\t\t\tgot[i] = flattenBars(ind.Update(r[0], r[1], r[2], r[3], r[4], 0))")
+    elif a == "footprint":
+        lines.append("\t\t\tgot[i] = flattenBars(ind.Update(r[3], r[4], r[3] >= r[0], int64(i)))")
+    else:
+        raise SystemExit("unknown arch " + a)
+    lines.append("\t\t}")
+    lines.append(f'\t\tcompareGolden(t, "{canon}", got)')
+    lines.append("\t})")
+    return "\n".join(lines)
+
+
+HEADER = '''// Code generated by gen_golden_test.py. DO NOT EDIT.
+//
+// Value-parity for every one of the 514 Go indicators: the shared golden input
+// is replayed through each one and checked bit-for-bit against the Rust
+// reference fixtures testdata/golden/g_<Canonical>.csv. Multi-output, profile
+// and bar shapes are flattened by reflection so a single comparator covers all
+// archetypes. Regenerate with: python bindings/go/gen_golden_test.py
+
+package wickra
+
+import (
+\t"bufio"
+\t"math"
+\t"os"
+\t"reflect"
+\t"strings"
+\t"testing"
+)
+
+// readGoldenRaw keeps blank lines (a candle on which no bar closed) so bar rows
+// stay aligned to the input; non-bar fixtures contain no blank lines.
+func readGoldenRaw(t *testing.T, name string) [][]string {
+\tt.Helper()
+\tf, err := os.Open("../../testdata/golden/" + name + ".csv")
+\tif err != nil {
+\t\tt.Fatalf("open %s: %v", name, err)
+\t}
+\tdefer f.Close()
+\tvar rows [][]string
+\tsc := bufio.NewScanner(f)
+\tsc.Buffer(make([]byte, 0, 1024*1024), 1024*1024)
+\tfirst := true
+\tfor sc.Scan() {
+\t\tline := sc.Text()
+\t\tif first {
+\t\t\tfirst = false
+\t\t\tcontinue
+\t\t}
+\t\tif line == "" {
+\t\t\trows = append(rows, []string{})
+\t\t\tcontinue
+\t\t}
+\t\trows = append(rows, strings.Split(line, ","))
+\t}
+\treturn rows
+}
+
+func nanRow(n int) []float64 {
+\tr := make([]float64, n)
+\tfor i := range r {
+\t\tr[i] = math.NaN()
+\t}
+\treturn r
+}
+
+func reflectRow(out any, ok bool, width int) []float64 {
+\tif !ok {
+\t\treturn nanRow(width)
+\t}
+\tv := reflect.ValueOf(out)
+\trow := make([]float64, 0, width)
+\tfor k := 0; k < v.NumField(); k++ {
+\t\trow = appendField(row, v.Field(k))
+\t}
+\treturn row
+}
+
+func appendField(row []float64, f reflect.Value) []float64 {
+\tswitch f.Kind() {
+\tcase reflect.Float64, reflect.Float32:
+\t\treturn append(row, f.Float())
+\tcase reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+\t\treturn append(row, float64(f.Int()))
+\tcase reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+\t\treturn append(row, float64(f.Uint()))
+\tcase reflect.Slice:
+\t\tfor j := 0; j < f.Len(); j++ {
+\t\t\trow = appendField(row, f.Index(j))
+\t\t}
+\t\treturn row
+\tdefault:
+\t\treturn row
+\t}
+}
+
+func flattenBars(bars any) []float64 {
+\tv := reflect.ValueOf(bars)
+\trow := []float64{}
+\tfor i := 0; i < v.Len(); i++ {
+\t\tbar := v.Index(i)
+\t\tfor k := 0; k < bar.NumField(); k++ {
+\t\t\trow = appendField(row, bar.Field(k))
+\t\t}
+\t}
+\treturn row
+}
+
+// Synthetic feeds derived from one OHLCV row, identical to gen_golden's Rust
+// construction (DerivativesTick / CrossSection / OrderBook).
+func derivFields(r []float64) [11]float64 {
+\to, h, l, c, v := r[0], r[1], r[2], r[3], r[4]
+\treturn [11]float64{
+\t\t(c - o) / c * 0.01, // funding_rate
+\t\tc,                  // mark_price
+\t\tc - 0.5,            // index_price
+\t\tc + 1.0,            // futures_price
+\t\tv * 10.0,           // open_interest
+\t\tv * 0.6,            // long_size
+\t\tv * 0.4,            // short_size
+\t\tv * 0.55,           // taker_buy_volume
+\t\tv * 0.45,           // taker_sell_volume
+\t\th - c,              // long_liquidation
+\t\tc - l,              // short_liquidation
+\t}
+}
+
+func crossLists(r []float64) ([]float64, []float64, []bool, []bool, []bool, []bool) {
+\to, c, v := r[0], r[3], r[4]
+\tchange := make([]float64, 5)
+\tvolume := make([]float64, 5)
+\tnewHigh := make([]bool, 5)
+\tnewLow := make([]bool, 5)
+\taboveMa := make([]bool, 5)
+\tonBuy := make([]bool, 5)
+\tfor j := 0; j < 5; j++ {
+\t\tjf := float64(j)
+\t\tchange[j] = (c - o) + jf
+\t\tvolume[j] = v + jf*10.0
+\t\tnewHigh[j] = j%2 == 0
+\t\tnewLow[j] = j%3 == 0
+\t\taboveMa[j] = j%2 == 0
+\t\tonBuy[j] = j%3 == 0
+\t}
+\treturn change, volume, newHigh, newLow, aboveMa, onBuy
+}
+
+func obLists(r []float64) ([]float64, []float64, []float64, []float64) {
+\tc, v := r[3], r[4]
+\tbidPx := make([]float64, 5)
+\tbidSz := make([]float64, 5)
+\taskPx := make([]float64, 5)
+\taskSz := make([]float64, 5)
+\tfor k := 0; k < 5; k++ {
+\t\tkf := float64(k + 1)
+\t\tbidPx[k] = c - 0.1*kf
+\t\tbidSz[k] = v / kf
+\t\taskPx[k] = c + 0.1*kf
+\t\taskSz[k] = v * 0.9 / kf
+\t}
+\treturn bidPx, bidSz, askPx, askSz
+}
+
+func compareGolden(t *testing.T, name string, got [][]float64) {
+\tt.Helper()
+\texp := readGoldenRaw(t, "g_"+name)
+\tif len(exp) != len(got) {
+\t\tt.Fatalf("%s: %d fixture rows vs %d computed", name, len(exp), len(got))
+\t}
+\tfor i := range exp {
+\t\tif len(exp[i]) != len(got[i]) {
+\t\t\tt.Fatalf("%s row %d: arity %d vs %d", name, i, len(got[i]), len(exp[i]))
+\t\t}
+\t\tfor k := range exp[i] {
+\t\t\twant := goldenCell(exp[i][k])
+\t\t\tg := got[i][k]
+\t\t\tif math.IsNaN(want) {
+\t\t\t\tif !math.IsNaN(g) {
+\t\t\t\t\tt.Fatalf("%s row %d col %d: want NaN got %v", name, i, k, g)
+\t\t\t\t}
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tif math.IsInf(want, 0) {
+\t\t\t\tif !math.IsInf(g, 0) || (g > 0) != (want > 0) {
+\t\t\t\t\tt.Fatalf("%s row %d col %d: want %v got %v", name, i, k, want, g)
+\t\t\t\t}
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\ttol := goldenTol * math.Max(1.0, math.Abs(want))
+\t\t\tif math.Abs(g-want) > tol {
+\t\t\t\tt.Fatalf("%s row %d col %d: got %v want %v", name, i, k, g, want)
+\t\t\t}
+\t\t}
+\t}
+}
+
+func TestGoldenAll(t *testing.T) {
+\trows := goldenInput(t)
+'''
+
+# bars need blank-line-preserving fixture reads; reuse readGolden but it skips
+# blanks. We need a raw reader for bars and input.
+out = [HEADER]
+for canon in canons:
+    out.append(block(canon))
+out.append("}")
+open(os.path.join(ROOT, "bindings", "go", "golden_all_test.go"), "w", encoding="utf-8").write("\n".join(out) + "\n")
+print("generated golden_all_test.go with", len(canons), "indicators")

bindings/go/go.mod

@@ -0,0 +1,3 @@
+module github.com/wickra-lib/wickra/bindings/go
+
+go 1.23

bindings/go/golden_test.go

@@ -0,0 +1,250 @@
+package wickra
+
+import (
+	"bufio"
+	"math"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Golden-fixture parity: replay the shared testdata/golden input series through
+// the Go FFI and assert every value matches the Rust reference output. Where the
+// archetype test only checks finiteness, this pins exact values, catching wiring
+// bugs (swapped params, wrong multi-output field). Fixtures are generated by
+// `cargo run -p wickra-examples --bin gen_golden`.
+
+const goldenTol = 1e-6
+
+func readGolden(t *testing.T, name string) [][]string {
+	t.Helper()
+	f, err := os.Open("../../testdata/golden/" + name + ".csv")
+	if err != nil {
+		t.Fatalf("open %s: %v", name, err)
+	}
+	defer f.Close()
+	var rows [][]string
+	sc := bufio.NewScanner(f)
+	first := true
+	for sc.Scan() {
+		line := sc.Text()
+		if first {
+			first = false
+			continue
+		}
+		if line == "" {
+			continue
+		}
+		rows = append(rows, strings.Split(line, ","))
+	}
+	return rows
+}
+
+func goldenCell(s string) float64 {
+	if s == "nan" {
+		return math.NaN()
+	}
+	v, _ := strconv.ParseFloat(s, 64)
+	return v
+}
+
+func goldenInput(t *testing.T) [][]float64 {
+	rows := readGolden(t, "input")
+	out := make([][]float64, len(rows))
+	for i, r := range rows {
+		vals := make([]float64, len(r))
+		for j, c := range r {
+			vals[j] = goldenCell(c)
+		}
+		out[i] = vals
+	}
+	return out
+}
+
+func assertGoldenClose(t *testing.T, got, want float64, row int, field string) {
+	t.Helper()
+	if math.IsNaN(want) {
+		if !math.IsNaN(got) {
+			t.Errorf("row %d %s: expected warmup/NaN, got %v", row, field, got)
+		}
+		return
+	}
+	tol := goldenTol * math.Max(1.0, math.Abs(want))
+	if math.Abs(got-want) > tol {
+		t.Errorf("row %d %s: got %v want %v", row, field, got, want)
+	}
+}
+
+func TestGoldenScalar(t *testing.T) {
+	input := goldenInput(t)
+	sma, err := NewSma(14)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer sma.Close()
+	ema, err := NewEma(14)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ema.Close()
+	rsi, err := NewRsi(14)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rsi.Close()
+
+	cases := []struct {
+		name string
+		upd  func(close float64) float64
+	}{
+		{"sma", sma.Update},
+		{"ema", ema.Update},
+		{"rsi", rsi.Update},
+	}
+	for _, tc := range cases {
+		exp := readGolden(t, tc.name)
+		for i := range input {
+			assertGoldenClose(t, tc.upd(input[i][3]), goldenCell(exp[i][0]), i, tc.name)
+		}
+	}
+}
+
+func TestGoldenAtr(t *testing.T) {
+	input := goldenInput(t)
+	exp := readGolden(t, "atr")
+	atr, err := NewAtr(14)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer atr.Close()
+	for i := range input {
+		got := atr.Update(input[i][0], input[i][1], input[i][2], input[i][3], input[i][4], int64(i))
+		assertGoldenClose(t, got, goldenCell(exp[i][0]), i, "atr")
+	}
+}
+
+func TestGoldenBeta(t *testing.T) {
+	input := goldenInput(t)
+	exp := readGolden(t, "beta")
+	beta, err := NewBeta(20)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer beta.Close()
+	for i := range input {
+		// generator fed (close, open)
+		assertGoldenClose(t, beta.Update(input[i][3], input[i][0]), goldenCell(exp[i][0]), i, "beta")
+	}
+}
+
+func TestGoldenMacd(t *testing.T) {
+	input := goldenInput(t)
+	exp := readGolden(t, "macd")
+	macd, err := NewMacdIndicator(12, 26, 9)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer macd.Close()
+	for i := range input {
+		out, ok := macd.Update(input[i][3])
+		if exp[i][0] == "nan" {
+			if ok {
+				t.Errorf("row %d macd: expected warmup, got %+v", i, out)
+			}
+			continue
+		}
+		if !ok {
+			t.Errorf("row %d macd: expected value, got warmup", i)
+			continue
+		}
+		assertGoldenClose(t, out.Macd, goldenCell(exp[i][0]), i, "macd.macd")
+		assertGoldenClose(t, out.Signal, goldenCell(exp[i][1]), i, "macd.signal")
+		assertGoldenClose(t, out.Histogram, goldenCell(exp[i][2]), i, "macd.histogram")
+	}
+}
+
+func TestGoldenAdx(t *testing.T) {
+	input := goldenInput(t)
+	exp := readGolden(t, "adx")
+	adx, err := NewAdx(14)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer adx.Close()
+	for i := range input {
+		out, ok := adx.Update(input[i][0], input[i][1], input[i][2], input[i][3], input[i][4], int64(i))
+		if exp[i][0] == "nan" {
+			if ok {
+				t.Errorf("row %d adx: expected warmup, got %+v", i, out)
+			}
+			continue
+		}
+		if !ok {
+			t.Errorf("row %d adx: expected value, got warmup", i)
+			continue
+		}
+		assertGoldenClose(t, out.PlusDi, goldenCell(exp[i][0]), i, "adx.plus_di")
+		assertGoldenClose(t, out.MinusDi, goldenCell(exp[i][1]), i, "adx.minus_di")
+		assertGoldenClose(t, out.Adx, goldenCell(exp[i][2]), i, "adx.adx")
+	}
+}
+
+// The four de-duplicated indicators: pin their corrected definitions against
+// the Rust reference so the Go FFI stays bit-identical.
+
+func TestGoldenAdOscillator(t *testing.T) {
+	input := goldenInput(t)
+	exp := readGolden(t, "ad_oscillator")
+	ad, err := NewAdOscillator()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ad.Close()
+	for i := range input {
+		got := ad.Update(input[i][0], input[i][1], input[i][2], input[i][3], input[i][4], int64(i))
+		assertGoldenClose(t, got, goldenCell(exp[i][0]), i, "ad_oscillator")
+	}
+}
+
+func TestGoldenIntradayIntensity(t *testing.T) {
+	input := goldenInput(t)
+	exp := readGolden(t, "intraday_intensity")
+	ii, err := NewIntradayIntensity()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer ii.Close()
+	for i := range input {
+		got := ii.Update(input[i][0], input[i][1], input[i][2], input[i][3], input[i][4], int64(i))
+		assertGoldenClose(t, got, goldenCell(exp[i][0]), i, "intraday_intensity")
+	}
+}
+
+func TestGoldenAwesomeOscillatorHistogram(t *testing.T) {
+	input := goldenInput(t)
+	exp := readGolden(t, "awesome_oscillator_histogram")
+	aoh, err := NewAwesomeOscillatorHistogram(5, 34, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer aoh.Close()
+	for i := range input {
+		got := aoh.Update(input[i][0], input[i][1], input[i][2], input[i][3], input[i][4], int64(i))
+		assertGoldenClose(t, got, goldenCell(exp[i][0]), i, "awesome_oscillator_histogram")
+	}
+}
+
+func TestGoldenAverageDrawdown(t *testing.T) {
+	input := goldenInput(t)
+	exp := readGolden(t, "average_drawdown")
+	avg, err := NewAverageDrawdown(20)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer avg.Close()
+	for i := range input {
+		// generator fed the close column as the equity-curve sample.
+		assertGoldenClose(t, avg.Update(input[i][3]), goldenCell(exp[i][0]), i, "average_drawdown")
+	}
+}

bindings/go/lib/.gitignore

@@ -0,0 +1,7 @@
+# Prebuilt Wickra C ABI libraries are provisioned locally / in CI, not committed.
+*.so
+*.dylib
+*.dll
+*.a
+*.lib
+*.exp

bindings/go/wickra.go

@@ -0,0 +1,34 @@
+// Package wickra provides idiomatic Go bindings for the Wickra
+// technical-analysis library over its C ABI hub.
+//
+// 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, 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}/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"
+
+import "errors"
+
+// ErrInvalidParams is returned by a New<Indicator> constructor when the native
+// constructor rejects the supplied parameters (for example a zero period).
+var ErrInvalidParams = errors.New("wickra: invalid indicator parameters")
+
+// ErrFeedClosed is returned by BinanceFeed.Next once the stream has been closed
+// or has errored out and exhausted its reconnect attempts.
+var ErrFeedClosed = errors.New("wickra: binance feed closed")

bindings/go/wickra_test.go

@@ -0,0 +1,179 @@
+package wickra
+
+import (
+	"math"
+	"testing"
+)
+
+// One indicator per FFI archetype, exercising the full New/Update/Batch/Reset/
+// Close surface against the real native library.
+
+func TestScalarKnownValue(t *testing.T) {
+	s, err := NewSma(3)
+	if err != nil {
+		t.Fatalf("NewSma: %v", err)
+	}
+	defer s.Close()
+
+	var last float64
+	for _, v := range []float64{1, 2, 3, 4, 5} {
+		last = s.Update(v)
+	}
+	if math.Abs(last-4.0) > 1e-9 {
+		t.Fatalf("sma(3) last = %v, want 4.0", last)
+	}
+}
+
+func TestWarmupPeriodAndIsReady(t *testing.T) {
+	s, err := NewSma(3)
+	if err != nil {
+		t.Fatalf("NewSma: %v", err)
+	}
+	defer s.Close()
+
+	if got := s.WarmupPeriod(); got != 3 {
+		t.Fatalf("sma(3) WarmupPeriod = %d, want 3", got)
+	}
+	if s.IsReady() {
+		t.Fatal("sma is ready before any update")
+	}
+	s.Update(1)
+	s.Update(2)
+	if s.IsReady() {
+		t.Fatal("sma is ready mid-warmup")
+	}
+	s.Update(3)
+	if !s.IsReady() {
+		t.Fatal("sma is not ready after the warmup period")
+	}
+	s.Reset()
+	if s.IsReady() {
+		t.Fatal("sma is ready after reset")
+	}
+}
+
+func TestScalarBatchMatchesStreaming(t *testing.T) {
+	input := []float64{1, 2, 3, 4, 5, 6, 7, 8}
+
+	stream, _ := NewSma(3)
+	defer stream.Close()
+	want := make([]float64, len(input))
+	for i, v := range input {
+		want[i] = stream.Update(v)
+	}
+
+	batchInd, _ := NewSma(3)
+	defer batchInd.Close()
+	got := batchInd.Batch(input)
+
+	if len(got) != len(want) {
+		t.Fatalf("batch len = %d, want %d", len(got), len(want))
+	}
+	for i := range want {
+		if math.IsNaN(want[i]) && math.IsNaN(got[i]) {
+			continue
+		}
+		if math.Abs(got[i]-want[i]) > 1e-9 {
+			t.Fatalf("batch[%d] = %v, streaming = %v", i, got[i], want[i])
+		}
+	}
+}
+
+func TestMultiOutput(t *testing.T) {
+	m, err := NewMacdIndicator(3, 6, 3)
+	if err != nil {
+		t.Fatalf("NewMacdIndicator: %v", err)
+	}
+	defer m.Close()
+
+	var ok bool
+	var out MacdOutput
+	for i := 0; i < 30; i++ {
+		out, ok = m.Update(100 + float64(i))
+	}
+	if !ok {
+		t.Fatal("macd never produced a value after warmup")
+	}
+	if math.IsNaN(out.Macd) {
+		t.Fatal("macd value is NaN after warmup")
+	}
+}
+
+func TestBars(t *testing.T) {
+	rb, err := NewRangeBars(2.0)
+	if err != nil {
+		t.Fatalf("NewRangeBars: %v", err)
+	}
+	defer rb.Close()
+
+	total := 0
+	for _, p := range []float64{100, 101, 103, 104, 99, 96, 102, 108, 95, 110} {
+		bars := rb.Update(p, p, p, p, 1, 0)
+		total += len(bars)
+	}
+	if total == 0 {
+		t.Fatal("range bars produced no bars over a 15-point move")
+	}
+}
+
+func TestProfile(t *testing.T) {
+	vp, err := NewVolumeProfile(10, 24)
+	if err != nil {
+		t.Fatalf("NewVolumeProfile: %v", err)
+	}
+	defer vp.Close()
+
+	var ok bool
+	var snap VolumeProfileOutputScalars
+	for i := 0; i < 50; i++ {
+		price := 100 + 5*math.Sin(float64(i)*0.3)
+		snap, ok = vp.Update(price, price+1, price-1, price, 1000, int64(i))
+	}
+	if !ok {
+		t.Fatal("volume profile never produced a snapshot")
+	}
+	if len(snap.Values) == 0 {
+		t.Fatal("volume profile returned an empty values buffer")
+	}
+}
+
+func TestArrayInput(t *testing.T) {
+	ob, err := NewOrderBookImbalanceFull()
+	if err != nil {
+		t.Fatalf("NewOrderBookImbalanceFull: %v", err)
+	}
+	defer ob.Close()
+
+	bidPrice := []float64{99.9, 99.8, 99.7}
+	bidSize := []float64{5, 3, 2}
+	askPrice := []float64{100.1, 100.2, 100.3}
+	askSize := []float64{1, 1, 1}
+	v := ob.Update(bidPrice, bidSize, askPrice, askSize)
+	if math.IsNaN(v) {
+		t.Fatal("order-book imbalance is NaN on a populated book")
+	}
+}
+
+func TestResetReturnsToWarmup(t *testing.T) {
+	s, _ := NewSma(3)
+	defer s.Close()
+	for _, v := range []float64{1, 2, 3} {
+		s.Update(v)
+	}
+	s.Reset()
+	if got := s.Update(10); !math.IsNaN(got) {
+		t.Fatalf("after reset first update = %v, want NaN (warmup)", got)
+	}
+}
+
+func TestInvalidParams(t *testing.T) {
+	if _, err := NewSma(0); err == nil {
+		t.Fatal("NewSma(0) should return ErrInvalidParams")
+	}
+}
+
+func TestCloseIsIdempotent(t *testing.T) {
+	s, _ := NewSma(3)
+	s.Close()
+	s.Close() // must not panic or double-free
+}

bindings/java/.gitignore

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

bindings/java/README.md

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

bindings/java/benchmarks/pom.xml

@@ -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.9.6</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.15.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.6.3</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>

bindings/java/benchmarks/src/main/java/org/wickra/benchmarks/Throughput.java

@@ -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) {}
+}

bindings/java/gen_golden_test.py

@@ -0,0 +1,293 @@
+"""Generate src/test/java/org/wickra/GoldenAllTest.java: a reflection-driven
+value-parity test that replays the shared golden input through every one of the
+514 Java indicators and checks output bit-for-bit against the Rust reference
+fixtures g_<Canonical>.csv. The per-indicator spec is embedded so the test has
+no JSON dependency; a single reflective runner covers all archetypes.
+
+Run from repo root:  python bindings/java/gen_golden_test.py
+"""
+import json
+import os
+
+ROOT = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MAN = json.load(open(os.path.join(ROOT, "testdata", "golden", "golden_manifest.json")))
+
+
+def params_lit(ps):
+    if not ps:
+        return "new double[]{}"
+    return "new double[]{" + ", ".join(repr(float(p)) for p in ps) + "}"
+
+
+specs = []
+for e in MAN:
+    n = e.get("n", e.get("width", 0))
+    specs.append(f'        new Spec("{e["canonical"]}", "{e["arch"]}", {params_lit(e["params"])}, {n}),')
+specs_block = "\n".join(specs)
+
+# Canonical core Indicator::name() per indicator, shared across every binding.
+NAMES = json.load(open(os.path.join(ROOT, "testdata", "golden", "names.json")))
+names_block = "\n".join(
+    f"        NAMES.put({json.dumps(c)}, {json.dumps(NAMES[c])});" for c in sorted(NAMES)
+)
+
+TEMPLATE = '''// Code generated by gen_golden_test.py. DO NOT EDIT.
+package org.wickra;
+
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.TestFactory;
+
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.RecordComponent;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.DynamicTest.dynamicTest;
+
+/**
+ * Reflection-driven value parity for the whole 514-indicator catalogue: each
+ * indicator is reconstructed by its class name, fed the synthetic stream derived
+ * from the shared golden input (identical to gen_golden's Rust construction) and
+ * checked bit-for-bit against testdata/golden/g_&lt;Canonical&gt;.csv. One runner
+ * flattens scalar, multi-output records, profiles and bar arrays by reflection.
+ */
+class GoldenAllTest {
+    private static final double TOL = 1e-6;
+
+    private record Spec(String canonical, String arch, double[] params, int width) {}
+
+    private static final Spec[] SPECS = {
+%SPECS%
+    };
+
+    private static final java.util.Map<String, String> NAMES = new java.util.HashMap<>();
+    static {
+%NAMES%
+    }
+
+    private static Path goldenDir() {
+        java.io.File d = new java.io.File("").getAbsoluteFile();
+        while (d != null) {
+            java.io.File g = new java.io.File(d, "testdata/golden");
+            if (g.isDirectory()) {
+                return g.toPath();
+            }
+            d = d.getParentFile();
+        }
+        throw new IllegalStateException("testdata/golden not found");
+    }
+
+    private static double cell(String s) {
+        return switch (s) {
+            case "nan" -> Double.NaN;
+            case "inf" -> Double.POSITIVE_INFINITY;
+            case "-inf" -> Double.NEGATIVE_INFINITY;
+            default -> Double.parseDouble(s);
+        };
+    }
+
+    private static double[][] input() throws IOException {
+        List<String> lines = Files.readAllLines(goldenDir().resolve("input.csv"));
+        List<double[]> rows = new ArrayList<>();
+        for (int i = 1; i < lines.size(); i++) {
+            if (lines.get(i).isEmpty()) continue;
+            String[] p = lines.get(i).split(",");
+            double[] r = new double[p.length];
+            for (int j = 0; j < p.length; j++) r[j] = Double.parseDouble(p[j]);
+            rows.add(r);
+        }
+        return rows.toArray(new double[0][]);
+    }
+
+    // Keep blank lines (a candle on which no bar closed) so rows stay aligned.
+    private static double[][] fixture(String name) throws IOException {
+        List<String> lines = Files.readAllLines(goldenDir().resolve("g_" + name + ".csv"));
+        List<double[]> rows = new ArrayList<>();
+        for (int i = 1; i < lines.size(); i++) {
+            String ln = lines.get(i);
+            if (ln.isEmpty()) {
+                rows.add(new double[0]);
+                continue;
+            }
+            String[] p = ln.split(",");
+            double[] r = new double[p.length];
+            for (int j = 0; j < p.length; j++) r[j] = cell(p[j]);
+            rows.add(r);
+        }
+        return rows.toArray(new double[0][]);
+    }
+
+    private static double[] nanRow(int n) {
+        double[] r = new double[n];
+        java.util.Arrays.fill(r, Double.NaN);
+        return r;
+    }
+
+    private static double[] derivFields(double[] r) {
+        double o = r[0], h = r[1], l = r[2], c = r[3], v = r[4];
+        return new double[]{
+            (c - o) / c * 0.01, c, c - 0.5, c + 1.0, v * 10.0, v * 0.6, v * 0.4,
+            v * 0.55, v * 0.45, h - c, c - l,
+        };
+    }
+
+    private static double[] crossList(double[] r, int which) {
+        double o = r[0], c = r[3], v = r[4];
+        double[] out = new double[5];
+        for (int j = 0; j < 5; j++) {
+            out[j] = switch (which) {
+                case 0 -> (c - o) + j;
+                case 1 -> v + j * 10.0;
+                case 2 -> j % 2 == 0 ? 1.0 : 0.0; // newHigh
+                case 3 -> j % 3 == 0 ? 1.0 : 0.0; // newLow
+                case 4 -> j % 2 == 0 ? 1.0 : 0.0; // aboveMa
+                default -> j % 3 == 0 ? 1.0 : 0.0; // onBuySignal
+            };
+        }
+        return out;
+    }
+
+    private static double[] obList(double[] r, int which) {
+        double c = r[3], v = r[4];
+        double[] out = new double[5];
+        for (int k = 0; k < 5; k++) {
+            double kf = k + 1;
+            out[k] = switch (which) {
+                case 0 -> c - 0.1 * kf;
+                case 1 -> v / kf;
+                case 2 -> c + 0.1 * kf;
+                default -> v * 0.9 / kf;
+            };
+        }
+        return out;
+    }
+
+    private static double[] flattenRecord(Object o) throws Exception {
+        RecordComponent[] rc = o.getClass().getRecordComponents();
+        List<Double> list = new ArrayList<>();
+        for (RecordComponent c : rc) {
+            Object v = c.getAccessor().invoke(o);
+            if (v instanceof double[] arr) {
+                for (double d : arr) list.add(d);
+            } else if (v instanceof Number num) {
+                list.add(num.doubleValue());
+            }
+        }
+        double[] out = new double[list.size()];
+        for (int i = 0; i < out.length; i++) out[i] = list.get(i);
+        return out;
+    }
+
+    private static double[] flattenArray(Object arr) throws Exception {
+        int len = Array.getLength(arr);
+        List<Double> list = new ArrayList<>();
+        for (int i = 0; i < len; i++) {
+            for (double d : flattenRecord(Array.get(arr, i))) list.add(d);
+        }
+        double[] out = new double[list.size()];
+        for (int i = 0; i < out.length; i++) out[i] = list.get(i);
+        return out;
+    }
+
+    private static Object construct(Spec s) throws Exception {
+        Class<?> cls = Class.forName("org.wickra." + s.canonical());
+        Constructor<?> ctor = cls.getConstructors()[0];
+        Class<?>[] pt = ctor.getParameterTypes();
+        Object[] args = new Object[pt.length];
+        for (int i = 0; i < pt.length; i++) {
+            double v = s.params()[i];
+            if (pt[i] == int.class) args[i] = (int) Math.round(v);
+            else if (pt[i] == long.class) args[i] = (long) Math.round(v);
+            else args[i] = v;
+        }
+        return ctor.newInstance(args);
+    }
+
+    private static Method updateMethod(Object ind) {
+        for (Method m : ind.getClass().getMethods()) {
+            if (m.getName().equals("update")) return m;
+        }
+        throw new IllegalStateException("no update on " + ind.getClass());
+    }
+
+    private static double[] row(Spec s, Object ind, Method upd, double[] r, int i) throws Exception {
+        double o = r[0], h = r[1], l = r[2], c = r[3], v = r[4];
+        Object res = switch (s.arch()) {
+            case "scalar_f64", "multi_f64" -> upd.invoke(ind, c);
+            case "pairwise", "multi_pairwise" -> upd.invoke(ind, c, o);
+            case "scalar_candle", "multi_candle", "profile_bins", "profile_pricebins" ->
+                upd.invoke(ind, o, h, l, c, v, (long) i);
+            case "trade" -> upd.invoke(ind, c, v, c >= o, (long) i);
+            case "trademid" -> upd.invoke(ind, c, v, c >= o, (long) i, (h + l) / 2);
+            case "ob" -> upd.invoke(ind, obList(r, 0), obList(r, 1), obList(r, 2), obList(r, 3));
+            case "cross" -> upd.invoke(ind, crossList(r, 0), crossList(r, 1), crossList(r, 2),
+                crossList(r, 3), crossList(r, 4), crossList(r, 5), (long) i);
+            case "deriv", "deriv_multi" -> {
+                double[] d = derivFields(r);
+                yield upd.invoke(ind, d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], d[8], d[9], d[10], (long) i);
+            }
+            case "bars_close" -> upd.invoke(ind, c, c, c, c, 1.0, 0L);
+            case "bars_candle4" -> upd.invoke(ind, o, h, l, c, 1.0, 0L);
+            case "bars_candle5" -> upd.invoke(ind, o, h, l, c, v, 0L);
+            case "footprint" -> upd.invoke(ind, c, v, c >= o, (long) i);
+            default -> throw new IllegalStateException("arch " + s.arch());
+        };
+        return switch (s.arch()) {
+            case "scalar_f64", "scalar_candle", "pairwise", "trade", "trademid", "ob", "cross", "deriv" ->
+                new double[]{((Number) res).doubleValue()};
+            case "multi_f64", "multi_candle", "multi_pairwise", "deriv_multi", "profile_pricebins" ->
+                res == null ? nanRow(s.width()) : flattenRecord(res);
+            case "profile_bins" -> res == null ? nanRow(s.width()) : (double[]) res;
+            default -> flattenArray(res); // bars_*, footprint
+        };
+    }
+
+    @TestFactory
+    List<DynamicTest> golden() throws Exception {
+        double[][] rows = input();
+        List<DynamicTest> tests = new ArrayList<>();
+        for (Spec s : SPECS) {
+            tests.add(dynamicTest(s.canonical(), () -> {
+                Object ind = construct(s);
+                String gotName = (String) ind.getClass().getMethod("name").invoke(ind);
+                assertTrue(gotName.equals(NAMES.get(s.canonical())),
+                    s.canonical() + ": name() " + gotName + " != " + NAMES.get(s.canonical()));
+                Method upd = updateMethod(ind);
+                double[][] exp = fixture(s.canonical());
+                assertTrue(exp.length == rows.length, s.canonical() + ": row count " + exp.length + " vs " + rows.length);
+                for (int i = 0; i < rows.length; i++) {
+                    double[] got = row(s, ind, upd, rows[i], i);
+                    double[] want = exp[i];
+                    assertTrue(got.length == want.length,
+                        s.canonical() + " row " + i + ": arity " + got.length + " vs " + want.length);
+                    for (int k = 0; k < want.length; k++) {
+                        double w = want[k], g = got[k];
+                        if (Double.isNaN(w)) {
+                            assertTrue(Double.isNaN(g), s.canonical() + " row " + i + " col " + k + ": want NaN got " + g);
+                        } else if (Double.isInfinite(w)) {
+                            assertTrue(Double.isInfinite(g) && Math.signum(g) == Math.signum(w),
+                                s.canonical() + " row " + i + " col " + k + ": want " + w + " got " + g);
+                        } else {
+                            double tol = TOL * Math.max(1.0, Math.abs(w));
+                            assertTrue(Math.abs(g - w) <= tol,
+                                s.canonical() + " row " + i + " col " + k + ": got " + g + " want " + w);
+                        }
+                    }
+                }
+            }));
+        }
+        return tests;
+    }
+}
+'''
+
+out = TEMPLATE.replace("%SPECS%", specs_block).replace("%NAMES%", names_block)
+dest = os.path.join(ROOT, "bindings", "java", "src", "test", "java", "org", "wickra", "GoldenAllTest.java")
+open(dest, "w", encoding="utf-8").write(out)
+print("generated GoldenAllTest.java with", len(MAN), "indicators")

bindings/java/osv-scanner.toml

@@ -0,0 +1,12 @@
+# OSV-Scanner suppression for this Maven manifest. OSV-Scanner looks for an
+# osv-scanner.toml next to each manifest it scans, and the repo-root config does
+# not cover Maven sub-directory scans — so the jackson finding is suppressed
+# here as well. See the root osv-scanner.toml and the SECURITY.md VEX section.
+#
+# tools.jackson.core:jackson-core 3.x is NOT a dependency of this project. Full
+# Maven resolution (the publishing plugin tree and the project dependency tree)
+# resolves only jackson 2.16.1 / 2.17.1; tools.jackson 3.x appears nowhere.
+# OSV-Scanner's own resolver flags it as a false positive.
+[[IgnoredVulns]]
+id = "GHSA-72hv-8253-57qq"
+reason = "tools.jackson.core:jackson-core 3.x is not a dependency; only jackson 2.x resolves. Not affected."