release: bump 0.4.2 -> 0.4.3 (#125)

* feat: effective spread microstructure indicator (part 3 of 4)

* feat: realized spread microstructure indicator (part 3 of 4)

* feat: kyle's lambda microstructure indicator (part 3 of 4)

* feat: depth slope microstructure indicator (part 3 of 4)

.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,3 @@
+# 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

.github/CODEOWNERS

@@ -3,4 +3,4 @@
 # The owner listed here is requested for review automatically on every pull
 # request. See https://docs.github.com/articles/about-code-owners.
 
-*       @kingchenc
+*       @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

@@ -1,7 +1,7 @@
 ---
 name: Bug report
 about: Report incorrect behaviour in Wickra
-title: "[bug] "
+title: "[Bug] "
 labels: bug
 assignees: ""
 ---
@@ -32,7 +32,7 @@ assignees: ""
 - Wickra version:
 - Language / binding: <!-- Rust crate / Python / Node / WASM -->
 - OS and architecture:
-- Rust / Python / Node version (if relevant):
+- Rust / Python / Node version (If relevant):
 
 ## Additional context
 

.github/ISSUE_TEMPLATE/bug_report_detailed.md

@@ -0,0 +1,56 @@
+---
+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`)
+- [ ] WebAssembly
+- [ ] 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 version | `python --version` / `node --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

@@ -1,8 +1,8 @@
 blank_issues_enabled: false
 contact_links:
   - name: Security vulnerability
-    url: https://github.com/kingchenc/wickra/security/advisories/new
+    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/kingchenc/wickra/discussions
+    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

@@ -1,7 +1,7 @@
 ---
 name: Feature request
 about: Suggest a new indicator or capability for Wickra
-title: "[feature] "
+title: "[Feature] "
 labels: enhancement
 assignees: ""
 ---

.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 / Wasm`
+- 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 / Wasm`

.github/PULL_REQUEST_TEMPLATE.md

@@ -23,9 +23,10 @@
 - [ ] `cargo test --workspace` passes.
 - [ ] New behaviour has tests; bug fixes have a regression test.
 - [ ] Public API changes are mirrored in the Python / Node / WASM bindings
-      and their type stubs (if applicable).
-- [ ] Documentation under `docs/wiki/` and the `README.md` is updated
-      (if applicable).
+      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

.github/PULL_REQUEST_TEMPLATE/detailed.md

@@ -0,0 +1,67 @@
+<!--
+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`)
+- [ ] WebAssembly binding (`bindings/wasm`)
+- [ ] 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 (PolyForm-NC-1.0.0)
+
+## Notes for reviewers
+
+<!-- Anything reviewers should look at first, known follow-ups, deliberately out-of-scope items. -->

.github/dependabot.yml

@@ -27,6 +27,19 @@ updates:
     commit-message:
       prefix: "deps(pip)"
 
+  # 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
+    commit-message:
+      prefix: "deps(ci-pip)"
+
   # 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

.github/requirements/bench.in

@@ -0,0 +1,9 @@
+# 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
+talipp
+finta

.github/requirements/bench.txt

@@ -0,0 +1,167 @@
+# This file was autogenerated by uv via the following command:
+#    ./scripts/update-lockfiles.sh
+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
+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
+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
+talipp==2.7.0 \
+    --hash=sha256:567f59ad74366cb59a14a00d350f35fd9d22e6924d6228bad581e6dcf1de2205 \
+    --hash=sha256:f749f22b9ad615605e71faf26457bb7f5e3fe16f04d3287f4ca54fd16bc3d4eb
+    # 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

@@ -22,8 +22,26 @@ on:
         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:
@@ -35,16 +53,39 @@ jobs:
       - uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
 
       - 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
-          python -m pip install maturin numpy pandas talipp finta
+          # 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
@@ -56,10 +97,16 @@ jobs:
 
       - 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 ${{ github.event.inputs.size || '20000' }} \
-            --iterations ${{ github.event.inputs.iterations || '10' }} \
+            --size "$BENCH_SIZE" \
+            --iterations "$BENCH_ITERATIONS" \
             --streaming-window 5000 --streaming-iterations 2 \
             | tee benchmark.txt
 

.github/workflows/ci.yml

@@ -6,9 +6,29 @@ on:
   pull_request:
     branches: [main]
 
+# Least-privilege default for the auto-injected GITHUB_TOKEN. None of the CI
+# jobs write back to the repo — coverage uploads via CODECOV_TOKEN, everything
+# else is build/test/lint — so a read-only token is sufficient (OpenSSF
+# Scorecard: Token-Permissions).
+permissions:
+  contents: read
+
 env:
   CARGO_TERM_COLOR: always
   RUSTFLAGS: "-D warnings"
+  # Network-flake resilience: retry transient registry/DNS failures at the tool
+  # level so a blip fetching crates.io / npm / PyPI inside any build step (cargo,
+  # napi, maturin, wasm-pack, npm ci, pip) retries automatically instead of
+  # failing the job and needing a manual re-run. 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. Complements the setup-action /
+  # cache retries (which only covered toolchain download + cache restore).
+  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:
   rust:
@@ -28,6 +48,8 @@ jobs:
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
 
       - name: Format check
         run: cargo fmt --all -- --check
@@ -55,6 +77,158 @@ jobs:
         # streaming.
         run: cargo build -p wickra-examples --bins
 
+  # Syntax/parse smoke for the non-Rust examples. The Rust examples are built
+  # in the `rust` job above (`cargo build -p wickra-examples --bins`); the Node,
+  # browser-WASM and Python examples otherwise have no build gate, so a broken
+  # edit could land unnoticed. This is a parse-only smoke — actually running the
+  # examples needs the built native binding / wasm module / wheel, which the
+  # binding jobs provide separately.
+  examples-smoke:
+    name: Examples (syntax smoke)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Set up Node
+        id: setup_node
+        continue-on-error: true
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+
+      - name: Wait before Node retry
+        if: steps.setup_node.outcome == 'failure'
+        shell: bash
+        run: |
+          echo "::warning::setup-node failed (likely CDN flake), waiting 30s before retry..."
+          sleep 30
+
+      - name: Set up Node (retry)
+        if: steps.setup_node.outcome == 'failure'
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+
+      - name: Set up Python
+        id: setup_python
+        continue-on-error: true
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.12"
+
+      - 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.12"
+
+      - name: Node examples — syntax check
+        run: |
+          shopt -s nullglob
+          count=0
+          for f in examples/node/*.js examples/wasm/*.js; do
+            echo "node --check $f"
+            node --check "$f"
+            count=$((count + 1))
+          done
+          echo "checked $count Node/WASM .js files"
+
+      - name: WASM demo module scripts — syntax check
+        # The .html demos embed an ES module; extract it and parse-check so a
+        # broken edit to the in-page strategy logic fails CI.
+        run: |
+          shopt -s nullglob
+          count=0
+          for f in examples/wasm/*.html; do
+            node -e 'const fs=require("fs");const h=fs.readFileSync(process.argv[1],"utf8");const m=h.match(/<script type="module">([\s\S]*?)<\/script>/);if(!m){console.error("no <script type=module> in "+process.argv[1]);process.exit(1);}fs.writeFileSync("module-check.mjs",m[1]);' "$f"
+            echo "node --check (module of) $f"
+            node --check module-check.mjs
+            count=$((count + 1))
+          done
+          rm -f module-check.mjs
+          echo "checked $count WASM .html module scripts"
+
+      - name: Python examples — byte-compile
+        run: |
+          shopt -s nullglob
+          count=0
+          for f in examples/python/*.py; do
+            echo "py_compile $f"
+            python -m py_compile "$f"
+            count=$((count + 1))
+          done
+          echo "compiled $count Python files"
+
+  # Clippy for the Python and Node bindings. These are kept out of the main
+  # `rust` job because PyO3 / napi build scripts need a Python interpreter and
+  # a Node toolchain on PATH, which the 3-OS matrix job does not provision.
+  # Ubuntu-only is sufficient: the lints are platform-independent.
+  clippy-bindings:
+    name: Clippy bindings
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
+        with:
+          components: clippy
+
+      - name: Set up Python
+        id: setup_python
+        continue-on-error: true
+        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.12"
+
+      - 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@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.12"
+
+      - name: Set up Node
+        id: setup_node
+        continue-on-error: true
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+
+      - name: Wait before Node retry
+        if: steps.setup_node.outcome == 'failure'
+        shell: bash
+        run: |
+          echo "::warning::setup-node failed (likely CDN flake), waiting 30s before retry..."
+          sleep 30
+
+      - name: Set up Node (retry)
+        if: steps.setup_node.outcome == 'failure'
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
+
+      - name: Clippy (bindings, all targets)
+        run: cargo clippy -p wickra-node -p wickra-python --all-targets -- -D warnings
+
   # Verify the crates still build and test on their declared minimum supported
   # Rust version. The workspace pins rust-version = "1.86" — that floor is
   # set by criterion 0.8.2 (the bench dev-dep), which itself rolled past the
@@ -87,6 +261,8 @@ jobs:
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
 
       - name: Build on MSRV
         run: cargo build ${{ matrix.packages }} --verbose
@@ -108,9 +284,12 @@ jobs:
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
 
       - name: Install cargo-llvm-cov
-        uses: taiki-e/install-action@6c1f7cf125e42770ff087ea443901b487cc5471a # v2.79.5
+        uses: taiki-e/install-action@0fd46367812ee04360509b4169d9f659d6892bb2 # v2.79.15
+        timeout-minutes: 10 # fail fast on a stuck download instead of hanging the job
         with:
           tool: cargo-llvm-cov
 
@@ -138,7 +317,7 @@ jobs:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: cargo-deny
-        uses: EmbarkStudios/cargo-deny-action@a531616d8ce3b9177443e48a1159bc945a099823 # v2.0.19
+        uses: EmbarkStudios/cargo-deny-action@bb137d7af7e4fb67e5f82a49c4fce4fad40782fe # v2.0.20
         with:
           command: check
 
@@ -160,6 +339,8 @@ jobs:
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
         with:
           workspaces: fuzz
 
@@ -171,7 +352,8 @@ jobs:
         # attributes the modern nightly compiler rejects, so the install
         # never gets off the ground. The prebuilt binary avoids the entire
         # transitive-dep compile.
-        uses: taiki-e/install-action@6c1f7cf125e42770ff087ea443901b487cc5471a # v2.79.5
+        uses: taiki-e/install-action@0fd46367812ee04360509b4169d9f659d6892bb2 # v2.79.15
+        timeout-minutes: 10 # fail fast on a stuck download instead of hanging the job
         with:
           tool: cargo-fuzz
 
@@ -211,16 +393,50 @@ jobs:
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
 
+      # setup-python downloads the interpreter from the Actions tool cache /
+      # nodejs CDN and occasionally hangs or 5xx's on the Windows runners.
+      # Run it with continue-on-error, then retry once after a backoff so a
+      # single CDN flake does not fail the whole job (see also: GitHub
+      # Actions runner-images#7061).
       - name: Set up Python
+        id: setup_python
+        continue-on-error: true
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ matrix.python-version }}
+          cache: pip
+          cache-dependency-path: .github/requirements/ci-dev-*.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: ${{ matrix.python-version }}
+          cache: pip
+          cache-dependency-path: .github/requirements/ci-dev-*.txt
 
       - name: Install Python dev dependencies
+        shell: bash
         run: |
           python -m pip install --upgrade pip
-          python -m pip install maturin pytest numpy hypothesis
+          # Hash-locked dev tooling (OpenSSF Scorecard PinnedDependencies).
+          # Split by Python version: numpy ships no single release with wheels
+          # for both cp39 and cp313 (<=2.0.2 has cp39 only, >=2.1 drops cp39).
+          if [ "${{ matrix.python-version }}" = "3.9" ]; then
+            python -m pip install --require-hashes -r .github/requirements/ci-dev-py39.txt
+          else
+            python -m pip install --require-hashes -r .github/requirements/ci-dev-py3.txt
+          fi
 
       - name: Build wheel
         working-directory: bindings/python
@@ -229,7 +445,12 @@ jobs:
       - name: Install wheel
         shell: bash
         working-directory: bindings/python
-        run: python -m pip install --find-links dist --force-reinstall wickra
+        # --no-index forces pip to ignore PyPI; --no-deps skips re-resolving
+        # numpy (already installed in the previous step). Without --no-index
+        # pip prefers the PyPI 0.2.x wheel over our freshly built one when
+        # platform tags overlap (e.g. macOS arm64), so tests would run
+        # against the released package and miss any new symbols the PR adds.
+        run: python -m pip install --no-index --find-links dist --force-reinstall --no-deps wickra
 
       - name: Run Python tests
         working-directory: bindings/python
@@ -248,9 +469,21 @@ jobs:
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
 
       - name: Install wasm-pack
-        uses: jetli/wasm-pack-action@0d096b08b4e5a7de8c28de67e11e945404e9eefa # v0.4.0
+        # jetli/wasm-pack-action@v0.4.0 with no `version:` input installs an
+        # old wasm-pack (~0.10.x) whose `build` subcommand does not yet accept
+        # `--features`, so `wasm-pack build … --features panic-hook` fails
+        # with "Found argument '--features' which wasn't expected". Use the
+        # same taiki-e prebuilt-binary installer we already use for
+        # cargo-llvm-cov and cargo-fuzz; it tracks the latest wasm-pack
+        # release, which has `--features` as a top-level flag (since 0.12).
+        uses: taiki-e/install-action@0fd46367812ee04360509b4169d9f659d6892bb2 # v2.79.15
+        timeout-minutes: 10 # fail fast on a stuck download instead of hanging the job
+        with:
+          tool: wasm-pack
 
       - name: Build WASM package
         run: wasm-pack build bindings/wasm --target web --release --features panic-hook
@@ -280,15 +513,40 @@ jobs:
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
 
+      # setup-node downloads Node from nodejs.org and we've seen it fail on
+      # Windows runners with "Attempting to download 18..." followed by a
+      # silent hang or curl error. Retry once after a backoff so a single
+      # CDN flake does not fail the whole job.
       - name: Set up Node
+        id: setup_node
+        continue-on-error: true
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: ${{ matrix.node-version }}
+          cache: npm
+          cache-dependency-path: bindings/node/package-lock.json
+
+      - name: Wait before Node retry
+        if: steps.setup_node.outcome == 'failure'
+        shell: bash
+        run: |
+          echo "::warning::setup-node failed (likely CDN flake), waiting 30s before retry..."
+          sleep 30
+
+      - name: Set up Node (retry)
+        if: steps.setup_node.outcome == 'failure'
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+          cache-dependency-path: bindings/node/package-lock.json
 
       - name: Install Node dependencies
         working-directory: bindings/node
-        run: npm install
+        run: npm ci
 
       - name: Build native module
         working-directory: bindings/node

.github/workflows/codeql.yml

@@ -0,0 +1,54 @@
+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@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@03e4368ac7daa2bd82b3e85262f3bf87ee112f57 # v3.36.0
+        with:
+          languages: ${{ matrix.language }}
+          build-mode: ${{ matrix.build-mode }}
+
+      - name: Perform CodeQL analysis
+        uses: github/codeql-action/analyze@03e4368ac7daa2bd82b3e85262f3bf87ee112f57 # v3.36.0
+        with:
+          category: "/language:${{ matrix.language }}"

.github/workflows/release.yml

@@ -5,8 +5,30 @@ on:
     tags: ["v*"]
   workflow_dispatch:
 
+# Least-privilege default for the auto-injected GITHUB_TOKEN. The publish jobs
+# (cargo/python/node) push to external registries via their own secrets
+# (CARGO_REGISTRY_TOKEN / PYPI_API_TOKEN / NPM_TOKEN), not the GITHUB_TOKEN, so
+# they need no repo write. The jobs that genuinely write through the
+# GITHUB_TOKEN — github-release (contents: write), node-/wasm-publish and
+# attestations (id-token / attestations: write) — declare those rights in their
+# own job-level permissions blocks, which override this default (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 / npm inside any build or publish step
+  # (cargo, napi, maturin, wasm-pack, npm) 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.
+  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:
   # --------------------------------------------------------------------------
@@ -26,6 +48,8 @@ jobs:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
       - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
 
       # Idempotent publishing: if the version is already on crates.io we
       # treat that as success so re-runs of the workflow don't fail.
@@ -79,6 +103,35 @@ jobs:
           name: crate-files
           path: target/package/*.crate
 
+      # CycloneDX SBOM per published crate. Attached to the GitHub Release
+      # alongside the .crate / .whl / .tgz artefacts so downstream
+      # consumers can audit the published dependency tree without
+      # re-resolving Cargo.lock.
+      - name: Install cargo-cyclonedx
+        uses: taiki-e/install-action@0fd46367812ee04360509b4169d9f659d6892bb2 # v2.79.15
+        timeout-minutes: 10 # fail fast on a stuck download instead of hanging the job
+        with:
+          tool: cargo-cyclonedx
+
+      - name: Generate CycloneDX SBOMs
+        run: |
+          # cargo-cyclonedx walks the whole workspace in a single pass and
+          # writes a <package>.cdx.json next to each member's Cargo.toml; it
+          # has no -p/--package selector. Collect the three crates.io crates
+          # (the .crate files published by this job) into the upload dir.
+          cargo cyclonedx --format json --top-level
+          mkdir -p sboms
+          cp crates/wickra-core/wickra-core.cdx.json sboms/
+          cp crates/wickra-data/wickra-data.cdx.json sboms/
+          cp crates/wickra/wickra.cdx.json sboms/
+          ls -lh sboms/
+
+      - name: Upload SBOMs
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: sboms
+          path: sboms/*.cdx.json
+
   # --------------------------------------------------------------------------
   # PyPI: cross-platform wheels + sdist
   # --------------------------------------------------------------------------
@@ -103,9 +156,26 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+      - name: Set up Python
+        id: setup_python
+        continue-on-error: true
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: "3.11"
+      - 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"
+      - name: Sync root README into bindings/python so it ships with the wheel
+        shell: bash
+        run: cp README.md bindings/python/README.md
       - uses: PyO3/maturin-action@e83996d129638aa358a18fbd1dfb82f0b0fb5d3b # v1.51.0
         with:
           working-directory: bindings/python
@@ -124,6 +194,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Sync root README into bindings/python so it ships in the sdist
+        run: cp README.md bindings/python/README.md
       - uses: PyO3/maturin-action@e83996d129638aa358a18fbd1dfb82f0b0fb5d3b # v1.51.0
         with:
           working-directory: bindings/python
@@ -168,20 +240,28 @@ jobs:
           - { host: macos-latest, target: x86_64-apple-darwin }
           - { host: macos-latest, target: aarch64-apple-darwin }
           - { host: windows-latest, target: x86_64-pc-windows-msvc }
-          # NOTE: aarch64-pc-windows-msvc is temporarily skipped for 0.2.1.
-          # The wickra-win32-arm64-msvc npm subpackage name is blocked by the
-          # npm spam-detection filter for new accounts (same situation that
-          # affected wickra-win32-x64-msvc through 0.1.4 until npm Support
-          # unblocked it). A support ticket is open; once the new arm64 name
-          # is unblocked this matrix entry will be restored alongside the
-          # corresponding optionalDependencies / napi.triples / npm/<target>
-          # entries in a follow-up release.
-          # - { host: windows-11-arm, target: aarch64-pc-windows-msvc }
+          - { host: windows-11-arm, target: aarch64-pc-windows-msvc }
     runs-on: ${{ matrix.host }}
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
-      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+      - name: Set up Node
+        id: setup_node
+        continue-on-error: true
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+
+      - name: Wait before Node retry
+        if: steps.setup_node.outcome == 'failure'
+        shell: bash
+        run: |
+          echo "::warning::setup-node failed (likely CDN flake), waiting 30s before retry..."
+          sleep 30
+
+      - name: Set up Node (retry)
+        if: steps.setup_node.outcome == 'failure'
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: "20"
 
@@ -190,10 +270,12 @@ jobs:
           targets: ${{ matrix.target }}
 
       - 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: Install Node deps
         working-directory: bindings/node
-        run: npm install
+        run: npm ci
 
       - name: Build native module
         working-directory: bindings/node
@@ -211,17 +293,42 @@ jobs:
     needs: node-build
     runs-on: ubuntu-latest
     environment: release
+    # `id-token: write` lets npm publish embed a Sigstore provenance
+    # attestation generated from the GitHub Actions OIDC token. The npm
+    # registry then shows a "Verified provenance" badge and lets
+    # consumers verify the package was built from this exact workflow
+    # run.
+    permissions:
+      contents: read
+      id-token: write
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
-      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+      - name: Set up Node
+        id: setup_node
+        continue-on-error: true
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Wait before Node retry
+        if: steps.setup_node.outcome == 'failure'
+        shell: bash
+        run: |
+          echo "::warning::setup-node failed (likely CDN flake), waiting 30s before retry..."
+          sleep 30
+
+      - name: Set up Node (retry)
+        if: steps.setup_node.outcome == 'failure'
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: "20"
           registry-url: "https://registry.npmjs.org"
 
       - name: Install Node deps
         working-directory: bindings/node
-        run: npm install
+        run: npm ci
 
       - name: Download all platform binaries
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
@@ -269,13 +376,13 @@ jobs:
             # scripts during publish (npm runs prepublishOnly/prepare/etc. from
             # the package being published — a malicious or stray script would
             # execute with the npm token in the environment).
-            (cd "$dir" && npm publish --access public --ignore-scripts)
+            (cd "$dir" && npm publish --access public --ignore-scripts --provenance)
             local rc=$?
             echo "::endgroup::"
             if [ "$rc" -ne 0 ]; then
               echo "::warning::first attempt of $pkgname failed (rc=$rc); retrying after 30s"
               sleep 30
-              (cd "$dir" && npm publish --access public --ignore-scripts)
+              (cd "$dir" && npm publish --access public --ignore-scripts --provenance)
               rc=$?
             fi
             if [ "$rc" -ne 0 ]; then
@@ -289,6 +396,14 @@ jobs:
           done
           exit $fail
 
+      - name: Sync root README into bindings/node so it ships with the npm tarball
+        # npm reads README.md from the package directory at publish time. Copy
+        # the canonical root README in just before the publish so every
+        # registry shows the same project page.
+        shell: bash
+        run: cp ../../README.md README.md
+        working-directory: bindings/node
+
       - name: Publish main package to npm (idempotent)
         working-directory: bindings/node
         env:
@@ -308,12 +423,12 @@ jobs:
           # --ignore-scripts so any leftover prepublish hooks (which would
           # otherwise try to republish the already-published platform
           # subpackages) can't sabotage the main publish.
-          npm publish --access public --ignore-scripts
+          npm publish --access public --ignore-scripts --provenance
           rc=$?
           if [ "$rc" -ne 0 ]; then
             echo "::warning::first attempt failed (rc=$rc); retrying after 30s"
             sleep 30
-            npm publish --access public --ignore-scripts
+            npm publish --access public --ignore-scripts --provenance
             rc=$?
           fi
           exit $rc
@@ -341,14 +456,39 @@ jobs:
   # --------------------------------------------------------------------------
   # WASM: wasm-pack build + npm publish (as `wickra-wasm`)
   # --------------------------------------------------------------------------
+  # Note: this job's npm publish call uses `--provenance` (see below),
+  # which requires the `id-token: write` permission set at the job level.
   wasm-publish:
     name: Publish wickra-wasm to npm
     runs-on: ubuntu-latest
     environment: release
+    # `id-token: write` lets npm publish embed a Sigstore provenance
+    # attestation generated from the GitHub Actions OIDC token (same
+    # mechanism as the node-publish job above).
+    permissions:
+      contents: read
+      id-token: write
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
-      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+      - name: Set up Node
+        id: setup_node
+        continue-on-error: true
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Wait before Node retry
+        if: steps.setup_node.outcome == 'failure'
+        shell: bash
+        run: |
+          echo "::warning::setup-node failed (likely CDN flake), waiting 30s before retry..."
+          sleep 30
+
+      - name: Set up Node (retry)
+        if: steps.setup_node.outcome == 'failure'
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: "20"
           registry-url: "https://registry.npmjs.org"
@@ -357,7 +497,19 @@ jobs:
         with:
           targets: wasm32-unknown-unknown
 
-      - uses: jetli/wasm-pack-action@0d096b08b4e5a7de8c28de67e11e945404e9eefa # v0.4.0
+      - name: Install wasm-pack (latest, via prebuilt binary)
+        # See the matching note in ci.yml: jetli's default installs an old
+        # 0.10.x wasm-pack whose build subcommand rejects --features.
+        uses: taiki-e/install-action@0fd46367812ee04360509b4169d9f659d6892bb2 # v2.79.15
+        timeout-minutes: 10 # fail fast on a stuck download instead of hanging the job
+        with:
+          tool: wasm-pack
+
+      - name: Sync root README into bindings/wasm so wasm-pack ships it in pkg/
+        # wasm-pack copies the crate's README.md into the generated pkg/
+        # directory it then publishes. Refresh it from the canonical root
+        # README right before the build.
+        run: cp README.md bindings/wasm/README.md
 
       - name: Build WASM package (bundler target)
         run: wasm-pack build bindings/wasm --target bundler --release --features panic-hook
@@ -368,10 +520,10 @@ jobs:
           node -e "
             const fs = require('fs');
             const pkg = JSON.parse(fs.readFileSync('package.json'));
-            pkg.author = 'kingchenc <kingchencp@gmail.com>';
-            pkg.repository = { type: 'git', url: 'https://github.com/kingchenc/wickra' };
-            pkg.homepage = 'https://github.com/kingchenc/wickra';
-            pkg.bugs = { url: 'https://github.com/kingchenc/wickra/issues' };
+            pkg.author = 'kingchenc <support@wickra.org>';
+            pkg.repository = { type: 'git', url: 'https://github.com/wickra-lib/wickra' };
+            pkg.homepage = 'https://github.com/wickra-lib/wickra';
+            pkg.bugs = { url: 'https://github.com/wickra-lib/wickra/issues' };
             pkg.license = 'PolyForm-Noncommercial-1.0.0';
             fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2));
           "
@@ -389,7 +541,7 @@ jobs:
       - name: Publish wickra-wasm to npm (idempotent)
         working-directory: bindings/wasm/pkg
         run: |
-          out=$(npm publish --access public 2>&1) && echo "$out" \
+          out=$(npm publish --access public --provenance 2>&1) && echo "$out" \
             || (echo "$out" | grep -q "You cannot publish over" && echo "skip: version already on npm" \
                 || (echo "$out"; exit 1))
         env:
@@ -397,13 +549,24 @@ jobs:
 
   # --------------------------------------------------------------------------
   # GitHub Release: attach every built artefact to the tag's release page.
+  #
+  # The release is created as a DRAFT here and only flipped to published by the
+  # downstream publish-release job, after the provenance bundle is attached. That
+  # ordering (draft -> attach everything -> publish) makes the pipeline compatible
+  # with GitHub release immutability, which locks assets at publish time (P24):
+  # the old "publish, then upload provenance" order would have the provenance
+  # upload rejected once immutability is enabled.
   # --------------------------------------------------------------------------
   github-release:
-    name: Attach assets to the GitHub Release
+    name: Attach assets to the draft GitHub Release
     needs: [cargo-publish, python-publish, node-publish, wasm-publish]
     runs-on: ubuntu-latest
     permissions:
       contents: write
+    # Expose the resolved tag so the attestations job can attach the provenance
+    # bundle to this same release without re-resolving it.
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
@@ -443,10 +606,12 @@ jobs:
           find artifacts -type f -name "wickra-*.tgz" -exec cp {} release-assets/ \;
           # Cargo .crate files (one per workspace member).
           find artifacts -type f -name "*.crate" -exec cp {} release-assets/ \;
+          # CycloneDX SBOMs (one per published crate).
+          find artifacts -type f -name "*.cdx.json" -exec cp {} release-assets/ \;
           ls -lh release-assets/
           echo "asset-count=$(ls release-assets/ | wc -l)"
 
-      - name: Create / update GitHub Release with assets
+      - name: Create / update the draft GitHub Release with assets
         uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
         with:
           tag_name: ${{ steps.tag.outputs.tag }}
@@ -454,6 +619,9 @@ jobs:
           files: release-assets/*
           generate_release_notes: true
           fail_on_unmatched_files: false
+          # Created as a draft; publish-release flips it to published + latest once
+          # the provenance bundle is attached (P24, immutability-ready).
+          draft: true
           body: |
             Wickra ${{ github.ref_name }} — streaming-first technical indicators across 4 language registries.
 
@@ -479,4 +647,110 @@ jobs:
 
             ### Auto-generated changelog
 
-            See below; GitHub computes it from the commits since the previous tag.
+            See below; GitHub computes it from the commits since the previous tag.
+
+  # --------------------------------------------------------------------------
+  # Build provenance attestations (findings P13.2)
+  # --------------------------------------------------------------------------
+  attestations:
+    name: Attest build provenance
+    needs: [cargo-publish, python-wheels, python-sdist, github-release]
+    runs-on: ubuntu-latest
+    # Signed SLSA build-provenance attestations for the published crates and
+    # Python wheels/sdist. npm tarballs already carry inline Sigstore provenance
+    # from `npm publish --provenance`, so they are covered there.
+    #
+    # The job stays isolated from the *publishes*: cargo/PyPI/npm all run upstream
+    # of github-release, so a Sigstore hiccup here can never block or corrupt a
+    # publish (the isolation the SBOM step lacked before #79). It additionally
+    # `needs: github-release` so the (still-draft) GitHub Release already exists
+    # when it attaches the provenance bundle as a release asset (P21.1e) — OpenSSF
+    # Scorecard's Signed-Releases check scans release *assets* (*.intoto.jsonl),
+    # not GitHub's separate attestations store, so the bundle has to live on the
+    # release. The release is published afterwards by the publish-release job
+    # whether or not this attestation succeeds (P24), so a failure here still only
+    # costs the provenance asset, never the release.
+    permissions:
+      id-token: write # OIDC for keyless Sigstore signing
+      attestations: write # write the attestations to this repo
+      contents: write # upload the provenance bundle as a release asset
+    steps:
+      - name: Download crate files
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: crate-files
+          path: artifacts/crates
+      - name: Download wheels + sdist
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: wheels-*
+          path: artifacts/python
+          merge-multiple: true
+      - name: Attest build provenance
+        id: attest
+        uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
+        with:
+          subject-path: |
+            artifacts/crates/*.crate
+            artifacts/python/*.whl
+            artifacts/python/*.tar.gz
+
+      # Attach the Sigstore provenance bundle to the GitHub Release as a
+      # `*.intoto.jsonl` asset so OpenSSF Scorecard's Signed-Releases check finds
+      # signed provenance on the release itself (P21.1e). attest-build-provenance
+      # writes a single JSONL bundle covering every subject above; copy it to a
+      # `.intoto.jsonl`-suffixed name and upload with --clobber so re-runs are
+      # idempotent. github.token has contents: write here, which is all gh needs.
+      - name: Attach provenance bundle to the GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ needs.github-release.outputs.tag }}
+          BUNDLE: ${{ steps.attest.outputs.bundle-path }}
+        run: |
+          if [ -z "$TAG" ]; then
+            echo "::error::no tag resolved from github-release; cannot attach provenance."
+            exit 1
+          fi
+          if [ -z "$BUNDLE" ] || [ ! -f "$BUNDLE" ]; then
+            echo "::error::attestation bundle not found at '$BUNDLE'."
+            exit 1
+          fi
+          dest="wickra-${TAG}.provenance.intoto.jsonl"
+          cp "$BUNDLE" "$dest"
+          echo "Uploading $dest to release $TAG"
+          gh release upload "$TAG" "$dest" --clobber --repo "${{ github.repository }}"
+
+  # --------------------------------------------------------------------------
+  # Publish the drafted release LAST (P24 — immutability-ready).
+  #
+  # github-release creates the release as a draft and attestations attaches the
+  # provenance bundle to it; only now, with every asset in place, is it flipped to
+  # published + latest. With GitHub release immutability enabled, assets lock at
+  # this publish step — so the provenance bundle and every build artefact are
+  # already present and never need a (rejected) post-publish upload.
+  #
+  # `if: always() && needs.github-release.result == 'success'` preserves the old
+  # robustness: the release is published whenever the draft was created, even if
+  # the attestations job hit a Sigstore hiccup — that only costs the provenance
+  # asset, exactly as before. If github-release was skipped (a publish job failed)
+  # there is no draft, so this is skipped too and no release is published.
+  # --------------------------------------------------------------------------
+  publish-release:
+    name: Publish the GitHub Release
+    needs: [github-release, attestations]
+    if: always() && needs.github-release.result == 'success'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # flip the draft release to published
+    steps:
+      - name: Flip the draft release to published (latest)
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ needs.github-release.outputs.tag }}
+        run: |
+          if [ -z "$TAG" ]; then
+            echo "::error::no tag resolved from github-release; cannot publish."
+            exit 1
+          fi
+          echo "::notice::publishing release $TAG (draft -> published, latest)"
+          gh release edit "$TAG" --draft=false --latest=true --repo "${{ github.repository }}"

.github/workflows/scorecard.yml

@@ -0,0 +1,49 @@
+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@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Run Scorecard analysis
+        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # Publish to the public OpenSSF endpoint that backs the README badge.
+          publish_results: true
+
+      - name: Upload SARIF artifact
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      - name: Upload SARIF to code-scanning
+        uses: github/codeql-action/upload-sarif@03e4368ac7daa2bd82b3e85262f3bf87ee112f57 # v3.36.0
+        with:
+          sarif_file: results.sarif

.github/workflows/sync-about.yml

@@ -0,0 +1,513 @@
+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 /
+#      .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: keep README in sync *before* a PR is merged, by pushing a
+# fix-up commit to the PR head branch. After squash-merge into main
+# the bot commit is folded into the single signed merge commit, so
+# main's history never shows an unsigned "sync indicator count" entry.
+#
+# The push to PR head uses the default `GITHUB_TOKEN`, whose pushes
+# explicitly do NOT trigger downstream workflows (anti-recursion
+# policy). So a counter fix-up does not re-trigger ci.yml on the PR
+# — it does, however, re-trigger sync-about.yml on the next PR
+# `synchronize` event, which is what we want (a no-op if the counter
+# is now correct).
+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
+    # The only GITHUB_TOKEN write in this workflow: pushing the counter fix-up
+    # commit onto a same-repo PR head branch (git push origin HEAD:<ref>).
+    permissions:
+      contents: write
+      pull-requests: read
+    steps:
+      # On PRs from forks the head ref lives in another repo; pushing
+      # back to it from this workflow is blocked by GitHub. We still
+      # want the PR to surface the missing counter, so the check below
+      # falls back to a hard failure when push isn't possible.
+      - name: Determine if push to PR head is possible
+        id: ctx
+        # Untrusted PR contexts (head.ref / head.repo.full_name are attacker
+        # controlled on fork PRs) are passed through the environment, never
+        # interpolated straight into the shell, so a crafted branch name cannot
+        # inject commands (OpenSSF Scorecard: Dangerous-Workflow).
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          HEAD_REPO: ${{ github.event.pull_request.head.repo.full_name }}
+          BASE_REPO: ${{ github.repository }}
+          HEAD_REF: ${{ github.event.pull_request.head.ref }}
+        run: |
+          if [ "$EVENT_NAME" = "pull_request" ]; then
+            if [ "$HEAD_REPO" = "$BASE_REPO" ]; then
+              echo "can_push=true" >> "$GITHUB_OUTPUT"
+              echo "head_ref=$HEAD_REF" >> "$GITHUB_OUTPUT"
+            else
+              echo "can_push=false" >> "$GITHUB_OUTPUT"
+              echo "head_ref=" >> "$GITHUB_OUTPUT"
+            fi
+          else
+            echo "can_push=false" >> "$GITHUB_OUTPUT"
+            echo "head_ref=" >> "$GITHUB_OUTPUT"
+          fi
+
+      # On PRs we check out the *head* commit (not the merge ref) so
+      # any fix-up commit we make goes onto the PR branch itself. On
+      # push events we check out the default ref. fetch-depth: 0 lets
+      # us push back without "shallow update not allowed".
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.ref || github.ref }}
+          repository: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name || github.repository }}
+          # Default GITHUB_TOKEN is fine for the same-repo PR-branch
+          # push; the About / Wiki steps re-authenticate with the PAT
+          # below where needed.
+
+      - 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)
+        if: github.event_name == 'pull_request'
+        id: pr_check
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          if grep -qE "^${n} streaming-first indicators" README.md; then
+            echo "matches=true" >> "$GITHUB_OUTPUT"
+            echo "README counter already at ${n}; nothing to do."
+          else
+            echo "matches=false" >> "$GITHUB_OUTPUT"
+            echo "README counter does not match ${n}; will fix up."
+          fi
+
+      - name: Fix counter on fork PR head (read-only, fail loud)
+        if: github.event_name == 'pull_request' && steps.pr_check.outputs.matches == 'false' && steps.ctx.outputs.can_push == 'false'
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          echo "::error::README.md says a different indicator count than mod.rs (${n}). This PR is from a fork, so the workflow cannot push the fix; please update README.md to '${n} streaming-first indicators' and push again."
+          exit 1
+
+      - name: Patch README on PR head
+        if: github.event_name == 'pull_request' && steps.pr_check.outputs.matches == 'false' && steps.ctx.outputs.can_push == 'true'
+        id: pr_patch
+        run: |
+          n="${{ steps.count.outputs.count }}"
+          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" README.md
+          # Bump the banner cache-buster so GitHub's Camo proxy refetches the org
+          # profile image (regenerated with the new count by .github/banner.yml)
+          # instead of serving a stale cached copy.
+          sed -i -E "s|(wickra-banner\.webp\?v=)[0-9]+|\1${n}|" README.md
+          if git diff --quiet; then
+            echo "No README changes after sed (counter regex did not match anything); skipping push."
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Commit & push counter fix to PR head
+        if: github.event_name == 'pull_request' && steps.pr_patch.outputs.changed == 'true'
+        # head_ref still carries the (untrusted) PR branch name forwarded by the
+        # ctx step; pass it through the environment so the push refspec cannot be
+        # used to inject shell commands (OpenSSF Scorecard: Dangerous-Workflow).
+        env:
+          COUNT: ${{ steps.count.outputs.count }}
+          HEAD_REF: ${{ steps.ctx.outputs.head_ref }}
+        run: |
+          git config user.name "wickra-bot"
+          git config user.email "wickra-bot@users.noreply.github.com"
+          git add README.md
+          git commit -m "chore: sync indicator count to ${COUNT}"
+          git push origin "HEAD:${HEAD_REF}"
+
+      # ----- main / tag flow ------------------------------------------
+      #
+      # After a PR squash-merges, this workflow runs again on the push
+      # to main. README is already correct (it was fixed on the PR
+      # branch before the merge); the only outward syncs left are the
+      # GitHub About description (repo metadata, not a commit) and the
+      # wiki repo (separate repo, no main history pollution). 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, and WebAssembly 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
+          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
+          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 (crates.io / PyPI / npm): replace only the
+          # version number, leaving the trailing padding + pipe intact. The '.' in
+          # the quickstart pattern matches the literal backtick around the version
+          # without needing a backtick in this shell string. Historical "since
+          # X.Y.Z" references contain no such anchor and are never matched.
+          sed -i -E "s/^(\| (crates\.io|PyPI|npm) .*\| )[0-9]+\.[0-9]+\.[0-9]+/\1${version}/" overview.md
+          sed -i -E "s/(published crate is at version .)[0-9]+\.[0-9]+\.[0-9]+/\1${version}/" Quickstart-Rust.md
+          if git diff --quiet; then
+            echo "Docs version already at ${version}."
+            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
+          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 .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 .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
+          # 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 .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,22 @@
+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@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.12"
+      - name: Audit repo-metadata.toml drift
+        run: python .github/scripts/sync-metadata.py --check

.gitignore

@@ -44,9 +44,14 @@ tarpaulin-report.html
 # Node binding artifacts
 **/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/

ARCHITECTURE.md

@@ -0,0 +1,321 @@
+# 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 three 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 │
+   │   • 214 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     │      │     WASM       │
+│ (PyO3)  │         │ (napi-rs)    │      │ (wasm-bindgen) │
+└─────────┘         └──────────────┘      └────────────────┘
+```
+
+| 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` | WebAssembly binding | `wasm-bindgen`, 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:
+
+- **Welford's online variance** is used in `StdDev`, `Variance`, `ZScore`,
+  `BollingerBands`, and several others. Standard sum-of-squares is
+  catastrophically lossy for low-variance inputs; Welford's recurrence
+  keeps O(eps) error.
+- **Kahan summation** is used wherever rolling sums could span > 1e6
+  elements without resetting — currently only Hurst-exponent's R/S
+  chunks. Most rolling sums are bounded by the window size and don't need
+  it.
+- **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_trading.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 does not have automated tests yet.** Smoke-validated only
+  through the manual examples. Adding `wasm-bindgen-test` coverage is
+  on the roadmap.
+
+For the high-level project goals see [`ROADMAP.md`](ROADMAP.md); for
+day-to-day contribution mechanics see [`CONTRIBUTING.md`](CONTRIBUTING.md).

CHANGELOG.md

@@ -7,6 +7,657 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.3] - 2026-06-01
+
+### Added
+- **Microstructure family — price impact & depth (part 3).** Indicators over a
+  trade paired with the prevailing mid (`TradeQuote`) and over the order-book
+  depth profile, exposed in Rust, Python, Node and WASM:
+  - **Effective Spread** — `2 · D · (tradePrice − mid) / mid · 10_000` bps, the
+    realised round-trip cost of a single trade against the mid.
+  - **Realized Spread** — `2 · D · (tradePrice − mid_{t+horizon}) / mid_t ·
+    10_000` bps, the share of the effective spread a liquidity provider keeps
+    once the mid has moved over a configurable horizon.
+  - **Kyle's Lambda** — the rolling OLS slope of mid changes on signed volume
+    (`cov(Δmid, q) / var(q)`), the canonical price-impact / market-depth proxy.
+  - **Depth Slope** — the mean per-side OLS slope of cumulative resting size
+    against distance from the mid, measuring how fast the book thickens away
+    from the touch.
+- **Microstructure family — footprint (part 4).** **Footprint** decomposes the
+  volume traded in a bar across price buckets (`round(price / tick_size)`),
+  splitting each bucket into buy-initiated (ask) and sell-initiated (bid)
+  volume. A multi-output, variable-length indicator: every `update` returns the
+  full footprint accumulated since the last `reset`, exposed in Rust, Python
+  (`(k, 3)` arrays), Node (`{ price, bidVol, askVol }` rows) and WASM.
+
+## [0.4.2] - 2026-06-01
+
+### Added
+- **Microstructure family — order book (part 1).** A new family of indicators
+  that consume an order-book depth snapshot (`OrderBook` of sorted, uncrossed
+  bid/ask `Level`s) rather than OHLCV, exposed in Rust, Python, Node and WASM:
+  - **Order-Book Imbalance** — `OrderBookImbalanceTop1`, `OrderBookImbalanceTopN`
+    (configurable depth) and `OrderBookImbalanceFull` measure signed depth
+    pressure `(bidDepth − askDepth) / (bidDepth + askDepth)` over the top level,
+    the top-N levels, or the full book.
+  - **Microprice** — the size-weighted fair value
+    `(bidPx·askSz + askPx·bidSz) / (bidSz + askSz)`, tilting the mid toward the
+    side more likely to be hit.
+  - **Quoted Spread** — the top-of-book spread in basis points of the mid.
+- **Microstructure family — trade flow (part 2).** Indicators over a trade tape
+  (`Trade` with an aggressor `Side`), exposed in Rust, Python, Node and WASM:
+  - **Signed Volume** — per-trade size signed by aggressor side (`+size` buy,
+    `−size` sell).
+  - **Cumulative Volume Delta** — the running total of signed volume; reset to
+    re-anchor per session.
+  - **Trade Imbalance** — the rolling `(buyVol − sellVol)/(buyVol + sellVol)`
+    over a configurable window of trades.
+
+  New public value types `Level`, `OrderBook`, `Side`, `Trade` and `TradeQuote`
+  back this and the upcoming trade-flow and price-impact indicators. Python and
+  Node accept a batch over a list of snapshots; WASM exposes per-snapshot
+  `update`.
+- **Signed Doji encoding.** `Doji` gains an opt-in `.signed()` mode
+  (`Doji(signed=True)` in Python, `new Doji(true)` in Node and WASM) that
+  classifies a detected Doji by the position of its body within the bar range —
+  a dragonfly (long lower shadow) emits `+1.0` (bullish), a gravestone (long
+  upper shadow) emits `−1.0` (bearish), and a long-legged / standard Doji emits
+  `0.0` (neutral). The default construction is unchanged — a direction-less
+  `+1.0` / `0.0` detection flag — so existing callers are unaffected. This
+  completes the uniform `+1` bull / `−1` bear / `0` none sign convention across
+  every candlestick pattern, making the family a drop-in machine-learning
+  feature where bullish and bearish instances share a single dimension.
+
+### Fixed
+- **README banner now self-updates.** The top README banner points at the org
+  profile image that `.github/banner.yml` regenerates from the indicator count,
+  and `sync-about.yml` bumps a `?v=<count>` cache-buster so GitHub's Camo proxy
+  refetches it immediately. Also fixes the webpage indicator-count sync, which
+  silently crashed on a removed `public/hero.svg` and left the marketing site's
+  count (and its OG banner) stale.
+
+### Security
+- **CI dependency installs are pinned by hash.** The Node binding now installs
+  with `npm ci` (strict `package-lock.json`), and the Python CI/bench tooling is
+  installed from hash-locked `--require-hashes` requirements under
+  `.github/requirements/` (OpenSSF Scorecard PinnedDependencies). The `ci-dev`
+  tooling is locked twice — for Python 3.9 and for 3.10+ — because numpy ships no
+  single release with wheels for both cp39 and cp313. A new
+  `scripts/update-lockfiles.sh` regenerates every workspace lockfile (Rust, Node
+  and the hash-pinned Python requirements) via `uv`, and Dependabot keeps the
+  pinned requirements current.
+
+## [0.4.1] - 2026-06-01
+
+### Added
+- **Cross-asset pairwise indicators.** A new two-series family of
+  `Indicator<Input = (f64, f64)>` implementations that relate two distinct
+  assets rather than a single OHLCV stream. Each is exposed in Rust, Python,
+  Node, and WASM:
+  - **Pairwise Beta** (`PairwiseBeta`) — rolling OLS slope of one asset's
+    **log-returns** on another's. Unlike `Beta`, which regresses the raw inputs
+    it is fed, `PairwiseBeta` differences consecutive prices into log-returns
+    internally — the conventional way to measure cross-asset beta, where a beta
+    on price levels would be dominated by the shared trend.
+  - **Pair Spread Z-Score** (`PairSpreadZScore`) — the standardised log-spread
+    `ln(a) − β·ln(b)` of a pair, where `β` is a rolling-OLS hedge ratio and the
+    spread is z-scored over its own look-back. The canonical mean-reversion /
+    statistical-arbitrage entry signal, with independent `beta_period` and
+    `z_period` windows.
+  - **Lead–Lag Cross-Correlation** (`LeadLagCrossCorrelation`) — the integer
+    offset `k ∈ [−max_lag, max_lag]` that maximises `|corr(a[t], b[t+k])|`,
+    answering which of two assets leads the other and by how many bars. Emits
+    `{ lag, correlation }`; a positive lag means `a` leads `b`.
+  - **Cointegration** (`Cointegration`) — the Engle–Granger two-step screen for
+    pairs trading: a rolling OLS hedge ratio `β`, the spread (residual)
+    `a − (α + β·b)`, and an augmented Dickey–Fuller `t`-statistic on the spread
+    (configurable `adf_lags`). A strongly negative statistic flags a
+    mean-reverting, tradeable spread. Emits `{ hedge_ratio, spread, adf_stat }`.
+  - **Relative Strength A-vs-B** (`RelativeStrengthAB`) — the comparative
+    relative strength of two assets: the ratio line `a / b` together with its
+    moving average and its RSI, the classic asset-vs-asset / asset-vs-index
+    rotation screen. Emits `{ ratio, ratio_ma, ratio_rsi }`.
+
+## [0.4.0] - 2026-06-01
+
+### Added
+- **Build-provenance attestations for release artifacts.** The release workflow
+  now emits signed SLSA build-provenance attestations for the published crates
+  and Python wheels/sdist (`actions/attest-build-provenance`); npm packages
+  carry inline Sigstore provenance from `npm publish --provenance`. Every
+  published artifact is cryptographically traceable to this repository's release
+  workflow run.
+
+### Security
+- **CodeQL static analysis and OpenSSF Scorecard run in CI.** CodeQL (Rust,
+  Python, JavaScript) and the OpenSSF Scorecard workflow now run on every push;
+  results appear under Security → Code scanning and a public Scorecard badge is
+  shown in the README.
+- **CI workflows hardened against script injection.** Untrusted event contexts
+  (PR branch names, `workflow_dispatch` inputs) are passed through the step
+  environment instead of being interpolated directly into shell commands.
+
+### Changed
+- **Node binding: invalid indicator periods now throw instead of being silently
+  clamped.** The scalar-indicator constructors previously clamped `period = 0`
+  to `1`; every Node constructor now propagates the core's validation error
+  (e.g. `period must be greater than zero`), matching the Python and WASM
+  bindings and the Rust core. Constructing with a valid period is unaffected.
+- **Binding package READMEs are now per-ecosystem.** The Python, Node.js, and
+  WebAssembly READMEs were byte-identical 314-line copies of the workspace
+  README and had drifted out of sync (stale indicator count, Python snippets
+  shown on the Node and WASM package pages). Each is now a focused landing page
+  with the correct install command, a language-correct quick-start snippet, and
+  links to the canonical documentation — removing the manual three-way sync
+  burden. No code or API changes.
+- **CONTRIBUTING now states the correct MSRV (1.86 workspace / 1.88
+  `bindings/node`)** and documents that these are the dependency-forced floors,
+  kept minimal on purpose. The previous text claimed 1.75 / 1.77, which the
+  `msrv` CI job has enforced against since the criterion and napi-build bumps.
+
+## [0.3.1] - 2026-05-30
+
+### Fixed
+- **Release pipeline — CycloneDX SBOM generation.** `cargo-cyclonedx` has no
+  `-p`/`--package` selector; it walks the whole workspace in a single pass.
+  The `release.yml` SBOM step invoked it as `cargo cyclonedx … -p <crate>` and
+  aborted with `error: unexpected argument '-p' found`, which failed the
+  crates.io publish job *after* the crates were already published and skipped
+  the GitHub Release attach-assets job (no release page, no SBOM artefacts).
+  The step now runs a single workspace pass and collects the three crates.io
+  crate SBOMs. No library changes relative to 0.3.0 — this patch republishes
+  the same code with a working release pipeline.
+
+## [0.3.0] - 2026-05-30
+
+### Added
+- **Family 15 — Risk / Performance metrics (17 new indicators).** Implemented
+  pragmatically as standard `Indicator`s rather than a separate
+  `wickra-metrics` crate; the input is a scalar `f64` per bar (period return,
+  equity sample, or trade P&L depending on the metric).
+  - **Scalar `Indicator<f64>` — 14 metrics:** Sharpe Ratio, Sortino Ratio,
+    Calmar Ratio, Omega Ratio, Max Drawdown (rolling), Average Drawdown,
+    Drawdown Duration (time-under-water), Pain Index, Value at Risk
+    (historical, linear-interpolated percentile), Conditional Value at Risk
+    (Expected Shortfall), Profit Factor, Gain/Loss Ratio, Recovery Factor,
+    Kelly Criterion.
+  - **Two-series `Indicator<(f64, f64)>` — 3 metrics on `(asset_return,
+    benchmark_return)` pairs:** Treynor Ratio, Information Ratio,
+    Jensen's Alpha (CAPM).
+- **Candlestick patterns family (15 indicators).** A new "Candlestick
+  Patterns" family covers the standard 1- to 3-bar reversal and
+  continuation shapes: `Doji`, `Hammer`, `InvertedHammer`, `HangingMan`,
+  `ShootingStar`, `Engulfing`, `Harami`, `MorningEveningStar`,
+  `ThreeSoldiersOrCrows`, `PiercingDarkCloud`, `Marubozu`, `Tweezer`,
+  `SpinningTop`, `ThreeInside` and `ThreeOutside`. Every detector takes a
+  `Candle` and emits a signed `f64` (`+1.0` bullish, `-1.0` bearish, `0.0`
+  no pattern; `Doji` is direction-less and emits `+1.0`/`0.0`). The MVP is
+  a pattern-shape check only — no trend filter is applied. Available
+  across Rust, Python, Node and WASM bindings. Harmonic and chart
+  patterns remain out of scope and will follow once the pattern-detection
+  framework (pivot detector + multi-bar state machines) lands.
+- **Market Profile family** (3 new indicators, opens family #9 across the
+  catalogue):
+  - `ValueArea(period, bin_count, value_area_pct)` — rolling
+    bin-approximation volume profile over the last `period` candles.
+    Outputs `{poc, vah, val}`: Point of Control is the bin with the highest
+    cumulative volume; the Value Area expands symmetrically from POC and
+    always absorbs the higher-volume neighbour next, until the configured
+    percentage of total volume (default 70%) is enclosed. Each candle's
+    volume is spread uniformly across its `[low, high]` range; single-print
+    bars (`low == high`) drop their entire volume into one bin.
+  - `InitialBalance(period)` — first-N-bar session high / low, frozen
+    once `period` bars have been ingested. Outputs `{high, low}`. Default
+    `period = 12` (one-hour IB on 5-minute bars for US equities). Callers
+    MUST invoke `reset()` at every session boundary, otherwise the IB
+    locks and stays fixed for the lifetime of the instance.
+  - `OpeningRange(period)` — same lock-after-N-bars semantics as IB but
+    with a smaller default window (`period = 6`, 30 min on 5-minute
+    bars) and a third output `breakout_distance` = `close - or_mid`,
+    signed (positive above the range, negative below).
+- Histogram-output Market Profile variants (Volume Profile / VPVR /
+  Composite Profile) and tick-data-only variants (TPO / Single Print /
+  Cumulative Delta / Order Flow Delta / Volume-Weighted Open) are
+  deliberately out of scope of this PR: the former need a new
+  histogram-output API layer, the latter need tick / L2 data which
+  `wickra-data` does not yet expose.
+- **Family 12 — Statistik / Regression (13 indicators).** A complete
+  statistical toolkit for analysing rolling price distributions and
+  cross-series relationships. Every indicator ships in the Rust core
+  plus all three bindings (Python, Node, WASM), with full streaming +
+  batch parity, fuzz coverage, and benches against the BTCUSDT
+  dataset:
+  - **Variance** — rolling population variance (`StdDev` squared).
+  - **CoefficientOfVariation** — `StdDev / Mean`, dimensionless dispersion.
+  - **Skewness** — rolling third standardised moment (Pearson skewness).
+  - **Kurtosis** — rolling excess kurtosis (fourth moment minus `3`).
+  - **StandardError** — standard error of estimate for the rolling OLS
+    fit, with `n − 2` residual degrees of freedom.
+  - **DetrendedStdDev** — population standard deviation of OLS
+    residuals (the StdDev that remains after subtracting the linear
+    trend).
+  - **RSquared** — coefficient of determination of the rolling OLS
+    fit; the trend-quality filter.
+  - **MedianAbsoluteDeviation** — robust dispersion measure that
+    survives outliers (median of absolute deviations from the median).
+  - **Autocorrelation** — rolling lag-`k` Pearson autocorrelation;
+    detects periodicity and tests for white-noise behaviour.
+  - **HurstExponent** — R/S-analysis estimator of trend-persistence
+    vs. mean-reversion regime (`0.5` is random walk).
+  - **PearsonCorrelation** — rolling correlation between two
+    synchronised series; takes `(x, y)` pairs.
+  - **Beta** — rolling OLS slope of an asset on a benchmark; the CAPM
+    sensitivity coefficient.
+  - **SpearmanCorrelation** — rolling rank correlation (monotone,
+    outlier-robust analogue of Pearson).
+
+  Indicator count: 71 → 84.
+- **Family 13 — Ichimoku & alternative charts.** Two new indicators:
+  - `Ichimoku` (Ichimoku Kinko Hyo) — the full five-line cloud system
+    (Tenkan-sen, Kijun-sen, Senkou Span A/B, Chikou Span) with the
+    classic `(9, 26, 52, 26)` defaults and configurable periods. Forward
+    displacement is handled in a streaming ring buffer so the
+    currently-visible Senkou A/B at bar *n* are the values computed
+    from bar *n − displacement*.
+  - `HeikinAshi` — the candle smoothing transform that recursively
+    averages OHLC into a four-component output (`ha_open`, `ha_high`,
+    `ha_low`, `ha_close`). Seeds `ha_open` from the first bar's
+    `(open + close) / 2`.
+
+  Exposed in all four bindings (Rust, Python, Node, WASM). Renko,
+  Kagi, and Point & Figure from the family ideas list are deferred:
+  they are custom bar generators rather than indicators and belong in
+  `wickra-data`.
+- **Family 10 — Ehlers / Cycle (DSP) indicators.** 16 new
+  streaming-first indicators implementing John Ehlers'
+  digital-signal-processing school of cycle analytics — a strong
+  differentiation feature versus TA-Lib and pandas-ta, which only
+  ship fragments of this catalogue:
+  - **MAMA / FAMA** (MESA Adaptive Moving Average + Following
+    Adaptive Moving Average) — phase-rate-adaptive smoothing pair
+    from the 2001 MESA paper, exposed both jointly via `Mama` (multi-
+    output) and as a scalar `Fama` wrapper.
+  - **Fisher Transform** and **Inverse Fisher Transform** — Gaussian
+    normalisation of price (Ehlers 2002) and its tanh-based bounded
+    counterpart for oscillators.
+  - **SuperSmoother**, **Roofing Filter**, **Decycler** and **Decycler
+    Oscillator** — 2-pole Butterworth lowpass, bandpass and
+    high-pass complement building blocks from *Cycle Analytics for
+    Traders* (2013).
+  - **Hilbert Dominant Cycle**, **Sine Wave** and **Adaptive Cycle**
+    — Hilbert-transform-based period estimation from *Rocket Science
+    for Traders* (2001).
+  - **Center of Gravity**, **Cybernetic Cycle Component**,
+    **Instantaneous Trendline**, **Ehlers Stochastic** and
+    **Empirical Mode Decomposition** — EasyLanguage classics from
+    Ehlers' published catalogue.
+  - All sixteen are exposed across Rust, Python, Node.js and WASM
+    bindings, fuzz-tested, benchmarked against real BTCUSDT
+    1-minute data, and pass `batch == streaming` equivalence.
+  - Indicator count rises from 71 to **87** across **nine** families.
+- **DeMark family (family 11) — 12 new indicators.** TD Setup (9-bar
+  buy/sell setup counter with parameterised lookback and target), TD
+  Sequential (Setup + Countdown phase machine emitting setup count,
+  countdown count and active countdown direction), TD DeMarker
+  (bounded [0, 1] range oscillator built from high/low expansions),
+  TD REI (Range Expansion Index — bounded ±100 oscillator with the
+  classic 5-bar default), TD Pressure (volume-weighted buying /
+  selling pressure normalised to ±100), TD Combo (aggressive
+  countdown variant with extra monotone-low / monotone-close
+  strictness conditions on top of the classic countdown rule), TD
+  Countdown (standalone 13-bar countdown phase machine emitting
+  only the signed countdown count and direction — smaller streaming
+  payload than the full TD Sequential), TD Lines (TDST horizontal
+  support / resistance levels derived from the highs and lows of
+  the most-recently-completed setup), TD Range Projection (next-bar
+  high / low projection from the current bar's OHLC via DeMark's
+  open-vs-close-weighted pivot), TD Differential (2-bar
+  buying-pressure-vs-selling-pressure reversal pattern emitting
+  +1 / -1 / 0), TD Open (gap-and-fade reversal pattern emitting
+  +1 / -1 / 0 when the open prints outside the prior bar's range
+  but the subsequent action recovers back into it), and TD Risk
+  Level (protective stop levels derived from the lowest-low / highest-
+  high setup bar's true range). All twelve are exposed through the
+  Rust, Python, Node, and WASM bindings with `batch == streaming`
+  equivalence tests, candle-stream fuzz coverage, and benchmark
+  entries on the BTCUSDT 1-minute dataset.
+- **Family 08 — Pivots & Support/Resistance.** Seven new indicators land
+  the previously empty pivot family: Classic (Floor-Trader) Pivot Points
+  with three resistance and support tiers, Fibonacci Pivots spaced by
+  0.382 / 0.618 / 1.000 of the prior range, Camarilla Pivots
+  (Nick Stott's four-tier `(H − L) · 1.1 / {12, 6, 4, 2}` levels),
+  Woodie Pivots with the close-weighted `PP = (H + L + 2·C) / 4`,
+  DeMark Pivots whose conditional `X` depends on whether the bar closed
+  up, down or flat, Williams Fractals as a five-bar swing detector and
+  ZigZag as a percent-threshold swing tracker. Every level/swing is
+  exposed across Rust, Python, Node and WASM with the standard
+  `update` / `batch` / `reset` / `is_ready` / `warmup_period` surface
+  and matching streaming-vs-batch and reference-value tests. The fuzz
+  candle target now covers all seven.
+- **Family 09 — Trailing Stops, seven new indicators.** Rounds out the
+  trailing-stop family from 5 to 12: `HiLoActivator` (Crabel's
+  SMA-of-high / SMA-of-low trail), `VoltyStop` (Cynthia Kase's
+  extreme-anchor ATR stop), `YoyoExit` (long-only ATR trail with a
+  re-entry trigger), `DonchianStop` (the original Turtle exit, lowest
+  low / highest high), `PercentageTrailingStop` (fixed-percent trail),
+  `StepTrailingStop` (round-number grid trail) and `RenkoTrailingStop`
+  (block-anchored Renko-style trail). All wired into the four bindings
+  (Rust, Python, Node, WASM), the streaming + batch fuzz targets, and
+  the bench harness.
+- **Klinger Volume Oscillator (KVO).** Stephen J. Klinger's trend-aware
+  volume-force oscillator: `EMA(vf, fast) − EMA(vf, slow)` over a daily
+  volume force scaled by cumulative-measurement ratio. Classic
+  `(fast, slow) = (34, 55)` exposed via `Kvo::classic()`.
+- **Volume Oscillator (VO).** Percent difference between a fast and a
+  slow SMA of bar volume: `100 · (SMA(vol, fast) − SMA(vol, slow)) /
+  SMA(vol, slow)`. Default `(14, 28)`.
+- **Negative Volume Index (NVI).** Paul Dysart's cumulative index that
+  only updates on volume-contraction bars (`volume_t < volume_{t−1}`),
+  absorbing the percent close change on those quiet days. Fosback
+  baseline `1000.0`, configurable via `Nvi::with_baseline`.
+- **Positive Volume Index (PVI).** The complementary index that
+  updates on volume-expansion bars (`volume_t > volume_{t−1}`).
+- **Williams Accumulation/Distribution.** Larry Williams' volume-less
+  cumulative flow that anchors to the previous close (true high/low) and
+  classifies each bar as accumulation, distribution, or neutral by the
+  sign of the close-to-close change.
+- **Anchored VWAP.** A cumulative VWAP whose accumulation begins at a
+  user-chosen anchor bar rather than the session open. Re-anchor at
+  runtime via `AnchoredVwap::set_anchor` for click-to-anchor trader
+  workflows.
+- **Demand Index (Sibbet).** James Sibbet's smoothed buying-vs-selling
+  pressure ratio in the streaming-friendly textbook form
+  `EMA(volume · close-return · (1 + range/close), period)`.
+- **Time Segmented Volume (TSV).** Don Worden's rolling sum of signed
+  volume weighted by the close-to-close move: a window-sum measure of
+  net accumulation/distribution.
+- **Volume Zone Oscillator (VZO).** Walid Khalil's normalised
+  volume-flow oscillator bounded in `[−100, 100]`, defined as
+  `100 · EMA(signed_volume) / EMA(volume)`.
+- **Market Facilitation Index (Bill Williams).** Per-bar
+  `(high − low) / volume` — how much price movement the market produces
+  per unit of volume.
+- **ADXR (Average Directional Movement Index Rating)** in the Trend &
+  Directional family. Wilder's directional-strength smoother: the
+  average of the current `ADX` and the `ADX` from `period - 1` bars
+  ago. Warmup is `3 * period - 1` (e.g. 41 for the default `period =
+  14`). Shipped across all four bindings (Rust core, Python, Node,
+  WASM) plus fuzz/test/bench coverage.
+- **Random Walk Index (RWI)** in the Trend & Directional family. Mike
+  Poulos' trend-vs.-random-walk gauge: for each lookback `i ∈ [2,
+  period]` the ratio of actual displacement to the random-walk
+  expectation `ATR_i * sqrt(i)` is taken; the per-bar output is the
+  maximum across lookbacks for both the high (`RWI_High`) and low
+  (`RWI_Low`) directions. Multi-output `(high, low)` across all four
+  bindings; warmup `= period`.
+- **Trend Intensity Index (TII)** in the Trend & Directional family.
+  M.H. Pee's `[0, 100]` oscillator: the share of the most recent
+  `dev_period` SMA-deviations that are positive, scaled to
+  `[0, 100]`. Saturates at 100 on a pure uptrend, at 0 on a pure
+  downtrend, and returns the neutral 50 on a perfectly flat market.
+  Canonical Python defaults `(sma_period=60, dev_period=30)`; warmup
+  `= sma_period + dev_period − 1`.
+- **Wave Trend Oscillator (LazyBear)** in the Trend & Directional
+  family. Two-line mean-reverting momentum gauge built from the
+  typical price and three cascaded EMAs:
+  `esa = EMA(ap, channel)`, `d = EMA(|ap − esa|, channel)`,
+  `ci = (ap − esa) / (0.015 · d)`, `wt1 = EMA(ci, average)`,
+  `wt2 = SMA(wt1, signal)`. `WaveTrend::classic()` exposes the
+  LazyBear defaults `(channel = 10, average = 21, signal = 4)`;
+  warmup `= 2 · channel + average + signal − 3` (42 for the classic
+  defaults). Includes a sub-ULP flat-tolerance guard on `ci` so a
+  perfectly flat market reports `(0, 0)` instead of the
+  mathematically indeterminate `−1 / 0.015 = −66.67`. Multi-output
+  `(wt1, wt2)` across all four bindings.
+- **Family 05 — Bands & Channels (11 new indicators).** Eleven additional
+  price-envelope overlays organised into the new "Bands & Channels"
+  family, exposed across all four bindings (Rust, Python, Node, WASM):
+  - `MaEnvelope` — SMA centerline with fixed-percent envelope (the oldest
+    band overlay still in use).
+  - `AccelerationBands` — Price Headley's momentum-biased bands that widen
+    with the bar's relative range `(H − L) / (H + L)`.
+  - `StarcBands` — Stoller Average Range Channel: SMA(close) ± k·ATR
+    (Keltner's SMA-centerline sibling).
+  - `AtrBands` — Close-anchored envelope of width `k · ATR`, the standard
+    volatility-targeting stop/target band.
+  - `HurstChannel` — SMA centerline wrapped by the rolling high-low range
+    (Brian Millard / Hurst-cycle channel).
+  - `LinRegChannel` — Linear-regression endpoint ± k·σ of the residuals,
+    measuring dispersion about the *trend* rather than the mean.
+  - `StandardErrorBands` — Linear regression with the OLS standard error
+    (denominator `n − 2`) for prediction-interval bands.
+  - `DoubleBollinger` — Kathy Lien's `±1σ` plus `±2σ` zone-partition setup.
+  - `TtmSqueeze` — John Carter's BB-inside-KC squeeze flag paired with a
+    detrended-close momentum reading.
+  - `FractalChaosBands` — Bill Williams 5-bar fractal high/low envelope.
+  - `VwapStdDevBands` — Cumulative VWAP with volume-weighted standard
+    deviation bands.
+  Indicator count rises from 71 to 82 across nine families; the README
+  family table and the wiki overview/sidebar/warmup pages were updated to
+  match.
+- **Yang-Zhang Volatility.** Yang & Zhang (2000) gold-standard OHLC
+  estimator: a convex blend of overnight (close-to-open), open-to-close
+  and Rogers-Satchell variances. The blending factor
+  `k = 0.34 / (1.34 + (n+1)/(n-1))` is the one that minimises
+  estimator variance under driftless GBM with overnight gaps. The
+  overnight and open-to-close pieces use sample variance (Bessel's
+  correction, divisor `n−1`), so the indicator needs `period + 1` bars
+  to emit. Output annualised to a percent. Defaults: `period = 20`,
+  `trading_periods = 252`. The recommended OHLC estimator for equities,
+  futures, and any asset with material close-to-open gaps.
+- **Rogers-Satchell Volatility.** Drift-free OHLC realised-volatility
+  estimator from Rogers, Satchell & Yoon (1994). Per-bar sample is
+  `ln(H/C)·ln(H/O) + ln(L/C)·ln(L/O)`; every term is non-negative by
+  construction (high >= open, close; low <= open, close), so the
+  rolling mean is exact, not biased, under arbitrary drift. The
+  algebraic drift-cancellation is what differentiates it from
+  Garman-Klass. Output annualised to a percent. Defaults:
+  `period = 20`, `trading_periods = 252`.
+- **Garman-Klass Volatility.** Garman & Klass (1980) OHLC realised
+  volatility estimator: per-bar sample is
+  `0.5·(ln H/L)² − (2·ln2 − 1)·(ln C/O)²`, then take the annualised
+  square root of the rolling mean. Roughly 7.4× more statistically
+  efficient than close-to-close stddev under driftless GBM. Output
+  annualised to a percent. Defaults: `period = 20`,
+  `trading_periods = 252`.
+- **Parkinson Volatility.** Michael Parkinson's (1980) high-low realised
+  volatility estimator: `sigma² = (1 / (4n·ln2)) · Σ (ln(H/L))²`. Output
+  annualised to a percent in the same style as `HistoricalVolatility`
+  (pass `trading_periods = 1` for the raw per-bar `sigma·100` figure).
+  Roughly 5× more statistically efficient than close-to-close stddev
+  under a driftless-GBM assumption. Defaults: `period = 20`,
+  `trading_periods = 252`.
+- **RVIVolatility (Relative Volatility Index).** Donald Dorsey's
+  RSI-shaped volatility gauge: partition the rolling standard
+  deviation of close into "up" (close rose) and "down" (close fell)
+  samples, Wilder-smooth each side, and compute
+  `100 · AvgUp / (AvgUp + AvgDown)`. Bounded on `[0, 100]`; saturates
+  at `100` in pure uptrends, `0` in pure downtrends, and falls back to
+  `50` on a completely flat series (same undefined-RS convention as
+  `RSI`). Single `period` parameter (default `10`) drives both the
+  stddev window and the Wilder smoothing. Named `RVIVolatility` rather
+  than plain `RVI` to disambiguate from Relative Vigor Index, which
+  ships in Family 02 under the shorter `RVI` name.
+- **Family 03 — MACD & Price Oscillators.** `Stc` (Schaff Trend Cycle,
+  Doug Schaff): doubly-`Stochastic`-smoothed MACD producing a bounded
+  `[0, 100]` reading that reacts faster than `MACD` itself. Four
+  parameters `(fast = 23, slow = 50, schaff_period = 10, factor = 0.5)`.
+  Output is clamped to `[0, 100]` to absorb floating-point rounding.
+  Exposed in all four bindings.
+- **Family 03 — MACD & Price Oscillators.** `ElderImpulse` (Alexander
+  Elder's Impulse System): tri-state momentum gauge combining `EMA`
+  trend slope with `MACD` histogram slope. Returns `+1` (green/buy)
+  when both rise, `−1` (red/sell) when both fall, `0` (blue/neutral)
+  on disagreement. Four parameters
+  `(ema_period, macd_fast, macd_slow, macd_signal)`; defaults
+  `(13, 12, 26, 9)` track *Come Into My Trading Room*. Exposed in all
+  four bindings.
+- **Family 03 — MACD & Price Oscillators.** `ZeroLagMacd`: classic
+  MACD topology with `ZLEMA` substituted for `EMA` everywhere — faster
+  reaction to trend changes at the cost of slightly noisier readings.
+  Multi-output `ZeroLagMacdOutput { macd, signal, histogram }`. Three
+  parameters `(fast = 12, slow = 26, signal = 9)`; `fast` must be
+  strictly less than `slow`. Exposed in all four bindings.
+- **Family 03 — MACD & Price Oscillators.** `CFO` (Chande Forecast
+  Oscillator): `100 · (close − LinReg(close, period)) / close`. Positive
+  when the close overshoots the linear forecast, negative when it
+  undershoots. Holds the previous value if the close is zero. Default
+  period 14. Exposed in all four bindings.
+- **Family 03 — MACD & Price Oscillators.** `AwesomeOscillatorHistogram`:
+  `AO − SMA(AO, sma_period)`. A configurable variant of the existing
+  `AcceleratorOscillator` (which fixes `(fast, slow, sma) = (5, 34, 5)`).
+  Three parameters; defaults match Bill Williams' Accelerator. Exposed
+  in all four bindings.
+- **Family 03 — MACD & Price Oscillators.** `APO` (Absolute Price
+  Oscillator): `EMA(close, fast) − EMA(close, slow)`. Like MACD's line
+  without the signal EMA. Default `(fast = 12, slow = 26)`. `fast` must
+  be strictly less than `slow`. Exposed in all four bindings.
+- **Family 02 — Momentum Oscillators.** `Inertia` (Dorsey): a
+  `LinearRegression` smoothing of the `RVI` series — preserves trend
+  direction while damping the underlying ratio. Candle input, two
+  parameters `(rvi_period, linreg_period)` (defaults 14 / 20). Exposed
+  in all four bindings.
+- **Family 02 — Momentum Oscillators.** `ConnorsRsi`: Larry Connors'
+  3-component aggregate — `RSI(close)`, `RSI(streak)`, and the
+  percentile rank of the 1-bar return over the recent `period_rank`
+  returns. Bounded in `[0, 100]`. Three parameters
+  `(period_rsi, period_streak, period_rank)` (defaults 3 / 2 / 100).
+  Exposed in all four bindings.
+- **Family 02 — Momentum Oscillators.** `LaguerreRsi` (Ehlers):
+  four-stage Laguerre polynomial filter wrapped in an RSI-style up/down
+  accumulator. Single parameter `gamma` in `[0, 1]` (default 0.5) trades
+  lag for smoothness. State is seeded to the first input so a constant
+  series stays at the neutral 50. Output clamped to `[0, 100]`. Exposed
+  in all four bindings.
+- **Family 02 — Momentum Oscillators.** `SMI` (Stochastic Momentum
+  Index, Blau): doubly-`EMA`-smoothed bounded oscillator measuring the
+  close's displacement from the centre of the recent high-low range,
+  scaled by the smoothed range. Candle input, three parameters
+  `(period, d_period, d2_period)` (defaults 5 / 3 / 3). Exposed in all
+  four bindings.
+- **Family 02 — Momentum Oscillators.** `KST` (Know Sure Thing, Pring):
+  weighted sum of four `SMA`-smoothed `ROC` series with Pring's fixed
+  weights `1, 2, 3, 4`, plus an `SMA` signal line. Nine parameters
+  (four ROC periods, four SMA periods, signal period); `Kst::classic()`
+  uses Pring's recommended defaults. Multi-output indicator emitting
+  `KstOutput { kst, signal }`. Exposed in all four bindings.
+- **Family 02 — Momentum Oscillators.** `PGO` (Pretty Good Oscillator,
+  Mark Johnson): `(close − SMA(close, period)) / EMA(TR, period)`.
+  Candle input, single parameter `period` (default 14). Roughly counts
+  how many ATR-equivalents the close is from its mean. Exposed in all
+  four bindings.
+- **Family 02 — Momentum Oscillators.** `RVI` (Relative Vigor Index,
+  Dorsey): per-bar ratio `SMA(close - open, period) / SMA(high - low,
+  period)`. Candle input, single parameter `period` (default 10).
+  Positive on average-bullish windows, negative on average-bearish.
+  Holds previous value if the entire window has zero range. Exposed in
+  all four bindings.
+- **Family 01 — Moving Averages.** `ALMA` (Arnaud Legoux Moving Average):
+  Gaussian-weighted moving average with configurable centre (`offset` in
+  `[0, 1]`) and kernel width (`sigma > 0`). Community-standard defaults
+  `(period = 9, offset = 0.85, sigma = 6.0)` available via `Alma::classic()`.
+  Exposed in all four bindings (Rust, Python, Node, WASM).
+- **Family 01 — Moving Averages.** `EVWMA` (Elastic Volume-Weighted
+  Moving Average, Fries 2001): an "elastic" recurrence whose smoothing
+  weight is the bar's volume relative to the running window-volume.
+  Candle input (uses close + volume), single parameter `period`
+  (default 20). Holds its previous value if the entire window has zero
+  volume. Exposed in all four bindings.
+- **Family 01 — Moving Averages.** `Alligator` (Bill Williams): three
+  SMMA lines (Jaw / Teeth / Lips) of the median price `(high + low) / 2`
+  with default periods 13 / 8 / 5. Multi-output indicator emitting
+  `AlligatorOutput { jaw, teeth, lips }`. Visual chart shift is left to
+  the consumer. Exposed in all four bindings.
+- **Family 01 — Moving Averages.** `JMA` (Jurik Moving Average):
+  three-stage filter reconstruction of Mark Jurik's adaptive MA.
+  Three parameters: `period` (14), `phase` in `[-100, 100]` (0), `power`
+  in `1..=4` (2). State is seeded to the first input so a constant series
+  is reproduced exactly. Exposed in all four bindings.
+- **Family 01 — Moving Averages.** `VIDYA` (Variable Index Dynamic
+  Average, Chande 1992): EMA whose smoothing factor is scaled by the
+  absolute Chande Momentum Oscillator. Two parameters `period` and
+  `cmo_period` (defaults 14 / 9). Exposed in all four bindings.
+- **Family 01 — Moving Averages.** `FRAMA` (Fractal Adaptive Moving
+  Average, Ehlers 2005): adapts its smoothing constant to the fractal
+  dimension of the recent window — fast in trends, slow in chop. Single
+  parameter `period` (must be even, default 16). Exposed in all four
+  bindings.
+- **Family 01 — Moving Averages.** `McGinleyDynamic`: John McGinley's
+  self-adjusting MA. Single parameter `period`; the recurrence
+  `MD + (price - MD) / (0.6 * period * (price / MD)^4)` speeds up when price
+  falls below the indicator and damps when price runs above. Seeded with the
+  simple average of the first `period` inputs. Exposed in all four bindings.
+
+## [0.2.7] - 2026-05-24
+
+### Added
+- **Windows ARM64 is back.** npm Support unblocked the
+  `wickra-win32-arm64-msvc` sub-package name (same path
+  `wickra-win32-x64-msvc` took through 0.1.4) and transferred write
+  access to @kingchenc. 0.2.7 ships the binding for
+  `aarch64-pc-windows-msvc` alongside the existing five platforms:
+  the `napi.triples.additional` entry, the `optionalDependencies`
+  pin, the `bindings/node/npm/win32-arm64-msvc/` sub-package and the
+  `windows-11-arm` row of the release.yml node-build matrix are all
+  restored from 8aa74cb. `npm install wickra` on Windows ARM64 now
+  resolves to a native build instead of failing the loader's
+  optional-dep lookup. PyPI's `win_arm64` wheel was unaffected and
+  carries through as before.
+
+### Changed
+- **Benchmark CPU renamed.** The "Reproduced on" line in every
+  README listed an AMD Ryzen 9 7950X3D; the canonical machine is
+  actually a Ryzen 9 9950X. Speedup ratios in the tables are
+  unchanged (they're relative across libraries on the same machine),
+  only the labelling is corrected. The performance-regression issue
+  template's CPU example was updated for consistency.
+
+## [0.2.6] - 2026-05-24
+
+### Fixed
+- **docs.rs build.** Rust 1.92 removed the `doc_auto_cfg` feature gate
+  and folded it back into `doc_cfg` (rust-lang/rust#138907). docs.rs
+  builds against the latest nightly and sets `--cfg docsrs`, so every
+  published 0.2.x failed with E0557 on the
+  `#![cfg_attr(docsrs, feature(doc_auto_cfg))]` line at the top of
+  `wickra`, `wickra-core`, and `wickra-data`. GitHub CI didn't see
+  this — stable rustc never enables the `docsrs` cfg. The three
+  library crates now gate on `doc_cfg` (same intent, same rendered
+  output on docs.rs, builds again on nightly).
+
+### Changed
+- **README — Wickra is now the top row of every comparison table.**
+  The "Why Wickra exists" library matrix and the per-indicator
+  benchmark tables previously placed Wickra at the bottom; a reader
+  landing on the README is here to compare *against* Wickra, so the
+  pivot row belongs at the top with a ★ marker. Same column data,
+  same winner annotations — only row order changed. Mirrored across
+  the umbrella README and every binding README so crates.io / PyPI /
+  npm landing pages stay in sync.
+
+## [0.2.5] - 2026-05-24
+
+### Added
+- `BinanceConfig` plus `BinanceKlineStream::connect_with_config(symbols, interval, config)`
+  in `wickra-data`'s `live::binance` module. `connect()` keeps its previous
+  signature and now forwards to the new entry-point with the defaults, so the
+  public API is backwards-compatible. The config lets callers point the
+  stream at Binance Testnet (`wss://testnet.binance.vision`) or tune the
+  read timeout, reconnect attempt count, initial / capped backoff and frame
+  size limits without rewriting the connector.
+- README **Disclaimer** section clarifying that Wickra is an indicator
+  toolkit (not a trading system) and that any production-trading use is at
+  the caller's own risk. The legal terms in [LICENSE](LICENSE) are
+  unchanged.
+
+### Changed
+- `BinanceKlineStream::next_event` now writes the Pong reply to a server
+  `Ping` on a best-effort basis. A failed write means the connection is
+  already dead, so the existing timeout / read-error reconnect arm one
+  loop iteration later picks it up — the previous explicit reconnect on
+  Pong-write failure is gone. Observable behaviour is unchanged for every
+  healthy connection.
+
 ## [0.2.1] - 2026-05-23
 
 ### Changed
@@ -329,11 +980,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   optional Binance live feed.
 - Bindings for Python, Node.js, and WebAssembly.
 
-[Unreleased]: https://github.com/kingchenc/wickra/compare/v0.2.1...HEAD
-[0.2.1]: https://github.com/kingchenc/wickra/compare/v0.2.0...v0.2.1
-[0.2.0]: https://github.com/kingchenc/wickra/compare/v0.1.4...v0.2.0
-[0.1.4]: https://github.com/kingchenc/wickra/compare/v0.1.3...v0.1.4
-[0.1.3]: https://github.com/kingchenc/wickra/compare/v0.1.2...v0.1.3
-[0.1.2]: https://github.com/kingchenc/wickra/compare/v0.1.1...v0.1.2
-[0.1.1]: https://github.com/kingchenc/wickra/compare/v0.1.0...v0.1.1
-[0.1.0]: https://github.com/kingchenc/wickra/releases/tag/v0.1.0
+[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.4.3...HEAD
+[0.4.3]: https://github.com/wickra-lib/wickra/compare/v0.4.2...v0.4.3
+[0.4.2]: https://github.com/wickra-lib/wickra/compare/v0.4.1...v0.4.2
+[0.4.1]: https://github.com/wickra-lib/wickra/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/wickra-lib/wickra/compare/v0.3.1...v0.4.0
+[0.3.1]: https://github.com/wickra-lib/wickra/compare/v0.3.0...v0.3.1
+[0.3.0]: https://github.com/wickra-lib/wickra/compare/v0.2.7...v0.3.0
+[0.2.7]: https://github.com/wickra-lib/wickra/compare/v0.2.6...v0.2.7
+[0.2.6]: https://github.com/wickra-lib/wickra/compare/v0.2.5...v0.2.6
+[0.2.5]: https://github.com/wickra-lib/wickra/compare/v0.2.1...v0.2.5
+[0.2.1]: https://github.com/wickra-lib/wickra/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/wickra-lib/wickra/compare/v0.1.4...v0.2.0
+[0.1.4]: https://github.com/wickra-lib/wickra/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/wickra-lib/wickra/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/wickra-lib/wickra/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/wickra-lib/wickra/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/wickra-lib/wickra/releases/tag/v0.1.0

CITATION.cff

@@ -0,0 +1,29 @@
+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: PolyForm-Noncommercial-1.0.0

CODE_OF_CONDUCT.md

@@ -33,7 +33,7 @@ project in public spaces.
 ## Enforcement
 
 Instances of unacceptable behaviour may be reported to the project maintainer
-at **kingchencp@gmail.com**. All reports will be reviewed and investigated
+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.
 

CONTRIBUTING.md

@@ -22,7 +22,7 @@ when proposing features or depending on Wickra elsewhere.
 | `bindings/node` | napi-rs bindings (`wickra` on npm). |
 | `bindings/wasm` | wasm-bindgen bindings (`wickra-wasm` on npm). |
 | `examples/` | Runnable examples. |
-| `docs/wiki/` | Documentation sources. |
+| `docs/` | Pointer to the project Wiki, which holds all documentation. |
 
 ## Building and testing
 
@@ -35,8 +35,13 @@ cargo test --workspace
 cargo test -p wickra-data --features live-binance
 ```
 
-The minimum supported Rust version is **1.75** for the workspace crates and
-**1.77** for `bindings/node`; the `msrv` CI job enforces both.
+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
 
@@ -63,6 +68,29 @@ 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
@@ -75,8 +103,10 @@ wasm-pack test --node bindings/wasm
   of `update` calls.
 - **Bindings.** A change to a public indicator API must be mirrored across the
   Python, Node, and WASM bindings, including their type stubs / `.d.ts`.
-- **Docs.** Update the relevant page under `docs/wiki/` and the `README.md`
-  when behaviour or the public API changes.
+- **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

Cargo.lock

@@ -1867,7 +1867,7 @@ dependencies = [
 
 [[package]]
 name = "wickra"
-version = "0.2.1"
+version = "0.4.3"
 dependencies = [
  "approx",
  "criterion",
@@ -1878,7 +1878,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-core"
-version = "0.2.1"
+version = "0.4.3"
 dependencies = [
  "approx",
  "proptest",
@@ -1888,7 +1888,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-data"
-version = "0.2.1"
+version = "0.4.3"
 dependencies = [
  "approx",
  "csv",
@@ -1915,7 +1915,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-node"
-version = "0.2.1"
+version = "0.4.3"
 dependencies = [
  "napi",
  "napi-build",
@@ -1925,7 +1925,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-python"
-version = "0.2.1"
+version = "0.4.3"
 dependencies = [
  "numpy",
  "pyo3",
@@ -1934,7 +1934,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-wasm"
-version = "0.2.1"
+version = "0.4.3"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

Cargo.toml

@@ -12,19 +12,19 @@ members = [
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.2.1"
-authors = ["kingchenc <kingchencp@gmail.com>"]
+version = "0.4.3"
+authors = ["kingchenc <support@wickra.org>"]
 edition = "2021"
 rust-version = "1.86"
-license = "PolyForm-Noncommercial-1.0.0"
-repository = "https://github.com/kingchenc/wickra"
-homepage = "https://github.com/kingchenc/wickra"
+license-file = "LICENSE"
+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.2.1" }
+wickra-core = { path = "crates/wickra-core", version = "0.4.3" }
 
 thiserror = "2"
 rayon = "1.10"

LICENSE

@@ -35,7 +35,7 @@ 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)
+> Required Notice: Copyright 2026 kingchenc (https://github.com/wickra-lib/wickra)
 
 ## Changes and New Works License
 
@@ -131,6 +131,31 @@ software under these terms.
 **Use** means anything you do with the software requiring one
 of your licenses.
 
+## Additional Permissions Granted by the Licensor
+
+These additional permissions supplement the PolyForm Noncommercial
+License 1.0.0 above. They only broaden, and never narrow, the
+licenses granted to you. The text of the PolyForm Noncommercial
+License 1.0.0 above is unmodified.
+
+Use by a natural person, acting for their own personal account and
+not on behalf of any third party, is use for a permitted purpose.
+This includes operating an automated trading bot or trading strategy
+on that person's own capital, whether or not it earns that person
+money.
+
+For the avoidance of doubt, the licenses above already let you use,
+fork, modify, and redistribute the software, and file issues and
+contribute changes, for any permitted purpose. Personal projects,
+research, education, nonprofit organizations, government use, and
+hobby trading bots are permitted purposes.
+
+Any other commercial use — in particular the commercial sale of the
+software itself, or the commercial sale of services built around it —
+requires a separate commercial license from the licensor. If you want
+to use Wickra commercially, get in touch about a license at
+<https://github.com/wickra-lib/wickra>.
+
 ---
 
-Required Notice: Copyright 2026 kingchenc (https://github.com/kingchenc/wickra)
+Required Notice: Copyright 2026 kingchenc (https://github.com/wickra-lib/wickra)

README.md

@@ -1,11 +1,18 @@
-# Wickra
+<p align="center">
+  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=232" 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)
-[![codecov](https://codecov.io/gh/kingchenc/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/kingchenc/wickra)
+[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![CodeQL](https://github.com/wickra-lib/wickra/actions/workflows/codeql.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/codeql.yml)
+[![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![GitHub release](https://img.shields.io/github/v/release/wickra-lib/wickra?logo=github&color=green)](https://github.com/wickra-lib/wickra/releases/latest)
 [![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)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/wickra-lib/wickra/badge)](https://scorecard.dev/viewer/?uri=github.com/wickra-lib/wickra)
+[![Build provenance](https://img.shields.io/badge/provenance-attested-brightgreen?logo=github)](https://github.com/wickra-lib/wickra/attestations)
+[![Docs](https://img.shields.io/badge/docs-docs.wickra.org-0ea5e9?logo=readthedocs&logoColor=white)](https://docs.wickra.org)
 
 **Streaming-first technical indicators. Install with `pip install wickra` — no system dependencies.**
 
@@ -31,21 +38,40 @@ 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).
+- **Indicators** — a per-indicator deep dive (formula, parameters, warmup) for
+  every one of the 232 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 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:
 
-| 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** |
+| Library                | Install pain    | Streaming | Multi-language | Active |
+|------------------------|-----------------|-----------|----------------|--------|
+| **★&nbsp;Wickra**      | **clean**       | **yes**   | **Python + Node + WASM + Rust** | **yes** |
+| 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 is the only library that combines all of: clean install, streaming,
 multi-language reach, and active maintenance.
@@ -58,7 +84,7 @@ depend on CPU, memory clock and OS scheduler. Read them as **relative
 speedups** between libraries on identical input, not as a universal
 performance contract.
 
-- **Reproduced on:** Windows 11 Pro 26200, AMD Ryzen 9 7950X3D, 64 GB DDR5,
+- **Reproduced on:** Windows 11 Pro 26200, AMD Ryzen 9 9950X, 64 GB DDR5,
   Rust 1.92 (release profile, `lto = "fat"`, `codegen-units = 1`),
   Python 3.12, Node 20.
 - **Reproduce yourself:** `pip install -e bindings/python[bench]` then
@@ -76,7 +102,7 @@ to recompute on every tick.
 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.
 
-| Indicator           | Wickra              | finta                       | talipp                        |
+| Indicator           | **★&nbsp;Wickra**   | finta                       | talipp                        |
 |---------------------|---------------------|-----------------------------|-------------------------------|
 | SMA(20)             | **95.6 µs ★**       | 343.5 µs (3.6× slower)      | 7 640.6 µs (79.9× slower)     |
 | EMA(20)             | **64.6 µs ★**       | 223.1 µs (3.5× slower)      | 12 160.9 µs (188.2× slower)   |
@@ -90,7 +116,7 @@ slower it is than Wickra in parentheses. **★** marks the winner per row.
 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)         |
+| Indicator | **★&nbsp;Wickra (per tick)** | talipp (per tick)         |
 |-----------|---------------------|---------------------------|
 | RSI(14)   | **0.119 µs ★**      | 1.644 µs (13.8× slower)   |
 
@@ -109,20 +135,36 @@ python -m benchmarks.compare_libraries
 
 ## Indicators
 
-71 streaming-first indicators across eight families. Every one passes the
+232 streaming-first indicators across seventeen families. Every one passes the
 `batch == streaming` equivalence test, reference-value tests, and reset
-semantics tests.
+semantics tests. Each has a per-indicator deep dive (formula, parameters,
+warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
 
 | Family | Indicators |
 |--------|-----------|
-| Moving Averages      | SMA, EMA, WMA, DEMA, TEMA, HMA, KAMA, SMMA, TRIMA, ZLEMA, T3, VWMA |
-| Momentum Oscillators | RSI (Wilder), Stochastic, CCI, ROC, Williams %R, MFI, Awesome Oscillator, MOM, CMO, TSI, PMO, StochRSI, Ultimate Oscillator |
-| Trend & Directional  | MACD, ADX (+DI/-DI), Aroon, TRIX, Aroon Oscillator, Vortex, Mass Index, Choppiness Index, Vertical Horizontal Filter |
-| Price Oscillators    | PPO, DPO, Coppock, Accelerator Oscillator, Balance of Power |
-| Volatility & Bands   | ATR, Bollinger Bands, Keltner Channels, Donchian Channels, NATR, StdDev, Ulcer Index, Historical Volatility, Bollinger Bandwidth, %B, True Range, Chaikin Volatility |
-| Trailing Stops       | Parabolic SAR, SuperTrend, Chandelier Exit, Chande Kroll Stop, ATR Trailing Stop |
-| Volume               | OBV, VWAP (cumulative + rolling), ADL, Volume-Price Trend, Chaikin Money Flow, Chaikin Oscillator, Force Index, Ease of Movement |
-| Price Statistics     | Typical Price, Median Price, Weighted Close, Linear Regression, Linear Regression Slope, Z-Score, Linear Regression Angle |
+| Moving Averages      | SMA, EMA, WMA, DEMA, TEMA, HMA, KAMA, SMMA, TRIMA, ZLEMA, T3, VWMA, ALMA, McGinley Dynamic, FRAMA, VIDYA, JMA, Alligator, EVWMA |
+| Momentum Oscillators | RSI (Wilder), Stochastic, CCI, ROC, Williams %R, MFI, Awesome Oscillator, MOM, CMO, TSI, PMO, StochRSI, Ultimate Oscillator, RVI, PGO, KST, SMI, Laguerre RSI, Connors RSI, Inertia |
+| Trend & Directional  | MACD, 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 |
+| Price Oscillators    | PPO, DPO, Coppock, Accelerator Oscillator, Balance of Power, APO, AO Histogram, CFO, Zero-Lag MACD, Elder Impulse, STC |
+| 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 |
+| 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 |
+| Trailing Stops       | Parabolic SAR, 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 |
+| 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, Anchored VWAP, Demand Index, TSV, VZO, Market Facilitation Index |
+| 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 |
+| Ehlers / Cycle (DSP) | MAMA, FAMA, Fisher Transform, Inverse Fisher Transform, SuperSmoother, Hilbert Dominant Cycle, Sine Wave, Decycler, Decycler Oscillator, Roofing Filter, Center of Gravity, Cybernetic Cycle, Adaptive Cycle, Empirical Mode Decomposition, Ehlers Stochastic, Instantaneous Trendline |
+| Pivots & S/R         | Classic Pivots, Fibonacci Pivots, Camarilla, Woodie Pivots, DeMark Pivots, Williams Fractals, ZigZag |
+| 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 |
+| Ichimoku & Charts    | Ichimoku Kinko Hyo (Tenkan, Kijun, Senkou A/B, Chikou), Heikin-Ashi |
+| 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 |
+| 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 |
+| Market Profile       | Value Area (POC / VAH / VAL), Initial Balance, Opening Range |
+| 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) |
+
+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; all four bindings
 inherit it automatically.
@@ -195,7 +237,7 @@ A Python live-trading example using the public `websockets` package lives at
 ```
 wickra/
 ├── crates/
-│   ├── wickra-core/         core engine + all 71 indicators
+│   ├── wickra-core/         core engine + all 232 indicators
 │   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
 │   └── wickra-data/         CSV reader, tick aggregator, live exchange feeds
 ├── bindings/
@@ -256,7 +298,7 @@ Every layer is covered; run the suites with the commands in
 ## 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:
 
@@ -287,17 +329,27 @@ 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.
 
+## 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://img.shields.io/github/stars/wickra-lib/wickra?style=for-the-badge&logo=github&logoColor=white&color=ffd866">
   </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://img.shields.io/github/forks/wickra-lib/wickra?style=for-the-badge&logo=github&logoColor=white&color=78dce8">
   </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://img.shields.io/github/issues/wickra-lib/wickra?style=for-the-badge&logo=github&logoColor=white&color=ff6188">
   </a>
 </p>
 

SECURITY.md

@@ -16,9 +16,9 @@ version only; please upgrade to the newest release before reporting an issue.
 
 Report it privately through one of:
 
-- GitHub's [private vulnerability reporting](https://github.com/kingchenc/wickra/security/advisories/new)
+- 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 **kingchencp@gmail.com** with a subject line starting with
+- email to **support@wickra.org** with a subject line starting with
   `[wickra security]`.
 
 Please include:

bindings/node/Cargo.toml

@@ -9,7 +9,7 @@ edition.workspace = true
 # also emits `cargo::` directives that require >= 1.77 — that older floor is
 # subsumed by the 1.88 requirement now.
 rust-version = "1.88"
-license.workspace = true
+license-file.workspace = true
 repository.workspace = true
 homepage.workspace = true
 readme.workspace = true

bindings/node/README.md

@@ -1,45 +1,73 @@
-# wickra
+# Wickra — Node.js
 
-Node.js bindings for the Wickra streaming-first technical indicators library.
+[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![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)](https://github.com/wickra-lib/wickra/blob/main/LICENSE)
+
+**Streaming-first technical indicators for Node.js. `npm install wickra` —
+prebuilt native binary, no system dependencies.**
+
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js, and WebAssembly. 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 Node.js binding (napi-rs);
+it exposes 200+ streaming-first indicators across sixteen families.
 
 ## Install
 
-Once published, install per platform via the precompiled native package:
-
 ```bash
 npm install wickra
 ```
 
-## Build from source
+The native addon ships as a prebuilt binary per platform (Linux, macOS,
+Windows — x64 and arm64), selected automatically through optional
+dependencies. There is nothing to compile.
 
-```bash
-cd bindings/node
-npm install
-npm run build
-npm test
-```
-
-The native module is built via [napi-rs](https://napi.rs/). The build script
-produces a `wickra.<platform>-<arch>.node` binary in the package root that
-`index.js` loads at runtime.
-
-## Usage
+## Quick start
 
 ```js
-import { SMA, RSI, MACD, version } from 'wickra';
+const wickra = require('wickra');
 
-console.log('wickra', version());
+// Batch: run an indicator over a whole array.
+const prices = Array.from({ length: 1000 }, (_, i) => 100 + i * 0.1);
+const values = new wickra.RSI(14).batch(prices); // null during warmup
 
-// Batch:
-const prices = Array.from({ length: 1000 }, (_, i) => 100 + Math.sin(i * 0.1) * 5);
-const rsi = new RSI(14).batch(prices);
-
-// Streaming:
-const macd = new MACD(12, 26, 9);
-for (const p of livePriceStream) {
-  const v = macd.update(p);
-  if (v && v.histogram > 0) console.log('bullish crossover candidate');
+// Streaming: the same indicator, fed tick by tick in O(1).
+const rsi = new wickra.RSI(14);
+for (const price of liveFeed) {
+  const value = rsi.update(price); // no recomputation over history
+  if (value !== null && value > 70) {
+    console.log('overbought');
+  }
 }
 ```
 
-See `index.d.ts` for the full TypeScript surface.
+`batch(prices)` and feeding the same prices through `update()` produce
+identical values — the equivalence is enforced by the test suite.
+
+## 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/node/`](https://github.com/wickra-lib/wickra/tree/main/examples/node)
+
+Wickra ships four bindings — Python, Node.js, WebAssembly, and Rust — that all
+expose the same indicators from the shared, `unsafe`-forbidden Rust core.
+
+## Disclaimer
+
+Wickra is an indicator toolkit, not a trading system. The values it computes
+are deterministic transforms of the input data — they are not financial advice
+and do not predict the market. Any use in a live trading context is at your own
+risk. The library is provided **as is**, without warranty of any kind.
+
+## License
+
+Licensed under the **PolyForm Noncommercial License 1.0.0**. Personal projects,
+research, education, non-profits, and hobby trading bots are all fine; the one
+thing not allowed is commercial sale of the software or of services built
+around it. See [LICENSE](https://github.com/wickra-lib/wickra/blob/main/LICENSE).

bindings/node/__tests__/completeness.test.js

@@ -0,0 +1,70 @@
+// Completeness contract for the Wickra Node bindings: every exported indicator
+// class must expose the full streaming + batch + lifecycle interface. This
+// catches a new indicator being wired into the binding without the standard
+// methods (or an export silently disappearing) without needing a hand-written
+// test per indicator.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const wickra = require('..');
+
+// An "indicator class" is an exported constructor whose prototype carries the
+// streaming `update` method. This excludes `version` (a plain function) and any
+// non-indicator export.
+function indicatorClasses() {
+  return Object.keys(wickra).filter((name) => {
+    const value = wickra[name];
+    return (
+      typeof value === 'function' &&
+      value.prototype &&
+      typeof value.prototype.update === 'function'
+    );
+  });
+}
+
+test('the binding exports the full indicator catalogue', () => {
+  const names = indicatorClasses();
+  // The published catalogue is 214 indicators. Guard against a regression that
+  // silently drops exported classes (e.g. a stale or partial native build).
+  assert.ok(
+    names.length >= 200,
+    `expected at least 200 indicator classes, got ${names.length}`,
+  );
+});
+
+test('every exported indicator exposes update / batch / reset / isReady / warmupPeriod', () => {
+  const required = ['update', 'batch', 'reset', 'isReady', 'warmupPeriod'];
+  const missing = [];
+  for (const name of indicatorClasses()) {
+    const proto = wickra[name].prototype;
+    for (const method of required) {
+      if (typeof proto[method] !== 'function') {
+        missing.push(`${name}.${method}`);
+      }
+    }
+  }
+  assert.deepEqual(
+    missing,
+    [],
+    `indicator classes missing required methods: ${missing.join(', ')}`,
+  );
+});
+
+test('a freshly constructed indicator reports not-ready with a positive warmup', () => {
+  // Every indicator that takes no constructor arguments must still satisfy the
+  // pre-warmup contract. (Indicators with required parameters are exercised by
+  // the dedicated suites; here we cover the zero-arg ones generically.)
+  let checked = 0;
+  for (const name of indicatorClasses()) {
+    let instance;
+    try {
+      instance = new wickra[name]();
+    } catch {
+      continue; // needs constructor arguments — covered elsewhere
+    }
+    assert.equal(instance.isReady(), false, `${name} should start un-ready`);
+    assert.ok(instance.warmupPeriod() >= 1, `${name} warmup must be >= 1`);
+    checked += 1;
+  }
+  assert.ok(checked > 0, 'expected at least one zero-arg indicator to check');
+});

bindings/node/__tests__/indicators.test.js

@@ -17,6 +17,7 @@ const open = close.map((c) => c - 0.5);
 
 function eq(a, b) {
   if (Number.isNaN(a)) return Number.isNaN(b);
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return a === b;
   return Math.abs(a - b) < 1e-9;
 }
 
@@ -37,6 +38,11 @@ const scalarFactories = {
   ROC: () => new wickra.ROC(12),
   TRIX: () => new wickra.TRIX(9),
   KAMA: () => new wickra.KAMA(10, 2, 30),
+  ALMA: () => new wickra.ALMA(9, 0.85, 6.0),
+  McGinleyDynamic: () => new wickra.McGinleyDynamic(10),
+  FRAMA: () => new wickra.FRAMA(16),
+  VIDYA: () => new wickra.VIDYA(14, 9),
+  JMA: () => new wickra.JMA(14, 0, 2),
   SMMA: () => new wickra.SMMA(14),
   TRIMA: () => new wickra.TRIMA(20),
   ZLEMA: () => new wickra.ZLEMA(14),
@@ -45,8 +51,13 @@ const scalarFactories = {
   CMO: () => new wickra.CMO(14),
   TSI: () => new wickra.TSI(25, 13),
   PMO: () => new wickra.PMO(35, 20),
+  TII: () => new wickra.TII(20, 10),
   StochRSI: () => new wickra.StochRSI(14, 14),
   PPO: () => new wickra.PPO(12, 26),
+  APO: () => new wickra.APO(12, 26),
+  CFO: () => new wickra.CFO(14),
+  ElderImpulse: () => new wickra.ElderImpulse(13, 12, 26, 9),
+  STC: () => new wickra.STC(23, 50, 10, 0.5),
   DPO: () => new wickra.DPO(20),
   Coppock: () => new wickra.Coppock(14, 11, 10),
   StdDev: () => new wickra.StdDev(20),
@@ -59,8 +70,79 @@ const scalarFactories = {
   VerticalHorizontalFilter: () => new wickra.VerticalHorizontalFilter(28),
   ZScore: () => new wickra.ZScore(20),
   LinRegAngle: () => new wickra.LinRegAngle(14),
+  PercentageTrailingStop: () => new wickra.PercentageTrailingStop(5),
+  StepTrailingStop: () => new wickra.StepTrailingStop(1),
+  RenkoTrailingStop: () => new wickra.RenkoTrailingStop(1),
+  LaguerreRSI: () => new wickra.LaguerreRSI(0.5),
+  ConnorsRSI: () => new wickra.ConnorsRSI(3, 2, 100),
+  RVIVolatility: () => new wickra.RVIVolatility(10),
+  // Family 10 — Ehlers / Cycle
+  SuperSmoother: () => new wickra.SuperSmoother(10),
+  FisherTransform: () => new wickra.FisherTransform(10),
+  InverseFisherTransform: () => new wickra.InverseFisherTransform(1.0),
+  Decycler: () => new wickra.Decycler(20),
+  DecyclerOscillator: () => new wickra.DecyclerOscillator(10, 30),
+  RoofingFilter: () => new wickra.RoofingFilter(10, 48),
+  CenterOfGravity: () => new wickra.CenterOfGravity(10),
+  CyberneticCycle: () => new wickra.CyberneticCycle(10),
+  InstantaneousTrendline: () => new wickra.InstantaneousTrendline(20),
+  EhlersStochastic: () => new wickra.EhlersStochastic(20),
+  EmpiricalModeDecomposition: () => new wickra.EmpiricalModeDecomposition(20, 0.5),
+  HilbertDominantCycle: () => new wickra.HilbertDominantCycle(),
+  AdaptiveCycle: () => new wickra.AdaptiveCycle(),
+  SineWave: () => new wickra.SineWave(),
+  FAMA: () => new wickra.FAMA(0.5, 0.05),
+  // Family 12 — Statistik / Regression
+  Variance: () => new wickra.Variance(20),
+  CoefficientOfVariation: () => new wickra.CoefficientOfVariation(20),
+  Skewness: () => new wickra.Skewness(20),
+  Kurtosis: () => new wickra.Kurtosis(20),
+  StandardError: () => new wickra.StandardError(14),
+  DetrendedStdDev: () => new wickra.DetrendedStdDev(14),
+  RSquared: () => new wickra.RSquared(14),
+  MedianAbsoluteDeviation: () => new wickra.MedianAbsoluteDeviation(20),
+  Autocorrelation: () => new wickra.Autocorrelation(20, 1),
+  HurstExponent: () => new wickra.HurstExponent(40, 4),
+  // Family 15 — Risk / Performance metrics (scalar f64 input).
+  SharpeRatio: () => new wickra.SharpeRatio(20, 0),
+  SortinoRatio: () => new wickra.SortinoRatio(20, 0),
+  CalmarRatio: () => new wickra.CalmarRatio(20),
+  OmegaRatio: () => new wickra.OmegaRatio(20, 0),
+  MaxDrawdown: () => new wickra.MaxDrawdown(20),
+  AverageDrawdown: () => new wickra.AverageDrawdown(20),
+  DrawdownDuration: () => new wickra.DrawdownDuration(),
+  PainIndex: () => new wickra.PainIndex(20),
+  ValueAtRisk: () => new wickra.ValueAtRisk(20, 0.95),
+  ConditionalValueAtRisk: () => new wickra.ConditionalValueAtRisk(20, 0.95),
+  ProfitFactor: () => new wickra.ProfitFactor(20),
+  GainLossRatio: () => new wickra.GainLossRatio(20),
+  RecoveryFactor: () => new wickra.RecoveryFactor(),
+  KellyCriterion: () => new wickra.KellyCriterion(20),
 };
 
+// --- Two-series (asset, benchmark) ratio indicators ---
+
+const ratioPairFactories = {
+  TreynorRatio: () => new wickra.TreynorRatio(20, 0),
+  InformationRatio: () => new wickra.InformationRatio(20),
+  Alpha: () => new wickra.Alpha(20, 0),
+};
+
+const asset = Array.from({ length: N }, (_, i) => 0.001 + Math.sin(i * 0.15) * 0.01);
+const bench = Array.from({ length: N }, (_, i) => 0.001 + Math.sin(i * 0.15) * 0.007);
+
+for (const [name, make] of Object.entries(ratioPairFactories)) {
+  test(`${name}: streaming update matches batch (pair)`, () => {
+    const batch = make().batch(asset, bench);
+    const streaming = make();
+    assert.equal(batch.length, N);
+    for (let i = 0; i < N; i++) {
+      const s = num(streaming.update(asset[i], bench[i]));
+      assert.ok(eq(s, batch[i]), `${name} mismatch at ${i}: ${s} vs ${batch[i]}`);
+    }
+  });
+}
+
 for (const [name, make] of Object.entries(scalarFactories)) {
   test(`${name}: streaming update matches batch`, () => {
     const batch = make().batch(close);
@@ -86,6 +168,11 @@ const candleScalar = {
   AwesomeOscillator: { make: () => new wickra.AwesomeOscillator(5, 34), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
   OBV: { make: () => new wickra.OBV(), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
   VWMA: { make: () => new wickra.VWMA(20), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
+  RVI: { make: () => new wickra.RVI(10), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Inertia: { make: () => new wickra.Inertia(14, 20), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  PGO: { make: () => new wickra.PGO(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  SMI: { make: () => new wickra.SMI(5, 3, 3), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  EVWMA: { make: () => new wickra.EVWMA(20), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
   UltimateOscillator: { make: () => new wickra.UltimateOscillator(7, 14, 28), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   AroonOscillator: { make: () => new wickra.AroonOscillator(14), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
   NATR: { make: () => new wickra.NATR(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
@@ -96,15 +183,58 @@ const candleScalar = {
   ChaikinOscillator: { make: () => new wickra.ChaikinOscillator(3, 10), step: (ind, i) => ind.update(high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(high, low, close, volume) },
   ForceIndex: { make: () => new wickra.ForceIndex(13), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
   EaseOfMovement: { make: () => new wickra.EaseOfMovement(14, 1e8), step: (ind, i) => ind.update(high[i], low[i], volume[i]), batch: (ind) => ind.batch(high, low, volume) },
+  KVO: { make: () => new wickra.KVO(34, 55), step: (ind, i) => ind.update(high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(high, low, close, volume) },
+  VolumeOscillator: { make: () => new wickra.VolumeOscillator(14, 28), step: (ind, i) => ind.update(volume[i]), batch: (ind) => ind.batch(volume) },
+  NVI: { make: () => new wickra.NVI(), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
+  PVI: { make: () => new wickra.PVI(), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
+  WilliamsAD: { make: () => new wickra.WilliamsAD(), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  AnchoredVWAP: { make: () => new wickra.AnchoredVWAP(), step: (ind, i) => ind.update(high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(high, low, close, volume) },
+  DemandIndex: { make: () => new wickra.DemandIndex(10), step: (ind, i) => ind.update(high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(high, low, close, volume) },
+  TSV: { make: () => new wickra.TSV(18), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
+  VZO: { make: () => new wickra.VZO(14), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
+  MarketFacilitationIndex: { make: () => new wickra.MarketFacilitationIndex(), step: (ind, i) => ind.update(high[i], low[i], volume[i]), batch: (ind) => ind.batch(high, low, volume) },
   AtrTrailingStop: { make: () => new wickra.AtrTrailingStop(14, 3), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  HiLoActivator: { make: () => new wickra.HiLoActivator(3), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  VoltyStop: { make: () => new wickra.VoltyStop(14, 2), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  YoyoExit: { make: () => new wickra.YoyoExit(14, 2), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   TypicalPrice: { make: () => new wickra.TypicalPrice(), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   MedianPrice: { make: () => new wickra.MedianPrice(), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
   WeightedClose: { make: () => new wickra.WeightedClose(), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   AcceleratorOscillator: { make: () => new wickra.AcceleratorOscillator(5, 34, 5), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  AwesomeOscillatorHistogram: { make: () => new wickra.AwesomeOscillatorHistogram(5, 34, 5), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
   BalanceOfPower: { make: () => new wickra.BalanceOfPower(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
   ChoppinessIndex: { make: () => new wickra.ChoppinessIndex(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   TrueRange: { make: () => new wickra.TrueRange(), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   ChaikinVolatility: { make: () => new wickra.ChaikinVolatility(10, 10), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  ADXR: { make: () => new wickra.ADXR(7), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  ParkinsonVolatility: { make: () => new wickra.ParkinsonVolatility(20, 252), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  GarmanKlassVolatility: { make: () => new wickra.GarmanKlassVolatility(20, 252), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  RogersSatchellVolatility: { make: () => new wickra.RogersSatchellVolatility(20, 252), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  YangZhangVolatility: { make: () => new wickra.YangZhangVolatility(20, 252), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  TDSetup: { make: () => new wickra.TDSetup(4, 9), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  TDDeMarker: { make: () => new wickra.TDDeMarker(14), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  TDREI: { make: () => new wickra.TDREI(5), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  TDPressure: { make: () => new wickra.TDPressure(5), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(open, high, low, close, volume) },
+  TDCombo: { make: () => new wickra.TDCombo(4, 9, 2, 13), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  TDCountdown: { make: () => new wickra.TDCountdown(4, 9, 2, 13), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  TDDifferential: { make: () => new wickra.TDDifferential(), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  TDOpen: { make: () => new wickra.TDOpen(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  // Family 14 — Candlestick patterns
+  Doji: { make: () => new wickra.Doji(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Hammer: { make: () => new wickra.Hammer(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  InvertedHammer: { make: () => new wickra.InvertedHammer(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  HangingMan: { make: () => new wickra.HangingMan(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  ShootingStar: { make: () => new wickra.ShootingStar(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Engulfing: { make: () => new wickra.Engulfing(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Harami: { make: () => new wickra.Harami(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  MorningEveningStar: { make: () => new wickra.MorningEveningStar(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  ThreeSoldiersOrCrows: { make: () => new wickra.ThreeSoldiersOrCrows(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  PiercingDarkCloud: { make: () => new wickra.PiercingDarkCloud(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Marubozu: { make: () => new wickra.Marubozu(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  Tweezer: { make: () => new wickra.Tweezer(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  SpinningTop: { make: () => new wickra.SpinningTop(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  ThreeInside: { make: () => new wickra.ThreeInside(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  ThreeOutside: { make: () => new wickra.ThreeOutside(), step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
 };
 
 for (const [name, d] of Object.entries(candleScalar)) {
@@ -122,7 +252,11 @@ for (const [name, d] of Object.entries(candleScalar)) {
 // --- Multi-output indicators: object update vs interleaved batch ---
 
 const multi = {
+  KST: { make: () => new wickra.KST(10, 15, 20, 30, 10, 10, 10, 15, 9), fields: ['kst', 'signal'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  Alligator: { make: () => new wickra.Alligator(13, 8, 5), fields: ['jaw', 'teeth', 'lips'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  ZeroLagMACD: { make: () => new wickra.ZeroLagMACD(12, 26, 9), fields: ['macd', 'signal', 'histogram'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
   MACD: { make: () => new wickra.MACD(12, 26, 9), fields: ['macd', 'signal', 'histogram'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  KST: { make: () => wickra.KST.classic(), fields: ['kst', 'signal'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
   BollingerBands: { make: () => new wickra.BollingerBands(20, 2), fields: ['upper', 'middle', 'lower', 'stddev'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
   Stochastic: { make: () => new wickra.Stochastic(14, 3), fields: ['k', 'd'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   ADX: { make: () => new wickra.ADX(14), fields: ['plusDi', 'minusDi', 'adx'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
@@ -130,9 +264,46 @@ const multi = {
   Donchian: { make: () => new wickra.Donchian(20), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
   Aroon: { make: () => new wickra.Aroon(14), fields: ['up', 'down'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
   Vortex: { make: () => new wickra.Vortex(14), fields: ['plus', 'minus'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  RWI: { make: () => new wickra.RWI(14), fields: ['high', 'low'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  WaveTrend: { make: () => wickra.WaveTrend.classic(), fields: ['wt1', 'wt2'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   SuperTrend: { make: () => new wickra.SuperTrend(10, 3), fields: ['value', 'direction'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   ChandelierExit: { make: () => new wickra.ChandelierExit(22, 3), fields: ['longStop', 'shortStop'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   ChandeKrollStop: { make: () => new wickra.ChandeKrollStop(10, 1, 9), fields: ['stopLong', 'stopShort'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  // Family 16: Market Profile
+  ValueArea: { make: () => new wickra.ValueArea(20, 50, 0.70), fields: ['poc', 'vah', 'val'], step: (ind, i) => ind.update(high[i], low[i], volume[i]), batch: (ind) => ind.batch(high, low, volume) },
+  InitialBalance: { make: () => new wickra.InitialBalance(12), fields: ['high', 'low'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  OpeningRange: { make: () => new wickra.OpeningRange(6), fields: ['high', 'low', 'breakoutDistance'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  DonchianStop: { make: () => new wickra.DonchianStop(10), fields: ['stopLong', 'stopShort'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  // Family 05: bands & channels
+  MaEnvelope: { make: () => new wickra.MaEnvelope(20, 0.025), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  AccelerationBands: { make: () => new wickra.AccelerationBands(20, 0.001), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  StarcBands: { make: () => new wickra.StarcBands(6, 15, 2), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  AtrBands: { make: () => new wickra.AtrBands(14, 3), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  HurstChannel: { make: () => new wickra.HurstChannel(10, 0.5), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  LinRegChannel: { make: () => new wickra.LinRegChannel(20, 2), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  StandardErrorBands: { make: () => new wickra.StandardErrorBands(21, 2), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  DoubleBollinger: { make: () => new wickra.DoubleBollinger(20, 1, 2), fields: ['upperOuter', 'upperInner', 'middle', 'lowerInner', 'lowerOuter'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  TtmSqueeze: { make: () => new wickra.TtmSqueeze(20, 2, 1.5), fields: ['squeeze', 'momentum'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  FractalChaosBands: { make: () => new wickra.FractalChaosBands(2), fields: ['upper', 'lower'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  VwapStdDevBands: { make: () => new wickra.VwapStdDevBands(2), fields: ['upper', 'middle', 'lower', 'stddev'], step: (ind, i) => ind.update(high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(high, low, close, volume) },
+  // Family 08: Pivots & Support/Resistance
+  ClassicPivots: { make: () => new wickra.ClassicPivots(), fields: ['pp', 'r1', 'r2', 'r3', 's1', 's2', 's3'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  FibonacciPivots: { make: () => new wickra.FibonacciPivots(), fields: ['pp', 'r1', 'r2', 'r3', 's1', 's2', 's3'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  Camarilla: { make: () => new wickra.Camarilla(), fields: ['pp', 'r1', 'r2', 'r3', 'r4', 's1', 's2', 's3', 's4'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  WoodiePivots: { make: () => new wickra.WoodiePivots(), fields: ['pp', 'r1', 'r2', 's1', 's2'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  DemarkPivots: { make: () => new wickra.DemarkPivots(), fields: ['pp', 'r1', 's1'], step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  WilliamsFractals: { make: () => new wickra.WilliamsFractals(), fields: ['up', 'down'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  ZigZag: { make: () => new wickra.ZigZag(0.02), fields: ['swing', 'direction'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  // Family 11: DeMark
+  TDSequential: { make: () => new wickra.TDSequential(4, 9, 2, 13), fields: ['setup', 'countdown', 'direction'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  TDLines: { make: () => new wickra.TDLines(4, 9), fields: ['resistance', 'support'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  TDRangeProjection: { make: () => new wickra.TDRangeProjection(), fields: ['high', 'low'], step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
+  TDRiskLevel: { make: () => new wickra.TDRiskLevel(4, 9), fields: ['buyRisk', 'sellRisk'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  // Family 10: Ehlers / Cycle (multi-output)
+  MAMA: { make: () => new wickra.MAMA(0.5, 0.05), fields: ['mama', 'fama'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  // Family 13: Ichimoku & alternative charts
+  Ichimoku: { make: () => new wickra.Ichimoku(9, 26, 52, 26), fields: ['tenkan', 'kijun', 'senkouA', 'senkouB', 'chikou'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  HeikinAshi: { make: () => new wickra.HeikinAshi(), fields: ['open', 'high', 'low', 'close'], step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
 };
 
 for (const [name, d] of Object.entries(multi)) {
@@ -258,3 +429,668 @@ test('LinRegAngle of a unit-slope series is 45 degrees', () => {
   const out = new wickra.LinRegAngle(5).batch([1, 2, 3, 4, 5, 6]);
   assert.ok(Math.abs(out[4] - 45) < 1e-9);
 });
+
+test('InitialBalance(2) locks after period and ignores subsequent bars', () => {
+  const ib = new wickra.InitialBalance(2);
+  let v = ib.update(102, 100);
+  assert.equal(v.high, 102);
+  assert.equal(v.low, 100);
+  v = ib.update(103, 99);
+  assert.equal(v.high, 103);
+  assert.equal(v.low, 99);
+  assert.equal(ib.isLocked(), true);
+  // Extreme bar after lock must not modify the IB.
+  v = ib.update(200, 50);
+  assert.equal(v.high, 103);
+  assert.equal(v.low, 99);
+});
+
+test('OpeningRange(2) breakout distance is signed close minus midpoint', () => {
+  const or = new wickra.OpeningRange(2);
+  or.update(102, 100, 101);
+  or.update(103, 101, 102);
+  // OR locked at high 103 / low 100 / mid 101.5. Close 105 -> +3.5.
+  const v = or.update(110, 102, 105);
+  assert.equal(v.high, 103);
+  assert.equal(v.low, 100);
+  assert.ok(Math.abs(v.breakoutDistance - 3.5) < 1e-9);
+});
+
+// --- Family 12: two-series indicators (Pearson / Beta / Spearman) ---
+
+const pairFactories = {
+  PearsonCorrelation: () => new wickra.PearsonCorrelation(14),
+  Beta: () => new wickra.Beta(14),
+  PairwiseBeta: () => new wickra.PairwiseBeta(14),
+  PairSpreadZScore: () => new wickra.PairSpreadZScore(14, 14),
+  SpearmanCorrelation: () => new wickra.SpearmanCorrelation(14),
+};
+
+for (const [name, make] of Object.entries(pairFactories)) {
+  test(`${name}: streaming update matches batch over a pair of series`, () => {
+    const xs = Array.from({ length: N }, (_, i) => Math.sin(i * 0.2) + 0.05 * i);
+    const ys = Array.from({ length: N }, (_, i) => Math.cos(i * 0.3) + 0.02 * i);
+    const batch = make().batch(xs, ys);
+    const streaming = make();
+    assert.equal(batch.length, N);
+    for (let i = 0; i < N; i++) {
+      const s = num(streaming.update(xs[i], ys[i]));
+      assert.ok(eq(s, batch[i]), `${name} mismatch at ${i}: ${s} vs ${batch[i]}`);
+    }
+  });
+}
+
+test('PearsonCorrelation perfect positive is 1', () => {
+  const x = Array.from({ length: 10 }, (_, i) => i);
+  const y = x.map((v) => 2 * v + 3);
+  const out = new wickra.PearsonCorrelation(5).batch(x, y);
+  assert.ok(Math.abs(out[out.length - 1] - 1) < 1e-9);
+});
+
+test('Beta perfect two-to-one', () => {
+  const bench = Array.from({ length: 10 }, (_, i) => i);
+  const asset = bench.map((v) => 2 * v);
+  const out = new wickra.Beta(5).batch(asset, bench);
+  assert.ok(Math.abs(out[out.length - 1] - 2) < 1e-9);
+});
+
+test('PairwiseBeta squared price is two', () => {
+  // b needs varying returns; a = b² ⇒ a's log-returns are exactly 2× b's.
+  const bench = Array.from({ length: 20 }, (_, i) => 100 + 10 * Math.sin(i * 0.5));
+  const asset = bench.map((v) => v * v);
+  const out = new wickra.PairwiseBeta(5).batch(asset, bench);
+  assert.ok(Math.abs(out[out.length - 1] - 2) < 1e-9);
+});
+
+test('PairSpreadZScore flat benchmark is sign of last move', () => {
+  // Flat b ⇒ hedge ratio 0 ⇒ spread = ln(a); z_period = 2 ⇒ z = sign of move.
+  const a = [100, 100, 110, 105, 130];
+  const b = [100, 100, 100, 100, 100];
+  const out = new wickra.PairSpreadZScore(2, 2).batch(a, b);
+  assert.ok(Math.abs(out[out.length - 1] - 1) < 1e-9);
+  assert.ok(Math.abs(out[out.length - 2] + 1) < 1e-9);
+});
+
+const llSignal = (t) =>
+  Math.sin(t * 0.4) + 0.4 * Math.sin(t * 1.1) + 0.2 * Math.cos(t * 0.27);
+
+test('LeadLagCrossCorrelation detects positive lead (object output)', () => {
+  const ll = new wickra.LeadLagCrossCorrelation(12, 5);
+  let last = null;
+  // b is a delayed by 3 ⇒ a leads b ⇒ lag = +3.
+  for (let t = 0; t < 60; t++) last = ll.update(llSignal(t), llSignal(t - 3));
+  assert.equal(last.lag, 3);
+  assert.ok(last.correlation > 0.99);
+});
+
+test('LeadLagCrossCorrelation batch is flat 2*n with last row matching', () => {
+  const n = 60;
+  const a = Array.from({ length: n }, (_, t) => llSignal(t));
+  const b = Array.from({ length: n }, (_, t) => llSignal(t - 3));
+  const out = new wickra.LeadLagCrossCorrelation(12, 5).batch(a, b);
+  assert.equal(out.length, 2 * n);
+  assert.equal(out[2 * (n - 1)], 3);
+  assert.ok(out[2 * (n - 1) + 1] > 0.99);
+});
+
+test('Cointegration detects mean-reverting pair (object output)', () => {
+  const n = 80;
+  const b = Array.from({ length: n }, (_, t) => 50 + 0.5 * t);
+  const a = b.map((v, t) => 2 * v + 1 + 0.5 * Math.sin(t * 0.6));
+  const co = new wickra.Cointegration(40, 1);
+  let last = null;
+  for (let i = 0; i < n; i++) last = co.update(a[i], b[i]);
+  assert.ok(Math.abs(last.hedgeRatio - 2) < 0.1);
+  assert.ok(last.adfStat < -2);
+});
+
+test('Cointegration batch is flat 3*n with last row matching', () => {
+  const n = 80;
+  const b = Array.from({ length: n }, (_, t) => 50 + 0.5 * t);
+  const a = b.map((v, t) => 2 * v + 1 + 0.5 * Math.sin(t * 0.6));
+  const out = new wickra.Cointegration(40, 1).batch(a, b);
+  assert.equal(out.length, 3 * n);
+  assert.ok(Math.abs(out[3 * (n - 1)] - 2) < 0.1);
+  assert.ok(out[3 * (n - 1) + 2] < -2);
+});
+
+test('RelativeStrengthAB constant ratio is flat (object output)', () => {
+  const rs = new wickra.RelativeStrengthAB(5, 5);
+  let last = null;
+  for (let i = 0; i < 30; i++) last = rs.update(200, 100); // ratio is a constant 2
+  assert.ok(Math.abs(last.ratio - 2) < 1e-12);
+  assert.ok(Math.abs(last.ratioMa - 2) < 1e-12);
+  assert.ok(Math.abs(last.ratioRsi - 50) < 1e-9);
+});
+
+test('RelativeStrengthAB batch is flat 3*n with last row matching', () => {
+  const n = 30;
+  const a = Array.from({ length: n }, () => 200);
+  const b = Array.from({ length: n }, () => 100);
+  const out = new wickra.RelativeStrengthAB(5, 5).batch(a, b);
+  assert.equal(out.length, 3 * n);
+  assert.ok(Math.abs(out[3 * (n - 1)] - 2) < 1e-12);
+  assert.ok(Math.abs(out[3 * (n - 1) + 2] - 50) < 1e-9);
+});
+
+test('SpearmanCorrelation monotone non-linear is 1', () => {
+  const x = Array.from({ length: 10 }, (_, i) => i + 1);
+  const y = x.map((v) => v ** 3);
+  const out = new wickra.SpearmanCorrelation(5).batch(x, y);
+  assert.ok(Math.abs(out[out.length - 1] - 1) < 1e-9);
+});
+
+test('Variance(3) of [2, 4, 6] equals 8/3', () => {
+  const out = new wickra.Variance(3).batch([2, 4, 6]);
+  assert.ok(Math.abs(out[2] - 8 / 3) < 1e-12);
+});
+
+test('RSquared on a perfect line is 1', () => {
+  const xs = Array.from({ length: 20 }, (_, i) => 2 * i + 5);
+  const out = new wickra.RSquared(5).batch(xs);
+  for (let i = 5; i < out.length; i++) {
+    assert.ok(Math.abs(out[i] - 1) < 1e-9);
+  }
+});
+
+test('MedianAbsoluteDeviation ignores a single huge outlier', () => {
+  const xs = Array(9).fill(5).concat([1000]);
+  const out = new wickra.MedianAbsoluteDeviation(10).batch(xs);
+  assert.ok(Math.abs(out[9]) < 1e-12);
+});
+
+test('Autocorrelation of an alternating series is strongly negative at lag 1', () => {
+  const xs = Array.from({ length: 20 }, (_, i) => (i % 2 === 0 ? -1 : 1));
+  const out = new wickra.Autocorrelation(10, 1).batch(xs);
+  assert.ok(out[out.length - 1] < -0.5);
+});
+
+test('HurstExponent of a monotone ramp is above 0.5', () => {
+  const xs = Array.from({ length: 200 }, (_, i) => i);
+  const out = new wickra.HurstExponent(100, 4).batch(xs);
+  assert.ok(out[out.length - 1] > 0.5);
+});
+
+test('Ichimoku classic warmup is 77 and tenkan emits at bar 9', () => {
+  const ichi = new wickra.Ichimoku(9, 26, 52, 26);
+  assert.equal(ichi.warmupPeriod(), 77);
+  const n = 30;
+  const h = Array.from({ length: n }, (_, i) => 100 + i + 2);
+  const l = Array.from({ length: n }, (_, i) => 100 + i - 2);
+  const c = Array.from({ length: n }, (_, i) => 100 + i + 1);
+  const out = ichi.batch(h, l, c);
+  for (let i = 0; i < 8; i++) {
+    assert.ok(Number.isNaN(out[i * 5]), `tenkan should be NaN at bar ${i}`);
+  }
+  assert.ok(!Number.isNaN(out[8 * 5]), 'tenkan should be defined at bar 9');
+});
+
+test('HeikinAshi first bar seeds from real open and close', () => {
+  const ha = new wickra.HeikinAshi();
+  const out = ha.update(10, 12, 9, 11);
+  assert.ok(Math.abs(out.open - (10 + 11) / 2) < 1e-12);
+  assert.ok(Math.abs(out.close - (10 + 12 + 9 + 11) / 4) < 1e-12);
+});
+
+test('PercentageTrailingStop seeds and ratchets', () => {
+  const s = new wickra.PercentageTrailingStop(10);
+  assert.ok(Math.abs(s.update(100) - 90) < 1e-9);
+  assert.ok(Math.abs(s.update(110) - 99) < 1e-9);
+});
+
+test('RenkoTrailingStop only advances after a full block', () => {
+  const s = new wickra.RenkoTrailingStop(1);
+  assert.ok(Math.abs(s.update(100) - 99) < 1e-9);
+  assert.ok(Math.abs(s.update(100.5) - 99) < 1e-9);
+  assert.ok(Math.abs(s.update(101) - 100) < 1e-9);
+});
+
+test('DonchianStop window extremes', () => {
+  const out = new wickra.DonchianStop(5).batch([1, 2, 3, 4, 5], [0, 1, 2, 3, 4]);
+  // [long0, short0, long1, short1, ...]: idx 8 (=4*2) = long_5th, idx 9 = short_5th.
+  assert.ok(Math.abs(out[8] - 0) < 1e-9);
+  assert.ok(Math.abs(out[9] - 5) < 1e-9);
+});
+
+test('MaEnvelope reference values', () => {
+  // SMA([10, 20, 30]) = 20; with percent 0.10: upper=22, lower=18.
+  const out = new wickra.MaEnvelope(3, 0.10).batch([10, 20, 30]);
+  assert.ok(Number.isNaN(out[0]) && Number.isNaN(out[3]));
+  assert.ok(Math.abs(out[2 * 3 + 0] - 22) < 1e-9); // upper
+  assert.ok(Math.abs(out[2 * 3 + 1] - 20) < 1e-9); // middle
+  assert.ok(Math.abs(out[2 * 3 + 2] - 18) < 1e-9); // lower
+});
+
+test('AccelerationBands single-bar reference', () => {
+  // high=12, low=8, close=10, factor=0.5, period=1.
+  // ratio=0.2, raw_up=13.2, raw_lo=7.2.
+  const v = new wickra.AccelerationBands(1, 0.5).update(12, 8, 10);
+  assert.ok(Math.abs(v.upper - 13.2) < 1e-9);
+  assert.ok(Math.abs(v.middle - 10) < 1e-9);
+  assert.ok(Math.abs(v.lower - 7.2) < 1e-9);
+});
+
+test('LinRegChannel reference values for [1, 2, 9]', () => {
+  // Line y=4x, endpoint=8, residuals=[1,-2,1], sigma=sqrt(2).
+  const out = new wickra.LinRegChannel(3, 2).batch([1, 2, 9]);
+  const s = Math.sqrt(2);
+  const i = 2;
+  assert.ok(Math.abs(out[i * 3 + 0] - (8 + 2 * s)) < 1e-9);
+  assert.ok(Math.abs(out[i * 3 + 1] - 8) < 1e-9);
+  assert.ok(Math.abs(out[i * 3 + 2] - (8 - 2 * s)) < 1e-9);
+});
+
+test('VwapStdDevBands two-bar reference', () => {
+  const v = new wickra.VwapStdDevBands(1.5);
+  v.update(8, 8, 8, 1);
+  const o = v.update(12, 12, 12, 1);
+  assert.ok(Math.abs(o.upper - 13) < 1e-9);
+  assert.ok(Math.abs(o.middle - 10) < 1e-9);
+  assert.ok(Math.abs(o.lower - 7) < 1e-9);
+  assert.ok(Math.abs(o.stddev - 2) < 1e-9);
+});
+
+test('RVIVolatility pure uptrend saturates at 100', () => {
+  const prices = Array.from({ length: 40 }, (_, i) => i + 1);
+  const out = new wickra.RVIVolatility(5).batch(prices);
+  for (let i = 9; i < out.length; i++) {
+    assert.ok(Math.abs(out[i] - 100) < 1e-9, `RVIVolatility[${i}] = ${out[i]}`);
+  }
+});
+
+test('ParkinsonVolatility zero-range bars yield zero', () => {
+  const n = 30;
+  const h = Array(n).fill(10);
+  const l = Array(n).fill(10);
+  const out = new wickra.ParkinsonVolatility(14, 252).batch(h, l);
+  for (let i = 13; i < n; i++) {
+    assert.ok(Math.abs(out[i]) < 1e-12, `Parkinson[${i}] = ${out[i]}`);
+  }
+});
+
+test('GarmanKlassVolatility zero-movement bars yield zero', () => {
+  const n = 30;
+  const flat = Array(n).fill(10);
+  const out = new wickra.GarmanKlassVolatility(14, 252).batch(flat, flat, flat, flat);
+  for (let i = 13; i < n; i++) {
+    assert.ok(Math.abs(out[i]) < 1e-12, `GK[${i}] = ${out[i]}`);
+  }
+});
+
+test('RogersSatchellVolatility zero-movement bars yield zero', () => {
+  const n = 30;
+  const flat = Array(n).fill(10);
+  const out = new wickra.RogersSatchellVolatility(14, 252).batch(flat, flat, flat, flat);
+  for (let i = 13; i < n; i++) {
+    assert.ok(Math.abs(out[i]) < 1e-12, `RS[${i}] = ${out[i]}`);
+  }
+});
+
+test('YangZhangVolatility zero-movement bars yield zero', () => {
+  const n = 30;
+  const flat = Array(n).fill(10);
+  const out = new wickra.YangZhangVolatility(14, 252).batch(flat, flat, flat, flat);
+  for (let i = 14; i < n; i++) {
+    assert.ok(Math.abs(out[i]) < 1e-12, `YZ[${i}] = ${out[i]}`);
+  }
+});
+
+test('ZeroLagMACD on a flat series converges to zero', () => {
+  const out = new wickra.ZeroLagMACD(3, 5, 3).batch(Array(60).fill(42));
+  // Last interleaved row: macd, signal, histogram all 0.
+  const n = 60;
+  assert.ok(Math.abs(out[(n - 1) * 3]) < 1e-12);
+  assert.ok(Math.abs(out[(n - 1) * 3 + 1]) < 1e-12);
+  assert.ok(Math.abs(out[(n - 1) * 3 + 2]) < 1e-12);
+});
+
+test('AwesomeOscillatorHistogram on a flat median converges to zero', () => {
+  const n = 50;
+  const out = new wickra.AwesomeOscillatorHistogram(3, 5, 3).batch(
+    Array(n).fill(11),
+    Array(n).fill(9),
+  );
+  // warmup = 5 + 3 - 1 = 7.
+  for (let i = 6; i < n; i++) assert.ok(Math.abs(out[i]) < 1e-12);
+});
+
+test('STC on a flat series stays at zero', () => {
+  const out = new wickra.STC(3, 5, 4, 0.5).batch(Array(60).fill(42));
+  // Latest values must be exactly zero.
+  for (let i = out.length - 5; i < out.length; i++) {
+    if (Number.isNaN(out[i])) continue;
+    assert.equal(out[i], 0);
+  }
+});
+
+test('ElderImpulse on a flat series stays neutral (0)', () => {
+  const out = new wickra.ElderImpulse(13, 12, 26, 9).batch(Array(120).fill(42));
+  for (let i = 0; i < out.length; i++) {
+    if (Number.isNaN(out[i])) continue;
+    assert.equal(out[i], 0);
+  }
+});
+
+test('CFO(5) on a perfectly linear series yields zero', () => {
+  const prices = Array.from({ length: 20 }, (_, i) => (i + 1) * 2);
+  const out = new wickra.CFO(5).batch(prices);
+  for (let i = 4; i < 20; i++) assert.ok(Math.abs(out[i]) < 1e-9);
+});
+
+test('APO(3, 5) on a flat series converges to zero', () => {
+  const out = new wickra.APO(3, 5).batch(Array(30).fill(42));
+  for (let i = 0; i < 4; i++) assert.ok(Number.isNaN(out[i]));
+  for (let i = 4; i < 30; i++) assert.ok(Math.abs(out[i]) < 1e-12);
+});
+
+test('Inertia(3, 4) on a constant RVI series equals that RVI', () => {
+  const n = 60;
+  // Every bar (open, high, low, close) = (10, 11, 9, 10.5) -> RVI = 0.25.
+  const out = new wickra.Inertia(3, 4).batch(
+    Array(n).fill(10),
+    Array(n).fill(11),
+    Array(n).fill(9),
+    Array(n).fill(10.5),
+  );
+  for (let i = 5; i < n; i++) assert.ok(Math.abs(out[i] - 0.25) < 1e-12);
+});
+
+test('ConnorsRSI stays bounded in [0, 100]', () => {
+  const prices = Array.from({ length: 250 }, (_, i) => 100 + 20 * Math.sin(i * 0.12));
+  const out = new wickra.ConnorsRSI(3, 2, 100).batch(prices);
+  for (let i = 0; i < out.length; i++) {
+    if (Number.isNaN(out[i])) continue;
+    assert.ok(out[i] >= 0 && out[i] <= 100, `out[${i}] = ${out[i]}`);
+  }
+});
+
+test('LaguerreRSI on a flat series stays at the neutral 50', () => {
+  const out = new wickra.LaguerreRSI(0.5).batch(Array(40).fill(42));
+  for (let i = 0; i < out.length; i++) assert.ok(Math.abs(out[i] - 50) < 1e-12);
+});
+
+test('SMI with close at range centre emits zero after warmup', () => {
+  const n = 60;
+  const out = new wickra.SMI(5, 3, 3).batch(Array(n).fill(11), Array(n).fill(9), Array(n).fill(10));
+  // warmup_period = 5 + 3 + 3 - 2 = 9.
+  for (let i = 8; i < n; i++) assert.ok(Math.abs(out[i]) < 1e-12);
+});
+
+test('KST on a flat series emits zero after warmup', () => {
+  const kst = new wickra.KST(10, 15, 20, 30, 10, 10, 10, 15, 9);
+  const n = 80;
+  const out = kst.batch(Array(n).fill(42));
+  const warmup = kst.warmupPeriod();
+  for (let i = warmup - 1; i < n; i++) {
+    assert.ok(Math.abs(out[i * 2]) < 1e-12, `kst[${i}] = ${out[i * 2]}`);
+    assert.ok(Math.abs(out[i * 2 + 1]) < 1e-12, `signal[${i}] = ${out[i * 2 + 1]}`);
+  }
+});
+
+test('PGO(5) on a flat close emits zero after warmup', () => {
+  const n = 20;
+  const out = new wickra.PGO(5).batch(Array(n).fill(11), Array(n).fill(9), Array(n).fill(10));
+  for (let i = 0; i < 4; i++) assert.ok(Number.isNaN(out[i]));
+  for (let i = 4; i < n; i++) assert.ok(Math.abs(out[i]) < 1e-12, `out[${i}] = ${out[i]}`);
+});
+
+test('RVI(2) reference value on two bars', () => {
+  // Bars (open, high, low, close): (10, 11, 9, 10.5), (10.5, 11.5, 10, 11).
+  const out = new wickra.RVI(2).batch([10, 10.5], [11, 11.5], [9, 10], [10.5, 11]);
+  assert.ok(Number.isNaN(out[0]));
+  assert.ok(Math.abs(out[1] - 1 / 3.5) < 1e-12);
+});
+
+test('EVWMA(2) reference values on [10, 20, 30] with volumes [1, 3, 1]', () => {
+  const out = new wickra.EVWMA(2).batch([10, 20, 30], [1, 3, 1]);
+  assert.ok(Number.isNaN(out[0]));
+  assert.ok(Math.abs(out[1] - 20) < 1e-12);
+  assert.ok(Math.abs(out[2] - 22.5) < 1e-12);
+});
+
+test('Alligator on a flat median price seeds to that median', () => {
+  const n = 30;
+  const out = new wickra.Alligator(13, 8, 5).batch(Array(n).fill(11), Array(n).fill(9));
+  // All three SMMAs see median (11 + 9) / 2 = 10 every bar.
+  for (let i = 12; i < n; i++) {
+    assert.ok(Math.abs(out[i * 3] - 10) < 1e-12, `jaw at ${i}: ${out[i * 3]}`);
+    assert.ok(Math.abs(out[i * 3 + 1] - 10) < 1e-12);
+    assert.ok(Math.abs(out[i * 3 + 2] - 10) < 1e-12);
+  }
+});
+
+test('JMA on a flat series reproduces the constant', () => {
+  const out = new wickra.JMA(14, 0, 2).batch(Array(30).fill(42));
+  for (let i = 0; i < 30; i++) assert.ok(Math.abs(out[i] - 42) < 1e-12);
+});
+
+test('VIDYA on a flat series holds the seed', () => {
+  const out = new wickra.VIDYA(14, 4).batch(Array(20).fill(42));
+  for (let i = 0; i < 4; i++) assert.ok(Number.isNaN(out[i]));
+  for (let i = 4; i < 20; i++) assert.ok(Math.abs(out[i] - 42) < 1e-12);
+});
+
+test('FRAMA pure uptrend hugs the latest close', () => {
+  const out = new wickra.FRAMA(4).batch([1, 2, 3, 4, 5, 6, 7, 8]);
+  assert.ok(Math.abs(out[out.length - 1] - 8) < 0.05);
+});
+
+test('McGinleyDynamic(3) seeds with SMA and recurses on the next price', () => {
+  // Seed = SMA([10, 20, 30]) = 20. On 40: ratio = 2, divisor = 0.6*3*16 = 28.8.
+  const out = new wickra.McGinleyDynamic(3).batch([10, 20, 30, 40]);
+  assert.ok(Number.isNaN(out[0]) && Number.isNaN(out[1]));
+  assert.ok(Math.abs(out[2] - 20) < 1e-12);
+  const expected = 20 + 20 / (0.6 * 3 * 16);
+  assert.ok(Math.abs(out[3] - expected) < 1e-12);
+});
+
+test('ALMA(3, 0.85, 6) reference value on [10, 20, 30]', () => {
+  // m = 0.85 * 2 = 1.7; s = 3 / 6 = 0.5; 2*s^2 = 0.5.
+  const out = new wickra.ALMA(3, 0.85, 6).batch([10, 20, 30]);
+  assert.ok(Number.isNaN(out[0]) && Number.isNaN(out[1]));
+  const w = [0, 1, 2].map((i) => Math.exp(-Math.pow(i - 1.7, 2) / 0.5));
+  const s = w[0] + w[1] + w[2];
+  const expected = (10 * w[0] + 20 * w[1] + 30 * w[2]) / s;
+  assert.ok(Math.abs(out[2] - expected) < 1e-12);
+  // The heavy offset toward the newest sample lifts the average above the
+  // simple mean of 20.
+  assert.ok(out[2] > 20);
+});
+
+test('Doji signed mode encodes dragonfly/gravestone/neutral direction', () => {
+  // Default: direction-less detection flag (+1 doji / 0 otherwise).
+  const flag = new wickra.Doji();
+  assert.equal(flag.isSigned(), false);
+  assert.equal(flag.update(10, 11, 9, 10), 1); // body 0, range 2 -> doji
+  assert.equal(flag.update(10, 12, 10, 12), 0); // body == range -> not a doji
+
+  // Signed: classify a detected doji by its body position within the range.
+  const d = new wickra.Doji(true);
+  assert.equal(d.isSigned(), true);
+  assert.equal(d.update(10, 10.05, 6, 10), 1); // dragonfly -> bullish +1
+  assert.equal(d.update(10, 14, 9.95, 10), -1); // gravestone -> bearish -1
+  assert.equal(d.update(10, 12, 8, 10), 0); // long-legged -> neutral 0
+  assert.equal(d.update(10, 12, 10, 12), 0); // not a doji -> 0
+});
+
+test('order-book indicators reference values', () => {
+  // Top-1: (3 - 1) / (3 + 1) = 0.5.
+  assert.equal(new wickra.OrderBookImbalanceTop1().update([100], [3], [101], [1]), 0.5);
+  // Top-2: bidDepth 3, askDepth 2 -> (3 - 2) / 5 = 0.2.
+  assert.ok(
+    Math.abs(new wickra.OrderBookImbalanceTopN(2).update([100, 99], [2, 1], [101, 102], [1, 1]) - 0.2) < 1e-12,
+  );
+  // Full: bidDepth 1, askDepth 3 -> -0.5.
+  assert.equal(new wickra.OrderBookImbalanceFull().update([100], [1], [101, 102], [2, 1]), -0.5);
+  // Microprice: (100*3 + 101*1) / 4 = 100.25.
+  assert.equal(new wickra.Microprice().update([100], [1], [101], [3]), 100.25);
+  // Quoted spread: 1 / 100.5 * 10000 ≈ 99.5025 bps.
+  assert.ok(Math.abs(new wickra.QuotedSpread().update([100], [1], [101], [1]) - 99.50248756) < 1e-6);
+  // Depth slope: each side distances 1,2 -> cumulative 1,3 -> OLS slope 2.
+  assert.ok(Math.abs(new wickra.DepthSlope().update([99, 98], [1, 2], [101, 102], [1, 2]) - 2.0) < 1e-9);
+  // Single level per side -> no slope -> 0.
+  assert.equal(new wickra.DepthSlope().update([100], [1], [101], [1]), 0.0);
+});
+
+test('order-book streaming update matches batch', () => {
+  const snaps = Array.from({ length: 30 }, (_, i) => ({
+    bidPx: [100, 99],
+    bidSz: [1 + (i % 5), 1],
+    askPx: [101, 102],
+    askSz: [1 + ((i + 1) % 3), 1],
+  }));
+  const batch = new wickra.Microprice().batch(snaps);
+  const streamer = new wickra.Microprice();
+  assert.equal(batch.length, snaps.length);
+  for (let i = 0; i < snaps.length; i++) {
+    const s = streamer.update(snaps[i].bidPx, snaps[i].bidSz, snaps[i].askPx, snaps[i].askSz);
+    assert.ok(Math.abs(s - batch[i]) < 1e-12, `mismatch at ${i}: ${s} vs ${batch[i]}`);
+  }
+});
+
+test('order-book TopN rejects zero levels', () => {
+  assert.throws(() => new wickra.OrderBookImbalanceTopN(0));
+});
+
+test('order-book update rejects a crossed book', () => {
+  assert.throws(() => new wickra.QuotedSpread().update([102], [1], [101], [1]));
+});
+
+test('trade-flow indicators reference values', () => {
+  assert.equal(new wickra.SignedVolume().update(100, 2, true), 2);
+  assert.equal(new wickra.SignedVolume().update(100, 3, false), -3);
+  const cvd = new wickra.CumulativeVolumeDelta();
+  assert.equal(cvd.update(100, 5, true), 5);
+  assert.equal(cvd.update(100, 2, false), 3);
+  const ti = new wickra.TradeImbalance(2);
+  assert.equal(ti.update(100, 3, true), null); // warming up
+  assert.equal(ti.update(100, 1, false), 0.5); // (3 - 1) / 4
+});
+
+test('trade-flow streaming update matches batch', () => {
+  const n = 30;
+  const price = Array.from({ length: n }, () => 100);
+  const size = Array.from({ length: n }, (_, i) => 1 + (i % 4));
+  const isBuy = Array.from({ length: n }, (_, i) => i % 3 !== 0);
+  const batch = new wickra.CumulativeVolumeDelta().batch(price, size, isBuy);
+  const streamer = new wickra.CumulativeVolumeDelta();
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    const s = streamer.update(price[i], size[i], isBuy[i]);
+    assert.ok(Math.abs(s - batch[i]) < 1e-12, `mismatch at ${i}: ${s} vs ${batch[i]}`);
+  }
+});
+
+test('trade-flow rejects bad input', () => {
+  assert.throws(() => new wickra.TradeImbalance(0));
+  assert.throws(() => new wickra.SignedVolume().update(100, -1, true));
+});
+
+test('price-impact indicators reference values', () => {
+  // Buy at 100.05 vs mid 100.0: 2 * (100.05 - 100) / 100 * 10000 = 10 bps.
+  assert.ok(Math.abs(new wickra.EffectiveSpread().update(100.05, 1, true, 100.0) - 10.0) < 1e-9);
+  // Sell at 99.95 vs mid 100.0: 2 * -1 * (99.95 - 100) / 100 * 10000 = 10 bps.
+  assert.ok(Math.abs(new wickra.EffectiveSpread().update(99.95, 1, false, 100.0) - 10.0) < 1e-9);
+  // A buy filled below the mid is price improvement -> negative.
+  assert.ok(new wickra.EffectiveSpread().update(99.95, 1, true, 100.0) < 0.0);
+});
+
+test('price-impact streaming update matches batch', () => {
+  const n = 30;
+  const mid = Array.from({ length: n }, (_, i) => 100 + 0.25 * Math.sin(i * 0.5));
+  const isBuy = Array.from({ length: n }, (_, i) => i % 3 !== 0);
+  const price = Array.from({ length: n }, (_, i) => mid[i] + (isBuy[i] ? 0.03 : -0.03));
+  const size = Array.from({ length: n }, (_, i) => 1 + (i % 4));
+  const batch = new wickra.EffectiveSpread().batch(price, size, isBuy, mid);
+  const streamer = new wickra.EffectiveSpread();
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    const s = streamer.update(price[i], size[i], isBuy[i], mid[i]);
+    assert.ok(Math.abs(s - batch[i]) < 1e-9, `mismatch at ${i}: ${s} vs ${batch[i]}`);
+  }
+});
+
+test('realized spread resolves against the future mid', () => {
+  const rs = new wickra.RealizedSpread(1);
+  assert.equal(rs.update(100.10, 1, true, 100.0), null); // buffered
+  // 2 * (+1) * (100.10 - 100.20) / 100.0 * 10000 = -20 bps.
+  assert.ok(Math.abs(rs.update(99.90, 1, false, 100.20) - -20.0) < 1e-9);
+});
+
+test('realized spread streaming update matches batch', () => {
+  const n = 30;
+  const mid = Array.from({ length: n }, (_, i) => 100 + 0.25 * Math.sin(i * 0.5));
+  const isBuy = Array.from({ length: n }, (_, i) => i % 3 !== 0);
+  const price = Array.from({ length: n }, (_, i) => mid[i] + (isBuy[i] ? 0.03 : -0.03));
+  const size = Array.from({ length: n }, (_, i) => 1 + (i % 4));
+  const batch = new wickra.RealizedSpread(4).batch(price, size, isBuy, mid);
+  const streamer = new wickra.RealizedSpread(4);
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    const s = streamer.update(price[i], size[i], isBuy[i], mid[i]);
+    const got = s === null ? NaN : s;
+    assert.ok(
+      (Number.isNaN(got) && Number.isNaN(batch[i])) || Math.abs(got - batch[i]) < 1e-9,
+      `mismatch at ${i}: ${got} vs ${batch[i]}`,
+    );
+  }
+});
+
+test("kyle's lambda recovers a constant price-impact slope", () => {
+  // Each trade moves the mid by exactly 0.5 per unit of signed volume.
+  const impact = 0.5;
+  let mid = 100;
+  const price = [];
+  const size = [];
+  const isBuy = [];
+  const mids = [];
+  for (let i = 0; i < 20; i++) {
+    const buy = i % 2 === 0;
+    const sz = 1 + (i % 3);
+    const signed = buy ? sz : -sz;
+    mid += impact * signed;
+    price.push(mid);
+    size.push(sz);
+    isBuy.push(buy);
+    mids.push(mid);
+  }
+  const out = new wickra.KylesLambda(6).batch(price, size, isBuy, mids);
+  assert.ok(Math.abs(out[out.length - 1] - 0.5) < 1e-9);
+});
+
+test('price-impact rejects bad input', () => {
+  assert.throws(() => new wickra.EffectiveSpread().update(100, 1, true, 0));
+  assert.throws(() => new wickra.RealizedSpread(0));
+  assert.throws(() => new wickra.KylesLambda(1));
+});
+
+test('footprint buckets buy and sell volume per price level', () => {
+  const fp = new wickra.Footprint(1.0);
+  fp.update(100.2, 2, true); // bucket 100 -> ask 2
+  fp.update(100.7, 3, false); // bucket 101 -> bid 3
+  const out = fp.update(100.1, 1, true); // bucket 100 -> ask 3
+  assert.equal(out.length, 2);
+  assert.deepEqual(
+    { price: out[0].price, bidVol: out[0].bidVol, askVol: out[0].askVol },
+    { price: 100.0, bidVol: 0.0, askVol: 3.0 },
+  );
+  assert.deepEqual(
+    { price: out[1].price, bidVol: out[1].bidVol, askVol: out[1].askVol },
+    { price: 101.0, bidVol: 3.0, askVol: 0.0 },
+  );
+});
+
+test('footprint streaming update matches batch and rejects bad tick', () => {
+  const n = 12;
+  const price = Array.from({ length: n }, (_, i) => 100 + (i % 5) * 0.3);
+  const size = Array.from({ length: n }, (_, i) => 1 + (i % 3));
+  const isBuy = Array.from({ length: n }, (_, i) => i % 2 === 0);
+  const batch = new wickra.Footprint(1.0).batch(price, size, isBuy);
+  const streamer = new wickra.Footprint(1.0);
+  assert.equal(batch.length, n);
+  for (let i = 0; i < n; i++) {
+    const s = streamer.update(price[i], size[i], isBuy[i]);
+    assert.deepEqual(s, batch[i], `mismatch at ${i}`);
+  }
+  assert.throws(() => new wickra.Footprint(0));
+});

bindings/node/__tests__/input_validation.test.js

@@ -0,0 +1,84 @@
+// Input-validation tests for the Wickra Node bindings: malformed constructor
+// parameters and mismatched batch inputs must raise a JS Error (the napi
+// wrapper turns the Rust `Err` into a thrown Error), not crash the process.
+// Node counterpart of bindings/python/tests/test_input_validation.py.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const wickra = require('..');
+
+// --- Constructors reject invalid periods / parameters ---
+
+test('ATR rejects a zero period at construction', () => {
+  // ATR validates its period (it drives the Wilder-smoothing length). The
+  // plain moving averages (SMA/EMA/RSI/StdDev) instead treat period 0 as a
+  // warmup-1 pass-through rather than an error, so they are not asserted here.
+  assert.throws(() => new wickra.ATR(0), /.*/);
+});
+
+test('MACD rejects zero and non-increasing fast/slow periods', () => {
+  assert.throws(() => new wickra.MACD(0, 0, 0), /.*/);
+  // fast must be strictly less than slow.
+  assert.throws(() => new wickra.MACD(26, 12, 9), /.*/);
+});
+
+test('BollingerBands rejects a negative standard-deviation multiplier', () => {
+  assert.throws(() => new wickra.BollingerBands(20, -1), /.*/);
+});
+
+test('PSAR rejects a step greater than its maximum', () => {
+  assert.throws(() => new wickra.PSAR(0.3, 0.02, 0.2), /.*/);
+});
+
+test('ValueArea rejects zero periods and out-of-range value-area percentages', () => {
+  assert.throws(() => new wickra.ValueArea(0, 50, 0.7), /.*/);
+  assert.throws(() => new wickra.ValueArea(20, 0, 0.7), /.*/);
+  assert.throws(() => new wickra.ValueArea(20, 50, 0.0), /.*/);
+  assert.throws(() => new wickra.ValueArea(20, 50, 1.5), /.*/);
+});
+
+test('InitialBalance and OpeningRange reject a zero period', () => {
+  assert.throws(() => new wickra.InitialBalance(0), /.*/);
+  assert.throws(() => new wickra.OpeningRange(0), /.*/);
+});
+
+test('Ichimoku rejects zero and non-increasing periods', () => {
+  assert.throws(() => new wickra.Ichimoku(0, 26, 52, 26), /.*/);
+  assert.throws(() => new wickra.Ichimoku(9, 26, 52, 0), /.*/);
+  // Periods must satisfy tenkan < kijun < senkouB.
+  assert.throws(() => new wickra.Ichimoku(26, 9, 52, 26), /.*/);
+  assert.throws(() => new wickra.Ichimoku(9, 52, 52, 26), /.*/);
+});
+
+test('Family 10 (Ehlers / cycle) indicators reject invalid parameters', () => {
+  // InverseFisherTransform needs a non-zero scaling factor.
+  assert.throws(() => new wickra.InverseFisherTransform(0.0), /.*/);
+  // DecyclerOscillator / RoofingFilter need the short cutoff below the long one.
+  assert.throws(() => new wickra.DecyclerOscillator(30, 10), /.*/);
+  assert.throws(() => new wickra.RoofingFilter(48, 10), /.*/);
+  // MAMA needs fast limit > slow limit.
+  assert.throws(() => new wickra.MAMA(0.05, 0.5), /.*/);
+  // EmpiricalModeDecomposition needs a positive fraction.
+  assert.throws(() => new wickra.EmpiricalModeDecomposition(20, 0.0), /.*/);
+  // NOTE: SuperSmoother(0) / FisherTransform(0) are NOT asserted: the Node
+  // binding treats their period 0 as a warmup-1 pass-through (same as the
+  // simple moving averages) rather than an error.
+});
+
+// --- Batch methods reject mismatched input lengths ---
+
+test('candle batch methods reject unequal-length columns', () => {
+  const high = [10, 11, 12];
+  const low = [9, 10]; // one short
+  const close = [9.5, 10.5, 11.5];
+  assert.throws(() => new wickra.ATR(14).batch(high, low, close), /.*/);
+  assert.throws(() => new wickra.WilliamsR(14).batch(high, low, close), /.*/);
+  assert.throws(() => new wickra.Aroon(14).batch(high, low), /.*/);
+});
+
+test('ValueArea batch rejects unequal-length columns', () => {
+  const high = [1, 2, 3];
+  const low = [0.5, 1.5]; // short
+  const volume = [10, 10, 10];
+  assert.throws(() => new wickra.ValueArea(2, 10, 0.7).batch(high, low, volume), /.*/);
+});

bindings/node/__tests__/smoke.test.js

@@ -73,10 +73,10 @@ test('ATR batch shape', () => {
   }
 });
 
-test('zero period is clamped to a valid window', () => {
-  // Constructors cannot throw from JS (napi-rs 2.16 limitation), so they
-  // clamp pathological values like period=0 to the smallest valid window.
-  const sma = new wickra.SMA(0);
-  assert.equal(sma.warmupPeriod(), 1);
-  assert.equal(sma.update(42), 42);
+test('zero period is rejected at construction', () => {
+  // The core rejects period 0 (Error::PeriodZero); the Node binding propagates
+  // it as a thrown JS error, consistent with the Python and WASM bindings.
+  assert.throws(() => new wickra.SMA(0), /period must be greater than zero/);
+  // A valid period still constructs and runs.
+  assert.equal(new wickra.SMA(1).update(42), 42);
 });

bindings/node/benchmarks/throughput.js

@@ -0,0 +1,99 @@
+// Throughput benchmark for the Wickra Node bindings.
+//
+// Measures how many indicator updates per second the native binding sustains,
+// both per-tick (streaming `update`) and bulk (`batch`), over a synthetic
+// OHLCV series. It is the Node counterpart of the Rust criterion benches and
+// the Python `benchmarks/compare_libraries.py`; it benchmarks Wickra's own
+// O(1) streaming engine (there is no install-free TA library on npm with a
+// comparable surface to compare against), so the headline number is raw
+// throughput, not a cross-library ratio.
+//
+// Run after building the binding:
+//
+//   cd bindings/node && npm install && npx napi build --platform --release
+//   node benchmarks/throughput.js               # 200k bars (default)
+//   node benchmarks/throughput.js --bars 1000000
+
+const wickra = require('..');
+
+function parseBars() {
+  const idx = process.argv.indexOf('--bars');
+  if (idx !== -1 && process.argv[idx + 1]) {
+    const n = Number(process.argv[idx + 1]);
+    if (Number.isFinite(n) && n >= 1000) return Math.floor(n);
+    console.error('--bars must be a number >= 1000');
+    process.exit(1);
+  }
+  return 200_000;
+}
+
+const BARS = parseBars();
+
+// Deterministic synthetic OHLCV (no RNG, so runs are comparable).
+const close = new Array(BARS);
+const high = new Array(BARS);
+const low = new Array(BARS);
+const volume = new Array(BARS);
+for (let i = 0; i < BARS; i++) {
+  const mid = 100 + Math.sin(i * 0.001) * 20 + i * 1e-4;
+  close[i] = mid + Math.sin(i * 0.05) * 2;
+  high[i] = Math.max(close[i], mid) + 1.5;
+  low[i] = Math.min(close[i], mid) - 1.5;
+  volume[i] = 1000 + (i % 97) * 13;
+}
+
+// Median elapsed-ns over a few repetitions, after one warmup pass.
+function timeNs(fn, reps = 3) {
+  fn(); // warmup (JIT + cache)
+  const samples = [];
+  for (let r = 0; r < reps; r++) {
+    const t0 = process.hrtime.bigint();
+    fn();
+    samples.push(Number(process.hrtime.bigint() - t0));
+  }
+  samples.sort((a, b) => a - b);
+  return samples[Math.floor(samples.length / 2)];
+}
+
+function mupsFromNs(ns) {
+  return (BARS / (ns / 1e9)) / 1e6; // million updates per second
+}
+
+// Each indicator: a streaming step and a batch call over the full series.
+const indicators = [
+  { name: 'SMA(20)', make: () => new wickra.SMA(20), step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  { name: 'EMA(20)', make: () => new wickra.EMA(20), step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  { name: 'RSI(14)', make: () => new wickra.RSI(14), step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  { name: 'StdDev(20)', make: () => new wickra.StdDev(20), step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  { name: 'MACD(12,26,9)', make: () => new wickra.MACD(12, 26, 9), step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  { name: 'BollingerBands(20,2)', make: () => new wickra.BollingerBands(20, 2), step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  { name: 'KAMA(10,2,30)', make: () => new wickra.KAMA(10, 2, 30), step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) },
+  { name: 'ATR(14)', make: () => new wickra.ATR(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  { name: 'ADX(14)', make: () => new wickra.ADX(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  { name: 'Stochastic(14,3)', make: () => new wickra.Stochastic(14, 3), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  { name: 'SuperTrend(10,3)', make: () => new wickra.SuperTrend(10, 3), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  { name: 'OBV', make: () => new wickra.OBV(), step: (ind, i) => ind.update(close[i], volume[i]), batch: (ind) => ind.batch(close, volume) },
+];
+
+console.log(`Wickra Node throughput — ${BARS.toLocaleString('en-US')} bars (median of 3 runs)\n`);
+console.log(`${'Indicator'.padEnd(22)}${'streaming (Mupd/s)'.padStart(20)}${'batch (Mupd/s)'.padStart(18)}`);
+console.log('-'.repeat(60));
+
+for (const ind of indicators) {
+  const streamNs = timeNs(() => {
+    const inst = ind.make();
+    for (let i = 0; i < BARS; i++) ind.step(inst, i);
+  });
+  const batchNs = timeNs(() => {
+    ind.batch(ind.make());
+  });
+  console.log(
+    `${ind.name.padEnd(22)}${mupsFromNs(streamNs).toFixed(1).padStart(20)}${mupsFromNs(batchNs).toFixed(1).padStart(18)}`,
+  );
+}
+
+console.log(
+  '\nMupd/s = million indicator updates per second. Streaming is the per-tick\n' +
+    '`update` path (one value at a time); batch is the bulk array path. Higher is\n' +
+    'better. Numbers are machine-dependent — use them for relative comparison.',
+);

bindings/node/index.js

@@ -310,7 +310,7 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { version, SMA, EMA, WMA, RSI, DEMA, TEMA, HMA, ROC, TRIX, SMMA, TRIMA, ZLEMA, MOM, CMO, DPO, StdDev, UlcerIndex, VerticalHorizontalFilter, ZScore, MACD, BollingerBands, ATR, Stochastic, OBV, ADX, CCI, WilliamsR, MFI, PSAR, Keltner, Donchian, VWAP, RollingVWAP, AwesomeOscillator, Aroon, KAMA, T3, TSI, PMO, ADL, VolumePriceTrend, ChaikinMoneyFlow, ChaikinOscillator, ForceIndex, EaseOfMovement, SuperTrend, ChandelierExit, ChandeKrollStop, AtrTrailingStop, TypicalPrice, MedianPrice, WeightedClose, LinearRegression, LinRegSlope, AcceleratorOscillator, BalanceOfPower, ChoppinessIndex, TrueRange, ChaikinVolatility, LinRegAngle, BollingerBandwidth, PercentB, NATR, HistoricalVolatility, AroonOscillator, Vortex, MassIndex, StochRSI, UltimateOscillator, PPO, Coppock, VWMA } = nativeBinding
+const { version, SMA, EMA, WMA, RSI, DEMA, TEMA, HMA, ROC, TRIX, SMMA, TRIMA, ZLEMA, MOM, CMO, DPO, StdDev, UlcerIndex, VerticalHorizontalFilter, ZScore, McGinleyDynamic, FRAMA, SuperSmoother, FisherTransform, Decycler, CenterOfGravity, CyberneticCycle, InstantaneousTrendline, EhlersStochastic, RVIVolatility, Variance, CoefficientOfVariation, Skewness, Kurtosis, StandardError, DetrendedStdDev, RSquared, MedianAbsoluteDeviation, Autocorrelation, HurstExponent, PearsonCorrelation, Beta, PairwiseBeta, SpearmanCorrelation, PairSpreadZScore, LeadLagCrossCorrelation, Cointegration, RelativeStrengthAB, MACD, BollingerBands, ATR, Stochastic, OBV, ADX, ADXR, CCI, WilliamsR, MFI, PSAR, Keltner, Donchian, VWAP, RollingVWAP, AwesomeOscillator, Aroon, Inertia, ConnorsRSI, LaguerreRSI, SMI, KST, PGO, RVI, AwesomeOscillatorHistogram, STC, ElderImpulse, ZeroLagMACD, CFO, APO, KAMA, EVWMA, Alligator, JMA, VIDYA, ALMA, T3, TSI, PMO, TII, ADL, VolumePriceTrend, ChaikinMoneyFlow, ChaikinOscillator, ForceIndex, NVI, PVI, VolumeOscillator, KVO, WilliamsAD, AnchoredVWAP, DemandIndex, TSV, VZO, MarketFacilitationIndex, EaseOfMovement, SuperTrend, ChandelierExit, ChandeKrollStop, AtrTrailingStop, HiLoActivator, VoltyStop, YoyoExit, DonchianStop, PercentageTrailingStop, StepTrailingStop, RenkoTrailingStop, TypicalPrice, MedianPrice, WeightedClose, LinearRegression, LinRegSlope, AcceleratorOscillator, BalanceOfPower, ChoppinessIndex, TrueRange, ChaikinVolatility, YangZhangVolatility, RogersSatchellVolatility, GarmanKlassVolatility, ParkinsonVolatility, LinRegAngle, BollingerBandwidth, PercentB, NATR, HistoricalVolatility, AroonOscillator, WaveTrend, RWI, Vortex, MassIndex, StochRSI, UltimateOscillator, PPO, Coppock, VWMA, MaEnvelope, AccelerationBands, StarcBands, AtrBands, HurstChannel, LinRegChannel, StandardErrorBands, DoubleBollinger, TtmSqueeze, FractalChaosBands, VwapStdDevBands, ClassicPivots, FibonacciPivots, Camarilla, WoodiePivots, DemarkPivots, WilliamsFractals, ZigZag, TDSetup, TDSequential, TDDeMarker, TDREI, TDPressure, TDCombo, TDCountdown, TDLines, TDRangeProjection, TDDifferential, TDOpen, TDRiskLevel, InverseFisherTransform, DecyclerOscillator, RoofingFilter, EmpiricalModeDecomposition, HilbertDominantCycle, AdaptiveCycle, SineWave, MAMA, FAMA, Ichimoku, HeikinAshi, ValueArea, InitialBalance, OpeningRange, Doji, Hammer, InvertedHammer, HangingMan, ShootingStar, Engulfing, Harami, MorningEveningStar, ThreeSoldiersOrCrows, PiercingDarkCloud, Marubozu, Tweezer, SpinningTop, ThreeInside, ThreeOutside, OrderBookImbalanceTop1, OrderBookImbalanceFull, Microprice, QuotedSpread, DepthSlope, OrderBookImbalanceTopN, SignedVolume, CumulativeVolumeDelta, TradeImbalance, EffectiveSpread, RealizedSpread, KylesLambda, Footprint, SharpeRatio, SortinoRatio, CalmarRatio, OmegaRatio, MaxDrawdown, AverageDrawdown, DrawdownDuration, PainIndex, ValueAtRisk, ConditionalValueAtRisk, ProfitFactor, GainLossRatio, RecoveryFactor, KellyCriterion, TreynorRatio, InformationRatio, Alpha } = nativeBinding
 
 module.exports.version = version
 module.exports.SMA = SMA
@@ -332,12 +332,41 @@ module.exports.StdDev = StdDev
 module.exports.UlcerIndex = UlcerIndex
 module.exports.VerticalHorizontalFilter = VerticalHorizontalFilter
 module.exports.ZScore = ZScore
+module.exports.McGinleyDynamic = McGinleyDynamic
+module.exports.FRAMA = FRAMA
+module.exports.SuperSmoother = SuperSmoother
+module.exports.FisherTransform = FisherTransform
+module.exports.Decycler = Decycler
+module.exports.CenterOfGravity = CenterOfGravity
+module.exports.CyberneticCycle = CyberneticCycle
+module.exports.InstantaneousTrendline = InstantaneousTrendline
+module.exports.EhlersStochastic = EhlersStochastic
+module.exports.RVIVolatility = RVIVolatility
+module.exports.Variance = Variance
+module.exports.CoefficientOfVariation = CoefficientOfVariation
+module.exports.Skewness = Skewness
+module.exports.Kurtosis = Kurtosis
+module.exports.StandardError = StandardError
+module.exports.DetrendedStdDev = DetrendedStdDev
+module.exports.RSquared = RSquared
+module.exports.MedianAbsoluteDeviation = MedianAbsoluteDeviation
+module.exports.Autocorrelation = Autocorrelation
+module.exports.HurstExponent = HurstExponent
+module.exports.PearsonCorrelation = PearsonCorrelation
+module.exports.Beta = Beta
+module.exports.PairwiseBeta = PairwiseBeta
+module.exports.SpearmanCorrelation = SpearmanCorrelation
+module.exports.PairSpreadZScore = PairSpreadZScore
+module.exports.LeadLagCrossCorrelation = LeadLagCrossCorrelation
+module.exports.Cointegration = Cointegration
+module.exports.RelativeStrengthAB = RelativeStrengthAB
 module.exports.MACD = MACD
 module.exports.BollingerBands = BollingerBands
 module.exports.ATR = ATR
 module.exports.Stochastic = Stochastic
 module.exports.OBV = OBV
 module.exports.ADX = ADX
+module.exports.ADXR = ADXR
 module.exports.CCI = CCI
 module.exports.WilliamsR = WilliamsR
 module.exports.MFI = MFI
@@ -348,20 +377,56 @@ module.exports.VWAP = VWAP
 module.exports.RollingVWAP = RollingVWAP
 module.exports.AwesomeOscillator = AwesomeOscillator
 module.exports.Aroon = Aroon
+module.exports.Inertia = Inertia
+module.exports.ConnorsRSI = ConnorsRSI
+module.exports.LaguerreRSI = LaguerreRSI
+module.exports.SMI = SMI
+module.exports.KST = KST
+module.exports.PGO = PGO
+module.exports.RVI = RVI
+module.exports.AwesomeOscillatorHistogram = AwesomeOscillatorHistogram
+module.exports.STC = STC
+module.exports.ElderImpulse = ElderImpulse
+module.exports.ZeroLagMACD = ZeroLagMACD
+module.exports.CFO = CFO
+module.exports.APO = APO
 module.exports.KAMA = KAMA
+module.exports.EVWMA = EVWMA
+module.exports.Alligator = Alligator
+module.exports.JMA = JMA
+module.exports.VIDYA = VIDYA
+module.exports.ALMA = ALMA
 module.exports.T3 = T3
 module.exports.TSI = TSI
 module.exports.PMO = PMO
+module.exports.TII = TII
 module.exports.ADL = ADL
 module.exports.VolumePriceTrend = VolumePriceTrend
 module.exports.ChaikinMoneyFlow = ChaikinMoneyFlow
 module.exports.ChaikinOscillator = ChaikinOscillator
 module.exports.ForceIndex = ForceIndex
+module.exports.NVI = NVI
+module.exports.PVI = PVI
+module.exports.VolumeOscillator = VolumeOscillator
+module.exports.KVO = KVO
+module.exports.WilliamsAD = WilliamsAD
+module.exports.AnchoredVWAP = AnchoredVWAP
+module.exports.DemandIndex = DemandIndex
+module.exports.TSV = TSV
+module.exports.VZO = VZO
+module.exports.MarketFacilitationIndex = MarketFacilitationIndex
 module.exports.EaseOfMovement = EaseOfMovement
 module.exports.SuperTrend = SuperTrend
 module.exports.ChandelierExit = ChandelierExit
 module.exports.ChandeKrollStop = ChandeKrollStop
 module.exports.AtrTrailingStop = AtrTrailingStop
+module.exports.HiLoActivator = HiLoActivator
+module.exports.VoltyStop = VoltyStop
+module.exports.YoyoExit = YoyoExit
+module.exports.DonchianStop = DonchianStop
+module.exports.PercentageTrailingStop = PercentageTrailingStop
+module.exports.StepTrailingStop = StepTrailingStop
+module.exports.RenkoTrailingStop = RenkoTrailingStop
 module.exports.TypicalPrice = TypicalPrice
 module.exports.MedianPrice = MedianPrice
 module.exports.WeightedClose = WeightedClose
@@ -372,12 +437,18 @@ module.exports.BalanceOfPower = BalanceOfPower
 module.exports.ChoppinessIndex = ChoppinessIndex
 module.exports.TrueRange = TrueRange
 module.exports.ChaikinVolatility = ChaikinVolatility
+module.exports.YangZhangVolatility = YangZhangVolatility
+module.exports.RogersSatchellVolatility = RogersSatchellVolatility
+module.exports.GarmanKlassVolatility = GarmanKlassVolatility
+module.exports.ParkinsonVolatility = ParkinsonVolatility
 module.exports.LinRegAngle = LinRegAngle
 module.exports.BollingerBandwidth = BollingerBandwidth
 module.exports.PercentB = PercentB
 module.exports.NATR = NATR
 module.exports.HistoricalVolatility = HistoricalVolatility
 module.exports.AroonOscillator = AroonOscillator
+module.exports.WaveTrend = WaveTrend
+module.exports.RWI = RWI
 module.exports.Vortex = Vortex
 module.exports.MassIndex = MassIndex
 module.exports.StochRSI = StochRSI
@@ -385,3 +456,92 @@ module.exports.UltimateOscillator = UltimateOscillator
 module.exports.PPO = PPO
 module.exports.Coppock = Coppock
 module.exports.VWMA = VWMA
+module.exports.MaEnvelope = MaEnvelope
+module.exports.AccelerationBands = AccelerationBands
+module.exports.StarcBands = StarcBands
+module.exports.AtrBands = AtrBands
+module.exports.HurstChannel = HurstChannel
+module.exports.LinRegChannel = LinRegChannel
+module.exports.StandardErrorBands = StandardErrorBands
+module.exports.DoubleBollinger = DoubleBollinger
+module.exports.TtmSqueeze = TtmSqueeze
+module.exports.FractalChaosBands = FractalChaosBands
+module.exports.VwapStdDevBands = VwapStdDevBands
+module.exports.ClassicPivots = ClassicPivots
+module.exports.FibonacciPivots = FibonacciPivots
+module.exports.Camarilla = Camarilla
+module.exports.WoodiePivots = WoodiePivots
+module.exports.DemarkPivots = DemarkPivots
+module.exports.WilliamsFractals = WilliamsFractals
+module.exports.ZigZag = ZigZag
+module.exports.TDSetup = TDSetup
+module.exports.TDSequential = TDSequential
+module.exports.TDDeMarker = TDDeMarker
+module.exports.TDREI = TDREI
+module.exports.TDPressure = TDPressure
+module.exports.TDCombo = TDCombo
+module.exports.TDCountdown = TDCountdown
+module.exports.TDLines = TDLines
+module.exports.TDRangeProjection = TDRangeProjection
+module.exports.TDDifferential = TDDifferential
+module.exports.TDOpen = TDOpen
+module.exports.TDRiskLevel = TDRiskLevel
+module.exports.InverseFisherTransform = InverseFisherTransform
+module.exports.DecyclerOscillator = DecyclerOscillator
+module.exports.RoofingFilter = RoofingFilter
+module.exports.EmpiricalModeDecomposition = EmpiricalModeDecomposition
+module.exports.HilbertDominantCycle = HilbertDominantCycle
+module.exports.AdaptiveCycle = AdaptiveCycle
+module.exports.SineWave = SineWave
+module.exports.MAMA = MAMA
+module.exports.FAMA = FAMA
+module.exports.Ichimoku = Ichimoku
+module.exports.HeikinAshi = HeikinAshi
+module.exports.ValueArea = ValueArea
+module.exports.InitialBalance = InitialBalance
+module.exports.OpeningRange = OpeningRange
+module.exports.Doji = Doji
+module.exports.Hammer = Hammer
+module.exports.InvertedHammer = InvertedHammer
+module.exports.HangingMan = HangingMan
+module.exports.ShootingStar = ShootingStar
+module.exports.Engulfing = Engulfing
+module.exports.Harami = Harami
+module.exports.MorningEveningStar = MorningEveningStar
+module.exports.ThreeSoldiersOrCrows = ThreeSoldiersOrCrows
+module.exports.PiercingDarkCloud = PiercingDarkCloud
+module.exports.Marubozu = Marubozu
+module.exports.Tweezer = Tweezer
+module.exports.SpinningTop = SpinningTop
+module.exports.ThreeInside = ThreeInside
+module.exports.ThreeOutside = ThreeOutside
+module.exports.OrderBookImbalanceTop1 = OrderBookImbalanceTop1
+module.exports.OrderBookImbalanceFull = OrderBookImbalanceFull
+module.exports.Microprice = Microprice
+module.exports.QuotedSpread = QuotedSpread
+module.exports.DepthSlope = DepthSlope
+module.exports.OrderBookImbalanceTopN = OrderBookImbalanceTopN
+module.exports.SignedVolume = SignedVolume
+module.exports.CumulativeVolumeDelta = CumulativeVolumeDelta
+module.exports.TradeImbalance = TradeImbalance
+module.exports.EffectiveSpread = EffectiveSpread
+module.exports.RealizedSpread = RealizedSpread
+module.exports.KylesLambda = KylesLambda
+module.exports.Footprint = Footprint
+module.exports.SharpeRatio = SharpeRatio
+module.exports.SortinoRatio = SortinoRatio
+module.exports.CalmarRatio = CalmarRatio
+module.exports.OmegaRatio = OmegaRatio
+module.exports.MaxDrawdown = MaxDrawdown
+module.exports.AverageDrawdown = AverageDrawdown
+module.exports.DrawdownDuration = DrawdownDuration
+module.exports.PainIndex = PainIndex
+module.exports.ValueAtRisk = ValueAtRisk
+module.exports.ConditionalValueAtRisk = ConditionalValueAtRisk
+module.exports.ProfitFactor = ProfitFactor
+module.exports.GainLossRatio = GainLossRatio
+module.exports.RecoveryFactor = RecoveryFactor
+module.exports.KellyCriterion = KellyCriterion
+module.exports.TreynorRatio = TreynorRatio
+module.exports.InformationRatio = InformationRatio
+module.exports.Alpha = Alpha

bindings/node/npm/darwin-arm64/package.json

@@ -1,12 +1,12 @@
 {
   "name": "wickra-darwin-arm64",
-  "version": "0.2.1",
+  "version": "0.4.3",
   "description": "Native binding for wickra (macOS Apple Silicon). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.darwin-arm64.node",
   "files": [
     "wickra.darwin-arm64.node"
   ],
-  "license": "PolyForm-Noncommercial-1.0.0",
+  "license": "LicenseRef-Wickra-Noncommercial-1.0.0",
   "engines": {
     "node": ">= 18"
   },
@@ -18,7 +18,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/kingchenc/wickra"
+    "url": "https://github.com/wickra-lib/wickra"
   },
-  "homepage": "https://github.com/kingchenc/wickra"
+  "homepage": "https://github.com/wickra-lib/wickra"
 }

bindings/node/npm/darwin-x64/package.json

@@ -1,12 +1,12 @@
 {
   "name": "wickra-darwin-x64",
-  "version": "0.2.1",
+  "version": "0.4.3",
   "description": "Native binding for wickra (macOS Intel). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.darwin-x64.node",
   "files": [
     "wickra.darwin-x64.node"
   ],
-  "license": "PolyForm-Noncommercial-1.0.0",
+  "license": "LicenseRef-Wickra-Noncommercial-1.0.0",
   "engines": {
     "node": ">= 18"
   },
@@ -18,7 +18,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/kingchenc/wickra"
+    "url": "https://github.com/wickra-lib/wickra"
   },
-  "homepage": "https://github.com/kingchenc/wickra"
+  "homepage": "https://github.com/wickra-lib/wickra"
 }

bindings/node/npm/linux-arm64-gnu/package.json

@@ -1,12 +1,12 @@
 {
   "name": "wickra-linux-arm64-gnu",
-  "version": "0.2.1",
+  "version": "0.4.3",
   "description": "Native binding for wickra (linux arm64 GNU). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.linux-arm64-gnu.node",
   "files": [
     "wickra.linux-arm64-gnu.node"
   ],
-  "license": "PolyForm-Noncommercial-1.0.0",
+  "license": "LicenseRef-Wickra-Noncommercial-1.0.0",
   "engines": {
     "node": ">= 18"
   },
@@ -21,7 +21,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/kingchenc/wickra"
+    "url": "https://github.com/wickra-lib/wickra"
   },
-  "homepage": "https://github.com/kingchenc/wickra"
+  "homepage": "https://github.com/wickra-lib/wickra"
 }

bindings/node/npm/linux-x64-gnu/package.json

@@ -1,12 +1,12 @@
 {
   "name": "wickra-linux-x64-gnu",
-  "version": "0.2.1",
+  "version": "0.4.3",
   "description": "Native binding for wickra (linux x64 GNU). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.linux-x64-gnu.node",
   "files": [
     "wickra.linux-x64-gnu.node"
   ],
-  "license": "PolyForm-Noncommercial-1.0.0",
+  "license": "LicenseRef-Wickra-Noncommercial-1.0.0",
   "engines": {
     "node": ">= 18"
   },
@@ -21,7 +21,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/kingchenc/wickra"
+    "url": "https://github.com/wickra-lib/wickra"
   },
-  "homepage": "https://github.com/kingchenc/wickra"
+  "homepage": "https://github.com/wickra-lib/wickra"
 }

bindings/node/npm/win32-arm64-msvc/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "wickra-win32-arm64-msvc",
+  "version": "0.4.3",
+  "description": "Native binding for wickra (Windows arm64 MSVC). Installed automatically as an optional dependency of wickra on matching platforms.",
+  "main": "wickra.win32-arm64-msvc.node",
+  "files": [
+    "wickra.win32-arm64-msvc.node"
+  ],
+  "license": "LicenseRef-Wickra-Noncommercial-1.0.0",
+  "engines": {
+    "node": ">= 18"
+  },
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wickra-lib/wickra"
+  },
+  "homepage": "https://github.com/wickra-lib/wickra"
+}

bindings/node/npm/win32-x64-msvc/package.json

@@ -1,12 +1,12 @@
 {
   "name": "wickra-win32-x64-msvc",
-  "version": "0.2.1",
+  "version": "0.4.3",
   "description": "Native binding for wickra (Windows x64 MSVC). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.win32-x64-msvc.node",
   "files": [
     "wickra.win32-x64-msvc.node"
   ],
-  "license": "PolyForm-Noncommercial-1.0.0",
+  "license": "LicenseRef-Wickra-Noncommercial-1.0.0",
   "engines": {
     "node": ">= 18"
   },
@@ -18,7 +18,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/kingchenc/wickra"
+    "url": "https://github.com/wickra-lib/wickra"
   },
-  "homepage": "https://github.com/kingchenc/wickra"
+  "homepage": "https://github.com/wickra-lib/wickra"
 }

bindings/node/package-lock.json

@@ -0,0 +1,140 @@
+{
+  "name": "wickra",
+  "version": "0.4.3",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "wickra",
+      "version": "0.4.3",
+      "license": "PolyForm-Noncommercial-1.0.0",
+      "devDependencies": {
+        "@napi-rs/cli": "^2.18.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "optionalDependencies": {
+        "wickra-darwin-arm64": "0.4.3",
+        "wickra-darwin-x64": "0.4.3",
+        "wickra-linux-arm64-gnu": "0.4.3",
+        "wickra-linux-x64-gnu": "0.4.3",
+        "wickra-win32-arm64-msvc": "0.4.3",
+        "wickra-win32-x64-msvc": "0.4.3"
+      }
+    },
+    "node_modules/@napi-rs/cli": {
+      "version": "2.18.4",
+      "resolved": "https://registry.npmjs.org/@napi-rs/cli/-/cli-2.18.4.tgz",
+      "integrity": "sha512-SgJeA4df9DE2iAEpr3M2H0OKl/yjtg1BnRI5/JyowS71tUWhrfSu2LT0V3vlHET+g1hBVlrO60PmEXwUEKp8Mg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "napi": "scripts/index.js"
+      },
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/wickra-darwin-arm64": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.4.3.tgz",
+      "integrity": "sha512-4eZiBR/yGUdr4nzhEUFy2i69XgNx64iI2ax/LPamsThgylC0KpHOZKK19QzJ2d9KbK4C8nMjME5FLuR+4GNEwQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "PolyForm-Noncommercial-1.0.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/wickra-darwin-x64": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.4.3.tgz",
+      "integrity": "sha512-6hf8zI3QPjTFp4zCpmgUwDvNtu6jHqNUHKD5e55POo0CgA52HkpyxSPtVm8TGTIZDI7kPjlbOdBM8CJ76mmXwA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "PolyForm-Noncommercial-1.0.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/wickra-linux-arm64-gnu": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.4.3.tgz",
+      "integrity": "sha512-kSe6y0xBMSiqdPLXNjwop5WZdHtvdBNKSEBCwZ4hFq33p4apW25/wrlzv9/oDuyD4kuPabJEhCCnFOplh58CUg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "PolyForm-Noncommercial-1.0.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/wickra-linux-x64-gnu": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.4.3.tgz",
+      "integrity": "sha512-tWBWS4qz7hxM4xnpFb59bhf6TaLwXq0Z3jEa/2l7r8PiHA94g8r8S53NRMiT+4yiL5hSWe/nUiC/YXdRrhEZ4g==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "PolyForm-Noncommercial-1.0.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/wickra-win32-arm64-msvc": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.4.3.tgz",
+      "integrity": "sha512-EXIckHxAtF75PUGDKRzXyqMe9ldP0JjSdu68WFN6iJfp+McYrGu6h40TEJlQ/oUEIoPqiZB/xhVyo/el5Lg7zw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "PolyForm-Noncommercial-1.0.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/wickra-win32-x64-msvc": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.4.3.tgz",
+      "integrity": "sha512-Yfsqq1Xwp6hdxMyLze411vNdo7BDwI6+lPSe7A9XdqyPecNDbtKwYLpsal2r8EHbNzqM+R8XnuRtUaEQS5VlUQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "PolyForm-Noncommercial-1.0.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 18"
+      }
+    }
+  }
+}

bindings/node/package.json

@@ -1,11 +1,11 @@
 {
   "name": "wickra",
-  "version": "0.2.1",
+  "version": "0.4.3",
   "description": "Streaming-first technical indicators: incremental, fast, install-free. Node bindings powered by Rust.",
-  "author": "kingchenc <kingchencp@gmail.com>",
+  "author": "kingchenc <support@wickra.org>",
   "main": "index.js",
   "types": "index.d.ts",
-  "license": "PolyForm-Noncommercial-1.0.0",
+  "license": "LicenseRef-Wickra-Noncommercial-1.0.0",
   "keywords": [
     "trading",
     "indicators",
@@ -17,12 +17,12 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/kingchenc/wickra"
+    "url": "https://github.com/wickra-lib/wickra"
   },
   "bugs": {
-    "url": "https://github.com/kingchenc/wickra/issues"
+    "url": "https://github.com/wickra-lib/wickra/issues"
   },
-  "homepage": "https://github.com/kingchenc/wickra",
+  "homepage": "https://github.com/wickra-lib/wickra",
   "files": [
     "index.js",
     "index.d.ts",
@@ -38,7 +38,8 @@
         "aarch64-unknown-linux-gnu",
         "x86_64-apple-darwin",
         "aarch64-apple-darwin",
-        "x86_64-pc-windows-msvc"
+        "x86_64-pc-windows-msvc",
+        "aarch64-pc-windows-msvc"
       ]
     }
   },
@@ -46,11 +47,12 @@
     "node": ">= 18"
   },
   "optionalDependencies": {
-    "wickra-linux-x64-gnu": "0.2.1",
-    "wickra-linux-arm64-gnu": "0.2.1",
-    "wickra-darwin-x64": "0.2.1",
-    "wickra-darwin-arm64": "0.2.1",
-    "wickra-win32-x64-msvc": "0.2.1"
+    "wickra-linux-x64-gnu": "0.4.3",
+    "wickra-linux-arm64-gnu": "0.4.3",
+    "wickra-darwin-x64": "0.4.3",
+    "wickra-darwin-arm64": "0.4.3",
+    "wickra-win32-x64-msvc": "0.4.3",
+    "wickra-win32-arm64-msvc": "0.4.3"
   },
   "scripts": {
     "build": "napi build --platform --release",
@@ -58,7 +60,8 @@
     "artifacts": "napi artifacts",
     "universal": "napi universal",
     "version": "napi version",
-    "test": "node --test __tests__/"
+    "test": "node --test __tests__/",
+    "bench": "node benchmarks/throughput.js"
   },
   "devDependencies": {
     "@napi-rs/cli": "^2.18.0"

bindings/python/Cargo.toml

@@ -5,7 +5,7 @@ version.workspace = true
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
-license.workspace = true
+license-file.workspace = true
 repository.workspace = true
 homepage.workspace = true
 readme.workspace = true

bindings/python/README.md

@@ -1,66 +1,72 @@
-# Wickra — Python bindings
+# Wickra — Python
 
-Streaming-first technical indicators powered by a Rust core.
+[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![PyPI](https://img.shields.io/pypi/v/wickra.svg?logo=pypi&color=blue)](https://pypi.org/project/wickra/)
+[![License: PolyForm-NC](https://img.shields.io/badge/license-PolyForm--NC--1.0.0-purple)](https://github.com/wickra-lib/wickra/blob/main/LICENSE)
+
+**Streaming-first technical indicators for Python. `pip install wickra` — no
+system dependencies, no C build tooling.**
+
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js, and WebAssembly. 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 Python binding (PyO3); it
+exposes 200+ streaming-first indicators across sixteen families.
+
+## Install
 
 ```bash
 pip install wickra
 ```
 
+Pre-built wheels ship for Linux, macOS, and Windows — there is nothing to
+compile and no C library to track down.
+
 ## Quick start
 
 ```python
 import numpy as np
 import wickra as ta
 
-# Batch — TA-Lib-style usage
+# Batch: classic TA-Lib-style usage over a whole array.
 prices = np.linspace(100, 200, 1000)
-rsi = ta.RSI(14).batch(prices)            # NumPy array; NaN during warmup
-
-# Streaming — feed ticks one at a time
 rsi = ta.RSI(14)
-for price in live_prices:
-    v = rsi.update(price)                 # O(1) per tick
-    if v is not None and v > 70:
-        ...
+values = rsi.batch(prices)              # numpy array, NaN during warmup
+
+# Streaming: the same indicator, fed tick by tick in O(1).
+rsi = ta.RSI(14)
+for price in live_feed:
+    value = rsi.update(price)           # no recomputation over history
+    if value is not None and value > 70:
+        print("overbought")
 ```
 
-## What's included
+`batch(prices)` and feeding the same prices through `update()` produce
+identical values — the equivalence is enforced by the test suite.
 
-71 streaming-first indicators across eight families. Every one passes a
-`batch == streaming` equivalence test and reference-value tests:
+## Documentation
 
-- **Moving Averages** — SMA, EMA, WMA, DEMA, TEMA, HMA, KAMA, SMMA, TRIMA,
-  ZLEMA, T3, VWMA
-- **Momentum Oscillators** — RSI (Wilder), Stochastic, CCI, ROC, Williams %R,
-  MFI, Awesome Oscillator, MOM, CMO, TSI, PMO, StochRSI, Ultimate Oscillator
-- **Trend & Directional** — MACD, ADX (+DI/-DI), Aroon, TRIX, Aroon
-  Oscillator, Vortex, Mass Index, Choppiness Index, Vertical Horizontal Filter
-- **Price Oscillators** — PPO, DPO, Coppock, Accelerator Oscillator, Balance
-  of Power
-- **Volatility & Bands** — ATR, Bollinger Bands, Keltner Channels, Donchian
-  Channels, NATR, StdDev, Ulcer Index, Historical Volatility, Bollinger
-  Bandwidth, %B, True Range, Chaikin Volatility
-- **Trailing Stops** — Parabolic SAR, SuperTrend, Chandelier Exit, Chande
-  Kroll Stop, ATR Trailing Stop
-- **Volume** — OBV, VWAP (cumulative + rolling), ADL, Volume-Price Trend,
-  Chaikin Money Flow, Chaikin Oscillator, Force Index, Ease of Movement
-- **Price Statistics** — Typical Price, Median Price, Weighted Close, Linear
-  Regression, Linear Regression Slope, Z-Score, Linear Regression Angle
+The full indicator catalogue, guides, quickstarts, and API reference live in
+the main repository and documentation site:
 
-## Why streaming-first matters
+- **Repository & full indicator list:** <https://github.com/wickra-lib/wickra>
+- **Docs** (quickstarts, cookbook, TA-Lib migration): <https://docs.wickra.org>
+- **Runnable examples:** [`examples/python/`](https://github.com/wickra-lib/wickra/tree/main/examples/python)
 
-Classic TA libraries are batch-only: every live tick triggers a full
-recomputation over the entire history. Wickra updates indicator state in
-O(1) per tick. On a 5K-bar history the streaming RSI gap is ~17× over the
-nearest peer with a streaming API and 100×+ over batch-only libraries.
+Wickra ships four bindings — Python, Node.js, WebAssembly, and Rust — that all
+expose the same indicators from the shared, `unsafe`-forbidden Rust core.
 
-## Full project
+## Disclaimer
 
-See <https://github.com/kingchenc/wickra> for benchmarks, the Rust core,
-Node.js and WebAssembly bindings, examples, and CI.
+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 the **PolyForm Noncommercial License 1.0.0**. Personal,
-research, educational, and non-profit use are all permitted. Commercial
-sale requires a separate license — contact via the GitHub repo.
+Licensed under the **PolyForm Noncommercial License 1.0.0**. Personal projects,
+research, education, non-profits, and hobby trading bots are all fine; the one
+thing not allowed is commercial sale of the software or of services built
+around it. See [LICENSE](https://github.com/wickra-lib/wickra/blob/main/LICENSE).

bindings/python/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "maturin"
 
 [project]
 name = "wickra"
-version = "0.2.1"
+version = "0.4.3"
 description = "Streaming-first technical indicators: incremental, fast, install-free."
 readme = "README.md"
-license = { text = "PolyForm-Noncommercial-1.0.0" }
-authors = [{ name = "kingchenc", email = "kingchencp@gmail.com" }]
+license = { text = "PolyForm-Noncommercial-1.0.0 with additional personal-account permissions; see LICENSE" }
+authors = [{ name = "kingchenc", email = "support@wickra.org" }]
 requires-python = ">=3.9"
 keywords = ["finance", "trading", "indicators", "technical-analysis", "ta-lib"]
 classifiers = [
@@ -47,9 +47,9 @@ bench = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/kingchenc/wickra"
-Repository = "https://github.com/kingchenc/wickra"
-Issues = "https://github.com/kingchenc/wickra/issues"
+Homepage = "https://github.com/wickra-lib/wickra"
+Repository = "https://github.com/wickra-lib/wickra"
+Issues = "https://github.com/wickra-lib/wickra/issues"
 
 [tool.maturin]
 manifest-path = "Cargo.toml"

bindings/python/python/wickra/__init__.py

@@ -38,6 +38,13 @@ from ._wickra import (
     ZLEMA,
     T3,
     VWMA,
+    ALMA,
+    McGinleyDynamic,
+    FRAMA,
+    VIDYA,
+    JMA,
+    Alligator,
+    EVWMA,
     # Momentum
     RSI,
     MACD,
@@ -46,6 +53,7 @@ from ._wickra import (
     ROC,
     WilliamsR,
     ADX,
+    ADXR,
     MFI,
     TRIX,
     AwesomeOscillator,
@@ -54,13 +62,30 @@ from ._wickra import (
     CMO,
     TSI,
     PMO,
+    TII,
+    KST,
     StochRSI,
     UltimateOscillator,
+    RVI,
+    PGO,
+    KST,
+    SMI,
+    LaguerreRSI,
+    ConnorsRSI,
+    Inertia,
+    APO,
+    AwesomeOscillatorHistogram,
+    CFO,
+    ZeroLagMACD,
+    ElderImpulse,
+    STC,
     PPO,
     DPO,
     Coppock,
     AroonOscillator,
     Vortex,
+    RWI,
+    WaveTrend,
     MassIndex,
     AcceleratorOscillator,
     BalanceOfPower,
@@ -82,8 +107,20 @@ from ._wickra import (
     ChandelierExit,
     ChandeKrollStop,
     AtrTrailingStop,
+    HiLoActivator,
+    VoltyStop,
+    YoyoExit,
+    DonchianStop,
+    PercentageTrailingStop,
+    StepTrailingStop,
+    RenkoTrailingStop,
     TrueRange,
     ChaikinVolatility,
+    RVIVolatility,
+    ParkinsonVolatility,
+    GarmanKlassVolatility,
+    RogersSatchellVolatility,
+    YangZhangVolatility,
     # Volume
     OBV,
     VWAP,
@@ -93,6 +130,16 @@ from ._wickra import (
     ChaikinMoneyFlow,
     ChaikinOscillator,
     ForceIndex,
+    KVO,
+    VolumeOscillator,
+    NVI,
+    PVI,
+    WilliamsAD,
+    AnchoredVWAP,
+    DemandIndex,
+    TSV,
+    VZO,
+    MarketFacilitationIndex,
     EaseOfMovement,
     # Statistics
     TypicalPrice,
@@ -102,6 +149,132 @@ from ._wickra import (
     LinRegSlope,
     ZScore,
     LinRegAngle,
+    Variance,
+    CoefficientOfVariation,
+    Skewness,
+    Kurtosis,
+    StandardError,
+    DetrendedStdDev,
+    RSquared,
+    Autocorrelation,
+    MedianAbsoluteDeviation,
+    HurstExponent,
+    PearsonCorrelation,
+    Beta,
+    PairwiseBeta,
+    PairSpreadZScore,
+    LeadLagCrossCorrelation,
+    Cointegration,
+    RelativeStrengthAB,
+    SpearmanCorrelation,
+    # Ehlers / Cycle
+    SuperSmoother,
+    FisherTransform,
+    InverseFisherTransform,
+    Decycler,
+    DecyclerOscillator,
+    RoofingFilter,
+    CenterOfGravity,
+    CyberneticCycle,
+    InstantaneousTrendline,
+    EhlersStochastic,
+    EmpiricalModeDecomposition,
+    HilbertDominantCycle,
+    AdaptiveCycle,
+    SineWave,
+    MAMA,
+    FAMA,
+    # Bands & Channels
+    MaEnvelope,
+    AccelerationBands,
+    StarcBands,
+    AtrBands,
+    HurstChannel,
+    LinRegChannel,
+    StandardErrorBands,
+    DoubleBollinger,
+    TtmSqueeze,
+    FractalChaosBands,
+    VwapStdDevBands,
+    # Pivots & S/R
+    ClassicPivots,
+    FibonacciPivots,
+    Camarilla,
+    WoodiePivots,
+    DemarkPivots,
+    WilliamsFractals,
+    ZigZag,
+    # DeMark
+    TDSetup,
+    TDSequential,
+    TDDeMarker,
+    TDREI,
+    TDPressure,
+    TDCombo,
+    TDCountdown,
+    TDLines,
+    TDRangeProjection,
+    TDDifferential,
+    TDOpen,
+    TDRiskLevel,
+    # Ichimoku & alternative charts
+    Ichimoku,
+    HeikinAshi,
+    # Market Profile
+    ValueArea,
+    InitialBalance,
+    OpeningRange,
+    # Candlestick patterns
+    Doji,
+    Hammer,
+    InvertedHammer,
+    HangingMan,
+    ShootingStar,
+    Engulfing,
+    Harami,
+    MorningEveningStar,
+    ThreeSoldiersOrCrows,
+    PiercingDarkCloud,
+    Marubozu,
+    Tweezer,
+    SpinningTop,
+    ThreeInside,
+    ThreeOutside,
+    # Microstructure: order book
+    OrderBookImbalanceTop1,
+    OrderBookImbalanceTopN,
+    OrderBookImbalanceFull,
+    Microprice,
+    QuotedSpread,
+    DepthSlope,
+    # Microstructure: trade flow
+    SignedVolume,
+    CumulativeVolumeDelta,
+    TradeImbalance,
+    # Microstructure: price impact
+    EffectiveSpread,
+    RealizedSpread,
+    KylesLambda,
+    # Microstructure: footprint
+    Footprint,
+    # Risk / Performance
+    SharpeRatio,
+    SortinoRatio,
+    CalmarRatio,
+    OmegaRatio,
+    MaxDrawdown,
+    AverageDrawdown,
+    DrawdownDuration,
+    PainIndex,
+    ValueAtRisk,
+    ConditionalValueAtRisk,
+    ProfitFactor,
+    GainLossRatio,
+    RecoveryFactor,
+    KellyCriterion,
+    TreynorRatio,
+    InformationRatio,
+    Alpha,
 )
 
 __all__ = [
@@ -119,6 +292,13 @@ __all__ = [
     "ZLEMA",
     "T3",
     "VWMA",
+    "ALMA",
+    "McGinleyDynamic",
+    "FRAMA",
+    "VIDYA",
+    "JMA",
+    "Alligator",
+    "EVWMA",
     # Momentum
     "RSI",
     "MACD",
@@ -127,6 +307,7 @@ __all__ = [
     "ROC",
     "WilliamsR",
     "ADX",
+    "ADXR",
     "MFI",
     "TRIX",
     "AwesomeOscillator",
@@ -135,13 +316,30 @@ __all__ = [
     "CMO",
     "TSI",
     "PMO",
+    "TII",
+    "KST",
     "StochRSI",
     "UltimateOscillator",
+    "RVI",
+    "PGO",
+    "KST",
+    "SMI",
+    "LaguerreRSI",
+    "ConnorsRSI",
+    "Inertia",
+    "APO",
+    "AwesomeOscillatorHistogram",
+    "CFO",
+    "ZeroLagMACD",
+    "ElderImpulse",
+    "STC",
     "PPO",
     "DPO",
     "Coppock",
     "AroonOscillator",
     "Vortex",
+    "RWI",
+    "WaveTrend",
     "MassIndex",
     "AcceleratorOscillator",
     "BalanceOfPower",
@@ -163,8 +361,20 @@ __all__ = [
     "ChandelierExit",
     "ChandeKrollStop",
     "AtrTrailingStop",
+    "HiLoActivator",
+    "VoltyStop",
+    "YoyoExit",
+    "DonchianStop",
+    "PercentageTrailingStop",
+    "StepTrailingStop",
+    "RenkoTrailingStop",
     "TrueRange",
     "ChaikinVolatility",
+    "RVIVolatility",
+    "ParkinsonVolatility",
+    "GarmanKlassVolatility",
+    "RogersSatchellVolatility",
+    "YangZhangVolatility",
     # Volume
     "OBV",
     "VWAP",
@@ -174,6 +384,16 @@ __all__ = [
     "ChaikinMoneyFlow",
     "ChaikinOscillator",
     "ForceIndex",
+    "KVO",
+    "VolumeOscillator",
+    "NVI",
+    "PVI",
+    "WilliamsAD",
+    "AnchoredVWAP",
+    "DemandIndex",
+    "TSV",
+    "VZO",
+    "MarketFacilitationIndex",
     "EaseOfMovement",
     # Statistics
     "TypicalPrice",
@@ -183,4 +403,130 @@ __all__ = [
     "LinRegSlope",
     "ZScore",
     "LinRegAngle",
+    "Variance",
+    "CoefficientOfVariation",
+    "Skewness",
+    "Kurtosis",
+    "StandardError",
+    "DetrendedStdDev",
+    "RSquared",
+    "Autocorrelation",
+    "MedianAbsoluteDeviation",
+    "HurstExponent",
+    "PearsonCorrelation",
+    "Beta",
+    "PairwiseBeta",
+    "PairSpreadZScore",
+    "LeadLagCrossCorrelation",
+    "Cointegration",
+    "RelativeStrengthAB",
+    "SpearmanCorrelation",
+    # Ehlers / Cycle
+    "SuperSmoother",
+    "FisherTransform",
+    "InverseFisherTransform",
+    "Decycler",
+    "DecyclerOscillator",
+    "RoofingFilter",
+    "CenterOfGravity",
+    "CyberneticCycle",
+    "InstantaneousTrendline",
+    "EhlersStochastic",
+    "EmpiricalModeDecomposition",
+    "HilbertDominantCycle",
+    "AdaptiveCycle",
+    "SineWave",
+    "MAMA",
+    "FAMA",
+    # Bands & Channels
+    "MaEnvelope",
+    "AccelerationBands",
+    "StarcBands",
+    "AtrBands",
+    "HurstChannel",
+    "LinRegChannel",
+    "StandardErrorBands",
+    "DoubleBollinger",
+    "TtmSqueeze",
+    "FractalChaosBands",
+    "VwapStdDevBands",
+    # Pivots & S/R
+    "ClassicPivots",
+    "FibonacciPivots",
+    "Camarilla",
+    "WoodiePivots",
+    "DemarkPivots",
+    "WilliamsFractals",
+    "ZigZag",
+    # DeMark
+    "TDSetup",
+    "TDSequential",
+    "TDDeMarker",
+    "TDREI",
+    "TDPressure",
+    "TDCombo",
+    "TDCountdown",
+    "TDLines",
+    "TDRangeProjection",
+    "TDDifferential",
+    "TDOpen",
+    "TDRiskLevel",
+    # Ichimoku & alternative charts
+    "Ichimoku",
+    "HeikinAshi",
+    # Market Profile
+    "ValueArea",
+    "InitialBalance",
+    "OpeningRange",
+    # Candlestick patterns
+    "Doji",
+    "Hammer",
+    "InvertedHammer",
+    "HangingMan",
+    "ShootingStar",
+    "Engulfing",
+    "Harami",
+    "MorningEveningStar",
+    "ThreeSoldiersOrCrows",
+    "PiercingDarkCloud",
+    "Marubozu",
+    "Tweezer",
+    "SpinningTop",
+    "ThreeInside",
+    "ThreeOutside",
+    # Microstructure: order book
+    "OrderBookImbalanceTop1",
+    "OrderBookImbalanceTopN",
+    "OrderBookImbalanceFull",
+    "Microprice",
+    "QuotedSpread",
+    "DepthSlope",
+    # Microstructure: trade flow
+    "SignedVolume",
+    "CumulativeVolumeDelta",
+    "TradeImbalance",
+    # Microstructure: price impact
+    "EffectiveSpread",
+    "RealizedSpread",
+    "KylesLambda",
+    # Microstructure: footprint
+    "Footprint",
+    # Risk / Performance
+    "SharpeRatio",
+    "SortinoRatio",
+    "CalmarRatio",
+    "OmegaRatio",
+    "MaxDrawdown",
+    "AverageDrawdown",
+    "DrawdownDuration",
+    "PainIndex",
+    "ValueAtRisk",
+    "ConditionalValueAtRisk",
+    "ProfitFactor",
+    "GainLossRatio",
+    "RecoveryFactor",
+    "KellyCriterion",
+    "TreynorRatio",
+    "InformationRatio",
+    "Alpha",
 ]

bindings/python/tests/test_input_validation.py

@@ -35,7 +35,206 @@ def test_unequal_length_candle_batch_raises(ohlc_series):
         ta.Aroon(14).batch(high, short)
 
 
+def test_pairwise_beta_rejects_bad_period():
+    with pytest.raises(ValueError):
+        ta.PairwiseBeta(0)
+    with pytest.raises(ValueError):
+        ta.PairwiseBeta(1)
+
+
+def test_unequal_length_pair_batch_raises(sine_prices):
+    a = np.ascontiguousarray((sine_prices + 100.0).astype(np.float64))
+    b = a[:-1]
+    with pytest.raises(ValueError):
+        ta.PairwiseBeta(20).batch(a, b)
+    with pytest.raises(ValueError):
+        ta.PairSpreadZScore(20, 20).batch(a, b)
+
+
+def test_pair_spread_zscore_rejects_bad_periods():
+    with pytest.raises(ValueError):
+        ta.PairSpreadZScore(1, 20)
+    with pytest.raises(ValueError):
+        ta.PairSpreadZScore(20, 1)
+
+
+def test_lead_lag_rejects_bad_params():
+    with pytest.raises(ValueError):
+        ta.LeadLagCrossCorrelation(1, 5)
+    with pytest.raises(ValueError):
+        ta.LeadLagCrossCorrelation(10, 0)
+
+
+def test_lead_lag_unequal_length_batch_raises(sine_prices):
+    a = np.ascontiguousarray((sine_prices + 100.0).astype(np.float64))
+    b = a[:-1]
+    with pytest.raises(ValueError):
+        ta.LeadLagCrossCorrelation(12, 5).batch(a, b)
+
+
+def test_cointegration_rejects_too_small_period():
+    # period must be >= 2*adf_lags + 4.
+    with pytest.raises(ValueError):
+        ta.Cointegration(3, 0)
+    with pytest.raises(ValueError):
+        ta.Cointegration(5, 1)
+
+
+def test_cointegration_unequal_length_batch_raises(sine_prices):
+    a = np.ascontiguousarray((sine_prices + 100.0).astype(np.float64))
+    b = a[:-1]
+    with pytest.raises(ValueError):
+        ta.Cointegration(20, 1).batch(a, b)
+
+
+def test_relative_strength_rejects_zero_periods():
+    with pytest.raises(ValueError):
+        ta.RelativeStrengthAB(0, 14)
+    with pytest.raises(ValueError):
+        ta.RelativeStrengthAB(20, 0)
+
+
+def test_relative_strength_unequal_length_batch_raises(sine_prices):
+    a = np.ascontiguousarray((sine_prices + 100.0).astype(np.float64))
+    b = a[:-1]
+    with pytest.raises(ValueError):
+        ta.RelativeStrengthAB(10, 14).batch(a, b)
+
+
 def test_roc_and_trix_have_default_periods():
     # ROC/TRIX gained constructor defaults matching the TA-Lib convention.
     assert ta.ROC().period == 10
     assert ta.TRIX() is not None
+
+
+def test_value_area_rejects_zero_period():
+    with pytest.raises(ValueError):
+        ta.ValueArea(0, 50, 0.7)
+    with pytest.raises(ValueError):
+        ta.ValueArea(20, 0, 0.7)
+
+
+def test_value_area_rejects_invalid_pct():
+    with pytest.raises(ValueError):
+        ta.ValueArea(20, 50, 0.0)
+    with pytest.raises(ValueError):
+        ta.ValueArea(20, 50, 1.5)
+
+
+def test_initial_balance_rejects_zero_period():
+    with pytest.raises(ValueError):
+        ta.InitialBalance(0)
+
+
+def test_opening_range_rejects_zero_period():
+    with pytest.raises(ValueError):
+        ta.OpeningRange(0)
+
+
+def test_value_area_unequal_length_raises():
+    high = np.array([1.0, 2.0, 3.0])
+    low = np.array([0.5, 1.5])
+    volume = np.array([10.0, 10.0, 10.0])
+    with pytest.raises(ValueError):
+        ta.ValueArea(2, 10, 0.7).batch(high, low, volume)
+
+
+def test_ichimoku_rejects_zero_and_non_increasing_periods():
+    with pytest.raises(ValueError):
+        ta.Ichimoku(0, 26, 52, 26)
+    with pytest.raises(ValueError):
+        ta.Ichimoku(9, 26, 52, 0)
+    # Periods must satisfy tenkan < kijun < senkou_b.
+    with pytest.raises(ValueError):
+        ta.Ichimoku(26, 9, 52, 26)
+    with pytest.raises(ValueError):
+        ta.Ichimoku(9, 52, 52, 26)
+
+
+def test_family_10_ehlers_rejects_invalid_parameters():
+    with pytest.raises(ValueError):
+        ta.SuperSmoother(0)
+    with pytest.raises(ValueError):
+        ta.FisherTransform(0)
+    with pytest.raises(ValueError):
+        ta.InverseFisherTransform(0.0)
+    with pytest.raises(ValueError):
+        ta.DecyclerOscillator(30, 10)
+    with pytest.raises(ValueError):
+        ta.RoofingFilter(48, 10)
+    with pytest.raises(ValueError):
+        ta.MAMA(0.05, 0.5)
+    with pytest.raises(ValueError):
+        ta.EmpiricalModeDecomposition(20, 0.0)
+
+
+def test_orderbook_topn_zero_levels_raises():
+    with pytest.raises(ValueError):
+        ta.OrderBookImbalanceTopN(0)
+
+
+def test_orderbook_unequal_price_size_lengths_raise():
+    # bid_px has 2 entries but bid_sz has 1 -> mismatched -> ValueError.
+    with pytest.raises(ValueError):
+        ta.OrderBookImbalanceTop1().update([100.0, 99.0], [1.0], [101.0], [1.0])
+    with pytest.raises(ValueError):
+        ta.Microprice().update([100.0], [1.0], [101.0, 102.0], [1.0])
+
+
+def test_orderbook_crossed_book_raises():
+    # best_bid (102) >= best_ask (101) is a crossed book -> rejected.
+    with pytest.raises(ValueError):
+        ta.QuotedSpread().update([102.0], [1.0], [101.0], [1.0])
+
+
+def test_orderbook_misordered_levels_raise():
+    # Bids must be strictly descending in price.
+    with pytest.raises(ValueError):
+        ta.OrderBookImbalanceFull().update([99.0, 100.0], [1.0, 1.0], [101.0], [1.0])
+
+
+def test_trade_imbalance_zero_window_raises():
+    with pytest.raises(ValueError):
+        ta.TradeImbalance(0)
+
+
+def test_trade_negative_size_raises():
+    with pytest.raises(ValueError):
+        ta.SignedVolume().update(100.0, -1.0, True)
+
+
+def test_trade_non_positive_price_raises():
+    with pytest.raises(ValueError):
+        ta.CumulativeVolumeDelta().update(0.0, 1.0, True)
+
+
+def test_trade_batch_unequal_lengths_raise():
+    with pytest.raises(ValueError):
+        ta.SignedVolume().batch([100.0, 100.0], [1.0], [True, False])
+
+
+def test_effective_spread_non_positive_mid_raises():
+    with pytest.raises(ValueError):
+        ta.EffectiveSpread().update(100.0, 1.0, True, 0.0)
+
+
+def test_effective_spread_batch_unequal_lengths_raise():
+    with pytest.raises(ValueError):
+        ta.EffectiveSpread().batch([100.0, 100.0], [1.0, 1.0], [True, False], [100.0])
+
+
+def test_realized_spread_zero_horizon_raises():
+    with pytest.raises(ValueError):
+        ta.RealizedSpread(0)
+
+
+def test_kyles_lambda_window_below_two_raises():
+    with pytest.raises(ValueError):
+        ta.KylesLambda(1)
+
+
+def test_footprint_non_positive_tick_raises():
+    with pytest.raises(ValueError):
+        ta.Footprint(0.0)
+    with pytest.raises(ValueError):
+        ta.Footprint(-1.0)

bindings/python/tests/test_known_values.py

@@ -66,6 +66,224 @@ def test_rsi_wilder_textbook_first_value():
     assert math.isclose(out[14], 70.464, abs_tol=0.05)
 
 
+def test_inertia_constant_rvi_passes_through_linreg():
+    # Every bar identical (open, high, low, close) = (10, 11, 9, 10.5):
+    # RVI = (c-o) / (h-l) = 0.5 / 2 = 0.25 every bar. LinReg of a constant
+    # series equals that constant after warmup.
+    n = 60
+    out = ta.Inertia(3, 4).batch(
+        np.full(n, 10.0), np.full(n, 11.0), np.full(n, 9.0), np.full(n, 10.5)
+    )
+    # warmup_period = 3 + 4 - 1 = 6.
+    np.testing.assert_allclose(out[5:], 0.25, atol=1e-12)
+
+
+def test_connors_rsi_output_is_bounded():
+    # CRSI is the average of three [0, 100] components, so the aggregate must
+    # also sit in [0, 100] after warmup.
+    prices = 100.0 + 20.0 * np.sin(np.linspace(0, 30, 250))
+    out = ta.ConnorsRSI(3, 2, 100).batch(prices.astype(np.float64))
+    ready = out[~np.isnan(out)]
+    assert ready.size > 0
+    assert ready.min() >= 0.0
+    assert ready.max() <= 100.0
+
+
+def test_laguerre_rsi_constant_series_stays_at_mid_band():
+    # All four Laguerre stages seed to the first input, so subsequent flat
+    # inputs keep them equal and the up/down accumulator is 0 — Wickra maps
+    # that to the neutral 50.
+    out = ta.LaguerreRSI(0.5).batch(np.full(40, 42.0, dtype=np.float64))
+    np.testing.assert_allclose(out, 50.0, atol=1e-12)
+
+
+def test_smi_close_at_centre_yields_zero():
+    # Close at the midpoint of a flat high/low range -> displacement is
+    # always zero -> SMI converges to 0.
+    n = 60
+    out = ta.SMI(5, 3, 3).batch(np.full(n, 11.0), np.full(n, 9.0), np.full(n, 10.0))
+    # warmup_period = 5 + 3 + 3 - 2 = 9.
+    np.testing.assert_allclose(out[8:], 0.0, atol=1e-12)
+
+
+def test_kst_constant_series_yields_zero():
+    # ROC is zero on a flat input, so every RCMA is zero, so KST and its
+    # signal SMA are both zero after warmup.
+    kst = ta.KST(10, 15, 20, 30, 10, 10, 10, 15, 9)
+    out = kst.batch(np.full(80, 42.0, dtype=np.float64))
+    warmup = kst.warmup_period()
+    # Use NaN-safe comparison on the post-warmup tail.
+    tail = out[warmup - 1 :]
+    assert np.all(np.isfinite(tail))
+    np.testing.assert_allclose(tail, 0.0, atol=1e-12)
+
+
+def test_pgo_flat_close_yields_zero():
+    # On a constant close the numerator (close − SMA) is zero, so PGO emits 0
+    # regardless of the TR-EMA in the denominator.
+    n = 20
+    high = np.full(n, 11.0)
+    low = np.full(n, 9.0)
+    close = np.full(n, 10.0)
+    out = ta.PGO(5).batch(high, low, close)
+    assert np.all(np.isnan(out[:4]))
+    np.testing.assert_allclose(out[4:], 0.0, atol=1e-12)
+
+
+def test_rvi_reference_value_period_2():
+    # Two bars: (open, high, low, close) = (10, 11, 9, 10.5), (10.5, 11.5, 10, 11).
+    #   num = (0.5 + 0.5) = 1.0; den = (2.0 + 1.5) = 3.5; RVI = 1 / 3.5.
+    out = ta.RVI(2).batch(
+        np.array([10.0, 10.5]),
+        np.array([11.0, 11.5]),
+        np.array([9.0, 10.0]),
+        np.array([10.5, 11.0]),
+    )
+    assert math.isnan(out[0])
+    assert math.isclose(out[1], 1.0 / 3.5, abs_tol=1e-12)
+
+
+def test_alma_constant_series_yields_the_constant():
+    # ALMA's Gaussian weights are normalised, so any constant series is
+    # reproduced exactly after warmup.
+    out = ta.ALMA(9, 0.85, 6.0).batch(np.full(30, 42.0, dtype=np.float64))
+    assert np.all(np.isnan(out[:8]))
+    np.testing.assert_allclose(out[8:], 42.0, atol=1e-12)
+
+
+def test_alma_reference_value_period_3():
+    # ALMA(period=3, offset=0.85, sigma=6) on [10, 20, 30].
+    # m = 0.85 * 2 = 1.7; s = 3 / 6 = 0.5; 2*s^2 = 0.5.
+    out = ta.ALMA(3, 0.85, 6.0).batch(np.array([10.0, 20.0, 30.0]))
+    assert math.isnan(out[0]) and math.isnan(out[1])
+    # Independently compute the expected Gaussian-weighted sum.
+    w = np.exp(-((np.arange(3, dtype=np.float64) - 1.7) ** 2) / 0.5)
+    expected = float(np.dot([10.0, 20.0, 30.0], w) / w.sum())
+    assert math.isclose(out[2], expected, abs_tol=1e-12)
+    # Sanity: heavy offset toward the newest sample lifts the average above
+    # the simple mean of 20.
+    assert out[2] > 20.0
+
+
+def test_mcginley_dynamic_constant_series_yields_the_constant():
+    # ratio = 1, so the recurrence collapses to MD + 0 / divisor = MD.
+    out = ta.McGinleyDynamic(5).batch(np.full(30, 42.0, dtype=np.float64))
+    assert np.all(np.isnan(out[:4]))
+    np.testing.assert_allclose(out[4:], 42.0, atol=1e-12)
+
+
+def test_mcginley_dynamic_reference_value():
+    # Period 3, seed = SMA([10, 20, 30]) = 20.0. Next price 40.0:
+    # ratio   = 2; divisor = 0.6 * 3 * 16 = 28.8; next = 20 + 20/28.8.
+    out = ta.McGinleyDynamic(3).batch(np.array([10.0, 20.0, 30.0, 40.0]))
+    assert math.isnan(out[0]) and math.isnan(out[1])
+    assert math.isclose(out[2], 20.0, abs_tol=1e-12)
+    expected = 20.0 + 20.0 / (0.6 * 3.0 * 16.0)
+    assert math.isclose(out[3], expected, abs_tol=1e-12)
+
+
+def test_frama_constant_series_yields_the_constant():
+    # Flat input -> degenerate ranges -> alpha clamps to 0.01 and the EMA
+    # recurrence holds the seed value.
+    out = ta.FRAMA(4).batch(np.full(20, 42.0, dtype=np.float64))
+    assert np.all(np.isnan(out[:3]))
+    np.testing.assert_allclose(out[3:], 42.0, atol=1e-12)
+
+
+def test_frama_pure_uptrend_hugs_latest():
+    # Monotonic uptrend -> alpha pushed toward 1.0, FRAMA tracks close.
+    out = ta.FRAMA(4).batch(np.arange(1.0, 9.0, dtype=np.float64))
+    assert math.isclose(out[-1], 8.0, abs_tol=0.05)
+
+
+def test_jma_constant_series_yields_the_constant():
+    # JMA seeds e0 and the output to the first input, so a constant series
+    # is reproduced exactly from the first sample.
+    out = ta.JMA(14, 0.0, 2).batch(np.full(30, 42.0, dtype=np.float64))
+    np.testing.assert_allclose(out, 42.0, atol=1e-12)
+
+
+def test_evwma_reference_value_period_2():
+    # EVWMA(2). Bars: (close, volume) = (10, 1), (20, 3), (30, 1).
+    #   Bar 2: sum_v = 4, seeded prev = 20, EVWMA = (1*20 + 3*20)/4 = 20.
+    #   Bar 3: sum_v = 4 (drops 1, gains 1), EVWMA = (3*20 + 1*30)/4 = 22.5.
+    out = ta.EVWMA(2).batch(np.array([10.0, 20.0, 30.0]), np.array([1.0, 3.0, 1.0]))
+    assert math.isnan(out[0])
+    assert math.isclose(out[1], 20.0, abs_tol=1e-12)
+    assert math.isclose(out[2], 22.5, abs_tol=1e-12)
+
+
+def test_alligator_constant_series_holds_at_median_price():
+    # Median price = (11 + 9) / 2 = 10 on every candle, so all three SMMAs
+    # seed at 10 and stay there.
+    n = 30
+    high = np.full(n, 11.0)
+    low = np.full(n, 9.0)
+    out = ta.Alligator(13, 8, 5).batch(high, low)
+    assert out.shape == (n, 3)
+    for row in out[12:]:
+        assert math.isclose(row[0], 10.0, abs_tol=1e-12)
+        assert math.isclose(row[1], 10.0, abs_tol=1e-12)
+        assert math.isclose(row[2], 10.0, abs_tol=1e-12)
+
+
+def test_vidya_constant_series_holds_seed():
+    # CMO = 0 on a flat series -> alpha = 0 -> VIDYA holds its seed value.
+    out = ta.VIDYA(14, 4).batch(np.full(20, 42.0, dtype=np.float64))
+    assert np.all(np.isnan(out[:4]))
+    np.testing.assert_allclose(out[4:], 42.0, atol=1e-12)
+
+
+def test_zero_lag_macd_constant_series_converges_to_zero():
+    # Each inner ZLEMA reproduces a constant, so macd, signal and histogram
+    # are all 0 once the slowest branch warms up.
+    out = ta.ZeroLagMACD(3, 5, 3).batch(np.full(60, 42.0, dtype=np.float64))
+    # Take the last row and verify all three columns are 0.
+    last = out[-1]
+    assert math.isclose(last[0], 0.0, abs_tol=1e-12)
+    assert math.isclose(last[1], 0.0, abs_tol=1e-12)
+    assert math.isclose(last[2], 0.0, abs_tol=1e-12)
+
+
+def test_awesome_oscillator_histogram_flat_series_converges_to_zero():
+    # Flat median price -> AO = 0 -> SMA(AO) = 0 -> AOHist = 0.
+    n = 50
+    high = np.full(n, 11.0)
+    low = np.full(n, 9.0)
+    out = ta.AwesomeOscillatorHistogram(3, 5, 3).batch(high, low)
+    # warmup = slow + sma - 1 = 5 + 3 - 1 = 7.
+    np.testing.assert_allclose(out[6:], 0.0, atol=1e-12)
+
+
+def test_stc_constant_series_yields_zero():
+    # Flat input collapses both stochastic stages to zero -> STC stays at 0.
+    out = ta.STC(3, 5, 4, 0.5).batch(np.full(60, 42.0, dtype=np.float64))
+    ready = out[~np.isnan(out)]
+    assert ready.size > 0
+    np.testing.assert_array_equal(ready[-5:], np.zeros(5))
+
+
+def test_elder_impulse_constant_series_is_neutral():
+    # Flat input -> neither EMA nor MACD histogram moves -> Impulse stays at 0.
+    out = ta.ElderImpulse(13, 12, 26, 9).batch(np.full(120, 42.0, dtype=np.float64))
+    ready = out[~np.isnan(out)]
+    assert ready.size > 0
+    np.testing.assert_array_equal(ready, np.zeros_like(ready))
+
+
+def test_cfo_perfect_linear_series_yields_zero():
+    # LinReg of a perfectly linear series fits exactly, so CFO = 0 after warmup.
+    out = ta.CFO(5).batch(np.arange(1.0, 21.0, dtype=np.float64) * 2.0)
+    np.testing.assert_allclose(out[4:], 0.0, atol=1e-9)
+
+
+def test_apo_constant_series_converges_to_zero():
+    # Both EMAs reproduce a constant exactly, so APO = 0 after warmup.
+    out = ta.APO(3, 5).batch(np.full(30, 42.0, dtype=np.float64))
+    assert np.all(np.isnan(out[:4]))
+    np.testing.assert_allclose(out[4:], 0.0, atol=1e-12)
+
+
 def test_macd_constant_series_converges_to_zero():
     out = ta.MACD().batch(np.full(200, 100.0))
     # Last row's MACD and signal must be ~0.
@@ -112,3 +330,619 @@ def test_obv_cumulative_known_sequence():
     volume = np.array([100.0, 20.0, 30.0, 40.0, 10.0])
     out = ta.OBV().batch(close, volume)
     np.testing.assert_allclose(out, [0.0, 20.0, -10.0, -10.0, 0.0])
+
+
+# --- Family 15: Risk / Performance ---------------------------------------
+
+
+def test_sharpe_ratio_known_window():
+    # returns [0.01, 0.02, 0.03, 0.04], rf = 0; mean = 0.025;
+    # sample-var = 0.000166...; Sharpe = 0.025 / sqrt(var).
+    out = ta.SharpeRatio(4, 0.0).batch(np.array([0.01, 0.02, 0.03, 0.04]))
+    expected = 0.025 / math.sqrt(0.000_166_666_666_666_666_67)
+    assert math.isclose(out[3], expected, rel_tol=1e-9)
+
+
+def test_sortino_ratio_known_window():
+    # returns [-0.02, 0.01, -0.01, 0.03], mar = 0; mean = 0.0025;
+    # downside_sq = 0.0005; dd = sqrt(0.0005/4); Sortino = 0.0025/dd.
+    out = ta.SortinoRatio(4, 0.0).batch(np.array([-0.02, 0.01, -0.01, 0.03]))
+    expected = 0.0025 / math.sqrt(0.000_125)
+    assert math.isclose(out[3], expected, rel_tol=1e-9)
+
+
+def test_max_drawdown_known_window():
+    # window [100, 120, 90] -> peak 120, trough 90 -> 25% drawdown.
+    out = ta.MaxDrawdown(3).batch(np.array([100.0, 120.0, 90.0]))
+    assert math.isclose(out[2], 0.25, abs_tol=1e-12)
+
+
+def test_pain_index_known_window():
+    # dd[0..2] = 0, 0, 0.25; mean = 0.25/3.
+    out = ta.PainIndex(3).batch(np.array([100.0, 120.0, 90.0]))
+    assert math.isclose(out[2], 0.25 / 3.0, abs_tol=1e-12)
+
+
+def test_profit_factor_known_window():
+    # gains 0.05, losses 0.03 -> PF = 5/3.
+    out = ta.ProfitFactor(4).batch(np.array([0.02, -0.01, 0.03, -0.02]))
+    assert math.isclose(out[3], 5.0 / 3.0, rel_tol=1e-9)
+
+
+def test_gain_loss_ratio_known_window():
+    # avg_win 0.03, avg_loss 0.02 -> GLR = 1.5.
+    out = ta.GainLossRatio(4).batch(np.array([0.02, -0.01, 0.04, -0.03]))
+    assert math.isclose(out[3], 1.5, rel_tol=1e-9)
+
+
+def test_omega_ratio_known_window():
+    # gains 0.04, losses 0.03 -> Omega = 4/3.
+    out = ta.OmegaRatio(4, 0.0).batch(np.array([-0.02, 0.01, -0.01, 0.03]))
+    assert math.isclose(out[3], 4.0 / 3.0, rel_tol=1e-9)
+
+
+def test_kelly_criterion_known_window():
+    # n_win=n_loss=2, payoff=2 -> Kelly = 0.5 - 0.5/2 = 0.25.
+    out = ta.KellyCriterion(4).batch(np.array([0.02, 0.04, -0.01, -0.02]))
+    assert math.isclose(out[3], 0.25, rel_tol=1e-9)
+
+
+def test_drawdown_duration_under_water_counter():
+    out = ta.DrawdownDuration().batch(np.array([100.0, 95.0, 90.0, 85.0]))
+    np.testing.assert_allclose(out, [0.0, 1.0, 2.0, 3.0])
+
+
+def test_recovery_factor_known_path():
+    # Start 100, peak 110, trough 88 -> max_dd = 0.20; end 130 ->
+    # net_return = 0.30 -> Recovery = 1.5.
+    prices = np.array([100.0, 110.0, 105.0, 95.0, 88.0, 100.0, 120.0, 130.0])
+    out = ta.RecoveryFactor().batch(prices)
+    assert math.isclose(out[-1], 1.5, rel_tol=1e-9)
+
+
+def test_alpha_perfect_capm_fit_yields_zero():
+    bench = np.array([0.01 * i for i in range(1, 21)])
+    asset = 2.0 * bench
+    out = ta.Alpha(20, 0.0).batch(asset, bench)
+    assert math.isclose(out[-1], 0.0, abs_tol=1e-12)
+
+
+def test_alpha_additive_offset_recovered():
+    bench = np.array([0.01 * i for i in range(1, 21)])
+    asset = bench + 0.005
+    out = ta.Alpha(20, 0.0).batch(asset, bench)
+    assert math.isclose(out[-1], 0.005, rel_tol=1e-9)
+
+
+def test_treynor_ratio_known_window():
+    bench = np.array([0.01 * i for i in range(1, 21)])
+    asset = 2.0 * bench
+    out = ta.TreynorRatio(20, 0.0).batch(asset, bench)
+    assert math.isclose(out[-1], bench.mean(), rel_tol=1e-9)
+
+
+def test_information_ratio_known_window():
+    asset = np.array([0.02, 0.04, 0.06, 0.08])
+    bench = np.array([0.01, 0.02, 0.03, 0.04])
+    out = ta.InformationRatio(4).batch(asset, bench)
+    expected = 0.025 / math.sqrt(0.000_166_666_666_666_666_67)
+    assert math.isclose(out[-1], expected, rel_tol=1e-9)
+
+
+def test_pairwise_beta_squared_price_is_two():
+    # a = b² ⇒ a's log-returns are exactly 2× b's ⇒ pairwise beta = 2.
+    # b must have *varying* returns (a constant-return path has zero variance
+    # and an undefined slope, which the indicator reports as 0).
+    b = np.array([100.0 + 10.0 * math.sin(i * 0.5) for i in range(20)])
+    a = b**2
+    out = ta.PairwiseBeta(5).batch(a, b)
+    assert math.isclose(out[-1], 2.0, rel_tol=1e-9)
+
+
+def test_pairwise_beta_inverse_price_is_minus_one():
+    # a = 1/b ⇒ a's log-returns are −1× b's ⇒ pairwise beta = −1.
+    b = np.array([100.0 + 10.0 * math.sin(i * 0.5) for i in range(20)])
+    a = 1.0 / b
+    out = ta.PairwiseBeta(5).batch(a, b)
+    assert math.isclose(out[-1], -1.0, rel_tol=1e-9)
+
+
+def test_pair_spread_zscore_flat_benchmark_sign():
+    # Flat b ⇒ hedge ratio 0 ⇒ spread = ln(a). With z_period = 2 the z-score
+    # collapses to the sign of the last move: rising a ⇒ +1, falling a ⇒ −1.
+    a = np.array([100.0, 100.0, 110.0, 105.0, 130.0])
+    b = np.full_like(a, 100.0)
+    out = ta.PairSpreadZScore(2, 2).batch(a, b)
+    assert math.isclose(out[-1], 1.0, abs_tol=1e-9)
+    assert math.isclose(out[-2], -1.0, abs_tol=1e-9)
+
+
+def test_lead_lag_cross_correlation_negative_lead():
+    # a is a delayed copy of b ⇒ b leads a ⇒ lag = −2, correlation ≈ 1.
+    def sig(t):
+        return math.sin(t * 0.4) + 0.4 * math.sin(t * 1.1) + 0.2 * math.cos(t * 0.27)
+
+    n = 60
+    a = np.array([sig(t - 2) for t in range(n)])
+    b = np.array([sig(t) for t in range(n)])
+    out = ta.LeadLagCrossCorrelation(12, 5).batch(a, b)
+    assert int(out[-1, 0]) == -2
+    assert out[-1, 1] > 0.99
+
+
+def test_cointegration_perfect_pair():
+    # a = 2*b + 5 exactly ⇒ hedge ratio 2, zero spread, degenerate ADF ⇒ 0.
+    b = np.array([100.0 + t for t in range(40)])
+    a = 2.0 * b + 5.0
+    out = ta.Cointegration(20, 1).batch(a, b)
+    assert math.isclose(out[-1, 0], 2.0, rel_tol=1e-9)
+    assert math.isclose(out[-1, 1], 0.0, abs_tol=1e-6)
+    assert math.isclose(out[-1, 2], 0.0, abs_tol=1e-12)
+
+
+def test_relative_strength_rising_ratio_is_overbought():
+    # a rises while b is flat ⇒ ratio strictly increases ⇒ RSI saturates at 100.
+    n = 20
+    a = np.array([100.0 + 2.0 * t for t in range(n)])
+    b = np.full(n, 100.0)
+    out = ta.RelativeStrengthAB(5, 5).batch(a, b)
+    assert out[-1, 0] > 1.0
+    assert math.isclose(out[-1, 2], 100.0, abs_tol=1e-9)
+
+
+def test_value_at_risk_known_window():
+    # returns -5..4 *0.01; q=0.05*9=0.45 -> -0.0455; VaR = 0.0455.
+    returns = np.array([i * 0.01 for i in range(-5, 5)])
+    out = ta.ValueAtRisk(10, 0.95).batch(returns)
+    assert math.isclose(out[-1], 0.0455, rel_tol=1e-9)
+
+
+def test_conditional_value_at_risk_known_window():
+    # tail = {-0.10}; CVaR = 0.10.
+    returns = np.array([i * 0.01 for i in range(-10, 10)])
+    out = ta.ConditionalValueAtRisk(20, 0.95).batch(returns)
+    assert math.isclose(out[-1], 0.10, rel_tol=1e-9)
+
+
+def test_calmar_ratio_known_path():
+    # returns [0.10, -0.20, 0.05]; equity 1.0->1.10->0.88->0.924;
+    # mdd = 0.20; mean = -0.01666...; Calmar = mean / 0.20.
+    out = ta.CalmarRatio(3).batch(np.array([0.10, -0.20, 0.05]))
+    expected = ((0.10 - 0.20 + 0.05) / 3.0) / 0.20
+    assert math.isclose(out[-1], expected, rel_tol=1e-9)
+
+
+def test_average_drawdown_known_window():
+    # window [100, 120, 90, 110]: dd = 0, 0, 0.25, 10/120;
+    # mean = (0.25 + 10/120) / 4.
+    out = ta.AverageDrawdown(4).batch(np.array([100.0, 120.0, 90.0, 110.0]))
+    expected = (0.25 + 10.0 / 120.0) / 4.0
+    assert math.isclose(out[-1], expected, rel_tol=1e-12)
+
+
+def test_value_area_concentrated_volume_locates_poc():
+    # Bars 0..3 sit at price 100 with low volume; bar 4 dumps massive volume
+    # at price 110. POC must fall inside the high-volume bar's [low, high]
+    # range; ties resolve to the lowest-index bin, so the POC may sit on the
+    # left edge of bar 4's range rather than at its midpoint.
+    high = np.array([100.5, 100.5, 100.5, 100.5, 110.5])
+    low = np.array([99.5, 99.5, 99.5, 99.5, 109.5])
+    volume = np.array([1.0, 1.0, 1.0, 1.0, 1000.0])
+    out = ta.ValueArea(5, 50, 0.70).batch(high, low, volume)
+    poc = out[-1, 0]
+    assert 109.5 <= poc <= 110.5
+    # VAH >= POC >= VAL.
+    assert out[-1, 1] >= poc >= out[-1, 2]
+
+
+def test_initial_balance_locks_after_period():
+    # First two bars set IB = [99, 103]. Third bar (extreme) must be ignored.
+    high = np.array([102.0, 103.0, 200.0])
+    low = np.array([100.0, 99.0, 50.0])
+    out = ta.InitialBalance(2).batch(high, low)
+    # Bar 0: IB = [100, 102]; Bar 1: IB locked at [99, 103]; Bar 2: unchanged.
+    np.testing.assert_allclose(out[0], [102.0, 100.0])
+    np.testing.assert_allclose(out[1], [103.0, 99.0])
+    np.testing.assert_allclose(out[2], [103.0, 99.0])
+
+
+def test_opening_range_breakout_distance_signed():
+    # OR locks after 2 bars at high 103 / low 100; mid 101.5. Third bar
+    # closes at 105 -> breakout +3.5; fourth bar closes at 95 -> -6.5.
+    high = np.array([102.0, 103.0, 110.0, 110.0])
+    low = np.array([100.0, 101.0, 102.0, 90.0])
+    close = np.array([101.0, 102.0, 105.0, 95.0])
+    out = ta.OpeningRange(2).batch(high, low, close)
+    assert math.isclose(out[2, 0], 103.0)
+    assert math.isclose(out[2, 1], 100.0)
+    assert math.isclose(out[2, 2], 105.0 - 101.5)
+    assert math.isclose(out[3, 2], 95.0 - 101.5)
+
+
+# --- Family 10 — Ehlers / Cycle reference values ---
+
+
+def test_inverse_fisher_saturates_for_large_input():
+    # tanh(10) ~ 0.99999996; very close to +1 without exceeding.
+    v = ta.InverseFisherTransform(1.0).batch(np.array([10.0]))[0]
+    assert v < 1.0
+    assert v > 0.999
+
+
+def test_super_smoother_constant_input_is_constant():
+    out = ta.SuperSmoother(20).batch(np.full(200, 50.0))
+    # Steady-state gain is 1, so a flat input stays flat.
+    np.testing.assert_allclose(out[-50:], 50.0, atol=1e-9)
+
+
+def test_decycler_oscillator_flat_series_is_zero():
+    out = ta.DecyclerOscillator(10, 30).batch(np.full(80, 42.0))
+    ready = out[~np.isnan(out)]
+    np.testing.assert_allclose(ready, 0.0, atol=1e-9)
+
+
+def test_mama_constant_series_both_lines_converge_to_price():
+    out = ta.MAMA().batch(np.full(200, 100.0))
+    last = out[-1]
+    # MAMA and FAMA both track price closely on a flat series.
+    assert abs(last[0] - 100.0) < 1.0
+    assert abs(last[1] - 100.0) < 1.0
+
+
+# --- DeMark family ---------------------------------------------------------
+
+
+def test_td_setup_buy_setup_completes_at_minus_9_uptrend():
+    # Strictly rising closes -> every bar has close > close[-4] (sell setup);
+    # the streak hits -9 at index 12 and caps there.
+    h = np.arange(2.0, 22.0)
+    l = h - 1.0
+    c = h - 0.5
+    out = ta.TDSetup(4, 9).batch(h, l, c)
+    assert out[12] == pytest.approx(-9.0)
+    assert out[-1] == pytest.approx(-9.0)
+
+
+def test_td_demarker_downtrend_pegs_at_zero():
+    n = 20
+    h = np.arange(30.0, 30.0 - n, -1.0)
+    l = h - 2.0
+    out = ta.TDDeMarker(5).batch(h, l)
+    assert out[-1] == pytest.approx(0.0)
+
+
+def test_td_pressure_pure_bearish_yields_minus_100():
+    n = 20
+    open_ = np.full(n, 11.0)
+    high = np.full(n, 11.0)
+    low = np.full(n, 9.0)
+    close = np.full(n, 9.0)
+    volume = np.full(n, 100.0)
+    out = ta.TDPressure(5).batch(open_, high, low, close, volume)
+    assert out[-1] == pytest.approx(-100.0)
+
+
+def test_td_combo_uptrend_completes_to_minus_13():
+    # Pure uptrend -> setup completes, then combo conditions (close>=high[-2],
+    # high>=prev.high, close>prev.close) all hold for every subsequent bar
+    # -> sell combo saturates at -13.
+    n = 40
+    high = np.arange(1.0, 1.0 + n) + 0.5
+    low = high - 1.0
+    close = high - 0.5
+    out = ta.TDCombo().batch(high, low, close)
+    assert out[-1] == pytest.approx(-13.0)
+
+
+def test_td_countdown_uptrend_completes_to_minus_13():
+    n = 40
+    high = np.arange(1.0, 1.0 + n) + 0.5
+    low = high - 1.0
+    close = high - 0.5
+    out = ta.TDCountdown().batch(high, low, close)
+    assert out[-1] == pytest.approx(-13.0)
+
+
+def test_td_range_projection_doji_reference():
+    # open=close=10, high=12, low=9 -> doji branch.
+    # pivot_sum = 12 + 9 + 2*10 = 41; half = 20.5.
+    # projHigh = 20.5 - 9 = 11.5; projLow = 20.5 - 12 = 8.5.
+    out = ta.TDRangeProjection().batch(
+        np.array([10.0]), np.array([12.0]), np.array([9.0]), np.array([10.0])
+    )
+    assert out[0, 0] == pytest.approx(11.5)
+    assert out[0, 1] == pytest.approx(8.5)
+
+
+def test_td_open_sell_signal_reference():
+    # Prev high=12. Curr open=13 > 12, curr low=11 < 12 -> -1.
+    td = ta.TDOpen()
+    assert td.update((10.0, 12.0, 9.0, 11.0, 1.0, 0)) is None
+    assert td.update((13.0, 13.5, 11.0, 11.5, 1.0, 1)) == pytest.approx(-1.0)
+
+
+def test_td_differential_sell_signal_reference():
+    # Prev high=10, low=8, close=9: buying=1, selling=1.
+    # Curr high=12, low=9.8, close=10.5: close>prev.close, selling=1.5>1,
+    # buying=0.7<1 -> sell signal -1.
+    td = ta.TDDifferential()
+    assert td.update((9.0, 10.0, 8.0, 9.0, 1.0, 0)) is None
+    assert td.update((10.5, 12.0, 9.8, 10.5, 1.0, 1)) == pytest.approx(-1.0)
+
+
+def test_td_lines_uptrend_support_reference():
+    # Strictly rising series -> sell setup completes at idx 12, the
+    # lowest low across bars 4..=12 is the low at idx 4 = 4.5.
+    n = 20
+    high = np.arange(1.0, 1.0 + n) + 0.5
+    low = high - 1.0
+    close = high - 0.5
+    out = ta.TDLines().batch(high, low, close)
+    assert math.isnan(out[-1, 0])
+    assert out[-1, 1] == pytest.approx(4.5)
+
+
+def test_td_risk_level_uptrend_sell_risk_reference():
+    # Strictly rising series -> sell setup completes at idx 12 with high
+    # 13.5 and true range 1.5 -> sell_risk = 13.5 + 1.5 = 15.0.
+    # Subsequent setups re-ratchet the level, so we check the first emission
+    # at idx 12 rather than the latest value.
+    n = 20
+    high = np.arange(1.0, 1.0 + n) + 0.5
+    low = high - 1.0
+    close = high - 0.5
+    out = ta.TDRiskLevel().batch(high, low, close)
+    assert math.isnan(out[12, 0])
+    assert out[12, 1] == pytest.approx(15.0)
+
+
+def test_percentage_trailing_stop_seed_and_ratchet():
+    # 10% trail: first close 100 -> stop 90; next 110 -> stop max(90, 99) = 99.
+    s = ta.PercentageTrailingStop(10.0)
+    assert math.isclose(s.update(100.0), 90.0, abs_tol=1e-12)
+    assert math.isclose(s.update(110.0), 99.0, abs_tol=1e-12)
+
+
+def test_step_trailing_stop_snaps_below_close():
+    # step 1: floor((100.4 - 1) / 1) = 99.
+    s = ta.StepTrailingStop(1.0)
+    assert math.isclose(s.update(100.4), 99.0, abs_tol=1e-12)
+
+
+def test_renko_trailing_stop_holds_until_full_block():
+    # block 1: seed 100 -> stop 99; 100.5 still 99; 101 -> stop 100.
+    s = ta.RenkoTrailingStop(1.0)
+    assert math.isclose(s.update(100.0), 99.0, abs_tol=1e-12)
+    assert math.isclose(s.update(100.5), 99.0, abs_tol=1e-12)
+    assert math.isclose(s.update(101.0), 100.0, abs_tol=1e-12)
+
+
+def test_donchian_stop_window_extremes():
+    # 5-bar window of highs 1..5 and lows 0..4.
+    high = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+    low = np.array([0.0, 1.0, 2.0, 3.0, 4.0])
+    out = ta.DonchianStop(5).batch(high, low)
+    # First 4 rows NaN, fifth row: stop_long = 0, stop_short = 5.
+    for i in range(4):
+        assert math.isnan(out[i, 0])
+        assert math.isnan(out[i, 1])
+    assert math.isclose(out[4, 0], 0.0, abs_tol=1e-12)
+    assert math.isclose(out[4, 1], 5.0, abs_tol=1e-12)
+
+
+def test_hilo_activator_flat_market_holds_low_sma():
+    # Flat candles H=11, L=9, C=10 -> close (10) sits between bands, so the
+    # initial long seed is preserved: emitted stop = lo_sma = 9.
+    h = np.full(15, 11.0)
+    l = np.full(15, 9.0)
+    c = np.full(15, 10.0)
+    out = ta.HiLoActivator(3).batch(h, l, c)
+    # warmup_period == period + 1 == 4, so indices 0..2 are NaN; index 3 onwards is 9.
+    for i in range(3):
+        assert math.isnan(out[i])
+    for i in range(3, 15):
+        assert math.isclose(out[i], 9.0, abs_tol=1e-12)
+
+
+def test_volty_stop_flat_market_constant_level():
+    # ATR=2, mult=2 -> band 4; anchor stays at close 10 -> stop = 10 - 4 = 6.
+    h = np.full(20, 11.0)
+    l = np.full(20, 9.0)
+    c = np.full(20, 10.0)
+    out = ta.VoltyStop(5, 2.0).batch(h, l, c)
+    for i in range(4):
+        assert math.isnan(out[i])
+    for i in range(4, 20):
+        assert math.isclose(out[i], 6.0, abs_tol=1e-12)
+
+
+def test_yoyo_exit_flat_market_constant_level():
+    # ATR=2, mult=2 -> band 4; trail = close - band = 10 - 4 = 6 and holds.
+    h = np.full(20, 11.0)
+    l = np.full(20, 9.0)
+    c = np.full(20, 10.0)
+    out = ta.YoyoExit(5, 2.0).batch(h, l, c)
+    for i in range(4):
+        assert math.isnan(out[i])
+    for i in range(4, 20):
+        assert math.isclose(out[i], 6.0, abs_tol=1e-12)
+
+
+def test_rvi_volatility_pure_uptrend_saturates_at_one_hundred():
+    # Strictly rising closes -> every stddev sample classified as "up" ->
+    # RVIVolatility saturates at 100. Renamed from the original ta.RVI in
+    # PR 42 to disambiguate from Family 02's Relative Vigor Index, which
+    # now owns the short ta.RVI name (candle input).
+    out = ta.RVIVolatility(5).batch(np.arange(1.0, 41.0, dtype=np.float64))
+    ready = out[~np.isnan(out)]
+    assert ready.size > 0
+    np.testing.assert_allclose(ready[-10:], 100.0, atol=1e-9)
+
+
+def test_parkinson_volatility_zero_range_yields_zero():
+    # H == L every bar -> ln(H/L) = 0 -> Parkinson sigma is zero.
+    h = np.full(30, 10.0)
+    l = np.full(30, 10.0)
+    out = ta.ParkinsonVolatility(14, 252).batch(h, l)
+    ready = out[~np.isnan(out)]
+    assert ready.size > 0
+    np.testing.assert_allclose(ready, 0.0, atol=1e-12)
+
+
+def test_garman_klass_zero_movement_yields_zero():
+    # O == H == L == C every bar -> both log terms are zero -> sigma is zero.
+    o = np.full(30, 10.0)
+    h = np.full(30, 10.0)
+    l = np.full(30, 10.0)
+    c = np.full(30, 10.0)
+    out = ta.GarmanKlassVolatility(14, 252).batch(o, h, l, c)
+    ready = out[~np.isnan(out)]
+    assert ready.size > 0
+    np.testing.assert_allclose(ready, 0.0, atol=1e-12)
+
+
+def test_rogers_satchell_zero_movement_yields_zero():
+    o = np.full(30, 10.0)
+    h = np.full(30, 10.0)
+    l = np.full(30, 10.0)
+    c = np.full(30, 10.0)
+    out = ta.RogersSatchellVolatility(14, 252).batch(o, h, l, c)
+    ready = out[~np.isnan(out)]
+    assert ready.size > 0
+    np.testing.assert_allclose(ready, 0.0, atol=1e-12)
+
+
+def test_yang_zhang_zero_movement_yields_zero():
+    # O == H == L == C and constant across bars -> every sub-component is
+    # zero -> Yang-Zhang sigma is zero.
+    o = np.full(30, 10.0)
+    h = np.full(30, 10.0)
+    l = np.full(30, 10.0)
+    c = np.full(30, 10.0)
+    out = ta.YangZhangVolatility(14, 252).batch(o, h, l, c)
+    ready = out[~np.isnan(out)]
+    assert ready.size > 0
+    np.testing.assert_allclose(ready, 0.0, atol=1e-12)
+
+
+def test_doji_default_is_directionless_flag():
+    # Default Doji is a direction-less detection flag: +1 on a doji, 0 else.
+    d = ta.Doji()
+    assert d.is_signed() is False
+    # body 0, range 2 -> doji.
+    assert d.update((10.0, 11.0, 9.0, 10.0, 1.0, 0)) == pytest.approx(1.0)
+    # body 2 == range -> not a doji.
+    assert d.update((10.0, 12.0, 10.0, 12.0, 1.0, 1)) == pytest.approx(0.0)
+
+
+def test_doji_signed_dragonfly_gravestone_neutral():
+    # Signed Doji classifies by body position within the range.
+    d = ta.Doji(signed=True)
+    assert d.is_signed() is True
+    # Dragonfly: body at the top, long lower shadow -> bullish +1.
+    assert d.update((10.0, 10.05, 6.0, 10.0, 1.0, 0)) == pytest.approx(1.0)
+    # Gravestone: body at the bottom, long upper shadow -> bearish -1.
+    assert d.update((10.0, 14.0, 9.95, 10.0, 1.0, 1)) == pytest.approx(-1.0)
+    # Long-legged: body centred, symmetric shadows -> neutral 0.
+    assert d.update((10.0, 12.0, 8.0, 10.0, 1.0, 2)) == pytest.approx(0.0)
+    # A large body is not a doji at all -> 0 regardless of position.
+    assert d.update((10.0, 12.0, 10.0, 12.0, 1.0, 3)) == pytest.approx(0.0)
+
+
+def test_orderbook_imbalance_reference_values():
+    # Top-1: (3 - 1) / (3 + 1) = 0.5.
+    assert ta.OrderBookImbalanceTop1().update([100.0], [3.0], [101.0], [1.0]) == pytest.approx(0.5)
+    # Top-2: bidDepth 3, askDepth 2 -> (3 - 2) / 5 = 0.2.
+    topn = ta.OrderBookImbalanceTopN(2)
+    assert topn.update([100.0, 99.0], [2.0, 1.0], [101.0, 102.0], [1.0, 1.0]) == pytest.approx(0.2)
+    # Full: bidDepth 1, askDepth 3 -> (1 - 3) / 4 = -0.5.
+    full = ta.OrderBookImbalanceFull()
+    assert full.update([100.0], [1.0], [101.0, 102.0], [2.0, 1.0]) == pytest.approx(-0.5)
+
+
+def test_microprice_reference_value():
+    # (100*3 + 101*1) / (1 + 3) = 401 / 4 = 100.25 — heavy ask pulls toward bid.
+    mp = ta.Microprice()
+    assert mp.update([100.0], [1.0], [101.0], [3.0]) == pytest.approx(100.25)
+
+
+def test_quoted_spread_reference_value():
+    # spread 1.0, mid 100.5 -> 1 / 100.5 * 10_000 ≈ 99.5025 bps.
+    qs = ta.QuotedSpread()
+    assert qs.update([100.0], [1.0], [101.0], [1.0]) == pytest.approx(99.50248756, abs=1e-6)
+
+
+def test_depth_slope_reference_value():
+    # Symmetric book, each side distances 1, 2 with cumulative sizes 1, 3.
+    # OLS slope of (1->1, 2->3) = 2; mean of two equal sides = 2.
+    ds = ta.DepthSlope()
+    out = ds.update([99.0, 98.0], [1.0, 2.0], [101.0, 102.0], [1.0, 2.0])
+    assert out == pytest.approx(2.0, abs=1e-9)
+    # A book with a single level per side has no slope -> 0.
+    assert ta.DepthSlope().update([100.0], [1.0], [101.0], [1.0]) == pytest.approx(0.0)
+
+
+def test_footprint_buckets_buy_and_sell_volume():
+    fp = ta.Footprint(1.0)
+    fp.update(100.2, 2.0, True)  # bucket 100 -> ask 2
+    fp.update(100.7, 3.0, False)  # bucket 101 -> bid 3
+    out = fp.update(100.1, 1.0, True)  # bucket 100 -> ask 3
+    # Columns are [price, bid_vol, ask_vol], rows sorted ascending by price.
+    assert out.shape == (2, 3)
+    assert list(out[0]) == [100.0, 0.0, 3.0]
+    assert list(out[1]) == [101.0, 3.0, 0.0]
+
+
+def test_signed_volume_reference_values():
+    assert ta.SignedVolume().update(100.0, 2.0, True) == pytest.approx(2.0)
+    assert ta.SignedVolume().update(100.0, 3.0, False) == pytest.approx(-3.0)
+
+
+def test_cumulative_volume_delta_reference_values():
+    cvd = ta.CumulativeVolumeDelta()
+    assert cvd.update(100.0, 5.0, True) == pytest.approx(5.0)
+    assert cvd.update(100.0, 2.0, False) == pytest.approx(3.0)
+    assert cvd.update(100.0, 4.0, False) == pytest.approx(-1.0)
+
+
+def test_trade_imbalance_reference_value():
+    ti = ta.TradeImbalance(2)
+    assert ti.update(100.0, 3.0, True) is None  # warming up
+    # Window full: buyVol 3, sellVol 1 -> (3 - 1) / 4 = 0.5.
+    assert ti.update(100.0, 1.0, False) == pytest.approx(0.5)
+
+
+def test_effective_spread_reference_values():
+    # Buy at 100.05 vs mid 100.0: 2 * (100.05 - 100) / 100 * 10000 = 10 bps.
+    assert ta.EffectiveSpread().update(100.05, 1.0, True, 100.0) == pytest.approx(10.0)
+    # Sell at 99.95 vs mid 100.0: 2 * -1 * (99.95 - 100) / 100 * 10000 = 10 bps.
+    assert ta.EffectiveSpread().update(99.95, 1.0, False, 100.0) == pytest.approx(10.0)
+    # A buy filled below the mid is price improvement -> negative.
+    assert ta.EffectiveSpread().update(99.95, 1.0, True, 100.0) < 0.0
+
+
+def test_realized_spread_reference_value():
+    rs = ta.RealizedSpread(1)
+    assert rs.update(100.10, 1.0, True, 100.0) is None  # buffered
+    # Resolved against mid 100.20 one trade later:
+    # 2 * (+1) * (100.10 - 100.20) / 100.0 * 10000 = -20 bps (adverse selection).
+    assert rs.update(99.90, 1.0, False, 100.20) == pytest.approx(-20.0)
+
+
+def test_kyles_lambda_recovers_constant_impact():
+    # Build a tape where each trade moves the mid by exactly 0.5 per unit of
+    # signed volume -> the rolling OLS slope is 0.5.
+    impact = 0.5
+    mid = 100.0
+    price, size, is_buy, mids = [], [], [], []
+    for i in range(20):
+        buy = i % 2 == 0
+        sz = 1.0 + (i % 3)
+        signed = sz if buy else -sz
+        mid += impact * signed
+        price.append(mid)
+        size.append(sz)
+        is_buy.append(buy)
+        mids.append(mid)
+    out = ta.KylesLambda(6).batch(price, size, is_buy, mids)
+    assert out[-1] == pytest.approx(0.5, abs=1e-9)

bindings/python/tests/test_lifecycle.py

@@ -86,3 +86,135 @@ def test_candle_tuple_input_supported():
     atr.update((10.0, 11.0, 9.0, 10.5, 1.0, 0))
     v = atr.update((10.5, 12.0, 10.0, 11.0, 1.0, 1))
     assert v is not None
+
+
+def test_initial_balance_reset_unlocks():
+    ib = ta.InitialBalance(2)
+    assert not ib.is_ready()
+    ib.update((101.0, 102.0, 100.0, 101.0, 0.0, 0))
+    ib.update((102.0, 103.0, 101.0, 102.0, 0.0, 1))
+    assert ib.is_ready()
+    assert ib.is_locked()
+    ib.reset()
+    assert not ib.is_ready()
+    assert not ib.is_locked()
+
+
+def test_opening_range_reset_unlocks():
+    or_ind = ta.OpeningRange(2)
+    or_ind.update((101.0, 102.0, 100.0, 101.0, 0.0, 0))
+    or_ind.update((102.0, 103.0, 101.0, 102.0, 0.0, 1))
+    assert or_ind.is_locked()
+    or_ind.reset()
+    assert not or_ind.is_locked()
+
+
+def test_value_area_warmup_equals_period():
+    assert ta.ValueArea(20, 50, 0.70).warmup_period() == 20
+    assert ta.ValueArea(10, 30, 0.80).warmup_period() == 10
+
+
+def test_ehlers_indicators_lifecycle():
+    # Spot-check a few Family-10 entries beyond what test_new_indicators covers.
+    series = np.linspace(1.0, 200.0, 200) + np.sin(np.arange(200) * 0.3) * 5.0
+    for ind in [
+        ta.SuperSmoother(10),
+        ta.FisherTransform(10),
+        ta.MAMA(),
+        ta.HilbertDominantCycle(),
+        ta.SineWave(),
+    ]:
+        assert not ind.is_ready()
+        ind.batch(series)
+        assert ind.is_ready()
+        ind.reset()
+        assert not ind.is_ready()
+
+
+def test_orderbook_lifecycle():
+    snapshot = ([100.0], [1.0], [101.0], [1.0])
+    for ind in [
+        ta.OrderBookImbalanceTop1(),
+        ta.OrderBookImbalanceTopN(3),
+        ta.OrderBookImbalanceFull(),
+        ta.Microprice(),
+        ta.QuotedSpread(),
+        ta.DepthSlope(),
+    ]:
+        assert ind.warmup_period() == 1
+        assert not ind.is_ready()
+        ind.update(*snapshot)
+        assert ind.is_ready()
+        ind.reset()
+        assert not ind.is_ready()
+
+
+def test_orderbook_topn_repr():
+    assert repr(ta.OrderBookImbalanceTopN(5)) == "OrderBookImbalanceTopN(levels=5)"
+
+
+def test_tradeflow_lifecycle():
+    for ind in [ta.SignedVolume(), ta.CumulativeVolumeDelta()]:
+        assert ind.warmup_period() == 1
+        assert not ind.is_ready()
+        ind.update(100.0, 1.0, True)
+        assert ind.is_ready()
+        ind.reset()
+        assert not ind.is_ready()
+
+
+def test_trade_imbalance_lifecycle_and_repr():
+    ti = ta.TradeImbalance(3)
+    assert ti.warmup_period() == 3
+    assert not ti.is_ready()
+    for _ in range(3):
+        ti.update(100.0, 1.0, True)
+    assert ti.is_ready()
+    ti.reset()
+    assert not ti.is_ready()
+    assert repr(ta.TradeImbalance(4)) == "TradeImbalance(window=4)"
+
+
+def test_effective_spread_lifecycle():
+    es = ta.EffectiveSpread()
+    assert es.warmup_period() == 1
+    assert not es.is_ready()
+    es.update(100.05, 1.0, True, 100.0)
+    assert es.is_ready()
+    es.reset()
+    assert not es.is_ready()
+
+
+def test_realized_spread_lifecycle_and_repr():
+    rs = ta.RealizedSpread(3)
+    assert rs.warmup_period() == 4
+    assert not rs.is_ready()
+    for _ in range(4):
+        rs.update(100.0, 1.0, True, 100.0)
+    assert rs.is_ready()
+    rs.reset()
+    assert not rs.is_ready()
+    assert repr(ta.RealizedSpread(5)) == "RealizedSpread(horizon=5)"
+
+
+def test_kyles_lambda_lifecycle_and_repr():
+    kl = ta.KylesLambda(3)
+    assert kl.warmup_period() == 4
+    assert not kl.is_ready()
+    for i in range(4):
+        kl.update(100.0 + i, 1.0 + (i % 2), i % 2 == 0, 100.0 + i)
+    assert kl.is_ready()
+    kl.reset()
+    assert not kl.is_ready()
+    assert repr(ta.KylesLambda(7)) == "KylesLambda(window=7)"
+
+
+def test_footprint_lifecycle_and_repr():
+    fp = ta.Footprint(0.5)
+    assert fp.warmup_period() == 1
+    assert not fp.is_ready()
+    fp.update(100.0, 1.0, True)
+    assert fp.is_ready()
+    fp.reset()
+    assert not fp.is_ready()
+    assert repr(ta.Footprint(0.25)) == "Footprint(tick_size=0.25)"

bindings/python/tests/test_smoke.py

@@ -55,3 +55,115 @@ def test_obv_batch_shape(ohlc_series):
     volume = np.ones_like(close)
     out = ta.OBV().batch(close, volume)
     assert out.shape == close.shape
+
+
+def test_value_area_batch_shape(ohlc_series):
+    high, low, close = ohlc_series
+    volume = np.ones_like(close)
+    out = ta.ValueArea(20, 50, 0.70).batch(high, low, volume)
+    assert out.shape == (close.size, 3)
+
+
+def test_initial_balance_batch_shape(ohlc_series):
+    high, low, _close = ohlc_series
+    out = ta.InitialBalance(12).batch(high, low)
+    assert out.shape == (high.size, 2)
+
+
+def test_opening_range_batch_shape(ohlc_series):
+    high, low, close = ohlc_series
+    out = ta.OpeningRange(6).batch(high, low, close)
+    assert out.shape == (close.size, 3)
+
+
+def test_ichimoku_batch_returns_n_by_5(ohlc_series):
+    high, low, close = ohlc_series
+    out = ta.Ichimoku().batch(high, low, close)
+    assert out.shape == (close.size, 5)
+
+
+def test_heikin_ashi_batch_returns_n_by_4(ohlc_series):
+    high, low, close = ohlc_series
+    open_ = (high + low) / 2.0
+    out = ta.HeikinAshi().batch(open_, high, low, close)
+    assert out.shape == (close.size, 4)
+
+
+def test_ehlers_super_smoother_batch_shape(sine_prices):
+    out = ta.SuperSmoother(10).batch(sine_prices)
+    assert out.shape == sine_prices.shape
+
+
+def test_mama_batch_shape(sine_prices):
+    out = ta.MAMA().batch(sine_prices)
+    assert out.shape == (sine_prices.size, 2)
+
+
+def test_orderbook_indicators_construct_and_emit():
+    # All five order-book indicators accept a four-array snapshot and emit a float.
+    snapshot = ([100.0, 99.0], [2.0, 1.0], [101.0, 102.0], [1.0, 1.0])
+    indicators = [
+        ta.OrderBookImbalanceTop1(),
+        ta.OrderBookImbalanceTopN(2),
+        ta.OrderBookImbalanceFull(),
+        ta.Microprice(),
+        ta.QuotedSpread(),
+        ta.DepthSlope(),
+    ]
+    for ind in indicators:
+        out = ind.update(*snapshot)
+        assert isinstance(out, float)
+
+
+def test_orderbook_batch_returns_one_value_per_snapshot():
+    snapshots = [([100.0], [3.0], [101.0], [1.0])] * 5
+    out = ta.OrderBookImbalanceTop1().batch(snapshots)
+    assert out.shape == (5,)
+    assert out.dtype == np.float64
+
+
+def test_tradeflow_indicators_construct_and_emit():
+    # SignedVolume and CVD emit from the first trade; TradeImbalance(1) too.
+    assert isinstance(ta.SignedVolume().update(100.0, 2.0, True), float)
+    assert isinstance(ta.CumulativeVolumeDelta().update(100.0, 2.0, True), float)
+    assert isinstance(ta.TradeImbalance(1).update(100.0, 2.0, True), float)
+
+
+def test_tradeflow_batch_returns_one_value_per_trade():
+    price = np.full(6, 100.0)
+    size = np.array([1.0, 2.0, 3.0, 1.0, 2.0, 3.0])
+    is_buy = [True, False, True, False, True, False]
+    out = ta.CumulativeVolumeDelta().batch(price, size, is_buy)
+    assert out.shape == (6,)
+    assert out.dtype == np.float64
+
+
+def test_price_impact_indicators_construct_and_emit():
+    # Price-impact indicators take a trade paired with the prevailing mid.
+    assert isinstance(ta.EffectiveSpread().update(100.05, 1.0, True, 100.0), float)
+    # RealizedSpread buffers until its horizon elapses.
+    assert ta.RealizedSpread(1).update(100.05, 1.0, True, 100.0) is None
+
+
+def test_price_impact_batch_returns_one_value_per_trade():
+    price = np.array([100.05, 99.95, 100.10, 99.90])
+    size = np.array([1.0, 2.0, 1.0, 2.0])
+    is_buy = [True, False, True, False]
+    mid = np.full(4, 100.0)
+    for ind in (ta.EffectiveSpread(), ta.RealizedSpread(2), ta.KylesLambda(2)):
+        out = ind.batch(price, size, is_buy, mid)
+        assert out.shape == (4,)
+        assert out.dtype == np.float64
+
+
+def test_footprint_constructs_and_emits():
+    out = ta.Footprint(1.0).update(100.2, 2.0, True)
+    assert out.shape == (1, 3)
+    assert out.dtype == np.float64
+
+
+def test_footprint_batch_returns_list_of_arrays():
+    res = ta.Footprint(1.0).batch([100.2, 100.7], [2.0, 3.0], [True, False])
+    assert isinstance(res, list)
+    assert len(res) == 2
+    assert res[-1].shape[1] == 3

bindings/python/tests/test_streaming_vs_batch.py

@@ -117,6 +117,30 @@ def test_obv_streaming_matches_batch(ohlc_series):
     assert _equal_with_nan(batch, streamed)
 
 
+def test_mama_streaming_matches_batch(sine_prices):
+    batch = ta.MAMA().batch(sine_prices)
+    streamer = ta.MAMA()
+    rows = []
+    for p in sine_prices:
+        v = streamer.update(float(p))
+        if v is None:
+            rows.append([math.nan, math.nan])
+        else:
+            rows.append(list(v))
+    streamed = np.array(rows, dtype=np.float64)
+    assert _equal_with_nan(batch, streamed)
+
+
+def test_super_smoother_streaming_matches_batch(sine_prices):
+    batch = ta.SuperSmoother(10).batch(sine_prices)
+    streamer = ta.SuperSmoother(10)
+    streamed = np.array(
+        [math.nan if (v := streamer.update(float(p))) is None else float(v) for p in sine_prices],
+        dtype=np.float64,
+    )
+    assert _equal_with_nan(batch, streamed)
+
+
 def test_rolling_vwap_streaming_matches_batch(ohlc_series):
     # RollingVWAP(20) on the shared OHLC series. Provides finite-memory VWAP
     # parity coverage now that the indicator is exposed across all bindings.
@@ -135,3 +159,92 @@ def test_rolling_vwap_streaming_matches_batch(ohlc_series):
     assert streamer.is_ready()
     streamer.reset()
     assert not streamer.is_ready()
+
+
+def test_value_area_streaming_matches_batch(ohlc_series):
+    high, low, close = ohlc_series
+    volume = np.linspace(100.0, 200.0, num=close.size, dtype=np.float64)
+    batch = ta.ValueArea(20, 50, 0.70).batch(high, low, volume)
+
+    streamer = ta.ValueArea(20, 50, 0.70)
+    rows = []
+    for h, l, v in zip(high, low, volume):
+        mid = float((h + l) / 2.0)
+        out = streamer.update((mid, float(h), float(l), mid, float(v), 0))
+        rows.append([math.nan, math.nan, math.nan] if out is None else list(out))
+    streamed = np.array(rows, dtype=np.float64)
+    assert _equal_with_nan(batch, streamed)
+
+
+def test_initial_balance_streaming_matches_batch(ohlc_series):
+    high, low, _close = ohlc_series
+    batch = ta.InitialBalance(12).batch(high, low)
+
+    streamer = ta.InitialBalance(12)
+    rows = []
+    for h, l in zip(high, low):
+        mid = float((h + l) / 2.0)
+        out = streamer.update((mid, float(h), float(l), mid, 0.0, 0))
+        rows.append([math.nan, math.nan] if out is None else list(out))
+    streamed = np.array(rows, dtype=np.float64)
+    assert _equal_with_nan(batch, streamed)
+
+
+def test_opening_range_streaming_matches_batch(ohlc_series):
+    high, low, close = ohlc_series
+    batch = ta.OpeningRange(6).batch(high, low, close)
+
+    streamer = ta.OpeningRange(6)
+    rows = []
+    for h, l, c in zip(high, low, close):
+        out = streamer.update((float(c), float(h), float(l), float(c), 0.0, 0))
+        rows.append([math.nan, math.nan, math.nan] if out is None else list(out))
+    streamed = np.array(rows, dtype=np.float64)
+    assert _equal_with_nan(batch, streamed)
+
+
+def test_orderbook_streaming_matches_batch():
+    snaps = [
+        (
+            [100.0, 99.0],
+            [1.0 + (i % 5), 1.0],
+            [101.0, 102.0],
+            [1.0 + ((i + 1) % 3), 1.0],
+        )
+        for i in range(30)
+    ]
+    batch = ta.Microprice().batch(snaps)
+    streamer = ta.Microprice()
+    streamed = np.array([streamer.update(*snap) for snap in snaps], dtype=np.float64)
+    assert _equal_with_nan(batch, streamed)
+
+
+def test_tradeflow_streaming_matches_batch():
+    n = 30
+    price = np.full(n, 100.0)
+    size = np.array([1.0 + (i % 4) for i in range(n)], dtype=np.float64)
+    is_buy = [i % 3 != 0 for i in range(n)]
+    batch = ta.CumulativeVolumeDelta().batch(price, size, is_buy)
+    streamer = ta.CumulativeVolumeDelta()
+    streamed = np.array(
+        [streamer.update(price[i], size[i], is_buy[i]) for i in range(n)],
+        dtype=np.float64,
+    )
+    assert _equal_with_nan(batch, streamed)
+
+
+def test_price_impact_streaming_matches_batch():
+    n = 30
+    mid = np.array([100.0 + 0.25 * math.sin(i * 0.5) for i in range(n)], dtype=np.float64)
+    is_buy = [i % 3 != 0 for i in range(n)]
+    price = np.array(
+        [mid[i] + (0.03 if is_buy[i] else -0.03) for i in range(n)], dtype=np.float64
+    )
+    size = np.array([1.0 + (i % 4) for i in range(n)], dtype=np.float64)
+    batch = ta.EffectiveSpread().batch(price, size, is_buy, mid)
+    streamer = ta.EffectiveSpread()
+    streamed = np.array(
+        [streamer.update(price[i], size[i], is_buy[i], mid[i]) for i in range(n)],
+        dtype=np.float64,
+    )
+    assert _equal_with_nan(batch, streamed)

bindings/wasm/Cargo.toml

@@ -5,7 +5,7 @@ version.workspace = true
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
-license.workspace = true
+license-file.workspace = true
 repository.workspace = true
 homepage.workspace = true
 readme.workspace = true

bindings/wasm/README.md

@@ -1,49 +1,72 @@
-# wickra-wasm
+# Wickra — WebAssembly
 
-WebAssembly bindings for the Wickra streaming-first technical indicators library.
+[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![npm](https://img.shields.io/npm/v/wickra-wasm.svg?logo=npm&color=red)](https://www.npmjs.com/package/wickra-wasm)
+[![License: PolyForm-NC](https://img.shields.io/badge/license-PolyForm--NC--1.0.0-purple)](https://github.com/wickra-lib/wickra/blob/main/LICENSE)
 
-## Build
+**Streaming-first technical indicators in the browser. `npm install
+wickra-wasm` — pure WebAssembly, runs anywhere a modern JS engine does.**
 
-You need [`wasm-pack`](https://rustwasm.github.io/wasm-pack/) and the
-`wasm32-unknown-unknown` Rust target:
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js, and WebAssembly. Every indicator is an O(1)
+streaming state machine, so live trading dashboards and historical backtests
+share the exact same implementation. This package is the WebAssembly binding
+(wasm-bindgen, built for the `web` target); it exposes 200+ streaming-first
+indicators across sixteen families.
+
+## Install
 
 ```bash
-rustup target add wasm32-unknown-unknown
-cargo install wasm-pack
+npm install wickra-wasm
 ```
 
-Then from the repository root:
+## Quick start
 
-```bash
-wasm-pack build bindings/wasm --target web --release --features panic-hook
-```
-
-The compiled package lands in `bindings/wasm/pkg/`. Targets:
-
-- `--target web` for native ES modules in browsers
-- `--target bundler` for webpack/Vite/Rollup
-- `--target nodejs` for Node.js
-
-## Example
+The module ships a default `init` export that loads the `.wasm` payload; await
+it once before constructing indicators.
 
 ```js
-import init, { SMA, RSI, MACD, version } from "./pkg/wickra_wasm.js";
+import init, { RSI } from 'wickra-wasm';
 
-await init();
-console.log("wickra:", version());
+await init(); // load the WebAssembly module once
 
-// Streaming
+// Streaming: feed prices tick by tick in O(1).
 const rsi = new RSI(14);
-for (const price of livePrices) {
-  const v = rsi.update(price);
-  if (v !== undefined && v > 70) console.log("overbought");
+for (const price of liveFeed) {
+  const value = rsi.update(price); // null during warmup
+  if (value !== null && value > 70) {
+    console.log('overbought');
+  }
 }
-
-// Batch (returns a Float64Array; NaN for warmup positions)
-const sma = new SMA(20).batch(new Float64Array(historicalPrices));
 ```
 
-An interactive demo lives in [`examples/wasm/index.html`](../../examples/wasm/index.html)
-(top-level alongside the other language examples). After building the package
-with `wasm-pack build`, serve the repository root and open
-`examples/wasm/index.html` in a browser.
+Constructors mirror the other bindings (`new SMA(20)`, `new MACD(12, 26, 9)`,
+`new BollingerBands(20, 2.0)`, …); `update()` returns the latest value or
+`null` while the indicator is still warming up.
+
+## 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 browser examples:** [`examples/wasm/`](https://github.com/wickra-lib/wickra/tree/main/examples/wasm)
+
+Wickra ships four bindings — Python, Node.js, WebAssembly, and Rust — that all
+expose the same indicators from the shared, `unsafe`-forbidden Rust core.
+
+## Disclaimer
+
+Wickra is an indicator toolkit, not a trading system. The values it computes
+are deterministic transforms of the input data — they are not financial advice
+and do not predict the market. Any use in a live trading context is at your own
+risk. The library is provided **as is**, without warranty of any kind.
+
+## License
+
+Licensed under the **PolyForm Noncommercial License 1.0.0**. Personal projects,
+research, education, non-profits, and hobby trading bots are all fine; the one
+thing not allowed is commercial sale of the software or of services built
+around it. See [LICENSE](https://github.com/wickra-lib/wickra/blob/main/LICENSE).

crates/wickra-core/Cargo.toml

@@ -5,7 +5,7 @@ version.workspace = true
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
-license.workspace = true
+license-file.workspace = true
 repository.workspace = true
 homepage.workspace = true
 readme.workspace = true

crates/wickra-core/src/error.rs

@@ -31,6 +31,18 @@ pub enum Error {
     /// A multiplier or factor must be strictly positive.
     #[error("multiplier must be greater than zero")]
     NonPositiveMultiplier,
+
+    /// An order-book snapshot whose levels do not satisfy the book invariants
+    /// (e.g. a crossed book, non-finite price, negative size, or mis-sorted
+    /// levels) was provided. Order books are a microstructure input distinct
+    /// from candles and ticks, so they surface as their own variant.
+    #[error("invalid order book: {message}")]
+    InvalidOrderBook { message: &'static str },
+
+    /// A trade whose components do not satisfy the trade invariants (e.g.
+    /// non-finite price or negative size) was provided.
+    #[error("invalid trade: {message}")]
+    InvalidTrade { message: &'static str },
 }
 
 /// Convenience alias for `Result<T, wickra_core::Error>`.

crates/wickra-core/src/indicators/acceleration_bands.rs

@@ -0,0 +1,277 @@
+//! Acceleration Bands (Price Headley).
+
+use crate::error::{Error, Result};
+use crate::indicators::sma::Sma;
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Acceleration Bands output: SMA of close with momentum-biased envelopes
+/// driven by the bar's high/low geometry.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct AccelerationBandsOutput {
+    /// Upper band: SMA of `high · (1 + factor · (high − low) / (high + low))`.
+    pub upper: f64,
+    /// Middle band: SMA of close.
+    pub middle: f64,
+    /// Lower band: SMA of `low · (1 − factor · (high − low) / (high + low))`.
+    pub lower: f64,
+}
+
+/// Acceleration Bands (Price Headley): SMA-smoothed bands that widen with each
+/// bar's relative range `(high − low) / (high + low)`.
+///
+/// ```text
+/// ratio  = (high − low) / (high + low)
+/// raw_up = high · (1 + factor · ratio)
+/// raw_lo = low  · (1 − factor · ratio)
+/// upper  = SMA(raw_up, period)
+/// middle = SMA(close,  period)
+/// lower  = SMA(raw_lo, period)
+/// ```
+///
+/// Headley's reference parameters are `period = 20`, `factor = 0.001` for
+/// intraday equity markets — the geometric `ratio` term tends to scale on
+/// fractional moves, so the literal `factor` is small. The bands compress in
+/// quiet markets and flare on impulsive bars, making them a momentum-biased
+/// alternative to the volatility-driven Bollinger or Keltner envelopes.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AccelerationBands, Candle, Indicator};
+///
+/// let mut indicator = AccelerationBands::new(20, 0.001).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     let base = 100.0 + f64::from(i);
+///     let candle =
+///         Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 10.0, i64::from(i)).unwrap();
+///     last = indicator.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct AccelerationBands {
+    upper_sma: Sma,
+    middle_sma: Sma,
+    lower_sma: Sma,
+    factor: f64,
+    period: usize,
+}
+
+impl AccelerationBands {
+    /// Construct a new Acceleration Bands indicator.
+    ///
+    /// # Errors
+    /// Returns [`Error::PeriodZero`] if `period == 0` and
+    /// [`Error::NonPositiveMultiplier`] if `factor` is not strictly positive
+    /// and finite.
+    pub fn new(period: usize, factor: f64) -> Result<Self> {
+        if !factor.is_finite() || factor <= 0.0 {
+            return Err(Error::NonPositiveMultiplier);
+        }
+        Ok(Self {
+            upper_sma: Sma::new(period)?,
+            middle_sma: Sma::new(period)?,
+            lower_sma: Sma::new(period)?,
+            factor,
+            period,
+        })
+    }
+
+    /// Headley's classic configuration: `period = 20`, `factor = 0.001`.
+    pub fn classic() -> Self {
+        Self::new(20, 0.001).expect("classic Acceleration Bands parameters are valid")
+    }
+
+    /// Configured `(period, factor)`.
+    pub const fn parameters(&self) -> (usize, f64) {
+        (self.period, self.factor)
+    }
+}
+
+impl Indicator for AccelerationBands {
+    type Input = Candle;
+    type Output = AccelerationBandsOutput;
+
+    fn update(&mut self, candle: Candle) -> Option<AccelerationBandsOutput> {
+        // (high + low) == 0 is geometrically impossible for valid OHLC
+        // (high >= low and a zero-sum requires both equal to 0, which would
+        // make the bar degenerate). Guard anyway so a hypothetical zero-price
+        // bar collapses the ratio to zero rather than emitting NaN.
+        let sum_hl = candle.high + candle.low;
+        let ratio = if sum_hl == 0.0 {
+            0.0
+        } else {
+            (candle.high - candle.low) / sum_hl
+        };
+        let raw_up = candle.high * self.factor.mul_add(ratio, 1.0);
+        let raw_lo = candle.low * (-self.factor).mul_add(ratio, 1.0);
+
+        // Feed all three SMAs unconditionally so they warm up in lock-step.
+        let upper = self.upper_sma.update(raw_up);
+        let middle = self.middle_sma.update(candle.close);
+        let lower = self.lower_sma.update(raw_lo);
+        let (upper, middle, lower) = (upper?, middle?, lower?);
+        Some(AccelerationBandsOutput {
+            upper,
+            middle,
+            lower,
+        })
+    }
+
+    fn reset(&mut self) {
+        self.upper_sma.reset();
+        self.middle_sma.reset();
+        self.lower_sma.reset();
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.middle_sma.is_ready()
+    }
+
+    fn name(&self) -> &'static str {
+        "AccelerationBands"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn c(h: f64, l: f64, cl: f64) -> Candle {
+        Candle::new(cl, h, l, cl, 1.0, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(
+            AccelerationBands::new(0, 0.001),
+            Err(Error::PeriodZero)
+        ));
+    }
+
+    #[test]
+    fn rejects_non_positive_factor() {
+        assert!(matches!(
+            AccelerationBands::new(20, 0.0),
+            Err(Error::NonPositiveMultiplier)
+        ));
+        assert!(matches!(
+            AccelerationBands::new(20, -1.0),
+            Err(Error::NonPositiveMultiplier)
+        ));
+        assert!(matches!(
+            AccelerationBands::new(20, f64::NAN),
+            Err(Error::NonPositiveMultiplier)
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let ab = AccelerationBands::classic();
+        let (p, f) = ab.parameters();
+        assert_eq!(p, 20);
+        assert_relative_eq!(f, 0.001, epsilon = 1e-12);
+        assert_eq!(ab.warmup_period(), 20);
+        assert_eq!(ab.name(), "AccelerationBands");
+    }
+
+    #[test]
+    fn flat_market_collapses_to_constant() {
+        // high == low so the ratio term is zero; all three SMAs converge to
+        // the same constant.
+        let candles: Vec<Candle> = (0..30).map(|_| c(10.0, 10.0, 10.0)).collect();
+        let mut ab = AccelerationBands::new(5, 0.5).unwrap();
+        let last = ab.batch(&candles).into_iter().flatten().last().unwrap();
+        assert_relative_eq!(last.middle, 10.0, epsilon = 1e-9);
+        assert_relative_eq!(last.upper, 10.0, epsilon = 1e-9);
+        assert_relative_eq!(last.lower, 10.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn warmup_returns_none() {
+        let mut ab = AccelerationBands::new(5, 0.001).unwrap();
+        for i in 0..4 {
+            let base = 100.0 + f64::from(i);
+            assert!(ab.update(c(base + 1.0, base - 1.0, base)).is_none());
+        }
+        assert!(ab.update(c(105.0, 103.0, 104.0)).is_some());
+    }
+
+    #[test]
+    fn upper_above_middle_above_lower() {
+        let candles: Vec<Candle> = (0..50)
+            .map(|i| {
+                let m = 100.0 + (f64::from(i) * 0.2).sin() * 5.0;
+                c(m + 1.0, m - 1.0, m)
+            })
+            .collect();
+        let mut ab = AccelerationBands::new(20, 0.5).unwrap();
+        for o in ab.batch(&candles).into_iter().flatten() {
+            assert!(o.upper >= o.middle, "{} < {}", o.upper, o.middle);
+            assert!(o.middle >= o.lower, "{} < {}", o.middle, o.lower);
+        }
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| c(f64::from(i) + 2.0, f64::from(i), f64::from(i) + 1.0))
+            .collect();
+        let mut a = AccelerationBands::new(10, 0.5).unwrap();
+        let mut b = AccelerationBands::new(10, 0.5).unwrap();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let candles: Vec<Candle> = (0..10)
+            .map(|i| c(f64::from(i) + 2.0, f64::from(i), f64::from(i) + 1.0))
+            .collect();
+        let mut ab = AccelerationBands::new(5, 0.5).unwrap();
+        ab.batch(&candles);
+        assert!(ab.is_ready());
+        ab.reset();
+        assert!(!ab.is_ready());
+        assert_eq!(ab.update(candles[0]), None);
+    }
+
+    #[test]
+    fn zero_price_candle_collapses_ratio_to_zero() {
+        // `high + low == 0` is geometrically only reachable with a fully-zero
+        // bar (high >= low and both non-negative for a real market, but
+        // `Candle::new` accepts the degenerate `(0, 0, 0, 0)` case). The
+        // ratio guard must fire and the bands all collapse to zero.
+        let zero = Candle::new(0.0, 0.0, 0.0, 0.0, 1.0, 0).unwrap();
+        let mut ab = AccelerationBands::new(1, 0.5).unwrap();
+        let v = ab.update(zero).unwrap();
+        assert_relative_eq!(v.upper, 0.0, epsilon = 1e-12);
+        assert_relative_eq!(v.middle, 0.0, epsilon = 1e-12);
+        assert_relative_eq!(v.lower, 0.0, epsilon = 1e-12);
+    }
+
+    /// Hand-computed reference. Single bar with `high = 12`, `low = 8`,
+    /// `close = 10`, `factor = 0.5`, `period = 1`.
+    /// `ratio  = (12 − 8) / (12 + 8) = 0.2`
+    /// `raw_up = 12 · (1 + 0.5 · 0.2) = 12 · 1.1 = 13.2`
+    /// `raw_lo = 8  · (1 − 0.5 · 0.2) = 8  · 0.9 = 7.2`
+    /// `middle = SMA(close, 1) = 10`
+    #[test]
+    fn reference_value_single_bar() {
+        let mut ab = AccelerationBands::new(1, 0.5).unwrap();
+        let v = ab.update(c(12.0, 8.0, 10.0)).unwrap();
+        assert_relative_eq!(v.upper, 13.2, epsilon = 1e-12);
+        assert_relative_eq!(v.middle, 10.0, epsilon = 1e-12);
+        assert_relative_eq!(v.lower, 7.2, epsilon = 1e-12);
+    }
+}

crates/wickra-core/src/indicators/accelerator_oscillator.rs

@@ -165,6 +165,16 @@ mod tests {
         assert!(AcceleratorOscillator::new(34, 5, 5).is_err());
     }
 
+    /// Cover the const accessor `params` (69-71) and the Indicator-impl
+    /// `name` body (99-101). Existing tests inspect numeric output but
+    /// never query the metadata.
+    #[test]
+    fn accessors_and_metadata() {
+        let ac = AcceleratorOscillator::classic();
+        assert_eq!(ac.params(), (5, 34, 5));
+        assert_eq!(ac.name(), "AcceleratorOscillator");
+    }
+
     #[test]
     fn reset_clears_state() {
         let candles: Vec<Candle> = (0..60).map(|i| c(11.0, 9.0, 10.0, i)).collect();

crates/wickra-core/src/indicators/ad_oscillator.rs

@@ -0,0 +1,220 @@
+//! Williams Accumulation/Distribution.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Larry Williams' Accumulation/Distribution — a cumulative volume-less price
+/// flow that classifies each bar as accumulation or distribution based on its
+/// close relative to the previous close, then sums the directional component.
+///
+/// Williams' definition (1972) uses a *true* high/low that includes the prior
+/// close as an anchor — the same idea that motivates true range:
+///
+/// ```text
+/// TR_h_t = max(close_{t−1}, high_t)
+/// TR_l_t = min(close_{t−1}, low_t)
+/// AD_t   = AD_{t−1} + (close_t − TR_l_t)   if close_t > close_{t−1}   (accumulation)
+/// AD_t   = AD_{t−1} + (close_t − TR_h_t)   if close_t < close_{t−1}   (distribution)
+/// AD_t   = AD_{t−1}                        if close_t == close_{t−1}  (no change)
+/// ```
+///
+/// Unlike Chaikin's Accumulation/Distribution Line, the Williams A/D ignores
+/// volume entirely — Williams argued that the relative position of the close
+/// already encodes the day's "true" buying or selling pressure. The series is
+/// unbounded and used primarily for divergence analysis. The first candle only
+/// seeds the previous close; the first emission lands at bar 2.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, AdOscillator};
+///
+/// let mut indicator = AdOscillator::new();
+/// let mut last = None;
+/// for i in 0..80 {
+///     let base = 100.0 + f64::from(i);
+///     let candle =
+///         Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 10.0, i64::from(i)).unwrap();
+///     last = indicator.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AdOscillator {
+    prev_close: Option<f64>,
+    total: f64,
+    has_emitted: bool,
+}
+
+impl AdOscillator {
+    /// Construct a new Williams A/D starting at zero.
+    pub const fn new() -> Self {
+        Self {
+            prev_close: None,
+            total: 0.0,
+            has_emitted: false,
+        }
+    }
+
+    /// Current cumulative value if at least one emission has happened.
+    pub const fn value(&self) -> Option<f64> {
+        if self.has_emitted {
+            Some(self.total)
+        } else {
+            None
+        }
+    }
+}
+
+impl Indicator for AdOscillator {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        let Some(prev) = self.prev_close else {
+            // The first bar only establishes the previous close anchor.
+            self.prev_close = Some(candle.close);
+            return None;
+        };
+        let delta = if candle.close > prev {
+            // Accumulation: distance from the true low.
+            let tr_l = prev.min(candle.low);
+            candle.close - tr_l
+        } else if candle.close < prev {
+            // Distribution: distance from the true high (negative).
+            let tr_h = prev.max(candle.high);
+            candle.close - tr_h
+        } else {
+            // Unchanged close contributes nothing.
+            0.0
+        };
+        self.total += delta;
+        self.prev_close = Some(candle.close);
+        self.has_emitted = true;
+        Some(self.total)
+    }
+
+    fn reset(&mut self) {
+        self.prev_close = None;
+        self.total = 0.0;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        // One seed bar; the second bar is the first emission.
+        2
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "WilliamsAD"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn c(open: f64, high: f64, low: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, 100.0, ts).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let ad = AdOscillator::new();
+        assert_eq!(ad.name(), "WilliamsAD");
+        assert_eq!(ad.warmup_period(), 2);
+        assert_eq!(ad.value(), None);
+    }
+
+    #[test]
+    fn value_returns_total_after_first_emission() {
+        let mut ad = AdOscillator::new();
+        ad.update(c(10.0, 11.0, 9.0, 10.0, 0));
+        let v = ad.update(c(11.0, 13.0, 8.0, 12.0, 1)).unwrap();
+        assert_relative_eq!(ad.value().unwrap(), v, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn first_bar_only_seeds() {
+        let mut ad = AdOscillator::new();
+        assert_eq!(ad.update(c(10.0, 11.0, 9.0, 10.0, 0)), None);
+        assert!(!ad.is_ready());
+    }
+
+    #[test]
+    fn accumulation_adds_distance_from_true_low() {
+        // prev close = 10, today low = 8, today close = 12 (up day).
+        //   TR_l = min(10, 8) = 8, delta = 12 - 8 = 4. AD = 0 + 4 = 4.
+        let mut ad = AdOscillator::new();
+        ad.update(c(10.0, 11.0, 9.0, 10.0, 0));
+        let v = ad.update(c(11.0, 13.0, 8.0, 12.0, 1)).unwrap();
+        assert_relative_eq!(v, 4.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn distribution_adds_distance_from_true_high() {
+        // prev close = 10, today high = 11, today close = 7 (down day).
+        //   TR_h = max(10, 11) = 11, delta = 7 - 11 = -4. AD = -4.
+        let mut ad = AdOscillator::new();
+        ad.update(c(10.0, 11.0, 9.0, 10.0, 0));
+        let v = ad.update(c(10.0, 11.0, 7.0, 7.0, 1)).unwrap();
+        assert_relative_eq!(v, -4.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn unchanged_close_keeps_total() {
+        // close equals prev close -> no contribution.
+        let mut ad = AdOscillator::new();
+        ad.update(c(10.0, 11.0, 9.0, 10.0, 0));
+        let v = ad.update(c(10.0, 12.0, 8.0, 10.0, 1)).unwrap();
+        assert_relative_eq!(v, 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn constant_series_yields_zero() {
+        // Every close equals the previous -> AD stays at zero forever.
+        let candles: Vec<Candle> = (0..40).map(|i| c(10.0, 11.0, 9.0, 10.0, i)).collect();
+        let mut ad = AdOscillator::new();
+        for v in ad.batch(&candles).into_iter().flatten() {
+            assert_relative_eq!(v, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..80i64)
+            .map(|i| {
+                let f = i as f64;
+                let mid = 100.0 + (f * 0.3).sin() * 5.0;
+                c(mid, mid + 2.0, mid - 2.0, mid + 0.5, i)
+            })
+            .collect();
+        let mut a = AdOscillator::new();
+        let mut b = AdOscillator::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut ad = AdOscillator::new();
+        ad.batch(&[
+            c(10.0, 11.0, 9.0, 10.0, 0),
+            c(10.0, 12.0, 9.0, 11.0, 1),
+            c(11.0, 13.0, 10.0, 12.0, 2),
+        ]);
+        assert!(ad.is_ready());
+        ad.reset();
+        assert!(!ad.is_ready());
+        assert_eq!(ad.value(), None);
+        assert_eq!(ad.update(c(10.0, 11.0, 9.0, 10.0, 3)), None);
+    }
+}

crates/wickra-core/src/indicators/adaptive_cycle.rs

@@ -0,0 +1,143 @@
+//! Ehlers Adaptive Cycle period estimator (for adaptive oscillators).
+
+use crate::indicators::hilbert_dominant_cycle::HilbertDominantCycle;
+use crate::traits::Indicator;
+
+/// Ehlers' Adaptive Cycle Indicator.
+///
+/// Returns half the current dominant cycle period — the "best" lookback for
+/// downstream oscillators like an adaptive RSI or adaptive Stochastic, per
+/// Ehlers' *Cycle Analytics for Traders* (2013, ch. 11). Halving accounts for
+/// the fact that an oscillator over a half-cycle captures the full peak-to-
+/// trough swing without aliasing.
+///
+/// The output is rounded to an integer-valued `f64` and clamped to `[3, 25]`,
+/// matching the typical operating range of period-adaptive oscillators.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Indicator, AdaptiveCycle};
+///
+/// let mut ac = AdaptiveCycle::new();
+/// let mut last = None;
+/// for i in 0..200 {
+///     last = ac.update(100.0 + (f64::from(i) * 0.4).sin() * 5.0);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AdaptiveCycle {
+    cycle: HilbertDominantCycle,
+    last_value: Option<f64>,
+}
+
+impl AdaptiveCycle {
+    /// Construct a new adaptive cycle estimator.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Current adaptive period if available.
+    pub const fn value(&self) -> Option<f64> {
+        self.last_value
+    }
+}
+
+impl Indicator for AdaptiveCycle {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, input: f64) -> Option<f64> {
+        let period = self.cycle.update(input)?;
+        let half = (period * 0.5).round().clamp(3.0, 25.0);
+        self.last_value = Some(half);
+        Some(half)
+    }
+
+    fn reset(&mut self) {
+        self.cycle.reset();
+        self.last_value = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.cycle.warmup_period()
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last_value.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "AdaptiveCycle"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    #[test]
+    fn accessors_and_metadata() {
+        let mut ac = AdaptiveCycle::new();
+        assert_eq!(ac.warmup_period(), 50);
+        assert_eq!(ac.name(), "AdaptiveCycle");
+        assert!(!ac.is_ready());
+        assert!(ac.value().is_none());
+        let prices: Vec<f64> = (0..120)
+            .map(|i| 100.0 + (f64::from(i) * 0.4).sin() * 5.0)
+            .collect();
+        ac.batch(&prices);
+        assert!(ac.is_ready());
+        assert!(ac.value().is_some());
+    }
+
+    #[test]
+    fn output_within_clamp_band() {
+        let prices: Vec<f64> = (0..200)
+            .map(|i| 100.0 + (f64::from(i) * 0.5).sin() * 5.0)
+            .collect();
+        let mut ac = AdaptiveCycle::new();
+        for v in ac.batch(&prices).into_iter().flatten() {
+            assert!((3.0..=25.0).contains(&v), "period {v} out of band");
+            assert_eq!(v, v.round(), "expected integer-valued output");
+        }
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (0..200)
+            .map(|i| 100.0 + (f64::from(i) * 0.3).sin() * 5.0)
+            .collect();
+        let mut a = AdaptiveCycle::new();
+        let mut b = AdaptiveCycle::new();
+        let batch = a.batch(&prices);
+        let streamed: Vec<_> = prices.iter().map(|p| b.update(*p)).collect();
+        assert_eq!(batch, streamed);
+    }
+
+    #[test]
+    fn ignores_non_finite_input() {
+        let mut ac = AdaptiveCycle::new();
+        let prices: Vec<f64> = (0..120)
+            .map(|i| 100.0 + (f64::from(i) * 0.4).sin() * 5.0)
+            .collect();
+        ac.batch(&prices);
+        let before = ac.value();
+        assert!(before.is_some());
+        assert_eq!(ac.update(f64::NAN), before);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut ac = AdaptiveCycle::new();
+        let prices: Vec<f64> = (0..120)
+            .map(|i| 100.0 + (f64::from(i) * 0.4).sin() * 5.0)
+            .collect();
+        ac.batch(&prices);
+        assert!(ac.is_ready());
+        ac.reset();
+        assert!(!ac.is_ready());
+    }
+}

crates/wickra-core/src/indicators/adl.rs

@@ -127,6 +127,14 @@ mod tests {
         assert!(adl.update(candle(8.0, 10.0, 8.0, 9.0, 50.0, 0)).is_some());
     }
 
+    /// Cover the Indicator-impl `name` body (94-96). The other accessors
+    /// are exercised by existing tests; `name` was never queried.
+    #[test]
+    fn accessors_and_metadata() {
+        let adl = Adl::new();
+        assert_eq!(adl.name(), "ADL");
+    }
+
     #[test]
     fn close_at_high_accumulates_full_volume() {
         // Every bar closes at its high: MFM = +1, so ADL grows by `volume`.

crates/wickra-core/src/indicators/adx.rs

@@ -269,6 +269,37 @@ mod tests {
         assert!(Adx::new(0).is_err());
     }
 
+    /// Cover the const accessor `period` (lines 89-91) and the Indicator-impl
+    /// `warmup_period` (199-201) + `name` (207-209). None of the trend tests
+    /// inspect these metadata methods.
+    #[test]
+    fn accessors_and_metadata() {
+        let adx = Adx::new(14).unwrap();
+        assert_eq!(adx.period(), 14);
+        assert_eq!(adx.warmup_period(), 28);
+        assert_eq!(adx.name(), "ADX");
+    }
+
+    /// Cover the `tr_v == 0.0` defensive branches in `update` (lines 142,
+    /// 147) — feeding a stream of perfectly flat candles (H == L == close
+    /// every bar) gives true-range 0 each step, so the smoothed `tr_smooth`
+    /// stays at 0.0 and the `plus_di` / `minus_di` divisions would otherwise
+    /// blow up. The indicator must emit zeros (DX denominator is also 0).
+    #[test]
+    fn zero_true_range_yields_zero_di_and_zero_adx() {
+        let candles: Vec<Candle> = (0..30).map(|_| c(10.0, 10.0, 10.0)).collect();
+        let mut adx = Adx::new(5).unwrap();
+        let last = adx
+            .batch(&candles)
+            .into_iter()
+            .flatten()
+            .last()
+            .expect("ADX emits after 2 * period candles");
+        assert_eq!(last.plus_di, 0.0);
+        assert_eq!(last.minus_di, 0.0);
+        assert_eq!(last.adx, 0.0);
+    }
+
     #[test]
     fn batch_equals_streaming() {
         let candles: Vec<Candle> = (0..60)

crates/wickra-core/src/indicators/adxr.rs

@@ -0,0 +1,246 @@
+//! Average Directional Movement Index Rating (ADXR).
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::indicators::adx::Adx;
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Wilder's Average Directional Movement Index Rating.
+///
+/// `ADXR` smooths the [`Adx`] line by averaging its current value with the value
+/// it had `period` bars ago:
+///
+/// ```text
+/// ADXR_t = (ADX_t + ADX_{t - (period - 1)}) / 2
+/// ```
+///
+/// The lookback length is the same `period` that feeds the underlying ADX.
+/// Wilder introduced ADXR alongside ADX in *New Concepts in Technical Trading
+/// Systems* (1978) as a more stable directional-strength reading: because the
+/// older `ADX` is `period - 1` bars stale, ADXR responds more slowly than ADX
+/// and is used to compare trend-strength between different instruments.
+///
+/// The first complete `ADXR` is emitted after `3 * period - 1` candles
+/// (`2 * period` to seed the ADX plus another `period - 1` to fill the
+/// lookback ring).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Adxr, Candle, Indicator};
+///
+/// let mut indicator = Adxr::new(5).unwrap();
+/// let mut last = None;
+/// for i in 0..80 {
+///     let base = 100.0 + f64::from(i);
+///     let candle =
+///         Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 10.0, i64::from(i)).unwrap();
+///     last = indicator.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct Adxr {
+    period: usize,
+    adx: Adx,
+    /// Ring buffer of the most recent `period` `ADX` values; the front is the
+    /// oldest, the back is the newest. ADXR is `(back + front) / 2` once the
+    /// ring is full.
+    window: VecDeque<f64>,
+    last: Option<f64>,
+}
+
+impl Adxr {
+    /// Construct a new ADXR with the given Wilder smoothing period.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `period == 0`.
+    pub fn new(period: usize) -> Result<Self> {
+        if period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            period,
+            adx: Adx::new(period)?,
+            window: VecDeque::with_capacity(period),
+            last: None,
+        })
+    }
+
+    /// Configured period.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+
+    /// Current value if available.
+    pub const fn value(&self) -> Option<f64> {
+        self.last
+    }
+}
+
+impl Indicator for Adxr {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        let adx_value = self.adx.update(candle)?.adx;
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(adx_value);
+        if self.window.len() < self.period {
+            return None;
+        }
+        let oldest = *self.window.front().expect("ring is full");
+        let adxr = f64::midpoint(adx_value, oldest);
+        self.last = Some(adxr);
+        Some(adxr)
+    }
+
+    fn reset(&mut self) {
+        self.adx.reset();
+        self.window.clear();
+        self.last = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        // ADX warmup is `2 * period` and emits one `ADX` per subsequent candle;
+        // the ADXR ring then needs `period - 1` more candles to fill, so the
+        // first ADXR lands at `2 * period + (period - 1) = 3 * period - 1`.
+        3 * self.period - 1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "ADXR"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn candle(h: f64, l: f64, c: f64, ts: i64) -> Candle {
+        Candle::new(c, h, l, c, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(Adxr::new(0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let mut a = Adxr::new(14).unwrap();
+        assert_eq!(a.period(), 14);
+        assert_eq!(a.warmup_period(), 41);
+        assert_eq!(a.name(), "ADXR");
+        assert!(a.value().is_none());
+        // Drive past warmup.
+        for i in 0..50_i64 {
+            let base = 100.0 + (i as f64) * 2.0;
+            a.update(candle(base + 1.0, base - 0.5, base + 0.5, i));
+        }
+        assert!(a.value().is_some());
+    }
+
+    #[test]
+    fn pure_uptrend_yields_finite_positive_adxr() {
+        let candles: Vec<Candle> = (0..80_i64)
+            .map(|i| {
+                let base = 100.0 + (i as f64) * 2.0;
+                candle(base + 1.0, base - 0.5, base + 0.5, i)
+            })
+            .collect();
+        let mut a = Adxr::new(14).unwrap();
+        let last = a.batch(&candles).into_iter().flatten().last().unwrap();
+        assert!(last > 0.0 && last <= 100.0 + 1e-9);
+    }
+
+    #[test]
+    fn constant_series_yields_zero_adxr() {
+        let candles: Vec<Candle> = (0..50_i64).map(|i| candle(10.0, 10.0, 10.0, i)).collect();
+        let mut a = Adxr::new(5).unwrap();
+        let last = a.batch(&candles).into_iter().flatten().last().unwrap();
+        assert_eq!(last, 0.0);
+    }
+
+    #[test]
+    fn first_emission_at_warmup_period() {
+        let candles: Vec<Candle> = (0..80_i64)
+            .map(|i| {
+                let p = 100.0 + ((i as f64) * 0.3).sin() * 5.0;
+                candle(p + 1.0, p - 1.0, p, i)
+            })
+            .collect();
+        let mut a = Adxr::new(5).unwrap();
+        let out = a.batch(&candles);
+        let warmup = 3 * 5 - 1; // 14
+        for v in out.iter().take(warmup - 1) {
+            assert!(v.is_none());
+        }
+        assert!(out[warmup - 1].is_some());
+    }
+
+    #[test]
+    fn reference_value_against_explicit_adx_average() {
+        // The first ADXR(p) emits at index `3p - 2` (0-based), and equals
+        // (ADX[index] + ADX[index - (p - 1)]) / 2. Verify against a separate
+        // ADX run.
+        let candles: Vec<Candle> = (0..60_i64)
+            .map(|i| {
+                let p = 100.0 + ((i as f64) * 0.2).sin() * 6.0;
+                candle(p + 1.5, p - 1.5, p, i)
+            })
+            .collect();
+        let period = 5;
+        let mut adx = Adx::new(period).unwrap();
+        let adx_out: Vec<_> = adx
+            .batch(&candles)
+            .into_iter()
+            .map(|o| o.map(|x| x.adx))
+            .collect();
+        let mut adxr = Adxr::new(period).unwrap();
+        let adxr_out = adxr.batch(&candles);
+        // First ADXR index (0-based) = 3 * period - 2 = 13.
+        let first = 3 * period - 2;
+        let prev = first - (period - 1);
+        let expected = f64::midpoint(adx_out[first].unwrap(), adx_out[prev].unwrap());
+        assert_relative_eq!(adxr_out[first].unwrap(), expected, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..60_i64)
+            .map(|i| {
+                let p = 100.0 + ((i as f64) * 0.25).sin() * 5.0;
+                candle(p + 1.0, p - 1.0, p, i)
+            })
+            .collect();
+        let mut a = Adxr::new(7).unwrap();
+        let mut b = Adxr::new(7).unwrap();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|c| b.update(*c)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let candles: Vec<Candle> = (0..60_i64).map(|i| candle(11.0, 9.0, 10.0, i)).collect();
+        let mut a = Adxr::new(5).unwrap();
+        a.batch(&candles);
+        assert!(a.is_ready());
+        a.reset();
+        assert!(!a.is_ready());
+        assert_eq!(a.update(candles[0]), None);
+    }
+}

crates/wickra-core/src/indicators/alligator.rs

@@ -0,0 +1,223 @@
+//! Bill Williams' Alligator indicator.
+
+use crate::error::{Error, Result};
+use crate::indicators::smma::Smma;
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Alligator output: three smoothed moving averages of the median price
+/// `(high + low) / 2`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct AlligatorOutput {
+    /// `Jaw` — the slowest line (default period 13).
+    pub jaw: f64,
+    /// `Teeth` — the middle line (default period 8).
+    pub teeth: f64,
+    /// `Lips` — the fastest line (default period 5).
+    pub lips: f64,
+}
+
+/// Bill Williams' Alligator: three `SMMA`s of the median price `(high + low) / 2`
+/// with different periods. Classic parameters are `(jaw = 13, teeth = 8, lips = 5)`.
+///
+/// The original chart variant additionally shifts each line forward by a fixed
+/// number of bars for display (Jaw +8, Teeth +5, Lips +3). Wickra publishes the
+/// *unshifted* `SMMA` values — the consumer can apply the visual shift on the
+/// chart side. The indicator emits values once all three `SMMA`s have warmed
+/// up, i.e. after `max(jaw, teeth, lips) = jaw` candles.
+///
+/// Reference: Bill Williams, *Trading Chaos*, 1995.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Alligator, Candle, Indicator};
+///
+/// let mut alligator = Alligator::classic();
+/// let mut last = None;
+/// for i in 0..40 {
+///     let base = 100.0 + f64::from(i);
+///     let candle =
+///         Candle::new(base, base + 1.0, base - 1.0, base, 1.0, i64::from(i)).unwrap();
+///     last = alligator.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct Alligator {
+    jaw_period: usize,
+    teeth_period: usize,
+    lips_period: usize,
+    jaw: Smma,
+    teeth: Smma,
+    lips: Smma,
+}
+
+impl Alligator {
+    /// # Errors
+    /// Returns [`Error::PeriodZero`] if any period is zero.
+    pub fn new(jaw_period: usize, teeth_period: usize, lips_period: usize) -> Result<Self> {
+        if jaw_period == 0 || teeth_period == 0 || lips_period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            jaw_period,
+            teeth_period,
+            lips_period,
+            jaw: Smma::new(jaw_period)?,
+            teeth: Smma::new(teeth_period)?,
+            lips: Smma::new(lips_period)?,
+        })
+    }
+
+    /// Bill Williams' classic parameters: `(jaw = 13, teeth = 8, lips = 5)`.
+    pub fn classic() -> Self {
+        Self::new(13, 8, 5).expect("classic Alligator parameters are valid")
+    }
+
+    /// Configured `(jaw_period, teeth_period, lips_period)`.
+    pub const fn periods(&self) -> (usize, usize, usize) {
+        (self.jaw_period, self.teeth_period, self.lips_period)
+    }
+}
+
+impl Indicator for Alligator {
+    type Input = Candle;
+    type Output = AlligatorOutput;
+
+    fn update(&mut self, candle: Candle) -> Option<AlligatorOutput> {
+        let median = f64::midpoint(candle.high, candle.low);
+        // Feed every `SMMA` on every bar so they warm up in parallel; gating
+        // the longer lines behind the shorter ones would starve them during
+        // their own warmup.
+        let lips = self.lips.update(median);
+        let teeth = self.teeth.update(median);
+        let jaw = self.jaw.update(median);
+        Some(AlligatorOutput {
+            jaw: jaw?,
+            teeth: teeth?,
+            lips: lips?,
+        })
+    }
+
+    fn reset(&mut self) {
+        self.jaw.reset();
+        self.teeth.reset();
+        self.lips.reset();
+    }
+
+    fn warmup_period(&self) -> usize {
+        // All three SMMAs run on every bar, so readiness is gated by the
+        // longest period — the Jaw with the default parameters.
+        self.jaw_period.max(self.teeth_period).max(self.lips_period)
+    }
+
+    fn is_ready(&self) -> bool {
+        self.jaw.is_ready() && self.teeth.is_ready() && self.lips.is_ready()
+    }
+
+    fn name(&self) -> &'static str {
+        "Alligator"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn candle(high: f64, low: f64, ts: i64) -> Candle {
+        let close = f64::midpoint(high, low);
+        Candle::new(close, high, low, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(Alligator::new(0, 8, 5), Err(Error::PeriodZero)));
+        assert!(matches!(Alligator::new(13, 0, 5), Err(Error::PeriodZero)));
+        assert!(matches!(Alligator::new(13, 8, 0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let alligator = Alligator::classic();
+        assert_eq!(alligator.periods(), (13, 8, 5));
+        assert_eq!(alligator.warmup_period(), 13);
+        assert_eq!(alligator.name(), "Alligator");
+    }
+
+    #[test]
+    fn constant_series_yields_the_constant() {
+        // Median price = 10 for every bar, so each SMMA seeds to 10 and stays.
+        let mut alligator = Alligator::classic();
+        let candles: Vec<Candle> = (0..40).map(|i| candle(11.0, 9.0, i)).collect();
+        let out = alligator.batch(&candles);
+        for v in out.iter().skip(12).flatten() {
+            assert_relative_eq!(v.jaw, 10.0, epsilon = 1e-12);
+            assert_relative_eq!(v.teeth, 10.0, epsilon = 1e-12);
+            assert_relative_eq!(v.lips, 10.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn warmup_emits_first_value_at_longest_period() {
+        let mut alligator = Alligator::new(5, 3, 2).unwrap();
+        let candles: Vec<Candle> = (0..6).map(|i| candle(11.0, 9.0, i)).collect();
+        let out = alligator.batch(&candles);
+        for v in out.iter().take(4) {
+            assert!(v.is_none());
+        }
+        assert!(out[4].is_some());
+    }
+
+    #[test]
+    fn pure_uptrend_ordering() {
+        // On a clean uptrend the fastest line (Lips, smallest SMMA) leads the
+        // slowest line (Jaw) — lips > teeth > jaw at the latest bar.
+        let mut alligator = Alligator::classic();
+        let candles: Vec<Candle> = (0_i64..80)
+            .map(|i| candle(10.0 + i as f64, 9.0 + i as f64, i))
+            .collect();
+        let out = alligator.batch(&candles);
+        let last = out.last().unwrap().unwrap();
+        assert!(
+            last.lips > last.teeth,
+            "lips {} > teeth {}",
+            last.lips,
+            last.teeth
+        );
+        assert!(
+            last.teeth > last.jaw,
+            "teeth {} > jaw {}",
+            last.teeth,
+            last.jaw
+        );
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..80_i64)
+            .map(|i| {
+                let base = 100.0 + (i as f64 * 0.2).sin() * 5.0;
+                candle(base + 1.0, base - 1.0, i)
+            })
+            .collect();
+        let mut a = Alligator::classic();
+        let mut b = Alligator::classic();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|c| b.update(*c)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut alligator = Alligator::classic();
+        let candles: Vec<Candle> = (0..40).map(|i| candle(11.0, 9.0, i)).collect();
+        alligator.batch(&candles);
+        assert!(alligator.is_ready());
+        alligator.reset();
+        assert!(!alligator.is_ready());
+    }
+}

crates/wickra-core/src/indicators/alma.rs

@@ -0,0 +1,335 @@
+//! Arnaud Legoux Moving Average (ALMA).
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Arnaud Legoux Moving Average — a Gaussian-weighted moving average.
+///
+/// Each output is a weighted sum of the last `period` inputs:
+///
+/// ```text
+/// w[i] = exp(-(i - m)^2 / (2 * s^2))   for i in 0..period
+/// m    = offset * (period - 1)
+/// s    = period / sigma
+/// ALMA = sum(price[i] * w[i]) / sum(w[i])
+/// ```
+///
+/// The Gaussian is centred on the relative index `offset * (period - 1)`, so
+/// `offset = 0.85` puts the peak near the newest sample (responsive), while
+/// `offset = 0.5` centres the peak in the middle of the window (smooth).
+/// `sigma` controls how concentrated the Gaussian is: larger `sigma` ->
+/// narrower kernel, smaller `sigma` -> broader (closer to SMA).
+///
+/// Reference: Arnaud Legoux and Dimitrios Kouzis-Loukas, 2009.
+///
+/// # Defaults
+///
+/// The community-standard parameters are `period = 9`, `offset = 0.85`,
+/// `sigma = 6.0`. The first output lands after exactly `period` inputs.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Alma, Indicator};
+///
+/// let mut alma = Alma::new(9, 0.85, 6.0).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     last = alma.update(100.0 + f64::from(i));
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct Alma {
+    period: usize,
+    offset: f64,
+    sigma: f64,
+    /// Pre-computed, normalised weights (sum to 1). `weights[0]` is the oldest
+    /// sample in the window, `weights[period - 1]` the newest.
+    weights: Vec<f64>,
+    window: VecDeque<f64>,
+    current: Option<f64>,
+}
+
+impl Alma {
+    /// Construct a new ALMA with the given period, offset and sigma.
+    ///
+    /// # Errors
+    ///
+    /// - [`Error::PeriodZero`] if `period == 0`.
+    /// - [`Error::InvalidPeriod`] if `offset` is outside `[0.0, 1.0]` or
+    ///   `sigma <= 0.0` or either of `offset` / `sigma` is non-finite.
+    pub fn new(period: usize, offset: f64, sigma: f64) -> Result<Self> {
+        if period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        if !offset.is_finite() || !(0.0..=1.0).contains(&offset) {
+            return Err(Error::InvalidPeriod {
+                message: "ALMA offset must be a finite value in [0, 1]",
+            });
+        }
+        if !sigma.is_finite() || sigma <= 0.0 {
+            return Err(Error::InvalidPeriod {
+                message: "ALMA sigma must be a finite positive value",
+            });
+        }
+        let m = offset * (period as f64 - 1.0);
+        let s = period as f64 / sigma;
+        let denom = 2.0 * s * s;
+        // The raw Gaussian weights sum to a strictly positive value because
+        // every term is `exp(_) > 0`, so the normalisation below cannot divide
+        // by zero.
+        let mut raw: Vec<f64> = (0..period)
+            .map(|i| (-((i as f64 - m).powi(2)) / denom).exp())
+            .collect();
+        let sum: f64 = raw.iter().sum();
+        for w in &mut raw {
+            *w /= sum;
+        }
+        Ok(Self {
+            period,
+            offset,
+            sigma,
+            weights: raw,
+            window: VecDeque::with_capacity(period),
+            current: None,
+        })
+    }
+
+    /// Construct ALMA with the community-standard parameters
+    /// `(period = 9, offset = 0.85, sigma = 6.0)`.
+    pub fn classic() -> Self {
+        Self::new(9, 0.85, 6.0).expect("classic ALMA parameters are valid")
+    }
+
+    /// Configured period.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+
+    /// Configured offset.
+    pub const fn offset(&self) -> f64 {
+        self.offset
+    }
+
+    /// Configured sigma.
+    pub const fn sigma(&self) -> f64 {
+        self.sigma
+    }
+}
+
+impl Indicator for Alma {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, input: f64) -> Option<f64> {
+        if !input.is_finite() {
+            return self.current;
+        }
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(input);
+        if self.window.len() < self.period {
+            return None;
+        }
+        let mut acc = 0.0;
+        for (w, p) in self.weights.iter().zip(self.window.iter()) {
+            acc += w * p;
+        }
+        self.current = Some(acc);
+        Some(acc)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.current = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.current.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "ALMA"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(Alma::new(0, 0.85, 6.0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn rejects_invalid_offset() {
+        assert!(matches!(
+            Alma::new(9, -0.1, 6.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            Alma::new(9, 1.1, 6.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            Alma::new(9, f64::NAN, 6.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn rejects_invalid_sigma() {
+        assert!(matches!(
+            Alma::new(9, 0.85, 0.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            Alma::new(9, 0.85, -1.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            Alma::new(9, 0.85, f64::INFINITY),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let alma = Alma::new(9, 0.85, 6.0).unwrap();
+        assert_eq!(alma.period(), 9);
+        assert_eq!(alma.warmup_period(), 9);
+        assert_eq!(alma.name(), "ALMA");
+        assert!((alma.offset() - 0.85).abs() < 1e-12);
+        assert!((alma.sigma() - 6.0).abs() < 1e-12);
+        // Weights are normalised by construction.
+        let sum: f64 = alma.weights.iter().sum();
+        assert_relative_eq!(sum, 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn classic_factory() {
+        let a = Alma::classic();
+        assert_eq!(a.period(), 9);
+        assert!((a.offset() - 0.85).abs() < 1e-12);
+        assert!((a.sigma() - 6.0).abs() < 1e-12);
+    }
+
+    #[test]
+    fn constant_series_yields_the_constant() {
+        // Normalised weights sum to 1, so any constant is reproduced exactly.
+        let mut alma = Alma::new(9, 0.85, 6.0).unwrap();
+        let out = alma.batch(&[42.0_f64; 40]);
+        for v in out.iter().skip(8).flatten() {
+            assert_relative_eq!(*v, 42.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn warmup_emits_first_value_at_period() {
+        let mut alma = Alma::new(5, 0.85, 6.0).unwrap();
+        for i in 0..4 {
+            assert_eq!(alma.update(f64::from(i)), None);
+        }
+        assert!(alma.update(4.0).is_some());
+    }
+
+    #[test]
+    fn reference_value_period_3() {
+        // ALMA(period=3, offset=0.85, sigma=6) on [10, 20, 30].
+        // m = 0.85 * 2 = 1.7;  s = 3 / 6 = 0.5;  2*s^2 = 0.5.
+        // Independently compute the normalised Gaussian weights and the
+        // expected weighted sum, then check the indicator output matches.
+        // Computing the expectation here (rather than pinning a printed
+        // constant) keeps the test stable across libm `exp` implementations.
+        let mut alma = Alma::new(3, 0.85, 6.0).unwrap();
+        alma.update(10.0);
+        alma.update(20.0);
+        let v = alma.update(30.0).expect("ALMA emits after period");
+
+        let w0 = (-((0.0_f64 - 1.7).powi(2)) / 0.5).exp();
+        let w1 = (-((1.0_f64 - 1.7).powi(2)) / 0.5).exp();
+        let w2 = (-((2.0_f64 - 1.7).powi(2)) / 0.5).exp();
+        let s = w0 + w1 + w2;
+        let expected = (10.0 * w0 + 20.0 * w1 + 30.0 * w2) / s;
+
+        // The weighted sum is heavily skewed toward the newest sample so the
+        // output must sit close to but below the latest input (30).
+        assert!(v > 25.0 && v < 30.0, "ALMA(3) on [10,20,30] = {v}");
+        assert_relative_eq!(v, expected, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn offset_zero_centres_on_oldest_sample() {
+        // With offset = 0 the Gaussian peaks at index 0, so ALMA leans toward
+        // the oldest sample in the window and away from the newest.
+        let mut alma = Alma::new(5, 0.0, 6.0).unwrap();
+        let series: Vec<f64> = (1..=5).map(f64::from).collect();
+        let mut last = None;
+        for p in &series {
+            last = alma.update(*p);
+        }
+        let v = last.unwrap();
+        let mean = series.iter().sum::<f64>() / series.len() as f64;
+        // Oldest sample is 1.0, mean is 3.0; an offset-0 ALMA should sit
+        // strictly below the mean.
+        assert!(v < mean, "{v} should be less than {mean}");
+    }
+
+    #[test]
+    fn offset_one_centres_on_newest_sample() {
+        // Symmetric to the above: offset = 1 leans toward the newest sample.
+        let mut alma = Alma::new(5, 1.0, 6.0).unwrap();
+        let series: Vec<f64> = (1..=5).map(f64::from).collect();
+        let mut last = None;
+        for p in &series {
+            last = alma.update(*p);
+        }
+        let v = last.unwrap();
+        let mean = series.iter().sum::<f64>() / series.len() as f64;
+        assert!(v > mean, "{v} should exceed {mean}");
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (1..=100)
+            .map(|i| (f64::from(i) * 0.2).sin() * 5.0 + f64::from(i) * 0.1)
+            .collect();
+        let mut a = Alma::new(9, 0.85, 6.0).unwrap();
+        let mut b = Alma::new(9, 0.85, 6.0).unwrap();
+        assert_eq!(
+            a.batch(&prices),
+            prices.iter().map(|p| b.update(*p)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut alma = Alma::new(9, 0.85, 6.0).unwrap();
+        alma.batch(&(1..=40).map(f64::from).collect::<Vec<_>>());
+        assert!(alma.is_ready());
+        alma.reset();
+        assert!(!alma.is_ready());
+        assert_eq!(alma.update(1.0), None);
+    }
+
+    #[test]
+    fn ignores_non_finite_input() {
+        let mut alma = Alma::new(5, 0.85, 6.0).unwrap();
+        alma.batch(&(1..=5).map(f64::from).collect::<Vec<_>>());
+        let before = alma.update(6.0).unwrap();
+        // Non-finite inputs leave the window/current untouched.
+        assert_eq!(alma.update(f64::NAN), Some(before));
+        assert_eq!(alma.update(f64::INFINITY), Some(before));
+    }
+}

crates/wickra-core/src/indicators/alpha.rs

@@ -0,0 +1,220 @@
+//! Rolling Jensen's Alpha (CAPM).
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Rolling Jensen's Alpha.
+///
+/// Each `update` receives one `(asset_return, benchmark_return)` pair. Over
+/// the trailing window of `period` pairs:
+///
+/// ```text
+/// Beta  = cov(asset, bench) / var(bench)
+/// Alpha = mean(asset) − ( risk_free + Beta · (mean(bench) − risk_free) )
+/// ```
+///
+/// Alpha is the *risk-adjusted excess return* — the slice of the asset's
+/// performance that cannot be explained by simple exposure to the
+/// benchmark. A positive alpha indicates outperformance net of the market
+/// premium implied by the asset's beta; negative alpha is the opposite.
+///
+/// Population covariance and variance are used (matching common
+/// implementations in pandas-ta / quantstats); the rolling estimator stays
+/// unbiased in the steady state for fixed `period`.
+///
+/// If the benchmark is flat (`var(bench) = 0`) the indicator falls back to
+/// `alpha = mean(asset) − risk_free` — the asset's mean excess return, with
+/// no market-risk adjustment, since the regression slope is undefined.
+///
+/// Each `update` is O(1).
+#[derive(Debug, Clone)]
+pub struct Alpha {
+    period: usize,
+    risk_free: f64,
+    window: VecDeque<(f64, f64)>,
+    sum_a: f64,
+    sum_b: f64,
+    sum_bb: f64,
+    sum_ab: f64,
+}
+
+impl Alpha {
+    /// Construct a new rolling Alpha.
+    ///
+    /// # Errors
+    /// Returns [`Error::InvalidPeriod`] if `period < 2`.
+    pub fn new(period: usize, risk_free: f64) -> Result<Self> {
+        if period < 2 {
+            return Err(Error::InvalidPeriod {
+                message: "alpha needs period >= 2",
+            });
+        }
+        Ok(Self {
+            period,
+            risk_free,
+            window: VecDeque::with_capacity(period),
+            sum_a: 0.0,
+            sum_b: 0.0,
+            sum_bb: 0.0,
+            sum_ab: 0.0,
+        })
+    }
+
+    /// Configured window length.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+
+    /// Configured per-period risk-free rate.
+    pub const fn risk_free(&self) -> f64 {
+        self.risk_free
+    }
+}
+
+impl Indicator for Alpha {
+    type Input = (f64, f64);
+    type Output = f64;
+
+    fn update(&mut self, input: (f64, f64)) -> Option<f64> {
+        let (a, b) = input;
+        if !a.is_finite() || !b.is_finite() {
+            return None;
+        }
+        if self.window.len() == self.period {
+            let (oa, ob) = self.window.pop_front().expect("non-empty");
+            self.sum_a -= oa;
+            self.sum_b -= ob;
+            self.sum_bb -= ob * ob;
+            self.sum_ab -= oa * ob;
+        }
+        self.window.push_back((a, b));
+        self.sum_a += a;
+        self.sum_b += b;
+        self.sum_bb += b * b;
+        self.sum_ab += a * b;
+        if self.window.len() < self.period {
+            return None;
+        }
+        let n = self.period as f64;
+        let mean_a = self.sum_a / n;
+        let mean_b = self.sum_b / n;
+        let var_b = (self.sum_bb / n) - mean_b * mean_b;
+        if var_b <= 0.0 {
+            // Undefined beta: report unadjusted excess.
+            return Some(mean_a - self.risk_free);
+        }
+        let cov_ab = (self.sum_ab / n) - mean_a * mean_b;
+        let beta = cov_ab / var_b;
+        Some(mean_a - (self.risk_free + beta * (mean_b - self.risk_free)))
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.sum_a = 0.0;
+        self.sum_b = 0.0;
+        self.sum_bb = 0.0;
+        self.sum_ab = 0.0;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.window.len() == self.period
+    }
+
+    fn name(&self) -> &'static str {
+        "Alpha"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_period_less_than_two() {
+        assert!(matches!(
+            Alpha::new(1, 0.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let a = Alpha::new(20, 0.001).unwrap();
+        assert_eq!(a.period(), 20);
+        assert_relative_eq!(a.risk_free(), 0.001, epsilon = 1e-12);
+        assert_eq!(a.name(), "Alpha");
+        assert_eq!(a.warmup_period(), 20);
+    }
+
+    #[test]
+    fn capm_perfect_fit_yields_zero_alpha() {
+        // asset = 2 * bench - constant beta of 2, no alpha; with rf = 0 the
+        // CAPM-implied return matches the asset's mean perfectly.
+        let mut a = Alpha::new(20, 0.0).unwrap();
+        let inputs: Vec<(f64, f64)> = (1..=20)
+            .map(|i| (2.0 * f64::from(i) * 0.01, f64::from(i) * 0.01))
+            .collect();
+        let out = a.batch(&inputs);
+        assert_relative_eq!(out[19].unwrap(), 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn constant_alpha_offset_recovered() {
+        // asset = bench + 0.005 (additive alpha of 0.5%), beta == 1.
+        // Expected alpha = 0.005.
+        let mut a = Alpha::new(20, 0.0).unwrap();
+        let inputs: Vec<(f64, f64)> = (1..=20)
+            .map(|i| (f64::from(i) * 0.01 + 0.005, f64::from(i) * 0.01))
+            .collect();
+        let out = a.batch(&inputs);
+        assert_relative_eq!(out[19].unwrap(), 0.005, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn flat_benchmark_falls_back_to_excess_return() {
+        // Benchmark all 0 -> beta undefined -> alpha = mean_a - rf.
+        let mut a = Alpha::new(4, 0.001).unwrap();
+        let out = a.batch(&[(0.01, 0.0), (0.02, 0.0), (-0.01, 0.0), (0.04, 0.0)]);
+        let mean = (0.01 + 0.02 - 0.01 + 0.04) / 4.0;
+        assert_relative_eq!(out[3].unwrap(), mean - 0.001, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn ignores_non_finite_input() {
+        let mut a = Alpha::new(3, 0.0).unwrap();
+        assert_eq!(a.update((f64::NAN, 0.0)), None);
+        assert_eq!(a.update((0.0, f64::INFINITY)), None);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut a = Alpha::new(3, 0.0).unwrap();
+        a.batch(&[(0.01, 0.005), (0.02, 0.01), (-0.01, -0.005)]);
+        assert!(a.is_ready());
+        a.reset();
+        assert!(!a.is_ready());
+        assert_eq!(a.update((0.01, 0.005)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let inputs: Vec<(f64, f64)> = (0..50)
+            .map(|i| {
+                let b = (f64::from(i) * 0.2).sin() * 0.01;
+                (1.5 * b + 0.002, b)
+            })
+            .collect();
+        let batch = Alpha::new(10, 0.0).unwrap().batch(&inputs);
+        let mut s = Alpha::new(10, 0.0).unwrap();
+        let streamed: Vec<_> = inputs.iter().map(|x| s.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/indicators/anchored_vwap.rs

@@ -0,0 +1,207 @@
+//! Anchored Volume-Weighted Average Price.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Anchored VWAP — a cumulative VWAP whose accumulation begins at a
+/// user-chosen anchor bar rather than the session open.
+///
+/// ```text
+/// AVWAP_t = Σ_{i ≥ anchor} (typical_price_i · volume_i) / Σ_{i ≥ anchor} volume_i
+/// ```
+///
+/// The indicator emits `None` until the first anchored bar has been ingested.
+/// Calling [`AnchoredVwap::set_anchor`] re-anchors at the **next** bar that
+/// arrives, clearing the running sums; this is the conventional behaviour for
+/// "click to anchor" trader workflows where the anchor is set on the close of
+/// a swing point and the next bar starts the new accumulation. The cumulative
+/// total is unbounded; for finite-memory needs use [`crate::RollingVwap`].
+///
+/// Bars where the running volume is still zero (only happens if every anchored
+/// bar so far carried zero volume) return `None` to avoid a zero-division.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AnchoredVwap, Candle, Indicator};
+///
+/// let mut indicator = AnchoredVwap::new();
+/// let mut last = None;
+/// for i in 0..80 {
+///     let base = 100.0 + f64::from(i);
+///     let candle =
+///         Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 10.0, i64::from(i)).unwrap();
+///     // Re-anchor at bar 40 (e.g. a major swing low).
+///     if i == 40 {
+///         indicator.set_anchor();
+///     }
+///     last = indicator.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AnchoredVwap {
+    sum_pv: f64,
+    sum_v: f64,
+    has_emitted: bool,
+    pending_anchor: bool,
+}
+
+impl AnchoredVwap {
+    /// Construct a fresh Anchored VWAP. The first bar to arrive is the anchor.
+    pub const fn new() -> Self {
+        Self {
+            sum_pv: 0.0,
+            sum_v: 0.0,
+            has_emitted: false,
+            pending_anchor: false,
+        }
+    }
+
+    /// Mark a re-anchor: the **next** [`Indicator::update`] call clears the
+    /// running sums before adding its own contribution, effectively starting a
+    /// fresh anchored window.
+    pub fn set_anchor(&mut self) {
+        self.pending_anchor = true;
+    }
+
+    /// Current anchored value if at least one bar with non-zero volume has
+    /// been observed in the current anchor window.
+    pub fn value(&self) -> Option<f64> {
+        if self.sum_v == 0.0 {
+            None
+        } else {
+            Some(self.sum_pv / self.sum_v)
+        }
+    }
+}
+
+impl Indicator for AnchoredVwap {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        if self.pending_anchor {
+            // Drop the old window before folding in this bar.
+            self.sum_pv = 0.0;
+            self.sum_v = 0.0;
+            self.has_emitted = false;
+            self.pending_anchor = false;
+        }
+        let tp = candle.typical_price();
+        self.sum_pv += tp * candle.volume;
+        self.sum_v += candle.volume;
+        if self.sum_v == 0.0 {
+            return None;
+        }
+        self.has_emitted = true;
+        Some(self.sum_pv / self.sum_v)
+    }
+
+    fn reset(&mut self) {
+        self.sum_pv = 0.0;
+        self.sum_v = 0.0;
+        self.has_emitted = false;
+        self.pending_anchor = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "AnchoredVWAP"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn c(price: f64, volume: f64, ts: i64) -> Candle {
+        Candle::new(price, price, price, price, volume, ts).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let v = AnchoredVwap::new();
+        assert_eq!(v.name(), "AnchoredVWAP");
+        assert_eq!(v.warmup_period(), 1);
+        assert_eq!(v.value(), None);
+    }
+
+    #[test]
+    fn first_bar_with_zero_volume_returns_none() {
+        let mut v = AnchoredVwap::new();
+        assert_eq!(v.update(c(50.0, 0.0, 0)), None);
+        assert!(!v.is_ready());
+        // The next bar with volume still works.
+        assert_relative_eq!(v.update(c(10.0, 4.0, 1)).unwrap(), 10.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn equal_volumes_yield_mean_typical_price() {
+        // typical_price of a flat OHLC bar equals the price.
+        let mut v = AnchoredVwap::new();
+        let out = v.batch(&[c(10.0, 1.0, 0), c(20.0, 1.0, 1), c(30.0, 1.0, 2)]);
+        assert_relative_eq!(out[2].unwrap(), 20.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn set_anchor_clears_old_window() {
+        // Run a few bars at price 10, then re-anchor and pump in price 100.
+        // After the re-anchor the running mean must be 100, not the mix.
+        let mut v = AnchoredVwap::new();
+        v.batch(&[c(10.0, 1.0, 0), c(10.0, 1.0, 1), c(10.0, 1.0, 2)]);
+        assert_relative_eq!(v.value().unwrap(), 10.0, epsilon = 1e-12);
+        v.set_anchor();
+        let after = v.update(c(100.0, 5.0, 3)).unwrap();
+        assert_relative_eq!(after, 100.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn set_anchor_before_first_bar_acts_as_normal_first_bar() {
+        // Calling set_anchor on an empty indicator should be a no-op effect:
+        // the first bar still anchors the window.
+        let mut v = AnchoredVwap::new();
+        v.set_anchor();
+        assert_relative_eq!(v.update(c(42.0, 2.0, 0)).unwrap(), 42.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn weighted_average_reference() {
+        // Two bars: 10@1, 20@3 -> (10 + 60) / 4 = 17.5.
+        let mut v = AnchoredVwap::new();
+        let out = v.batch(&[c(10.0, 1.0, 0), c(20.0, 3.0, 1)]);
+        assert_relative_eq!(out[1].unwrap(), 17.5, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (1..30).map(|i| c(f64::from(i), 1.0, i.into())).collect();
+        let mut a = AnchoredVwap::new();
+        let mut b = AnchoredVwap::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut v = AnchoredVwap::new();
+        v.batch(&[c(10.0, 1.0, 0), c(20.0, 1.0, 1)]);
+        assert!(v.is_ready());
+        v.reset();
+        assert!(!v.is_ready());
+        assert_eq!(v.value(), None);
+        // After reset the first bar acts as the new anchor.
+        assert_relative_eq!(v.update(c(50.0, 1.0, 2)).unwrap(), 50.0, epsilon = 1e-12);
+    }
+}

crates/wickra-core/src/indicators/apo.rs

@@ -0,0 +1,183 @@
+//! Absolute Price Oscillator (APO).
+
+use crate::error::{Error, Result};
+use crate::indicators::ema::Ema;
+use crate::traits::Indicator;
+
+/// Absolute Price Oscillator — the raw difference between a fast and a slow
+/// `EMA`. This is MACD's line without the signal-EMA — useful when only the
+/// momentum-direction reading is needed.
+///
+/// ```text
+/// APO_t = EMA(close, fast)_t − EMA(close, slow)_t
+/// ```
+///
+/// Default parameters mirror MACD: `(fast = 12, slow = 26)`. `fast` must be
+/// strictly less than `slow`.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Apo, Indicator};
+///
+/// let mut apo = Apo::new(12, 26).unwrap();
+/// let mut last = None;
+/// for i in 0..80 {
+///     last = apo.update(100.0 + f64::from(i));
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct Apo {
+    fast_period: usize,
+    slow_period: usize,
+    fast: Ema,
+    slow: Ema,
+}
+
+impl Apo {
+    /// # Errors
+    /// - [`Error::PeriodZero`] if either period is zero.
+    /// - [`Error::InvalidPeriod`] if `fast >= slow`.
+    pub fn new(fast: usize, slow: usize) -> Result<Self> {
+        if fast == 0 || slow == 0 {
+            return Err(Error::PeriodZero);
+        }
+        if fast >= slow {
+            return Err(Error::InvalidPeriod {
+                message: "APO fast period must be strictly less than slow",
+            });
+        }
+        Ok(Self {
+            fast_period: fast,
+            slow_period: slow,
+            fast: Ema::new(fast)?,
+            slow: Ema::new(slow)?,
+        })
+    }
+
+    /// MACD-style defaults: `(fast = 12, slow = 26)`.
+    pub fn classic() -> Self {
+        Self::new(12, 26).expect("classic APO parameters are valid")
+    }
+
+    /// Configured `(fast, slow)`.
+    pub const fn periods(&self) -> (usize, usize) {
+        (self.fast_period, self.slow_period)
+    }
+}
+
+impl Indicator for Apo {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, input: f64) -> Option<f64> {
+        // Feed both EMAs on every input so the slow one warms in parallel.
+        let f = self.fast.update(input);
+        let s = self.slow.update(input);
+        Some(f? - s?)
+    }
+
+    fn reset(&mut self) {
+        self.fast.reset();
+        self.slow.reset();
+    }
+
+    fn warmup_period(&self) -> usize {
+        // Slow EMA dominates; both EMAs emit at their `period` th input.
+        self.slow_period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.slow.is_ready()
+    }
+
+    fn name(&self) -> &'static str {
+        "APO"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(Apo::new(0, 26), Err(Error::PeriodZero)));
+        assert!(matches!(Apo::new(12, 0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn rejects_fast_geq_slow() {
+        assert!(matches!(Apo::new(26, 12), Err(Error::InvalidPeriod { .. })));
+        assert!(matches!(Apo::new(12, 12), Err(Error::InvalidPeriod { .. })));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let apo = Apo::classic();
+        assert_eq!(apo.periods(), (12, 26));
+        assert_eq!(apo.warmup_period(), 26);
+        assert_eq!(apo.name(), "APO");
+    }
+
+    #[test]
+    fn classic_factory() {
+        assert_eq!(Apo::classic().periods(), (12, 26));
+    }
+
+    #[test]
+    fn constant_series_converges_to_zero() {
+        // Both EMAs reproduce the constant exactly, so APO is 0.
+        let mut apo = Apo::new(3, 5).unwrap();
+        let out = apo.batch(&[42.0_f64; 30]);
+        for v in out.iter().skip(4).flatten() {
+            assert_relative_eq!(*v, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn warmup_emits_first_value_at_slow_period() {
+        let mut apo = Apo::new(2, 4).unwrap();
+        assert_eq!(apo.warmup_period(), 4);
+        for i in 1..=3 {
+            assert_eq!(apo.update(f64::from(i)), None);
+        }
+        assert!(apo.update(4.0).is_some());
+    }
+
+    #[test]
+    fn pure_uptrend_is_positive() {
+        // Fast EMA leads the slow EMA on an uptrend, so APO > 0.
+        let mut apo = Apo::classic();
+        let prices: Vec<f64> = (1..=200).map(f64::from).collect();
+        let out = apo.batch(&prices);
+        let last = out.iter().rev().flatten().next().unwrap();
+        assert!(*last > 0.0, "APO on uptrend should be positive: {last}");
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (1..=120)
+            .map(|i| 100.0 + (f64::from(i) * 0.2).sin() * 5.0)
+            .collect();
+        let mut a = Apo::classic();
+        let mut b = Apo::classic();
+        assert_eq!(
+            a.batch(&prices),
+            prices.iter().map(|p| b.update(*p)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut apo = Apo::classic();
+        apo.batch(&(1..=80).map(f64::from).collect::<Vec<_>>());
+        assert!(apo.is_ready());
+        apo.reset();
+        assert!(!apo.is_ready());
+        assert_eq!(apo.update(1.0), None);
+    }
+}

crates/wickra-core/src/indicators/aroon.rs

@@ -182,4 +182,13 @@ mod tests {
         assert!(!a.is_ready());
         assert_eq!(a.update(candles[0]), None);
     }
+
+    /// Cover the const accessor `period` (56-58) and the Indicator-impl
+    /// `name` body (104-106). `warmup_period` is exercised elsewhere.
+    #[test]
+    fn accessors_and_metadata() {
+        let a = Aroon::new(14).unwrap();
+        assert_eq!(a.period(), 14);
+        assert_eq!(a.name(), "Aroon");
+    }
 }

crates/wickra-core/src/indicators/aroon_oscillator.rs

@@ -107,6 +107,21 @@ mod tests {
         assert!(AroonOscillator::new(0).is_err());
     }
 
+    /// Cover the const accessors `period` / `value` (57-64) and the
+    /// Indicator-impl `name` body (90-92). `warmup_period` is covered
+    /// already by `warmup_period_matches_aroon`.
+    #[test]
+    fn accessors_and_metadata() {
+        let mut osc = AroonOscillator::new(7).unwrap();
+        assert_eq!(osc.period(), 7);
+        assert_eq!(osc.name(), "AroonOscillator");
+        assert_eq!(osc.value(), None);
+        for i in 0..8 {
+            osc.update(candle(100.0 + f64::from(i), 90.0, 95.0, i64::from(i)));
+        }
+        assert!(osc.value().is_some());
+    }
+
     #[test]
     fn pure_uptrend_yields_plus_100() {
         // Every bar a fresh high, no fresh low: AroonUp = 100, AroonDown = 0.

crates/wickra-core/src/indicators/atr.rs

@@ -151,6 +151,21 @@ mod tests {
         assert!(matches!(Atr::new(0), Err(Error::PeriodZero)));
     }
 
+    /// Cover the const accessors `period` / `value` (54-62) and the
+    /// Indicator-impl `name` body (103-105). Existing tests inspect
+    /// numeric ATR output but never query the metadata.
+    #[test]
+    fn accessors_and_metadata() {
+        let mut atr = Atr::new(14).unwrap();
+        assert_eq!(atr.period(), 14);
+        assert_eq!(atr.name(), "ATR");
+        assert_eq!(atr.value(), None);
+        for _ in 0..14 {
+            atr.update(c(11.0, 9.0, 10.0));
+        }
+        assert!(atr.value().is_some());
+    }
+
     #[test]
     fn warmup_emits_on_period_th_candle() {
         let candles = vec![

crates/wickra-core/src/indicators/atr_bands.rs

@@ -0,0 +1,214 @@
+//! ATR Bands.
+
+use crate::error::{Error, Result};
+use crate::indicators::atr::Atr;
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// ATR Bands output.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct AtrBandsOutput {
+    /// Upper band: `close + multiplier · ATR`.
+    pub upper: f64,
+    /// Middle band: the current close.
+    pub middle: f64,
+    /// Lower band: `close − multiplier · ATR`.
+    pub lower: f64,
+}
+
+/// ATR Bands: a close-anchored envelope of width `multiplier · ATR`.
+///
+/// ```text
+/// upper = close + multiplier · ATR(period)
+/// lower = close − multiplier · ATR(period)
+/// ```
+///
+/// Unlike [`Keltner`](crate::Keltner) or [`StarcBands`](crate::StarcBands), the
+/// centerline is the *raw close* rather than a smoothed average — the band
+/// rides the price tick-for-tick. This is the standard volatility-targeting
+/// envelope traders use to set initial stop-loss and profit targets: an entry
+/// at the close sets a `multiplier · ATR` stop and the symmetric target
+/// without ever needing to wait for a moving average to warm up.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AtrBands, Candle, Indicator};
+///
+/// let mut indicator = AtrBands::new(14, 3.0).unwrap();
+/// let mut last = None;
+/// for i in 0..30 {
+///     let base = 100.0 + f64::from(i);
+///     let candle =
+///         Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 10.0, i64::from(i)).unwrap();
+///     last = indicator.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct AtrBands {
+    atr: Atr,
+    multiplier: f64,
+}
+
+impl AtrBands {
+    /// # Errors
+    /// Returns [`Error::PeriodZero`] / [`Error::NonPositiveMultiplier`] on
+    /// invalid inputs.
+    pub fn new(period: usize, multiplier: f64) -> Result<Self> {
+        if !multiplier.is_finite() || multiplier <= 0.0 {
+            return Err(Error::NonPositiveMultiplier);
+        }
+        Ok(Self {
+            atr: Atr::new(period)?,
+            multiplier,
+        })
+    }
+
+    /// Configured ATR period.
+    pub const fn period(&self) -> usize {
+        self.atr.period()
+    }
+
+    /// Configured ATR multiplier.
+    pub const fn multiplier(&self) -> f64 {
+        self.multiplier
+    }
+}
+
+impl Indicator for AtrBands {
+    type Input = Candle;
+    type Output = AtrBandsOutput;
+
+    fn update(&mut self, candle: Candle) -> Option<AtrBandsOutput> {
+        let atr = self.atr.update(candle)?;
+        Some(AtrBandsOutput {
+            upper: candle.close + self.multiplier * atr,
+            middle: candle.close,
+            lower: candle.close - self.multiplier * atr,
+        })
+    }
+
+    fn reset(&mut self) {
+        self.atr.reset();
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.atr.warmup_period()
+    }
+
+    fn is_ready(&self) -> bool {
+        self.atr.is_ready()
+    }
+
+    fn name(&self) -> &'static str {
+        "AtrBands"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn c(h: f64, l: f64, cl: f64) -> Candle {
+        Candle::new(cl, h, l, cl, 1.0, 0).unwrap()
+    }
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(AtrBands::new(0, 3.0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn rejects_non_positive_multiplier() {
+        assert!(matches!(
+            AtrBands::new(14, 0.0),
+            Err(Error::NonPositiveMultiplier)
+        ));
+        assert!(matches!(
+            AtrBands::new(14, -1.0),
+            Err(Error::NonPositiveMultiplier)
+        ));
+        assert!(matches!(
+            AtrBands::new(14, f64::INFINITY),
+            Err(Error::NonPositiveMultiplier)
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let ab = AtrBands::new(14, 3.0).unwrap();
+        assert_eq!(ab.period(), 14);
+        assert_relative_eq!(ab.multiplier(), 3.0, epsilon = 1e-12);
+        assert_eq!(ab.warmup_period(), 14);
+        assert_eq!(ab.name(), "AtrBands");
+    }
+
+    #[test]
+    fn flat_market_collapses_bands() {
+        let candles: Vec<Candle> = (0..30).map(|_| c(10.0, 10.0, 10.0)).collect();
+        let mut ab = AtrBands::new(5, 3.0).unwrap();
+        let last = ab.batch(&candles).into_iter().flatten().last().unwrap();
+        assert_relative_eq!(last.upper, 10.0, epsilon = 1e-9);
+        assert_relative_eq!(last.middle, 10.0, epsilon = 1e-9);
+        assert_relative_eq!(last.lower, 10.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn upper_above_middle_above_lower() {
+        let candles: Vec<Candle> = (0..50)
+            .map(|i| {
+                let m = 100.0 + (f64::from(i) * 0.2).sin() * 5.0;
+                c(m + 1.0, m - 1.0, m)
+            })
+            .collect();
+        let mut ab = AtrBands::new(14, 3.0).unwrap();
+        for o in ab.batch(&candles).into_iter().flatten() {
+            assert!(o.upper >= o.middle);
+            assert!(o.middle >= o.lower);
+        }
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| c(f64::from(i) + 2.0, f64::from(i), f64::from(i) + 1.0))
+            .collect();
+        let mut a = AtrBands::new(10, 2.5).unwrap();
+        let mut b = AtrBands::new(10, 2.5).unwrap();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let candles: Vec<Candle> = (0..20)
+            .map(|i| c(f64::from(i) + 1.0, f64::from(i) - 1.0, f64::from(i)))
+            .collect();
+        let mut ab = AtrBands::new(5, 3.0).unwrap();
+        ab.batch(&candles);
+        assert!(ab.is_ready());
+        ab.reset();
+        assert!(!ab.is_ready());
+        assert_eq!(ab.update(candles[0]), None);
+    }
+
+    /// Reference: with constant high-low spread of 2, ATR(period) converges to
+    /// 2 immediately; for multiplier 3 the bands are at `close ± 6`.
+    #[test]
+    fn reference_values_constant_spread() {
+        // Five identical candles with TR = 2 each: ATR seeds to 2 on bar 5.
+        let candles: Vec<Candle> = (0..5).map(|_| c(11.0, 9.0, 10.0)).collect();
+        let mut ab = AtrBands::new(5, 3.0).unwrap();
+        let out = ab.batch(&candles);
+        assert!(out[0].is_none() && out[3].is_none());
+        let v = out[4].unwrap();
+        assert_relative_eq!(v.middle, 10.0, epsilon = 1e-9);
+        assert_relative_eq!(v.upper, 16.0, epsilon = 1e-9);
+        assert_relative_eq!(v.lower, 4.0, epsilon = 1e-9);
+    }
+}

crates/wickra-core/src/indicators/atr_trailing_stop.rs

@@ -234,6 +234,17 @@ mod tests {
         assert!(AtrTrailingStop::new(14, f64::NAN).is_err());
     }
 
+    /// Cover the const accessor `params` (77-79) and the Indicator-impl
+    /// `name` body (130-132). `warmup_period` is exercised elsewhere.
+    #[test]
+    fn accessors_and_metadata() {
+        let s = AtrTrailingStop::classic();
+        let (atr_p, mult) = s.params();
+        assert_eq!(atr_p, 14);
+        assert!((mult - 3.0).abs() < 1e-12);
+        assert_eq!(s.name(), "AtrTrailingStop");
+    }
+
     #[test]
     fn reset_clears_state() {
         let candles: Vec<Candle> = (0..40)

crates/wickra-core/src/indicators/autocorrelation.rs

@@ -0,0 +1,221 @@
+//! Rolling lag-`k` autocorrelation.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Rolling lag-`lag` autocorrelation of the last `period` inputs.
+///
+/// Over the trailing window the Pearson correlation between the series and
+/// itself shifted by `lag` is computed:
+///
+/// ```text
+/// y_i  for i = 0..period − 1
+/// ACF(lag) = Σ ( (y_i − ȳ) · (y_{i + lag} − ȳ) ) / Σ ( y_i − ȳ )²
+/// ```
+///
+/// `+1` means a perfectly repeating pattern at the given lag; `−1` means a
+/// perfect alternation. Values near `0` mean the series at `t` and `t −
+/// lag` carry no linear relationship — a clean white-noise proxy. The
+/// classic application is detecting periodicity (a peak in `|ACF(lag)|`
+/// flags a cycle of that length) or testing whether returns are
+/// uncorrelated (a key efficient-markets diagnostic).
+///
+/// `period` must be strictly greater than `lag` so that at least two
+/// `(y, y_lagged)` pairs exist. A flat window has zero variance; the
+/// indicator returns `0` rather than dividing by zero.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Autocorrelation, Indicator};
+///
+/// let mut indicator = Autocorrelation::new(20, 1).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     last = indicator.update(f64::from(i));
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct Autocorrelation {
+    period: usize,
+    lag: usize,
+    window: VecDeque<f64>,
+}
+
+impl Autocorrelation {
+    /// Construct a new rolling lag-`lag` autocorrelation over `period` inputs.
+    ///
+    /// # Errors
+    /// Returns [`Error::InvalidPeriod`] if `lag == 0` or `lag >= period`.
+    pub fn new(period: usize, lag: usize) -> Result<Self> {
+        if lag == 0 {
+            return Err(Error::InvalidPeriod {
+                message: "autocorrelation lag must be >= 1",
+            });
+        }
+        if period <= lag {
+            return Err(Error::InvalidPeriod {
+                message: "autocorrelation needs period > lag",
+            });
+        }
+        Ok(Self {
+            period,
+            lag,
+            window: VecDeque::with_capacity(period),
+        })
+    }
+
+    /// Configured window period.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+
+    /// Configured lag.
+    pub const fn lag(&self) -> usize {
+        self.lag
+    }
+}
+
+impl Indicator for Autocorrelation {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, value: f64) -> Option<f64> {
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(value);
+        if self.window.len() < self.period {
+            return None;
+        }
+        // ACF over the current window with a single inner pass. The window is
+        // small relative to a typical input stream so the O(period) per-bar
+        // cost is bounded by the user-chosen `period`; the constant factor
+        // is dominated by two adds and one multiply per element.
+        let n = self.period as f64;
+        let mean = self.window.iter().sum::<f64>() / n;
+        let mut denom = 0.0;
+        let mut numer = 0.0;
+        // The window is a deque; index via slices for cache-friendly access.
+        let (front, back) = self.window.as_slices();
+        let get = |i: usize| -> f64 {
+            if i < front.len() {
+                front[i]
+            } else {
+                back[i - front.len()]
+            }
+        };
+        for i in 0..self.period {
+            let d = get(i) - mean;
+            denom += d * d;
+        }
+        let lag = self.lag;
+        for i in 0..(self.period - lag) {
+            numer += (get(i) - mean) * (get(i + lag) - mean);
+        }
+        if denom == 0.0 {
+            return Some(0.0);
+        }
+        Some(numer / denom)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.window.len() == self.period
+    }
+
+    fn name(&self) -> &'static str {
+        "Autocorrelation"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_zero_lag() {
+        assert!(Autocorrelation::new(10, 0).is_err());
+    }
+
+    #[test]
+    fn rejects_lag_geq_period() {
+        assert!(Autocorrelation::new(5, 5).is_err());
+        assert!(Autocorrelation::new(5, 10).is_err());
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let a = Autocorrelation::new(14, 2).unwrap();
+        assert_eq!(a.period(), 14);
+        assert_eq!(a.lag(), 2);
+        assert_eq!(a.warmup_period(), 14);
+        assert_eq!(a.name(), "Autocorrelation");
+    }
+
+    #[test]
+    fn constant_series_yields_zero() {
+        let mut a = Autocorrelation::new(10, 1).unwrap();
+        for v in a.batch(&[42.0; 30]).into_iter().flatten() {
+            assert_relative_eq!(v, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn alternating_series_lag_one_is_strongly_negative() {
+        // [−1, 1, −1, 1, …] alternates each step.
+        let prices: Vec<f64> = (0..20)
+            .map(|i| if i % 2 == 0 { -1.0 } else { 1.0 })
+            .collect();
+        let mut a = Autocorrelation::new(10, 1).unwrap();
+        let last = a.batch(&prices).into_iter().flatten().last().unwrap();
+        assert!(
+            last < -0.5,
+            "alternating series should be strongly negative, got {last}"
+        );
+    }
+
+    #[test]
+    fn repeating_series_is_strongly_positive_at_period() {
+        // A series that repeats every 4 steps must have ACF(4) ≈ +1.
+        let pattern = [1.0, 2.0, 3.0, 4.0];
+        let prices: Vec<f64> = (0..32).map(|i| pattern[i % 4]).collect();
+        let mut a = Autocorrelation::new(16, 4).unwrap();
+        let last = a.batch(&prices).into_iter().flatten().last().unwrap();
+        assert!(
+            last > 0.5,
+            "period-4 repeat should ACF(4) > 0.5, got {last}"
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut a = Autocorrelation::new(5, 1).unwrap();
+        a.batch(&[1.0, 2.0, 3.0, 4.0, 5.0]);
+        assert!(a.is_ready());
+        a.reset();
+        assert!(!a.is_ready());
+        assert_eq!(a.update(1.0), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (0..60).map(|i| (f64::from(i) * 0.3).sin()).collect();
+        let batch = Autocorrelation::new(14, 2).unwrap().batch(&prices);
+        let mut b = Autocorrelation::new(14, 2).unwrap();
+        let streamed: Vec<_> = prices.iter().map(|p| b.update(*p)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/indicators/average_drawdown.rs

@@ -0,0 +1,172 @@
+//! Rolling Average Drawdown.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Rolling Average Drawdown.
+///
+/// Input is treated as an equity-curve sample. The indicator scans the
+/// trailing window of `period` values, tracks the running peak inside the
+/// window, and reports the **mean** of all bar-by-bar drawdowns (the average
+/// "pain" of being under water):
+///
+/// ```text
+/// drawdown_t = (peak_t − equity_t) / peak_t  (running peak inside window)
+/// AvgDD      = mean(drawdown_t over window)
+/// ```
+///
+/// Output is non-negative (a fraction; `0.05` ≈ 5 % average drawdown). This
+/// is the **Pain Index** under a different name — see [`crate::PainIndex`]
+/// for the same metric exposed under its conventional label.
+///
+/// Each `update` is O(period).
+#[derive(Debug, Clone)]
+pub struct AverageDrawdown {
+    period: usize,
+    window: VecDeque<f64>,
+}
+
+impl AverageDrawdown {
+    /// Construct a new rolling Average Drawdown.
+    ///
+    /// # Errors
+    /// Returns [`Error::PeriodZero`] if `period == 0`.
+    pub fn new(period: usize) -> Result<Self> {
+        if period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            period,
+            window: VecDeque::with_capacity(period),
+        })
+    }
+
+    /// Configured window length.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+}
+
+impl Indicator for AverageDrawdown {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, input: f64) -> Option<f64> {
+        if !input.is_finite() {
+            return None;
+        }
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(input);
+        if self.window.len() < self.period {
+            return None;
+        }
+        let mut peak = f64::NEG_INFINITY;
+        let mut sum_dd = 0.0_f64;
+        for &v in &self.window {
+            if v > peak {
+                peak = v;
+            }
+            if peak > 0.0 {
+                sum_dd += (peak - v) / peak;
+            }
+        }
+        Some(sum_dd / self.period as f64)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.window.len() == self.period
+    }
+
+    fn name(&self) -> &'static str {
+        "AverageDrawdown"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(AverageDrawdown::new(0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let a = AverageDrawdown::new(10).unwrap();
+        assert_eq!(a.period(), 10);
+        assert_eq!(a.name(), "AverageDrawdown");
+        assert_eq!(a.warmup_period(), 10);
+    }
+
+    #[test]
+    fn pure_uptrend_yields_zero() {
+        let mut a = AverageDrawdown::new(5).unwrap();
+        let out = a.batch(&(1..=20).map(f64::from).collect::<Vec<_>>());
+        for v in out.into_iter().flatten() {
+            assert_relative_eq!(v, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn reference_value() {
+        // window [100, 120, 90, 110]:
+        // peaks: 100, 120, 120, 120; dd: 0, 0, (30/120)=.25, (10/120)=.0833...
+        // avg = (.25 + .0833...) / 4 = .0833...
+        let mut a = AverageDrawdown::new(4).unwrap();
+        let out = a.batch(&[100.0, 120.0, 90.0, 110.0]);
+        let expected = (0.25 + (10.0 / 120.0)) / 4.0;
+        assert_relative_eq!(out[3].unwrap(), expected, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn ignores_non_finite_input() {
+        let mut a = AverageDrawdown::new(3).unwrap();
+        assert_eq!(a.update(f64::NAN), None);
+        assert_eq!(a.update(f64::INFINITY), None);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut a = AverageDrawdown::new(3).unwrap();
+        a.batch(&[100.0, 90.0, 110.0]);
+        assert!(a.is_ready());
+        a.reset();
+        assert!(!a.is_ready());
+        assert_eq!(a.update(100.0), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (0..40)
+            .map(|i| 100.0 + (f64::from(i) * 0.3).sin() * 8.0)
+            .collect();
+        let batch = AverageDrawdown::new(10).unwrap().batch(&prices);
+        let mut s = AverageDrawdown::new(10).unwrap();
+        let streamed: Vec<_> = prices.iter().map(|p| s.update(*p)).collect();
+        assert_eq!(batch, streamed);
+    }
+
+    #[test]
+    fn non_positive_peak_yields_zero() {
+        let mut a = AverageDrawdown::new(3).unwrap();
+        let out = a.batch(&[0.0_f64; 6]);
+        for v in out.into_iter().flatten() {
+            assert_eq!(v, 0.0);
+        }
+    }
+}

crates/wickra-core/src/indicators/awesome_oscillator.rs

@@ -118,6 +118,17 @@ mod tests {
         assert!(AwesomeOscillator::new(0, 5).is_err());
     }
 
+    /// Cover the const accessor `periods` (59-61) and the Indicator-impl
+    /// `warmup_period` (83-85) + `name` (91-93). Existing tests never
+    /// inspect these metadata methods.
+    #[test]
+    fn accessors_and_metadata() {
+        let ao = AwesomeOscillator::classic();
+        assert_eq!(ao.periods(), (5, 34));
+        assert_eq!(ao.warmup_period(), 34);
+        assert_eq!(ao.name(), "AwesomeOscillator");
+    }
+
     #[test]
     fn batch_equals_streaming() {
         let candles: Vec<Candle> = (0..50)

crates/wickra-core/src/indicators/awesome_oscillator_histogram.rs

@@ -0,0 +1,198 @@
+//! Awesome Oscillator Histogram.
+
+use crate::error::{Error, Result};
+use crate::indicators::awesome_oscillator::AwesomeOscillator;
+use crate::indicators::sma::Sma;
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// "Awesome Oscillator Histogram" — the difference between the Awesome
+/// Oscillator and its `sma_period`-bar `SMA`. Positive bars mean `AO` is
+/// trending up (bullish acceleration); negative bars mean `AO` is trending
+/// down (bearish acceleration).
+///
+/// ```text
+/// AO         = SMA(median, fast) − SMA(median, slow)
+/// AOHist     = AO − SMA(AO, sma_period)
+/// ```
+///
+/// With Williams' default `sma_period = 5`, this collapses to the existing
+/// `AcceleratorOscillator` for `fast = 5, slow = 34, sma_period = 5`; for any
+/// other parameterisation this is a more flexible variant.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AwesomeOscillatorHistogram, Candle, Indicator};
+///
+/// let mut hist = AwesomeOscillatorHistogram::classic();
+/// let mut last = None;
+/// for i in 0..80 {
+///     let p = 100.0 + f64::from(i);
+///     let candle = Candle::new(p, p + 0.5, p - 0.5, p, 1.0, i64::from(i)).unwrap();
+///     last = hist.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct AwesomeOscillatorHistogram {
+    fast_period: usize,
+    slow_period: usize,
+    sma_period: usize,
+    ao: AwesomeOscillator,
+    sma: Sma,
+}
+
+impl AwesomeOscillatorHistogram {
+    /// # Errors
+    /// - [`Error::PeriodZero`] if any period is zero.
+    /// - [`Error::InvalidPeriod`] if `fast >= slow`.
+    pub fn new(fast: usize, slow: usize, sma_period: usize) -> Result<Self> {
+        if fast == 0 || slow == 0 || sma_period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        if fast >= slow {
+            return Err(Error::InvalidPeriod {
+                message: "AwesomeOscillatorHistogram fast must be strictly less than slow",
+            });
+        }
+        Ok(Self {
+            fast_period: fast,
+            slow_period: slow,
+            sma_period,
+            ao: AwesomeOscillator::new(fast, slow)?,
+            sma: Sma::new(sma_period)?,
+        })
+    }
+
+    /// Bill Williams' Accelerator-equivalent defaults `(5, 34, 5)`.
+    pub fn classic() -> Self {
+        Self::new(5, 34, 5).expect("classic Awesome Oscillator Histogram parameters are valid")
+    }
+
+    /// Configured `(fast_period, slow_period, sma_period)`.
+    pub const fn periods(&self) -> (usize, usize, usize) {
+        (self.fast_period, self.slow_period, self.sma_period)
+    }
+}
+
+impl Indicator for AwesomeOscillatorHistogram {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        let ao = self.ao.update(candle)?;
+        let sma = self.sma.update(ao)?;
+        Some(ao - sma)
+    }
+
+    fn reset(&mut self) {
+        self.ao.reset();
+        self.sma.reset();
+    }
+
+    fn warmup_period(&self) -> usize {
+        // AO emits at `slow` candles; the SMA then needs `sma_period - 1`
+        // more AO values to fill its window.
+        self.slow_period + self.sma_period - 1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.sma.is_ready()
+    }
+
+    fn name(&self) -> &'static str {
+        "AwesomeOscillatorHistogram"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn candle(price: f64, ts: i64) -> Candle {
+        Candle::new(price, price + 0.5, price - 0.5, price, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(
+            AwesomeOscillatorHistogram::new(0, 34, 5),
+            Err(Error::PeriodZero)
+        ));
+        assert!(matches!(
+            AwesomeOscillatorHistogram::new(5, 0, 5),
+            Err(Error::PeriodZero)
+        ));
+        assert!(matches!(
+            AwesomeOscillatorHistogram::new(5, 34, 0),
+            Err(Error::PeriodZero)
+        ));
+    }
+
+    #[test]
+    fn rejects_fast_geq_slow() {
+        assert!(matches!(
+            AwesomeOscillatorHistogram::new(34, 5, 5),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let hist = AwesomeOscillatorHistogram::classic();
+        assert_eq!(hist.periods(), (5, 34, 5));
+        assert_eq!(hist.warmup_period(), 38);
+        assert_eq!(hist.name(), "AwesomeOscillatorHistogram");
+    }
+
+    #[test]
+    fn constant_series_converges_to_zero() {
+        // AO of a flat series is 0; SMA of 0 is 0; difference is 0.
+        let mut hist = AwesomeOscillatorHistogram::new(3, 5, 3).unwrap();
+        let candles: Vec<Candle> = (0..30).map(|i| candle(42.0, i)).collect();
+        let out = hist.batch(&candles);
+        for v in out.iter().skip(hist.warmup_period() - 1).flatten() {
+            assert_relative_eq!(*v, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn warmup_emits_first_value_at_warmup_period() {
+        let mut hist = AwesomeOscillatorHistogram::new(2, 4, 3).unwrap();
+        assert_eq!(hist.warmup_period(), 6);
+        let candles: Vec<Candle> = (0..8)
+            .map(|i| candle(10.0 + f64::from(i), i64::from(i)))
+            .collect();
+        let out = hist.batch(&candles);
+        for v in out.iter().take(5) {
+            assert!(v.is_none());
+        }
+        assert!(out[5].is_some());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..100_i64)
+            .map(|i| candle(100.0 + (i as f64 * 0.3).sin() * 5.0, i))
+            .collect();
+        let batch = AwesomeOscillatorHistogram::classic().batch(&candles);
+        let mut b = AwesomeOscillatorHistogram::classic();
+        let streamed: Vec<_> = candles.iter().map(|c| b.update(*c)).collect();
+        assert_eq!(batch, streamed);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut hist = AwesomeOscillatorHistogram::classic();
+        let candles: Vec<Candle> = (0..80)
+            .map(|i| candle(10.0 + f64::from(i), i64::from(i)))
+            .collect();
+        hist.batch(&candles);
+        assert!(hist.is_ready());
+        hist.reset();
+        assert!(!hist.is_ready());
+    }
+}

crates/wickra-core/src/indicators/balance_of_power.rs

@@ -132,6 +132,13 @@ mod tests {
         );
     }
 
+    /// Cover the Indicator-impl `name` body (73-75).
+    #[test]
+    fn name_metadata() {
+        let bop = BalanceOfPower::new();
+        assert_eq!(bop.name(), "BalanceOfPower");
+    }
+
     #[test]
     fn emits_from_first_candle() {
         let mut bop = BalanceOfPower::new();

crates/wickra-core/src/indicators/beta.rs

@@ -0,0 +1,228 @@
+//! Rolling Beta — sensitivity of an asset to a benchmark.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Rolling Beta of an `asset` series relative to a `benchmark` series.
+///
+/// Each `update` receives one `(asset, benchmark)` pair. Over the trailing
+/// window of `period` pairs:
+///
+/// ```text
+/// cov_ab = (1/n) · Σ a·b − ā·b̄
+/// var_b  = (1/n) · Σ b² − b̄²
+/// Beta   = cov_ab / var_b
+/// ```
+///
+/// Beta measures how much the asset moves for a unit move in the
+/// benchmark. A reading of `1.0` means the two move together one-for-one;
+/// `2.0` means the asset typically doubles the benchmark's moves;
+/// `0.5` means it moves only half as much; `0.0` means moves are
+/// uncorrelated; negative Betas signal a hedge. It is the slope of the
+/// OLS regression of the asset on the benchmark and the foundation of the
+/// CAPM. Unlike [`crate::PearsonCorrelation`], Beta is *not* unit-free —
+/// it carries the ratio of standard deviations.
+///
+/// Each `update` is O(1): four running sums (`Σa`, `Σb`, `Σb²`, `Σa·b`)
+/// are maintained as the window slides. A flat benchmark window has zero
+/// variance and Beta is undefined; the indicator returns `0` in that
+/// case rather than producing `NaN`.
+///
+/// Conventionally Beta is computed on **returns** (typically log-returns)
+/// rather than raw prices; feed the indicator pre-computed returns if
+/// that is your convention. The pure rolling OLS slope is the same
+/// either way.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Beta, Indicator};
+///
+/// let mut indicator = Beta::new(20).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     // Asset doubles every benchmark move.
+///     last = indicator.update((2.0 * f64::from(i), f64::from(i)));
+/// }
+/// assert!((last.unwrap() - 2.0).abs() < 1e-9);
+/// ```
+#[derive(Debug, Clone)]
+pub struct Beta {
+    period: usize,
+    window: VecDeque<(f64, f64)>,
+    sum_a: f64,
+    sum_b: f64,
+    sum_bb: f64,
+    sum_ab: f64,
+}
+
+impl Beta {
+    /// Construct a new rolling Beta.
+    ///
+    /// # Errors
+    /// Returns [`Error::InvalidPeriod`] if `period < 2`.
+    pub fn new(period: usize) -> Result<Self> {
+        if period < 2 {
+            return Err(Error::InvalidPeriod {
+                message: "beta needs period >= 2",
+            });
+        }
+        Ok(Self {
+            period,
+            window: VecDeque::with_capacity(period),
+            sum_a: 0.0,
+            sum_b: 0.0,
+            sum_bb: 0.0,
+            sum_ab: 0.0,
+        })
+    }
+
+    /// Configured period.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+}
+
+impl Indicator for Beta {
+    /// `(asset, benchmark)` pair.
+    type Input = (f64, f64);
+    type Output = f64;
+
+    fn update(&mut self, input: (f64, f64)) -> Option<f64> {
+        let (a, b) = input;
+        if self.window.len() == self.period {
+            let (oa, ob) = self.window.pop_front().expect("non-empty");
+            self.sum_a -= oa;
+            self.sum_b -= ob;
+            self.sum_bb -= ob * ob;
+            self.sum_ab -= oa * ob;
+        }
+        self.window.push_back((a, b));
+        self.sum_a += a;
+        self.sum_b += b;
+        self.sum_bb += b * b;
+        self.sum_ab += a * b;
+        if self.window.len() < self.period {
+            return None;
+        }
+        let n = self.period as f64;
+        let mean_a = self.sum_a / n;
+        let mean_b = self.sum_b / n;
+        let var_b = (self.sum_bb / n - mean_b * mean_b).max(0.0);
+        let cov = self.sum_ab / n - mean_a * mean_b;
+        if var_b == 0.0 {
+            // A flat benchmark has no defined beta.
+            return Some(0.0);
+        }
+        Some(cov / var_b)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.sum_a = 0.0;
+        self.sum_b = 0.0;
+        self.sum_bb = 0.0;
+        self.sum_ab = 0.0;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.window.len() == self.period
+    }
+
+    fn name(&self) -> &'static str {
+        "Beta"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_period_below_two() {
+        assert!(Beta::new(0).is_err());
+        assert!(Beta::new(1).is_err());
+        assert!(Beta::new(2).is_ok());
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let b = Beta::new(14).unwrap();
+        assert_eq!(b.period(), 14);
+        assert_eq!(b.warmup_period(), 14);
+        assert_eq!(b.name(), "Beta");
+    }
+
+    #[test]
+    fn perfect_two_to_one_relationship() {
+        let pairs: Vec<(f64, f64)> = (0..10)
+            .map(|i| (2.0 * f64::from(i), f64::from(i)))
+            .collect();
+        let last = Beta::new(5)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_relative_eq!(last, 2.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn perfect_negative_one() {
+        let pairs: Vec<(f64, f64)> = (0..10).map(|i| (-f64::from(i), f64::from(i))).collect();
+        let last = Beta::new(5)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_relative_eq!(last, -1.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn constant_benchmark_yields_zero() {
+        let pairs: Vec<(f64, f64)> = (0..10).map(|i| (f64::from(i), 7.0)).collect();
+        let last = Beta::new(5)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_relative_eq!(last, 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut b = Beta::new(5).unwrap();
+        b.batch(&[(1.0, 2.0), (2.0, 4.0), (3.0, 6.0), (4.0, 8.0), (5.0, 10.0)]);
+        assert!(b.is_ready());
+        b.reset();
+        assert!(!b.is_ready());
+        assert_eq!(b.update((1.0, 1.0)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let pairs: Vec<(f64, f64)> = (0..60)
+            .map(|i| {
+                let t = f64::from(i);
+                (t.sin() * 2.0 + 0.3 * t.cos(), t.sin())
+            })
+            .collect();
+        let batch = Beta::new(14).unwrap().batch(&pairs);
+        let mut b = Beta::new(14).unwrap();
+        let streamed: Vec<_> = pairs.iter().map(|p| b.update(*p)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/indicators/bollinger.rs

@@ -172,20 +172,21 @@ mod tests {
     use crate::traits::BatchExt;
     use approx::assert_relative_eq;
 
-    fn naive(prices: &[f64], period: usize, mult: f64) -> Option<BollingerOutput> {
-        if prices.len() < period {
-            return None;
-        }
+    fn naive(prices: &[f64], period: usize, mult: f64) -> BollingerOutput {
+        assert!(
+            prices.len() >= period,
+            "naive requires at least `period` prices"
+        );
         let w = &prices[prices.len() - period..];
         let mean = w.iter().sum::<f64>() / period as f64;
         let var = w.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / period as f64;
         let s = var.sqrt();
-        Some(BollingerOutput {
+        BollingerOutput {
             upper: mean + mult * s,
             middle: mean,
             lower: mean - mult * s,
             stddev: s,
-        })
+        }
     }
 
     #[test]
@@ -212,6 +213,20 @@ mod tests {
         ));
     }
 
+    /// Cover the convenience constructor `BollingerBands::classic()` plus the
+    /// const accessors `period` / `multiplier` and the Indicator-impl
+    /// metadata methods `warmup_period` / `name`. Existing tests never
+    /// invoked `classic()` (every test passed explicit parameters to
+    /// `new`) and never queried any of the four getters.
+    #[test]
+    fn classic_and_accessors_and_metadata() {
+        let bb = BollingerBands::classic();
+        assert_eq!(bb.period(), 20);
+        assert_relative_eq!(bb.multiplier(), 2.0, epsilon = 1e-12);
+        assert_eq!(bb.warmup_period(), 20);
+        assert_eq!(bb.name(), "BollingerBands");
+    }
+
     #[test]
     fn warmup_returns_none() {
         let mut bb = BollingerBands::new(5, 2.0).unwrap();
@@ -241,7 +256,7 @@ mod tests {
         let out = bb.batch(&prices);
         for i in 19..prices.len() {
             let got = out[i].unwrap();
-            let want = naive(&prices[..=i], 20, 2.0).unwrap();
+            let want = naive(&prices[..=i], 20, 2.0);
             assert_relative_eq!(got.middle, want.middle, epsilon = 1e-9);
             assert_relative_eq!(got.stddev, want.stddev, epsilon = 1e-9);
             assert_relative_eq!(got.upper, want.upper, epsilon = 1e-9);
@@ -301,8 +316,7 @@ mod tests {
             }
             window.push_back(v);
         }
-        let scratch =
-            naive(&window.iter().copied().collect::<Vec<_>>(), period, mult).expect("warmed up");
+        let scratch = naive(&window.iter().copied().collect::<Vec<_>>(), period, mult);
         let got = last.expect("warmed up");
         assert!(
             (got.middle - scratch.middle).abs() < 1e-3,

crates/wickra-core/src/indicators/bollinger_bandwidth.rs

@@ -113,6 +113,27 @@ mod tests {
         assert!(BollingerBandwidth::new(20, -1.0).is_err());
     }
 
+    /// Cover the public const accessors `period`, `multiplier`, `value` and
+    /// the Indicator-impl `warmup_period` + `name` methods. None of the
+    /// pre-existing tests inspected the metadata surface — they only fed
+    /// numeric updates and asserted on the bandwidth values, leaving the
+    /// five getter bodies (lines 54-66, 90-92, 98-100) untouched.
+    #[test]
+    fn accessors_and_metadata() {
+        let mut bbw = BollingerBandwidth::new(20, 2.0).unwrap();
+        assert_eq!(bbw.period(), 20);
+        assert_relative_eq!(bbw.multiplier(), 2.0, epsilon = 1e-12);
+        // value() before warmup must be the literal None branch of self.last.
+        assert_eq!(bbw.value(), None);
+        assert_eq!(bbw.warmup_period(), 20);
+        assert_eq!(bbw.name(), "BollingerBandwidth");
+        // Drive past warmup so value() exercises the Some branch as well.
+        for i in 1..=20 {
+            bbw.update(f64::from(i));
+        }
+        assert!(bbw.value().is_some());
+    }
+
     #[test]
     fn constant_series_yields_zero() {
         // Flat prices: the bands collapse onto the middle, so width is 0.
@@ -123,6 +144,23 @@ mod tests {
         }
     }
 
+    /// Cover the defensive `o.middle == 0.0` branch in `update` (line 77).
+    /// All other tests use price levels ≈100, so the rolling SMA is always
+    /// strictly positive and the zero-middle fallback is unreachable. Feed
+    /// a symmetric series whose 5-bar mean is exactly 0 to force the branch
+    /// and assert the indicator yields exactly 0.0 (rather than inf/nan).
+    #[test]
+    fn zero_middle_band_yields_zero_bandwidth() {
+        let mut bbw = BollingerBandwidth::new(5, 2.0).unwrap();
+        // sum(-2, -1, 0, 1, 2) = 0 exactly in IEEE-754, so the SMA middle
+        // lands on exactly 0.0 at the fifth input. Stddev > 0, so absent
+        // the guard the next line would divide by zero.
+        let out = bbw.batch(&[-2.0, -1.0, 0.0, 1.0, 2.0]);
+        assert_eq!(out[..4], [None, None, None, None]);
+        let v = out[4].expect("warmed up");
+        assert_eq!(v, 0.0, "zero-middle fallback must emit exactly 0.0");
+    }
+
     #[test]
     fn matches_bands_definition() {
         // Bandwidth must equal (upper - lower) / middle from BollingerBands.
@@ -131,13 +169,11 @@ mod tests {
             .collect();
         let bbw_out = BollingerBandwidth::new(20, 2.0).unwrap().batch(&prices);
         let bands_out = BollingerBands::new(20, 2.0).unwrap().batch(&prices);
-        for (w, b) in bbw_out.iter().zip(bands_out.iter()) {
-            match (w, b) {
-                (Some(wv), Some(bv)) => {
-                    assert_relative_eq!(*wv, (bv.upper - bv.lower) / bv.middle, epsilon = 1e-12);
-                }
-                (None, None) => {}
-                _ => panic!("warmup mismatch"),
+        for (i, (w, b)) in bbw_out.iter().zip(bands_out.iter()).enumerate() {
+            // Same warmup period on both — emission shape must agree at every index.
+            assert_eq!(w.is_some(), b.is_some(), "warmup mismatch at index {i}");
+            if let (Some(wv), Some(bv)) = (w, b) {
+                assert_relative_eq!(*wv, (bv.upper - bv.lower) / bv.middle, epsilon = 1e-12);
             }
         }
     }

crates/wickra-core/src/indicators/calmar_ratio.rs

@@ -0,0 +1,202 @@
+//! Rolling Calmar Ratio — return over max drawdown.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Rolling Calmar Ratio.
+///
+/// Input is treated as a single period return. Over the trailing window of
+/// `period` returns the indicator reconstructs the implied equity curve
+/// (cumulative-compounded), measures the worst peak-to-trough drawdown, and
+/// divides the mean return by that drawdown:
+///
+/// ```text
+/// equity_t = ∏(1 + r_i) for i in window up to t
+/// mdd      = max peak-to-trough decline of equity over window
+/// Calmar   = mean(returns) / mdd
+/// ```
+///
+/// If the drawdown is zero (monotonically non-decreasing equity in the
+/// window) the indicator returns `0.0` rather than `NaN` / `Inf`.
+///
+/// The equity curve is recomputed inside the window each `update`, which
+/// keeps each call O(period) — acceptable for typical backtest windows
+/// (`period ≤ 252`).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{CalmarRatio, Indicator};
+///
+/// let mut cr = CalmarRatio::new(20).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     last = cr.update(0.001 + (f64::from(i) * 0.1).sin() * 0.005);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct CalmarRatio {
+    period: usize,
+    window: VecDeque<f64>,
+    sum: f64,
+}
+
+impl CalmarRatio {
+    /// Construct a new rolling Calmar Ratio.
+    ///
+    /// # Errors
+    /// Returns [`Error::InvalidPeriod`] if `period < 2`.
+    pub fn new(period: usize) -> Result<Self> {
+        if period < 2 {
+            return Err(Error::InvalidPeriod {
+                message: "calmar ratio needs period >= 2",
+            });
+        }
+        Ok(Self {
+            period,
+            window: VecDeque::with_capacity(period),
+            sum: 0.0,
+        })
+    }
+
+    /// Configured window length.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+}
+
+impl Indicator for CalmarRatio {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, input: f64) -> Option<f64> {
+        if !input.is_finite() {
+            return None;
+        }
+        if self.window.len() == self.period {
+            let old = self.window.pop_front().expect("non-empty");
+            self.sum -= old;
+        }
+        self.window.push_back(input);
+        self.sum += input;
+        if self.window.len() < self.period {
+            return None;
+        }
+        let n = self.period as f64;
+        let mean = self.sum / n;
+        // Build equity curve and track the worst peak-to-trough drawdown.
+        let mut equity = 1.0_f64;
+        let mut peak = 1.0_f64;
+        let mut mdd = 0.0_f64;
+        for &r in &self.window {
+            equity *= 1.0 + r;
+            if equity > peak {
+                peak = equity;
+            }
+            // peak starts at 1.0 and never decreases, so peak > 0 by construction.
+            let dd = (peak - equity) / peak;
+            if dd > mdd {
+                mdd = dd;
+            }
+        }
+        if mdd == 0.0 {
+            return Some(0.0);
+        }
+        Some(mean / mdd)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.sum = 0.0;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.window.len() == self.period
+    }
+
+    fn name(&self) -> &'static str {
+        "CalmarRatio"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_period_less_than_two() {
+        assert!(matches!(
+            CalmarRatio::new(1),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let c = CalmarRatio::new(10).unwrap();
+        assert_eq!(c.period(), 10);
+        assert_eq!(c.name(), "CalmarRatio");
+        assert_eq!(c.warmup_period(), 10);
+    }
+
+    #[test]
+    fn pure_uptrend_yields_zero() {
+        // All positive returns -> no drawdown -> Calmar = 0 by convention.
+        let mut c = CalmarRatio::new(5).unwrap();
+        let out = c.batch(&[0.01; 10]);
+        for v in out.into_iter().flatten() {
+            assert_eq!(v, 0.0);
+        }
+    }
+
+    #[test]
+    fn reference_value() {
+        // returns = [0.10, -0.20, 0.05]
+        // equity: 1.0 -> 1.10 -> 0.88 -> 0.924
+        // peak 1.10, trough 0.88 -> mdd = 0.20.
+        // mean = (0.10 - 0.20 + 0.05) / 3 ≈ -0.01666...
+        // Calmar = -0.01666... / 0.20 ≈ -0.08333...
+        let mut c = CalmarRatio::new(3).unwrap();
+        let out = c.batch(&[0.10, -0.20, 0.05]);
+        let mean = (0.10 - 0.20 + 0.05) / 3.0;
+        let expected = mean / 0.20;
+        assert_relative_eq!(out[2].unwrap(), expected, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn ignores_non_finite_input() {
+        let mut c = CalmarRatio::new(3).unwrap();
+        assert_eq!(c.update(f64::NAN), None);
+        assert_eq!(c.update(f64::INFINITY), None);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut c = CalmarRatio::new(3).unwrap();
+        c.batch(&[0.10, -0.20, 0.05]);
+        assert!(c.is_ready());
+        c.reset();
+        assert!(!c.is_ready());
+        assert_eq!(c.update(0.01), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let returns: Vec<f64> = (0..50)
+            .map(|i| 0.001 + (f64::from(i) * 0.25).sin() * 0.02)
+            .collect();
+        let batch = CalmarRatio::new(10).unwrap().batch(&returns);
+        let mut s = CalmarRatio::new(10).unwrap();
+        let streamed: Vec<_> = returns.iter().map(|r| s.update(*r)).collect();
+        assert_eq!(batch, streamed);
+    }
+}