release: bump 0.4.3 -> 0.4.4 (#143)

Release 0.4.4.

Version bump only — no code changes. Ships the 40 TA-Lib candlestick patterns
(parts 2–9, #132–#141, 249 → 289 indicators) plus the candlestick rejection-
guard coverage tests (#142) that landed on `main` since 0.4.3.

Bumped: workspace `Cargo.toml` (+ `wickra-core` dep) and `Cargo.lock`,
`bindings/python/pyproject.toml`, `bindings/node/package.json` (+ 6 platform
`optionalDependencies`), the 6 `bindings/node/npm/*/package.json`, both
`package-lock.json` files, and `CHANGELOG.md` ([Unreleased] → [0.4.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/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/PULL_REQUEST_TEMPLATE.md

@@ -24,9 +24,9 @@
 - [ ] 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).
-- [ ] The relevant page on the [project Wiki](https://github.com/kingchenc/wickra/wiki)
-      and the `README.md` are updated (If applicable). Wiki edits go to a
-      separate repository: `https://github.com/kingchenc/wickra.wiki.git`.
+- [ ] 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/dependabot.yml

@@ -6,6 +6,8 @@ updates:
     schedule:
       interval: weekly
     open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
     commit-message:
       prefix: "deps(cargo)"
 
@@ -15,6 +17,8 @@ updates:
     schedule:
       interval: weekly
     open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
     commit-message:
       prefix: "deps(npm)"
 
@@ -24,9 +28,26 @@ updates:
     schedule:
       interval: weekly
     open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
     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
+    cooldown:
+      default-days: 7
+    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
@@ -34,5 +55,7 @@ updates:
     schedule:
       interval: weekly
     open-pull-requests-limit: 10
+    cooldown:
+      default-days: 7
     commit-message:
       prefix: "deps(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:
@@ -31,20 +49,45 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - 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 +99,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:
@@ -20,6 +40,8 @@ jobs:
         os: [ubuntu-latest, macos-latest, windows-latest]
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
@@ -28,6 +50,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 +79,162 @@ 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
+        with:
+          persist-credentials: false
+
+      - 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
+        with:
+          persist-credentials: false
+
+      - 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
@@ -79,6 +259,8 @@ jobs:
             packages: "-p wickra-node"
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Install Rust ${{ matrix.toolchain }}
         uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
@@ -87,6 +269,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
@@ -100,6 +284,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
@@ -108,9 +294,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
 
@@ -136,9 +325,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: cargo-deny
-        uses: EmbarkStudios/cargo-deny-action@a531616d8ce3b9177443e48a1159bc945a099823 # v2.0.19
+        uses: EmbarkStudios/cargo-deny-action@bb137d7af7e4fb67e5f82a49c4fce4fad40782fe # v2.0.20
         with:
           command: check
 
@@ -152,6 +343,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Install nightly Rust
         uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
@@ -160,6 +353,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 +366,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
 
@@ -205,22 +401,58 @@ jobs:
         python-version: ["3.9", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
 
+      # 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 +461,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
@@ -240,6 +477,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Install Rust toolchain (with wasm target)
         uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
@@ -248,6 +487,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: Install wasm-pack
         # jetli/wasm-pack-action@v0.4.0 with no `version:` input installs an
@@ -257,7 +498,8 @@ jobs:
         # 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@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: wasm-pack
 
@@ -283,21 +525,48 @@ jobs:
         node-version: ["18", "20"]
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable branch, 2026-03-27
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        continue-on-error: true # cache is an optimisation; never block on a stuck/slow restore
+        timeout-minutes: 6
 
+      # 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,56 @@
+name: CodeQL
+
+# Static analysis security testing (findings P13.x). Analyses the Rust core and
+# the Python / JavaScript binding surfaces with GitHub's CodeQL engine. Results
+# appear under Security → Code scanning. `build-mode: none` analyses source
+# directly — no compilation step — for every language here.
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: '31 3 * * 0' # Sundays 03:31 UTC
+
+# Least-privilege default for the auto-injected GITHUB_TOKEN. The analyze job
+# raises exactly the scopes CodeQL needs (security-events: write to upload
+# results) in its own job-level block below; this top-level read-only default
+# covers any future job (OpenSSF Scorecard: Token-Permissions).
+permissions:
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write # upload CodeQL results to code-scanning
+      packages: read
+      actions: read
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - language: rust
+            build-mode: none
+          - language: python
+            build-mode: none
+          - language: javascript-typescript
+            build-mode: none
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - 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:
   # --------------------------------------------------------------------------
@@ -24,8 +46,12 @@ jobs:
     environment: release
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
       - 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 +105,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,7 +158,23 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          persist-credentials: false
+      - 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
@@ -127,6 +198,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
       - 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
@@ -177,8 +250,26 @@ jobs:
     runs-on: ${{ matrix.host }}
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
-      - 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"
 
@@ -187,10 +278,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
@@ -208,17 +301,44 @@ 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
+        with:
+          persist-credentials: false
 
-      - 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
@@ -266,13 +386,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
@@ -313,12 +433,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
@@ -346,14 +466,41 @@ 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
+        with:
+          persist-credentials: false
 
-      - 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"
@@ -365,7 +512,8 @@ jobs:
       - 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@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: wasm-pack
 
@@ -384,10 +532,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));
           "
@@ -405,7 +553,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:
@@ -413,23 +561,43 @@ 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:
+          persist-credentials: false
           fetch-depth: 0
 
       - name: Resolve target tag
         id: tag
+        # Pass the (potentially attacker-influenceable on a tag push) ref context
+        # through the environment instead of interpolating it into the shell
+        # script, so a crafted tag name cannot inject commands (zizmor:
+        # template-injection).
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          REF: ${{ github.ref }}
+          REF_NAME: ${{ github.ref_name }}
         run: |
-          if [ "${{ github.event_name }}" = "push" ] && [[ "${{ github.ref }}" == refs/tags/* ]]; then
-            tag="${{ github.ref_name }}"
+          if [ "$EVENT_NAME" = "push" ] && [[ "$REF" == refs/tags/* ]]; then
+            tag="$REF_NAME"
           else
             # workflow_dispatch / non-tag push: attach to the latest v* tag.
             tag=$(git tag --list 'v*' --sort=-v:refname | head -n1)
@@ -459,10 +627,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 }}
@@ -470,6 +640,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.
 
@@ -495,4 +668,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,516 @@
+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 \
+            && grep -qE "\*\*${n} indicators\*\*" docs/README.md; then
+            echo "matches=true" >> "$GITHUB_OUTPUT"
+            echo "README + docs/README counter already at ${n}; nothing to do."
+          else
+            echo "matches=false" >> "$GITHUB_OUTPUT"
+            echo "README/docs 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 / docs/README.md say a different indicator count than lib.rs (${n}). This PR is from a fork, so the workflow cannot push the fix; please set README.md to '${n} streaming-first indicators' and docs/README.md to '**${n} indicators**', then 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 }}"
+          # docs/README.md carries the count in its docs.wickra.org pointer prose
+          # ("**N indicators**"); keep it in sync with README's prose count.
+          sed -i -E "s/[0-9]+ (streaming-first )?indicators/${n} \1indicators/g" README.md docs/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. (README only — docs has no banner.)
+          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 docs/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,24 @@
+name: sync-metadata
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  audit:
+    name: metadata audit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+      - 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

.github/workflows/zizmor.yml

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

.github/zizmor.yml

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

.gitignore

@@ -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,682 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.4] - 2026-06-02
+
+### Added
+- **TA-Lib candlestick patterns (part 1).** New candlestick pattern detectors
+  matching TA-Lib `CDL*`, emitting the family's signed `+1 / 0 / −1` convention
+  over OHLCV candles in Rust, Python, Node and WASM:
+  - **Two Crows** — a three-bar bearish reversal (`CDL2CROWS`): a long white
+    candle, a black candle whose body gaps up, then a black candle that opens
+    inside the second's body and closes inside the first's.
+  - **Upside Gap Two Crows** — a three-bar bearish reversal
+    (`CDLUPSIDEGAP2CROWS`): two black candles gap up over a long white candle,
+    the second engulfing the first crow yet still closing above the white body,
+    leaving the upside gap open.
+  - **Identical Three Crows** — a three-bar bearish reversal
+    (`CDLIDENTICAL3CROWS`): three red candles with steadily lower closes, each
+    opening at the prior candle's close so the bodies stack in an identical
+    staircase.
+  - **Three Line Strike** — a four-bar pattern (`CDL3LINESTRIKE`): a
+    three-candle advance or decline struck by a fourth opposite-colour candle
+    that engulfs the entire run; bullish `+1`, bearish `−1`.
+  - **Three Stars in the South** — a rare three-bar bullish reversal
+    (`CDL3STARSINSOUTH`): three shrinking red candles each carving a higher low
+    and contracting toward a tiny black marubozu as selling exhausts.
+  - **Abandoned Baby** — a strong three-bar reversal (`CDLABANDONEDBABY`): a doji
+    isolated by price gaps on both sides; bullish `+1` after a decline, bearish
+    `−1` after an advance.
+  - **Advance Block** — a three-bar bearish warning (`CDLADVANCEBLOCK`): three
+    green candles to higher closes whose bodies shrink as their upper shadows
+    lengthen, signalling the advance is stalling.
+  - **Belt-hold** — a single-bar reversal that opens at one extreme of its range and runs the other way; bullish +1, bearish -1 (`CDLBELTHOLD`).
+  - **Breakaway** — a 5-bar reversal that gaps with the trend, drifts two more bars, then snaps back into the bar1/bar2 body gap; bullish +1, bearish -1 (`CDLBREAKAWAY`).
+  - **Counterattack** — a 2-bar reversal where an opposite-coloured second bar closes level with the first (the counterattack line); bullish +1, bearish -1 (`CDLCOUNTERATTACK`).
+  - **Doji Star** — a long body followed by a doji gapping away in the trend direction; bullish +1, bearish -1 (`CDLDOJISTAR`).
+  - **Dragonfly Doji** — a doji opening and closing at the high with a long lower shadow, a bullish reversal; +1 (`CDLDRAGONFLYDOJI`).
+  - **Gravestone Doji** — a doji opening and closing at the low with a long upper shadow, a bearish reversal; -1 (`CDLGRAVESTONEDOJI`).
+  - **Long-Legged Doji** — a doji with long shadows on both sides, an indecision signal; +1 detection (`CDLLONGLEGGEDDOJI`).
+  - **Rickshaw Man** — a long-legged doji with the body centred in the range, an indecision signal; +1 detection (`CDLRICKSHAWMAN`).
+  - **Evening Doji Star** — a bearish top reversal: long white bar, a doji gapping up, then a black bar closing deep into the first body; -1 (`CDLEVENINGDOJISTAR`).
+  - **Morning Doji Star** — a bullish bottom reversal: long black bar, a doji gapping down, then a white bar closing deep into the first body; +1 (`CDLMORNINGDOJISTAR`).
+  - **Gap Side-by-Side White** — two similar white candles opening side by side after a gap, a continuation; gap up +1, gap down -1 (`CDLGAPSIDESIDEWHITE`).
+  - **High-Wave** — a small body with very long shadows on both sides, an extreme indecision signal; +1 detection (`CDLHIGHWAVE`).
+  - **Hikkake** — an inside bar followed by a failed breakout, a trap; bullish +1, bearish -1 (`CDLHIKKAKE`).
+  - **Modified Hikkake** — a close-confirmed Hikkake: an inside bar then a failed breakout closing back inside; bullish +1, bearish -1 (`CDLHIKKAKEMOD`).
+  - **Homing Pigeon** — two black candles, the second a small body inside the first, a bullish reversal; +1 (`CDLHOMINGPIGEON`).
+  - **On-Neck** — a long black candle then a white candle closing at its low (the neckline), a bearish continuation; -1 (`CDLONNECK`).
+  - **In-Neck** — a long black candle then a white candle closing just into its body, a bearish continuation; -1 (`CDLINNECK`).
+  - **Thrusting** — a long black candle then a white candle closing well into but below the midpoint of its body, a bearish continuation; -1 (`CDLTHRUSTING`).
+  - **Separating Lines** — opposite-coloured candles sharing the same open, the second an opening marubozu resuming the trend; bullish +1, bearish -1 (`CDLSEPARATINGLINES`).
+  - **Kicking** — two opposite-coloured marubozu separated by a gap; bullish +1, bearish -1 (`CDLKICKING`).
+  - **Kicking by Length** — a kicking pattern signalled by the colour of the longer marubozu; +1 / -1 (`CDLKICKINGBYLENGTH`).
+  - **Ladder Bottom** — three descending black candles, a fourth with an upper shadow, then a white candle gapping up, a bullish reversal; +1 (`CDLLADDERBOTTOM`).
+  - **Mat Hold** — a long white candle, a holding three-bar pullback, then a new-high white candle, a bullish continuation; +1 (`CDLMATHOLD`).
+  - **Matching Low** — a 2-bar bullish reversal where two black candles in a decline share the same close, signalling selling pressure is exhausting; bullish +1 (`CDLMATCHINGLOW`).
+  - **Long Line** — a single long-bodied candle with short shadows; bullish +1 (white) or bearish -1 (black) by colour (`CDLLONGLINE`).
+  - **Short Line** — a single short-bodied candle with short shadows; bullish +1 (white) or bearish -1 (black) by colour (`CDLSHORTLINE`).
+  - **Rising Three Methods** — a 5-bar bullish continuation: a long white candle, three small pullback bars holding within its range, then a white breakout to new highs; bullish +1 (`CDLRISEFALL3METHODS`).
+  - **Falling Three Methods** — the bearish mirror of rising three methods: a long black candle, three small bars holding within its range, then a black breakdown to new lows; bearish -1 (`CDLRISEFALL3METHODS`).
+  - **Upside Gap Three Methods** — a 3-bar bullish continuation: two white candles gap up, then a black candle opens within the second body and closes within the first; bullish +1 (`CDLXSIDEGAP3METHODS`).
+  - **Downside Gap Three Methods** — the bearish mirror of upside gap three methods: two black candles gap down, then a white candle opens within the second body and closes within the first; bearish -1 (`CDLXSIDEGAP3METHODS`).
+  - **Stalled Pattern** — a 3-bar bearish reversal warning: two long white candles then a small white candle riding the shoulder, signalling the rally is stalling; bearish -1 (`CDLSTALLEDPATTERN`).
+  - **Stick Sandwich** — a 3-bar bullish reversal: two black candles closing at the same level sandwich a white candle, marking a support floor; bullish +1 (`CDLSTICKSANDWICH`).
+  - **Takuri** — a single-bar bullish reversal, a strict Dragonfly Doji with a negligible upper shadow and very long lower shadow; bullish +1 (`CDLTAKURI`).
+  - **Closing Marubozu** — a single long-bodied candle with no shadow on the close end; bullish +1 (white, closes at the high) or bearish -1 (black, closes at the low) (`CDLCLOSINGMARUBOZU`).
+  - **Opening Marubozu** — a single long-bodied candle with no shadow on the open end; bullish +1 (white, opens at the low) or bearish -1 (black, opens at the high). No direct TA-Lib equivalent — completes the pair with the closing marubozu.
+  - **Tasuki Gap** — a 3-bar continuation: two same-coloured candles gap in the trend direction, then an opposite candle opens within the second body and closes back into the gap without filling it; upside +1, downside -1 (`CDLTASUKIGAP`).
+  - **Unique Three River** — a 3-bar bullish reversal: a long black candle, a black candle probing a new low with its body inside the first, then a small white candle held below it; bullish +1 (`CDLUNIQUE3RIVER`).
+  - **Concealing Baby Swallow** — a rare 4-bar bullish capitulation: two black marubozu, a black candle gapping down with an upper shadow into the second, then a large black candle engulfing it entirely; bullish +1 (`CDLCONCEALBABYSWALL`).
+- **Derivatives family — funding & open interest (part 1).** A new family of
+  indicators that consume a perpetual / futures tick (`DerivativesTick`,
+  bundling funding rate, mark / index / futures price, open interest,
+  positioning, taker flow and liquidations) rather than OHLCV, exposed in Rust,
+  Python, Node and WASM:
+  - **Funding Rate** — the current perpetual funding rate.
+  - **Funding Rate Mean** — the rolling mean funding rate over a window.
+  - **Funding Rate Z-Score** — the latest funding rate in standard deviations
+    from its rolling mean.
+  - **Funding Basis** — the perpetual's relative premium to spot,
+    `(markPrice − indexPrice) / indexPrice`.
+  - **Open-Interest Delta** — the tick-over-tick change in open interest.
+- **Derivatives family — open interest, flow & liquidations (part 2).** More
+  indicators over the same `DerivativesTick` feed:
+  - **OI / Price Divergence** — relative open-interest change minus relative
+    price change over a window, the positioning-vs-price gap.
+  - **OI-Weighted Price** — the cumulative mark price weighted by open interest.
+  - **Long/Short Ratio** — aggregate long size over short size.
+  - **Taker Buy/Sell Ratio** — taker buy volume over taker sell volume.
+  - **Liquidation Features** — a multi-output breakdown of long/short
+    liquidation notional into net, total and a bounded imbalance.
+- **Derivatives family — basis & term structure (part 3).** The final
+  perpetual-vs-futures basis indicators over the `DerivativesTick` feed:
+  - **Term-Structure Basis** — the dated future's relative premium to spot,
+    `(futuresPrice − indexPrice) / indexPrice`.
+  - **Calendar Spread** — the dated future's relative premium to the perpetual,
+    `(futuresPrice − markPrice) / markPrice`.
+
+## [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
@@ -399,14 +1075,21 @@ 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.7...HEAD
-[0.2.7]: https://github.com/kingchenc/wickra/compare/v0.2.6...v0.2.7
-[0.2.6]: https://github.com/kingchenc/wickra/compare/v0.2.5...v0.2.6
-[0.2.5]: https://github.com/kingchenc/wickra/compare/v0.2.1...v0.2.5
-[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.4...HEAD
+[0.4.4]: https://github.com/wickra-lib/wickra/compare/v0.4.3...v0.4.4
+[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/` | Pointer to the project Wiki, which holds all documentation. |
+| `docs/` | Pointer to the documentation site (docs.wickra.org); the docs live in the `wickra-lib/wickra-docs` repo. |
 
 ## 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
@@ -76,9 +104,9 @@ wasm-pack test --node bindings/wasm
 - **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 on the
-  [project Wiki](https://github.com/kingchenc/wickra/wiki) and the
-  `README.md` when behaviour or the public API changes. The Wiki lives in
-  a separate git repository: `https://github.com/kingchenc/wickra.wiki.git`.
+  [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.7"
+version = "0.4.4"
 dependencies = [
  "approx",
  "criterion",
@@ -1878,7 +1878,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-core"
-version = "0.2.7"
+version = "0.4.4"
 dependencies = [
  "approx",
  "proptest",
@@ -1888,7 +1888,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-data"
-version = "0.2.7"
+version = "0.4.4"
 dependencies = [
  "approx",
  "csv",
@@ -1915,7 +1915,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-node"
-version = "0.2.7"
+version = "0.4.4"
 dependencies = [
  "napi",
  "napi-build",
@@ -1925,7 +1925,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-python"
-version = "0.2.7"
+version = "0.4.4"
 dependencies = [
  "numpy",
  "pyo3",
@@ -1934,7 +1934,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-wasm"
-version = "0.2.7"
+version = "0.4.4"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

Cargo.toml

@@ -12,19 +12,19 @@ members = [
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.2.7"
-authors = ["kingchenc <kingchencp@gmail.com>"]
+version = "0.4.4"
+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.7" }
+wickra-core = { path = "crates/wickra-core", version = "0.4.4" }
 
 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=289" 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,6 +38,25 @@ 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 289 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,
@@ -109,20 +135,37 @@ python -m benchmarks.compare_libraries
 
 ## Indicators
 
-71 streaming-first indicators across eight families. Every one passes the
+289 streaming-first indicators across eighteen 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, Two Crows, Upside Gap Two Crows, Identical Three Crows, Three Line Strike, Three Stars in the South, Abandoned Baby, Advance Block, Belt-hold, Breakaway, Counterattack, Doji Star, Dragonfly Doji, Gravestone Doji, Long-Legged Doji, Rickshaw Man, Evening Doji Star, Morning Doji Star, Gap Side-by-Side White, High-Wave, Hikkake, Modified Hikkake, Homing Pigeon, On-Neck, In-Neck, Thrusting, Separating Lines, Kicking, Kicking by Length, Ladder Bottom, Mat Hold, Matching Low, Long Line, Short Line, Rising Three Methods, Falling Three Methods, Upside Gap Three Methods, Downside Gap Three Methods, Stalled Pattern, Stick Sandwich, Takuri, Closing Marubozu, Opening Marubozu, Tasuki Gap, Unique Three River, Concealing Baby Swallow |
+| 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 |
+| Derivatives          | Funding Rate, Funding Rate Mean, Funding Rate Z-Score, Funding Basis, Open-Interest Delta, OI / Price Divergence, OI-Weighted Price, Long/Short Ratio, Taker Buy/Sell Ratio, Liquidation Features, Term-Structure Basis, Calendar Spread |
+| 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 +238,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 289 indicators
 │   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
 │   └── wickra-data/         CSV reader, tick aggregator, live exchange feeds
 ├── bindings/
@@ -256,7 +299,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:
 
@@ -300,14 +343,14 @@ The library is provided **as is**, without warranty of any kind; see
 ---
 
 <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,306 +1,73 @@
-# Wickra
+# Wickra — Node.js
 
-[![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)
-[![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/)
+[![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)](LICENSE)
+[![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. Install with `pip install wickra` — no system dependencies.**
+**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 a state
-machine that updates in O(1) per new data point, so live trading bots and
-historical backtests share the exact same implementation.
+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.
 
-```python
-import numpy as np
-import wickra as ta
-
-# Batch: classic TA-Lib-style usage
-prices = np.linspace(100, 200, 1000)
-rsi = ta.RSI(14)
-values = rsi.batch(prices)              # numpy array, NaN during warmup
-
-# Streaming: same indicator, fed tick by tick
-rsi = ta.RSI(14)
-for price in live_feed:
-    value = rsi.update(price)           # O(1) — no recomputation over history
-    if value is not None and value > 70:
-        print("overbought")
-```
-
-## 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 |
-|------------------------|-----------------|-----------|----------------|--------|
-| **★ 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.
-
-## Benchmark: how much faster is "streaming-first"?
-
-The numbers below were measured on a single developer workstation and are not
-guaranteed to reproduce identically on different hardware — absolute µs values
-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 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
-  `python -m benchmarks.compare_libraries`. The script auto-detects every
-  installed peer library and runs them on the same generated inputs as
-  Wickra. The CI job `cross-library-bench` runs the same script on every
-  push and uploads the raw report as a build artefact.
-
-Lower µs/op = faster. Wickra wins every batch category outright, and the
-streaming gap widens linearly with how much history a batch-only library has
-to recompute on every tick.
-
-### Batch — single full pass over a 20 000-bar series
-
-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                        |
-|---------------------|---------------------|-----------------------------|-------------------------------|
-| 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)   |
-| RSI(14)             | **126.2 µs ★**      | 1 107.1 µs (8.8× slower)    | 15 792.2 µs (125.1× slower)   |
-| MACD(12, 26, 9)     | **119.0 µs ★**      | 531.8 µs (4.5× slower)      | 49 788.1 µs (418.2× slower)   |
-| Bollinger(20, 2.0)  | **105.3 µs ★**      | 812.0 µs (7.7× slower)      | 130 938.3 µs (1 243.7× slower)|
-| ATR(14)             | **123.5 µs ★**      | 5 144.8 µs (41.7× slower)   | 28 816.0 µs (233.4× slower)   |
-
-### Streaming — per-tick latency after seeding with 5 000 historical bars
-
-A batch-only library has to re-run its full indicator over the entire history on
-every new tick; Wickra updates state in O(1).
-
-| Indicator | **★ Wickra (per tick)** | talipp (per tick)         |
-|-----------|---------------------|---------------------------|
-| RSI(14)   | **0.119 µs ★**      | 1.644 µs (13.8× slower)   |
-
-> TA-Lib and pandas-ta are not included here because both fail to install
-> cleanly on Windows without C build tooling — which is precisely the install
-> pain Wickra was built to remove. The benchmark script auto-detects every
-> peer library it can find and runs them on the same inputs as Wickra; install
-> them in your environment to see those rows light up too.
-
-Run the suite yourself:
+## Install
 
 ```bash
-pip install -e bindings/python[bench]
-python -m benchmarks.compare_libraries
+npm install wickra
 ```
 
-## Indicators
+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.
 
-71 streaming-first indicators across eight families. Every one passes the
-`batch == streaming` equivalence test, reference-value tests, and reset
-semantics tests.
+## Quick start
 
-| 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 |
+```js
+const wickra = require('wickra');
 
-Adding a new indicator means implementing one trait in Rust; all four bindings
-inherit it automatically.
+// 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
 
-## Languages
-
-| Binding           | Install                                       | Example |
-|-------------------|-----------------------------------------------|---------|
-| Python (PyO3)     | `pip install wickra`                          | `examples/python/backtest.py` |
-| Node.js (napi-rs) | `npm install wickra`                          | `examples/node/backtest.js` |
-| Browser / WASM    | `npm install wickra-wasm`                     | `examples/wasm/index.html` |
-| Rust              | `cargo add wickra`                            | `examples/rust/src/bin/backtest.rs` |
-
-Each binding ships several runnable examples (streaming, backtest, live feed);
-[`examples/README.md`](examples/README.md) is the full cross-language index.
-
-The wickra-core crate is `unsafe`-forbidden, so every binding inherits a
-memory-safe implementation.
-
-## Rust API
-
-```rust
-use wickra::{Indicator, BatchExt, Chain, Ema, Rsi, Sma};
-
-// Streaming or batch — same trait, same code.
-let mut sma = Sma::new(14)?;
-let out: Vec<Option<f64>> = sma.batch(&[1.0, 2.0, 3.0, 4.0, 5.0]);
-
-let mut rsi = Rsi::new(14)?;
-for price in live_feed {
-    if let Some(v) = rsi.update(price) {
-        println!("RSI = {v}");
-    }
-}
-
-// Compose indicators: RSI(7) on top of EMA(14).
-let mut chain = Chain::new(Ema::new(14)?, Rsi::new(7)?);
-chain.update(price);
-```
-
-## Live data sources
-
-`wickra-data` (separate crate, opt-in) ships:
-
-- A streaming OHLCV **CSV reader**.
-- A **tick-to-candle aggregator** with arbitrary timeframes.
-- A **candle resampler** for multi-timeframe analysis (1m → 5m → 1h on the fly).
-- A **Binance Spot WebSocket** kline adapter (feature `live-binance`).
-
-```rust
-use wickra::{Indicator, Rsi};
-use wickra_data::live::binance::{BinanceKlineStream, Interval};
-
-let mut stream = BinanceKlineStream::connect(&["BTCUSDT".into()], Interval::OneMinute).await?;
-let mut rsi = Rsi::new(14)?;
-while let Some(event) = stream.next_event().await? {
-    if event.is_closed {
-        if let Some(v) = rsi.update(event.candle.close) {
-            println!("RSI = {v:.2}");
-        }
-    }
+// 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');
+  }
 }
 ```
 
-A Python live-trading example using the public `websockets` package lives at
-`examples/python/live_trading.py`.
+`batch(prices)` and feeding the same prices through `update()` produce
+identical values — the equivalence is enforced by the test suite.
 
-## Project layout
+## Documentation
 
-```
-wickra/
-├── crates/
-│   ├── wickra-core/         core engine + all 71 indicators
-│   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
-│   └── wickra-data/         CSV reader, tick aggregator, live exchange feeds
-├── bindings/
-│   ├── python/              PyO3 + maturin (publishes on PyPI)
-│   ├── node/                napi-rs (publishes on npm)
-│   └── wasm/                wasm-bindgen (browsers, bundlers, Node)
-├── examples/                examples/README.md indexes every language
-│   ├── data/                real BTCUSDT OHLCV datasets, one per timeframe
-│   ├── rust/                Rust workspace member (`wickra-examples`)
-│   ├── python/              backtest, live trading, parallel assets, multi-tf
-│   ├── node/                streaming, backtest, live trading (load `wickra`)
-│   └── wasm/                browser demo for `wickra-wasm`
-└── .github/workflows/       CI and release pipelines
-```
+The full indicator catalogue, guides, quickstarts, and API reference live in
+the main repository and documentation site:
 
-Rust benchmarks live in `crates/wickra/benches/`; runnable Rust examples live
-in the workspace member crate at `examples/rust/`. There is no top-level
-`benches/` directory.
+- **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)
 
-## Building everything from source
+Wickra ships four bindings — Python, Node.js, WebAssembly, and Rust — that all
+expose the same indicators from the shared, `unsafe`-forbidden Rust core.
 
-```bash
-# Rust core + tests
-cargo test --workspace
-cargo clippy --workspace --all-targets -- -D warnings
-cargo bench -p wickra
+## Disclaimer
 
-# Python binding (requires Rust toolchain + maturin)
-cd bindings/python
-maturin develop --release
-pytest
-
-# WASM binding (requires wasm-pack + wasm32-unknown-unknown target)
-wasm-pack build bindings/wasm --target web --release --features panic-hook
-
-# Node binding (requires @napi-rs/cli)
-cd bindings/node && npm install && npm run build && npm test
-```
-
-## Testing
-
-Every layer is covered; run the suites with the commands in
-[Building everything from source](#building-everything-from-source).
-
-- `wickra-core`: unit tests per indicator — textbook reference values
-  (Wilder RSI, Bollinger Bands, MACD, ATR, Stochastic), `batch == streaming`
-  equivalence, `reset` semantics, NaN/Inf handling, and property tests.
-- `wickra-data`: unit tests for CSV decoding, the tick aggregator, the
-  resampler, and the Binance payload parser.
-- `bindings/python`: pytest covering smoke checks, streaming/batch
-  equivalence, reference values, lifecycle, input validation, and
-  dict/tuple candle inputs.
-- `bindings/node`: `node --test` cases for batch, streaming, and reference
-  values across all indicators.
-- `bindings/wasm`: `wasm-bindgen-test` cases for constructors, equivalence,
-  and reference values.
-
-## Contributing
-
-Contributions are very welcome — issues, bug reports, ideas, and pull requests
-all land in the same place: <https://github.com/kingchenc/wickra>.
-
-A short orientation for first-time contributors:
-
-- **Adding an indicator.** Implement the `Indicator` trait in
-  `crates/wickra-core/src/indicators/<name>.rs`, wire it into
-  `indicators/mod.rs` and the crate root, and add reference-value tests,
-  a `batch == streaming` equivalence test, and (where it makes sense) a
-  proptest. The four bindings inherit your indicator automatically once
-  you expose it in the language wrappers.
-- **Fixing a numeric bug.** Add a failing test that pins the textbook value
-  first, then fix the math. Property tests in `crates/wickra-core` catch
-  most regressions; please don't disable them.
-- **Improving a binding.** Each binding lives under `bindings/<lang>` with
-  its own tests; please keep the `batch == streaming` invariant.
-- **Style.** `cargo fmt --all` + `cargo clippy --workspace --all-targets -- -D warnings`
-  are CI gates; running them locally before pushing keeps reviews short.
-
-For larger architectural changes, open an issue first so we can sketch the
-shape together before you invest the time.
+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**. See [LICENSE](LICENSE).
-
-In plain English: use it, fork it, modify it, redistribute it, file issues, send
-pull requests — all welcome. Personal projects, research, education, non-profits,
-government, hobby trading bots: all fine. The one thing that's not allowed is
-commercial sale of the software or of services built around it. If you want to
-use Wickra commercially, get in touch about a license.
-
----
-
-<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>
-  <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>
-  <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>
-</p>
-
-<p align="center">
-  If Wickra saved you time, the cheapest way to say thanks is to ⭐ the repo.
-</p>
+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__/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, TwoCrows, UpsideGapTwoCrows, IdenticalThreeCrows, ThreeLineStrike, ThreeStarsInSouth, AbandonedBaby, AdvanceBlock, BeltHold, Breakaway, Counterattack, DojiStar, DragonflyDoji, GravestoneDoji, LongLeggedDoji, RickshawMan, EveningDojiStar, MorningDojiStar, GapSideBySideWhite, HighWave, Hikkake, HikkakeModified, HomingPigeon, OnNeck, InNeck, Thrusting, SeparatingLines, Kicking, KickingByLength, LadderBottom, MatHold, MatchingLow, LongLine, ShortLine, RisingThreeMethods, FallingThreeMethods, UpsideGapThreeMethods, DownsideGapThreeMethods, StalledPattern, StickSandwich, Takuri, ClosingMarubozu, OpeningMarubozu, TasukiGap, UniqueThreeRiver, ConcealingBabySwallow, OrderBookImbalanceTop1, OrderBookImbalanceFull, Microprice, QuotedSpread, DepthSlope, OrderBookImbalanceTopN, SignedVolume, CumulativeVolumeDelta, TradeImbalance, EffectiveSpread, RealizedSpread, KylesLambda, Footprint, FundingRate, FundingRateMean, FundingRateZScore, FundingBasis, OpenInterestDelta, OIPriceDivergence, OIWeighted, LongShortRatio, TakerBuySellRatio, LiquidationFeatures, TermStructureBasis, CalendarSpread, 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,149 @@ 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.TwoCrows = TwoCrows
+module.exports.UpsideGapTwoCrows = UpsideGapTwoCrows
+module.exports.IdenticalThreeCrows = IdenticalThreeCrows
+module.exports.ThreeLineStrike = ThreeLineStrike
+module.exports.ThreeStarsInSouth = ThreeStarsInSouth
+module.exports.AbandonedBaby = AbandonedBaby
+module.exports.AdvanceBlock = AdvanceBlock
+module.exports.BeltHold = BeltHold
+module.exports.Breakaway = Breakaway
+module.exports.Counterattack = Counterattack
+module.exports.DojiStar = DojiStar
+module.exports.DragonflyDoji = DragonflyDoji
+module.exports.GravestoneDoji = GravestoneDoji
+module.exports.LongLeggedDoji = LongLeggedDoji
+module.exports.RickshawMan = RickshawMan
+module.exports.EveningDojiStar = EveningDojiStar
+module.exports.MorningDojiStar = MorningDojiStar
+module.exports.GapSideBySideWhite = GapSideBySideWhite
+module.exports.HighWave = HighWave
+module.exports.Hikkake = Hikkake
+module.exports.HikkakeModified = HikkakeModified
+module.exports.HomingPigeon = HomingPigeon
+module.exports.OnNeck = OnNeck
+module.exports.InNeck = InNeck
+module.exports.Thrusting = Thrusting
+module.exports.SeparatingLines = SeparatingLines
+module.exports.Kicking = Kicking
+module.exports.KickingByLength = KickingByLength
+module.exports.LadderBottom = LadderBottom
+module.exports.MatHold = MatHold
+module.exports.MatchingLow = MatchingLow
+module.exports.LongLine = LongLine
+module.exports.ShortLine = ShortLine
+module.exports.RisingThreeMethods = RisingThreeMethods
+module.exports.FallingThreeMethods = FallingThreeMethods
+module.exports.UpsideGapThreeMethods = UpsideGapThreeMethods
+module.exports.DownsideGapThreeMethods = DownsideGapThreeMethods
+module.exports.StalledPattern = StalledPattern
+module.exports.StickSandwich = StickSandwich
+module.exports.Takuri = Takuri
+module.exports.ClosingMarubozu = ClosingMarubozu
+module.exports.OpeningMarubozu = OpeningMarubozu
+module.exports.TasukiGap = TasukiGap
+module.exports.UniqueThreeRiver = UniqueThreeRiver
+module.exports.ConcealingBabySwallow = ConcealingBabySwallow
+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.FundingRate = FundingRate
+module.exports.FundingRateMean = FundingRateMean
+module.exports.FundingRateZScore = FundingRateZScore
+module.exports.FundingBasis = FundingBasis
+module.exports.OpenInterestDelta = OpenInterestDelta
+module.exports.OIPriceDivergence = OIPriceDivergence
+module.exports.OIWeighted = OIWeighted
+module.exports.LongShortRatio = LongShortRatio
+module.exports.TakerBuySellRatio = TakerBuySellRatio
+module.exports.LiquidationFeatures = LiquidationFeatures
+module.exports.TermStructureBasis = TermStructureBasis
+module.exports.CalendarSpread = CalendarSpread
+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.7",
+  "version": "0.4.4",
   "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.7",
+  "version": "0.4.4",
   "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.7",
+  "version": "0.4.4",
   "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.7",
+  "version": "0.4.4",
   "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

@@ -1,12 +1,12 @@
 {
   "name": "wickra-win32-arm64-msvc",
-  "version": "0.2.7",
+  "version": "0.4.4",
   "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": "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/win32-x64-msvc/package.json

@@ -1,12 +1,12 @@
 {
   "name": "wickra-win32-x64-msvc",
-  "version": "0.2.7",
+  "version": "0.4.4",
   "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.4",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "wickra",
+      "version": "0.4.4",
+      "license": "PolyForm-Noncommercial-1.0.0",
+      "devDependencies": {
+        "@napi-rs/cli": "^2.18.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "optionalDependencies": {
+        "wickra-darwin-arm64": "0.4.4",
+        "wickra-darwin-x64": "0.4.4",
+        "wickra-linux-arm64-gnu": "0.4.4",
+        "wickra-linux-x64-gnu": "0.4.4",
+        "wickra-win32-arm64-msvc": "0.4.4",
+        "wickra-win32-x64-msvc": "0.4.4"
+      }
+    },
+    "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.4",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.4.4.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.4",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.4.4.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.4",
+      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.4.4.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.4",
+      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.4.4.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.4",
+      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.4.4.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.4",
+      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.4.4.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.7",
+  "version": "0.4.4",
   "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",
@@ -47,12 +47,12 @@
     "node": ">= 18"
   },
   "optionalDependencies": {
-    "wickra-linux-x64-gnu": "0.2.7",
-    "wickra-linux-arm64-gnu": "0.2.7",
-    "wickra-darwin-x64": "0.2.7",
-    "wickra-darwin-arm64": "0.2.7",
-    "wickra-win32-x64-msvc": "0.2.7",
-    "wickra-win32-arm64-msvc": "0.2.7"
+    "wickra-linux-x64-gnu": "0.4.4",
+    "wickra-linux-arm64-gnu": "0.4.4",
+    "wickra-darwin-x64": "0.4.4",
+    "wickra-darwin-arm64": "0.4.4",
+    "wickra-win32-x64-msvc": "0.4.4",
+    "wickra-win32-arm64-msvc": "0.4.4"
   },
   "scripts": {
     "build": "napi build --platform --release",
@@ -60,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,306 +1,72 @@
-# Wickra
+# Wickra — Python
 
-[![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)
-[![crates.io](https://img.shields.io/crates/v/wickra.svg?logo=rust&color=orange)](https://crates.io/crates/wickra)
+[![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/)
-[![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)
+[![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. Install with `pip install wickra` — no system dependencies.**
+**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 a state
-machine that updates in O(1) per new data point, so live trading bots and
-historical backtests share the exact same implementation.
+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: classic TA-Lib-style usage
+# Batch: classic TA-Lib-style usage over a whole array.
 prices = np.linspace(100, 200, 1000)
 rsi = ta.RSI(14)
 values = rsi.batch(prices)              # numpy array, NaN during warmup
 
-# Streaming: same indicator, fed tick by tick
+# Streaming: the same indicator, fed tick by tick in O(1).
 rsi = ta.RSI(14)
 for price in live_feed:
-    value = rsi.update(price)           # O(1) — no recomputation over history
+    value = rsi.update(price)           # no recomputation over history
     if value is not None and value > 70:
         print("overbought")
 ```
 
-## Why Wickra exists
+`batch(prices)` and feeding the same prices through `update()` produce
+identical values — the equivalence is enforced by the test suite.
 
-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:
+## Documentation
 
-| Library                | Install pain    | Streaming | Multi-language | Active |
-|------------------------|-----------------|-----------|----------------|--------|
-| **★ 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    |
+The full indicator catalogue, guides, quickstarts, and API reference live in
+the main repository and documentation site:
 
-Wickra is the only library that combines all of: clean install, streaming,
-multi-language reach, and active maintenance.
+- **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)
 
-## Benchmark: how much faster is "streaming-first"?
+Wickra ships four bindings — Python, Node.js, WebAssembly, and Rust — that all
+expose the same indicators from the shared, `unsafe`-forbidden Rust core.
 
-The numbers below were measured on a single developer workstation and are not
-guaranteed to reproduce identically on different hardware — absolute µs values
-depend on CPU, memory clock and OS scheduler. Read them as **relative
-speedups** between libraries on identical input, not as a universal
-performance contract.
+## Disclaimer
 
-- **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
-  `python -m benchmarks.compare_libraries`. The script auto-detects every
-  installed peer library and runs them on the same generated inputs as
-  Wickra. The CI job `cross-library-bench` runs the same script on every
-  push and uploads the raw report as a build artefact.
-
-Lower µs/op = faster. Wickra wins every batch category outright, and the
-streaming gap widens linearly with how much history a batch-only library has
-to recompute on every tick.
-
-### Batch — single full pass over a 20 000-bar series
-
-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           | **★&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)   |
-| RSI(14)             | **126.2 µs ★**      | 1 107.1 µs (8.8× slower)    | 15 792.2 µs (125.1× slower)   |
-| MACD(12, 26, 9)     | **119.0 µs ★**      | 531.8 µs (4.5× slower)      | 49 788.1 µs (418.2× slower)   |
-| Bollinger(20, 2.0)  | **105.3 µs ★**      | 812.0 µs (7.7× slower)      | 130 938.3 µs (1 243.7× slower)|
-| ATR(14)             | **123.5 µs ★**      | 5 144.8 µs (41.7× slower)   | 28 816.0 µs (233.4× slower)   |
-
-### Streaming — per-tick latency after seeding with 5 000 historical bars
-
-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 | **★&nbsp;Wickra (per tick)** | talipp (per tick)         |
-|-----------|---------------------|---------------------------|
-| RSI(14)   | **0.119 µs ★**      | 1.644 µs (13.8× slower)   |
-
-> TA-Lib and pandas-ta are not included here because both fail to install
-> cleanly on Windows without C build tooling — which is precisely the install
-> pain Wickra was built to remove. The benchmark script auto-detects every
-> peer library it can find and runs them on the same inputs as Wickra; install
-> them in your environment to see those rows light up too.
-
-Run the suite yourself:
-
-```bash
-pip install -e bindings/python[bench]
-python -m benchmarks.compare_libraries
-```
-
-## Indicators
-
-71 streaming-first indicators across eight families. Every one passes the
-`batch == streaming` equivalence test, reference-value tests, and reset
-semantics tests.
-
-| 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 |
-
-Adding a new indicator means implementing one trait in Rust; all four bindings
-inherit it automatically.
-
-## Languages
-
-| Binding           | Install                                       | Example |
-|-------------------|-----------------------------------------------|---------|
-| Python (PyO3)     | `pip install wickra`                          | `examples/python/backtest.py` |
-| Node.js (napi-rs) | `npm install wickra`                          | `examples/node/backtest.js` |
-| Browser / WASM    | `npm install wickra-wasm`                     | `examples/wasm/index.html` |
-| Rust              | `cargo add wickra`                            | `examples/rust/src/bin/backtest.rs` |
-
-Each binding ships several runnable examples (streaming, backtest, live feed);
-[`examples/README.md`](examples/README.md) is the full cross-language index.
-
-The wickra-core crate is `unsafe`-forbidden, so every binding inherits a
-memory-safe implementation.
-
-## Rust API
-
-```rust
-use wickra::{Indicator, BatchExt, Chain, Ema, Rsi, Sma};
-
-// Streaming or batch — same trait, same code.
-let mut sma = Sma::new(14)?;
-let out: Vec<Option<f64>> = sma.batch(&[1.0, 2.0, 3.0, 4.0, 5.0]);
-
-let mut rsi = Rsi::new(14)?;
-for price in live_feed {
-    if let Some(v) = rsi.update(price) {
-        println!("RSI = {v}");
-    }
-}
-
-// Compose indicators: RSI(7) on top of EMA(14).
-let mut chain = Chain::new(Ema::new(14)?, Rsi::new(7)?);
-chain.update(price);
-```
-
-## Live data sources
-
-`wickra-data` (separate crate, opt-in) ships:
-
-- A streaming OHLCV **CSV reader**.
-- A **tick-to-candle aggregator** with arbitrary timeframes.
-- A **candle resampler** for multi-timeframe analysis (1m → 5m → 1h on the fly).
-- A **Binance Spot WebSocket** kline adapter (feature `live-binance`).
-
-```rust
-use wickra::{Indicator, Rsi};
-use wickra_data::live::binance::{BinanceKlineStream, Interval};
-
-let mut stream = BinanceKlineStream::connect(&["BTCUSDT".into()], Interval::OneMinute).await?;
-let mut rsi = Rsi::new(14)?;
-while let Some(event) = stream.next_event().await? {
-    if event.is_closed {
-        if let Some(v) = rsi.update(event.candle.close) {
-            println!("RSI = {v:.2}");
-        }
-    }
-}
-```
-
-A Python live-trading example using the public `websockets` package lives at
-`examples/python/live_trading.py`.
-
-## Project layout
-
-```
-wickra/
-├── crates/
-│   ├── wickra-core/         core engine + all 71 indicators
-│   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
-│   └── wickra-data/         CSV reader, tick aggregator, live exchange feeds
-├── bindings/
-│   ├── python/              PyO3 + maturin (publishes on PyPI)
-│   ├── node/                napi-rs (publishes on npm)
-│   └── wasm/                wasm-bindgen (browsers, bundlers, Node)
-├── examples/                examples/README.md indexes every language
-│   ├── data/                real BTCUSDT OHLCV datasets, one per timeframe
-│   ├── rust/                Rust workspace member (`wickra-examples`)
-│   ├── python/              backtest, live trading, parallel assets, multi-tf
-│   ├── node/                streaming, backtest, live trading (load `wickra`)
-│   └── wasm/                browser demo for `wickra-wasm`
-└── .github/workflows/       CI and release pipelines
-```
-
-Rust benchmarks live in `crates/wickra/benches/`; runnable Rust examples live
-in the workspace member crate at `examples/rust/`. There is no top-level
-`benches/` directory.
-
-## Building everything from source
-
-```bash
-# Rust core + tests
-cargo test --workspace
-cargo clippy --workspace --all-targets -- -D warnings
-cargo bench -p wickra
-
-# Python binding (requires Rust toolchain + maturin)
-cd bindings/python
-maturin develop --release
-pytest
-
-# WASM binding (requires wasm-pack + wasm32-unknown-unknown target)
-wasm-pack build bindings/wasm --target web --release --features panic-hook
-
-# Node binding (requires @napi-rs/cli)
-cd bindings/node && npm install && npm run build && npm test
-```
-
-## Testing
-
-Every layer is covered; run the suites with the commands in
-[Building everything from source](#building-everything-from-source).
-
-- `wickra-core`: unit tests per indicator — textbook reference values
-  (Wilder RSI, Bollinger Bands, MACD, ATR, Stochastic), `batch == streaming`
-  equivalence, `reset` semantics, NaN/Inf handling, and property tests.
-- `wickra-data`: unit tests for CSV decoding, the tick aggregator, the
-  resampler, and the Binance payload parser.
-- `bindings/python`: pytest covering smoke checks, streaming/batch
-  equivalence, reference values, lifecycle, input validation, and
-  dict/tuple candle inputs.
-- `bindings/node`: `node --test` cases for batch, streaming, and reference
-  values across all indicators.
-- `bindings/wasm`: `wasm-bindgen-test` cases for constructors, equivalence,
-  and reference values.
-
-## Contributing
-
-Contributions are very welcome — issues, bug reports, ideas, and pull requests
-all land in the same place: <https://github.com/kingchenc/wickra>.
-
-A short orientation for first-time contributors:
-
-- **Adding an indicator.** Implement the `Indicator` trait in
-  `crates/wickra-core/src/indicators/<name>.rs`, wire it into
-  `indicators/mod.rs` and the crate root, and add reference-value tests,
-  a `batch == streaming` equivalence test, and (where it makes sense) a
-  proptest. The four bindings inherit your indicator automatically once
-  you expose it in the language wrappers.
-- **Fixing a numeric bug.** Add a failing test that pins the textbook value
-  first, then fix the math. Property tests in `crates/wickra-core` catch
-  most regressions; please don't disable them.
-- **Improving a binding.** Each binding lives under `bindings/<lang>` with
-  its own tests; please keep the `batch == streaming` invariant.
-- **Style.** `cargo fmt --all` + `cargo clippy --workspace --all-targets -- -D warnings`
-  are CI gates; running them locally before pushing keeps reviews short.
-
-For larger architectural changes, open an issue first so we can sketch the
-shape together before you invest the time.
+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**. See [LICENSE](LICENSE).
-
-In plain English: use it, fork it, modify it, redistribute it, file issues, send
-pull requests — all welcome. Personal projects, research, education, non-profits,
-government, hobby trading bots: all fine. The one thing that's not allowed is
-commercial sale of the software or of services built around it. If you want to
-use Wickra commercially, get in touch about a license.
-
----
-
-<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>
-  <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>
-  <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>
-</p>
-
-<p align="center">
-  If Wickra saved you time, the cheapest way to say thanks is to ⭐ the repo.
-</p>
+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.7"
+version = "0.4.4"
 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,190 @@ 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,
+    TwoCrows,
+    UpsideGapTwoCrows,
+    IdenticalThreeCrows,
+    ThreeLineStrike,
+    ThreeStarsInSouth,
+    AbandonedBaby,
+    AdvanceBlock,
+    BeltHold,
+    Breakaway,
+    Counterattack,
+    DojiStar,
+    DragonflyDoji,
+    GravestoneDoji,
+    LongLeggedDoji,
+    RickshawMan,
+    EveningDojiStar,
+    MorningDojiStar,
+    GapSideBySideWhite,
+    HighWave,
+    Hikkake,
+    HikkakeModified,
+    HomingPigeon,
+    OnNeck,
+    InNeck,
+    Thrusting,
+    SeparatingLines,
+    Kicking,
+    KickingByLength,
+    LadderBottom,
+    MatHold,
+    MatchingLow,
+    LongLine,
+    ShortLine,
+    RisingThreeMethods,
+    FallingThreeMethods,
+    UpsideGapThreeMethods,
+    DownsideGapThreeMethods,
+    StalledPattern,
+    StickSandwich,
+    Takuri,
+    ClosingMarubozu,
+    OpeningMarubozu,
+    TasukiGap,
+    UniqueThreeRiver,
+    ConcealingBabySwallow,
+    # Microstructure: order book
+    OrderBookImbalanceTop1,
+    OrderBookImbalanceTopN,
+    OrderBookImbalanceFull,
+    Microprice,
+    QuotedSpread,
+    DepthSlope,
+    # Microstructure: trade flow
+    SignedVolume,
+    CumulativeVolumeDelta,
+    TradeImbalance,
+    # Microstructure: price impact
+    EffectiveSpread,
+    RealizedSpread,
+    KylesLambda,
+    # Microstructure: footprint
+    Footprint,
+    # Derivatives
+    FundingRate,
+    FundingRateMean,
+    FundingRateZScore,
+    FundingBasis,
+    OpenInterestDelta,
+    OIPriceDivergence,
+    OIWeighted,
+    LongShortRatio,
+    TakerBuySellRatio,
+    LiquidationFeatures,
+    TermStructureBasis,
+    CalendarSpread,
+    # Risk / Performance
+    SharpeRatio,
+    SortinoRatio,
+    CalmarRatio,
+    OmegaRatio,
+    MaxDrawdown,
+    AverageDrawdown,
+    DrawdownDuration,
+    PainIndex,
+    ValueAtRisk,
+    ConditionalValueAtRisk,
+    ProfitFactor,
+    GainLossRatio,
+    RecoveryFactor,
+    KellyCriterion,
+    TreynorRatio,
+    InformationRatio,
+    Alpha,
 )
 
 __all__ = [
@@ -119,6 +350,13 @@ __all__ = [
     "ZLEMA",
     "T3",
     "VWMA",
+    "ALMA",
+    "McGinleyDynamic",
+    "FRAMA",
+    "VIDYA",
+    "JMA",
+    "Alligator",
+    "EVWMA",
     # Momentum
     "RSI",
     "MACD",
@@ -127,6 +365,7 @@ __all__ = [
     "ROC",
     "WilliamsR",
     "ADX",
+    "ADXR",
     "MFI",
     "TRIX",
     "AwesomeOscillator",
@@ -135,13 +374,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 +419,20 @@ __all__ = [
     "ChandelierExit",
     "ChandeKrollStop",
     "AtrTrailingStop",
+    "HiLoActivator",
+    "VoltyStop",
+    "YoyoExit",
+    "DonchianStop",
+    "PercentageTrailingStop",
+    "StepTrailingStop",
+    "RenkoTrailingStop",
     "TrueRange",
     "ChaikinVolatility",
+    "RVIVolatility",
+    "ParkinsonVolatility",
+    "GarmanKlassVolatility",
+    "RogersSatchellVolatility",
+    "YangZhangVolatility",
     # Volume
     "OBV",
     "VWAP",
@@ -174,6 +442,16 @@ __all__ = [
     "ChaikinMoneyFlow",
     "ChaikinOscillator",
     "ForceIndex",
+    "KVO",
+    "VolumeOscillator",
+    "NVI",
+    "PVI",
+    "WilliamsAD",
+    "AnchoredVWAP",
+    "DemandIndex",
+    "TSV",
+    "VZO",
+    "MarketFacilitationIndex",
     "EaseOfMovement",
     # Statistics
     "TypicalPrice",
@@ -183,4 +461,188 @@ __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",
+    "TwoCrows",
+    "UpsideGapTwoCrows",
+    "IdenticalThreeCrows",
+    "ThreeLineStrike",
+    "ThreeStarsInSouth",
+    "AbandonedBaby",
+    "AdvanceBlock",
+    "BeltHold",
+    "Breakaway",
+    "Counterattack",
+    "DojiStar",
+    "DragonflyDoji",
+    "GravestoneDoji",
+    "LongLeggedDoji",
+    "RickshawMan",
+    "EveningDojiStar",
+    "MorningDojiStar",
+    "GapSideBySideWhite",
+    "HighWave",
+    "Hikkake",
+    "HikkakeModified",
+    "HomingPigeon",
+    "OnNeck",
+    "InNeck",
+    "Thrusting",
+    "SeparatingLines",
+    "Kicking",
+    "KickingByLength",
+    "LadderBottom",
+    "MatHold",
+    "MatchingLow",
+    "LongLine",
+    "ShortLine",
+    "RisingThreeMethods",
+    "FallingThreeMethods",
+    "UpsideGapThreeMethods",
+    "DownsideGapThreeMethods",
+    "StalledPattern",
+    "StickSandwich",
+    "Takuri",
+    "ClosingMarubozu",
+    "OpeningMarubozu",
+    "TasukiGap",
+    "UniqueThreeRiver",
+    "ConcealingBabySwallow",
+    # Microstructure: order book
+    "OrderBookImbalanceTop1",
+    "OrderBookImbalanceTopN",
+    "OrderBookImbalanceFull",
+    "Microprice",
+    "QuotedSpread",
+    "DepthSlope",
+    # Microstructure: trade flow
+    "SignedVolume",
+    "CumulativeVolumeDelta",
+    "TradeImbalance",
+    # Microstructure: price impact
+    "EffectiveSpread",
+    "RealizedSpread",
+    "KylesLambda",
+    # Microstructure: footprint
+    "Footprint",
+    # Derivatives
+    "FundingRate",
+    "FundingRateMean",
+    "FundingRateZScore",
+    "FundingBasis",
+    "OpenInterestDelta",
+    "OIPriceDivergence",
+    "OIWeighted",
+    "LongShortRatio",
+    "TakerBuySellRatio",
+    "LiquidationFeatures",
+    "TermStructureBasis",
+    "CalendarSpread",
+    # 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,246 @@ 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)
+
+
+def test_funding_rate_mean_zero_window_raises():
+    with pytest.raises(ValueError):
+        ta.FundingRateMean(0)
+
+
+def test_funding_rate_zscore_zero_window_raises():
+    with pytest.raises(ValueError):
+        ta.FundingRateZScore(0)
+
+
+def test_funding_basis_non_positive_index_raises():
+    with pytest.raises(ValueError):
+        ta.FundingBasis().update(100.0, 0.0)
+
+
+def test_funding_rate_non_finite_raises():
+    with pytest.raises(ValueError):
+        ta.FundingRate().update(float("nan"))
+
+
+def test_oi_price_divergence_zero_window_raises():
+    with pytest.raises(ValueError):
+        ta.OIPriceDivergence(0)
+
+
+def test_oi_weighted_non_positive_mark_raises():
+    with pytest.raises(ValueError):
+        ta.OIWeighted().update(0.0, 100.0)
+
+
+def test_term_structure_basis_non_positive_index_raises():
+    with pytest.raises(ValueError):
+        ta.TermStructureBasis().update(100.0, 0.0)
+
+
+def test_calendar_spread_non_positive_mark_raises():
+    with pytest.raises(ValueError):
+        ta.CalendarSpread().update(100.0, 0.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,699 @@ 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)
+
+
+def test_funding_rate_reference_values():
+    assert ta.FundingRate().update(0.0001) == pytest.approx(0.0001)
+    assert ta.FundingRate().update(-0.0003) == pytest.approx(-0.0003)
+
+
+def test_funding_rate_mean_reference_value():
+    frm = ta.FundingRateMean(2)
+    assert frm.update(0.001) is None  # warming up
+    # Window [0.001, 0.003] -> mean 0.002.
+    assert frm.update(0.003) == pytest.approx(0.002)
+
+
+def test_funding_rate_zscore_reference_value():
+    z = ta.FundingRateZScore(2)
+    assert z.update(0.001) is None  # warming up
+    # Window [0.001, 0.003]: mean 0.002, population stddev 0.001 -> +1.
+    assert z.update(0.003) == pytest.approx(1.0, abs=1e-9)
+
+
+def test_funding_basis_reference_value():
+    # mark 100.5 vs index 100.0 -> (100.5 - 100.0) / 100.0 = 0.005.
+    assert ta.FundingBasis().update(100.5, 100.0) == pytest.approx(0.005)
+    # A discount reads negative.
+    assert ta.FundingBasis().update(99.5, 100.0) == pytest.approx(-0.005)
+
+
+def test_open_interest_delta_reference_value():
+    oid = ta.OpenInterestDelta()
+    assert oid.update(1000.0) is None  # seeds the previous OI
+    assert oid.update(1250.0) == pytest.approx(250.0)
+    assert oid.update(1100.0) == pytest.approx(-150.0)
+
+
+def test_oi_price_divergence_reference_value():
+    div = ta.OIPriceDivergence(1)
+    assert div.update(1000.0, 100.0) is None  # warming up
+    # OI +10% while price flat -> divergence +0.1.
+    assert div.update(1100.0, 100.0) == pytest.approx(0.1)
+
+
+def test_oi_weighted_reference_value():
+    oiw = ta.OIWeighted()
+    assert oiw.update(100.0, 10.0) == pytest.approx(100.0)
+    # (100·10 + 110·30) / 40 = 107.5.
+    assert oiw.update(110.0, 30.0) == pytest.approx(107.5)
+
+
+def test_long_short_ratio_reference_value():
+    # 600 longs vs 400 shorts -> 1.5.
+    assert ta.LongShortRatio().update(600.0, 400.0) == pytest.approx(1.5)
+    # No short side -> 0.0.
+    assert ta.LongShortRatio().update(600.0, 0.0) == pytest.approx(0.0)
+
+
+def test_taker_buy_sell_ratio_reference_value():
+    # 60 taker buys vs 40 taker sells -> 1.5.
+    assert ta.TakerBuySellRatio().update(60.0, 40.0) == pytest.approx(1.5)
+    # No taker sell volume -> 0.0.
+    assert ta.TakerBuySellRatio().update(60.0, 0.0) == pytest.approx(0.0)
+
+
+def test_liquidation_features_reference_value():
+    # 30 long vs 10 short: (long, short, net, total, imbalance).
+    out = ta.LiquidationFeatures().update(30.0, 10.0)
+    assert out == pytest.approx((30.0, 10.0, 20.0, 40.0, 0.5))
+
+
+def test_term_structure_basis_reference_value():
+    # futures 102 vs index 100 -> 0.02 (contango).
+    assert ta.TermStructureBasis().update(102.0, 100.0) == pytest.approx(0.02)
+    # Backwardation reads negative.
+    assert ta.TermStructureBasis().update(98.0, 100.0) == pytest.approx(-0.02)
+
+
+def test_calendar_spread_reference_value():
+    # futures 101 vs perpetual mark 100 -> 0.01.
+    assert ta.CalendarSpread().update(101.0, 100.0) == pytest.approx(0.01)
+    assert ta.CalendarSpread().update(99.0, 100.0) == pytest.approx(-0.01)

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,306 +1,72 @@
-# Wickra
+# Wickra — WebAssembly
 
-[![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)
-[![crates.io](https://img.shields.io/crates/v/wickra.svg?logo=rust&color=orange)](https://crates.io/crates/wickra)
-[![PyPI](https://img.shields.io/pypi/v/wickra.svg?logo=pypi&color=blue)](https://pypi.org/project/wickra/)
-[![npm](https://img.shields.io/npm/v/wickra.svg?logo=npm&color=red)](https://www.npmjs.com/package/wickra)
-[![License: PolyForm-NC](https://img.shields.io/badge/license-PolyForm--NC--1.0.0-purple)](LICENSE)
+[![CI](https://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)
 
-**Streaming-first technical indicators. Install with `pip install wickra` — no system dependencies.**
+**Streaming-first technical indicators in the browser. `npm install
+wickra-wasm` — pure WebAssembly, runs anywhere a modern JS engine does.**
 
 Wickra is a multi-language technical-analysis library with a Rust core and
-bindings for Python, Node.js, and WebAssembly. Every indicator is a state
-machine that updates in O(1) per new data point, so live trading bots and
-historical backtests share the exact same implementation.
+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.
 
-```python
-import numpy as np
-import wickra as ta
-
-# Batch: classic TA-Lib-style usage
-prices = np.linspace(100, 200, 1000)
-rsi = ta.RSI(14)
-values = rsi.batch(prices)              # numpy array, NaN during warmup
-
-# Streaming: same indicator, fed tick by tick
-rsi = ta.RSI(14)
-for price in live_feed:
-    value = rsi.update(price)           # O(1) — no recomputation over history
-    if value is not None and value > 70:
-        print("overbought")
-```
-
-## 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 |
-|------------------------|-----------------|-----------|----------------|--------|
-| **★ 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.
-
-## Benchmark: how much faster is "streaming-first"?
-
-The numbers below were measured on a single developer workstation and are not
-guaranteed to reproduce identically on different hardware — absolute µs values
-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 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
-  `python -m benchmarks.compare_libraries`. The script auto-detects every
-  installed peer library and runs them on the same generated inputs as
-  Wickra. The CI job `cross-library-bench` runs the same script on every
-  push and uploads the raw report as a build artefact.
-
-Lower µs/op = faster. Wickra wins every batch category outright, and the
-streaming gap widens linearly with how much history a batch-only library has
-to recompute on every tick.
-
-### Batch — single full pass over a 20 000-bar series
-
-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                        |
-|---------------------|---------------------|-----------------------------|-------------------------------|
-| 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)   |
-| RSI(14)             | **126.2 µs ★**      | 1 107.1 µs (8.8× slower)    | 15 792.2 µs (125.1× slower)   |
-| MACD(12, 26, 9)     | **119.0 µs ★**      | 531.8 µs (4.5× slower)      | 49 788.1 µs (418.2× slower)   |
-| Bollinger(20, 2.0)  | **105.3 µs ★**      | 812.0 µs (7.7× slower)      | 130 938.3 µs (1 243.7× slower)|
-| ATR(14)             | **123.5 µs ★**      | 5 144.8 µs (41.7× slower)   | 28 816.0 µs (233.4× slower)   |
-
-### Streaming — per-tick latency after seeding with 5 000 historical bars
-
-A batch-only library has to re-run its full indicator over the entire history on
-every new tick; Wickra updates state in O(1).
-
-| Indicator | **★ Wickra (per tick)** | talipp (per tick)         |
-|-----------|---------------------|---------------------------|
-| RSI(14)   | **0.119 µs ★**      | 1.644 µs (13.8× slower)   |
-
-> TA-Lib and pandas-ta are not included here because both fail to install
-> cleanly on Windows without C build tooling — which is precisely the install
-> pain Wickra was built to remove. The benchmark script auto-detects every
-> peer library it can find and runs them on the same inputs as Wickra; install
-> them in your environment to see those rows light up too.
-
-Run the suite yourself:
+## Install
 
 ```bash
-pip install -e bindings/python[bench]
-python -m benchmarks.compare_libraries
+npm install wickra-wasm
 ```
 
-## Indicators
+## Quick start
 
-71 streaming-first indicators across eight families. Every one passes the
-`batch == streaming` equivalence test, reference-value tests, and reset
-semantics tests.
+The module ships a default `init` export that loads the `.wasm` payload; await
+it once before constructing indicators.
 
-| 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 |
+```js
+import init, { RSI } from 'wickra-wasm';
 
-Adding a new indicator means implementing one trait in Rust; all four bindings
-inherit it automatically.
+await init(); // load the WebAssembly module once
 
-## Languages
-
-| Binding           | Install                                       | Example |
-|-------------------|-----------------------------------------------|---------|
-| Python (PyO3)     | `pip install wickra`                          | `examples/python/backtest.py` |
-| Node.js (napi-rs) | `npm install wickra`                          | `examples/node/backtest.js` |
-| Browser / WASM    | `npm install wickra-wasm`                     | `examples/wasm/index.html` |
-| Rust              | `cargo add wickra`                            | `examples/rust/src/bin/backtest.rs` |
-
-Each binding ships several runnable examples (streaming, backtest, live feed);
-[`examples/README.md`](examples/README.md) is the full cross-language index.
-
-The wickra-core crate is `unsafe`-forbidden, so every binding inherits a
-memory-safe implementation.
-
-## Rust API
-
-```rust
-use wickra::{Indicator, BatchExt, Chain, Ema, Rsi, Sma};
-
-// Streaming or batch — same trait, same code.
-let mut sma = Sma::new(14)?;
-let out: Vec<Option<f64>> = sma.batch(&[1.0, 2.0, 3.0, 4.0, 5.0]);
-
-let mut rsi = Rsi::new(14)?;
-for price in live_feed {
-    if let Some(v) = rsi.update(price) {
-        println!("RSI = {v}");
-    }
-}
-
-// Compose indicators: RSI(7) on top of EMA(14).
-let mut chain = Chain::new(Ema::new(14)?, Rsi::new(7)?);
-chain.update(price);
-```
-
-## Live data sources
-
-`wickra-data` (separate crate, opt-in) ships:
-
-- A streaming OHLCV **CSV reader**.
-- A **tick-to-candle aggregator** with arbitrary timeframes.
-- A **candle resampler** for multi-timeframe analysis (1m → 5m → 1h on the fly).
-- A **Binance Spot WebSocket** kline adapter (feature `live-binance`).
-
-```rust
-use wickra::{Indicator, Rsi};
-use wickra_data::live::binance::{BinanceKlineStream, Interval};
-
-let mut stream = BinanceKlineStream::connect(&["BTCUSDT".into()], Interval::OneMinute).await?;
-let mut rsi = Rsi::new(14)?;
-while let Some(event) = stream.next_event().await? {
-    if event.is_closed {
-        if let Some(v) = rsi.update(event.candle.close) {
-            println!("RSI = {v:.2}");
-        }
-    }
+// Streaming: feed prices tick by tick in O(1).
+const rsi = new RSI(14);
+for (const price of liveFeed) {
+  const value = rsi.update(price); // null during warmup
+  if (value !== null && value > 70) {
+    console.log('overbought');
+  }
 }
 ```
 
-A Python live-trading example using the public `websockets` package lives at
-`examples/python/live_trading.py`.
+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.
 
-## Project layout
+## Documentation
 
-```
-wickra/
-├── crates/
-│   ├── wickra-core/         core engine + all 71 indicators
-│   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
-│   └── wickra-data/         CSV reader, tick aggregator, live exchange feeds
-├── bindings/
-│   ├── python/              PyO3 + maturin (publishes on PyPI)
-│   ├── node/                napi-rs (publishes on npm)
-│   └── wasm/                wasm-bindgen (browsers, bundlers, Node)
-├── examples/                examples/README.md indexes every language
-│   ├── data/                real BTCUSDT OHLCV datasets, one per timeframe
-│   ├── rust/                Rust workspace member (`wickra-examples`)
-│   ├── python/              backtest, live trading, parallel assets, multi-tf
-│   ├── node/                streaming, backtest, live trading (load `wickra`)
-│   └── wasm/                browser demo for `wickra-wasm`
-└── .github/workflows/       CI and release pipelines
-```
+The full indicator catalogue, guides, quickstarts, and API reference live in
+the main repository and documentation site:
 
-Rust benchmarks live in `crates/wickra/benches/`; runnable Rust examples live
-in the workspace member crate at `examples/rust/`. There is no top-level
-`benches/` directory.
+- **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)
 
-## Building everything from source
+Wickra ships four bindings — Python, Node.js, WebAssembly, and Rust — that all
+expose the same indicators from the shared, `unsafe`-forbidden Rust core.
 
-```bash
-# Rust core + tests
-cargo test --workspace
-cargo clippy --workspace --all-targets -- -D warnings
-cargo bench -p wickra
+## Disclaimer
 
-# Python binding (requires Rust toolchain + maturin)
-cd bindings/python
-maturin develop --release
-pytest
-
-# WASM binding (requires wasm-pack + wasm32-unknown-unknown target)
-wasm-pack build bindings/wasm --target web --release --features panic-hook
-
-# Node binding (requires @napi-rs/cli)
-cd bindings/node && npm install && npm run build && npm test
-```
-
-## Testing
-
-Every layer is covered; run the suites with the commands in
-[Building everything from source](#building-everything-from-source).
-
-- `wickra-core`: unit tests per indicator — textbook reference values
-  (Wilder RSI, Bollinger Bands, MACD, ATR, Stochastic), `batch == streaming`
-  equivalence, `reset` semantics, NaN/Inf handling, and property tests.
-- `wickra-data`: unit tests for CSV decoding, the tick aggregator, the
-  resampler, and the Binance payload parser.
-- `bindings/python`: pytest covering smoke checks, streaming/batch
-  equivalence, reference values, lifecycle, input validation, and
-  dict/tuple candle inputs.
-- `bindings/node`: `node --test` cases for batch, streaming, and reference
-  values across all indicators.
-- `bindings/wasm`: `wasm-bindgen-test` cases for constructors, equivalence,
-  and reference values.
-
-## Contributing
-
-Contributions are very welcome — issues, bug reports, ideas, and pull requests
-all land in the same place: <https://github.com/kingchenc/wickra>.
-
-A short orientation for first-time contributors:
-
-- **Adding an indicator.** Implement the `Indicator` trait in
-  `crates/wickra-core/src/indicators/<name>.rs`, wire it into
-  `indicators/mod.rs` and the crate root, and add reference-value tests,
-  a `batch == streaming` equivalence test, and (where it makes sense) a
-  proptest. The four bindings inherit your indicator automatically once
-  you expose it in the language wrappers.
-- **Fixing a numeric bug.** Add a failing test that pins the textbook value
-  first, then fix the math. Property tests in `crates/wickra-core` catch
-  most regressions; please don't disable them.
-- **Improving a binding.** Each binding lives under `bindings/<lang>` with
-  its own tests; please keep the `batch == streaming` invariant.
-- **Style.** `cargo fmt --all` + `cargo clippy --workspace --all-targets -- -D warnings`
-  are CI gates; running them locally before pushing keeps reviews short.
-
-For larger architectural changes, open an issue first so we can sketch the
-shape together before you invest the time.
+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**. See [LICENSE](LICENSE).
-
-In plain English: use it, fork it, modify it, redistribute it, file issues, send
-pull requests — all welcome. Personal projects, research, education, non-profits,
-government, hobby trading bots: all fine. The one thing that's not allowed is
-commercial sale of the software or of services built around it. If you want to
-use Wickra commercially, get in touch about a license.
-
----
-
-<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>
-  <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>
-  <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>
-</p>
-
-<p align="center">
-  If Wickra saved you time, the cheapest way to say thanks is to ⭐ the repo.
-</p>
+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/derivatives.rs

@@ -0,0 +1,321 @@
+//! Derivatives value type: the perpetual / futures tick.
+//!
+//! [`DerivativesTick`] is the non-OHLCV input consumed by the derivatives /
+//! perpetual-futures indicator family. A single tick bundles the funding,
+//! price, open-interest, positioning, taker-flow and liquidation fields a
+//! perp/futures venue publishes per update; each indicator reads only the
+//! subset it needs (the same one-rich-type-per-family pattern as [`Trade`] /
+//! [`OrderBook`] in [`crate::microstructure`]).
+//!
+//! [`Trade`]: crate::microstructure::Trade
+//! [`OrderBook`]: crate::microstructure::OrderBook
+
+use crate::error::{Error, Result};
+
+/// A single derivatives / perpetual-futures market tick.
+///
+/// Field invariants enforced by [`new`](DerivativesTick::new):
+///
+/// - `funding_rate` is finite and **may be negative** (a negative funding rate
+///   means shorts pay longs).
+/// - `mark_price`, `index_price` and `futures_price` are finite and strictly
+///   positive.
+/// - `open_interest`, `long_size`, `short_size`, `taker_buy_volume`,
+///   `taker_sell_volume`, `long_liquidation` and `short_liquidation` are finite
+///   and non-negative.
+///
+/// `timestamp` is a caller-defined epoch / resolution and is not validated.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct DerivativesTick {
+    /// Current funding rate for the interval (finite; may be negative).
+    pub funding_rate: f64,
+    /// Perpetual mark price (finite, strictly positive).
+    pub mark_price: f64,
+    /// Spot / index price the perpetual tracks (finite, strictly positive).
+    pub index_price: f64,
+    /// Dated (e.g. quarterly) futures mark price (finite, strictly positive).
+    pub futures_price: f64,
+    /// Open interest — outstanding contracts / notional (finite, non-negative).
+    pub open_interest: f64,
+    /// Aggregate long size / long account count (finite, non-negative).
+    pub long_size: f64,
+    /// Aggregate short size / short account count (finite, non-negative).
+    pub short_size: f64,
+    /// Taker buy (ask-lifting) volume (finite, non-negative).
+    pub taker_buy_volume: f64,
+    /// Taker sell (bid-hitting) volume (finite, non-negative).
+    pub taker_sell_volume: f64,
+    /// Long-side liquidation notional (finite, non-negative).
+    pub long_liquidation: f64,
+    /// Short-side liquidation notional (finite, non-negative).
+    pub short_liquidation: f64,
+    /// Tick timestamp (caller-defined epoch / resolution).
+    pub timestamp: i64,
+}
+
+impl DerivativesTick {
+    /// Construct a derivatives tick, validating every field invariant.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::InvalidDerivatives`] if `funding_rate` is not finite;
+    /// any of `mark_price`, `index_price`, `futures_price` is not a finite
+    /// positive number; or any of the six size / volume / liquidation fields is
+    /// not a finite non-negative number.
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        funding_rate: f64,
+        mark_price: f64,
+        index_price: f64,
+        futures_price: f64,
+        open_interest: f64,
+        long_size: f64,
+        short_size: f64,
+        taker_buy_volume: f64,
+        taker_sell_volume: f64,
+        long_liquidation: f64,
+        short_liquidation: f64,
+        timestamp: i64,
+    ) -> Result<Self> {
+        if !funding_rate.is_finite() {
+            return Err(Error::InvalidDerivatives {
+                message: "funding_rate must be finite",
+            });
+        }
+        for price in [mark_price, index_price, futures_price] {
+            if !price.is_finite() || price <= 0.0 {
+                return Err(Error::InvalidDerivatives {
+                    message:
+                        "mark_price, index_price and futures_price must be finite and positive",
+                });
+            }
+        }
+        for amount in [
+            open_interest,
+            long_size,
+            short_size,
+            taker_buy_volume,
+            taker_sell_volume,
+            long_liquidation,
+            short_liquidation,
+        ] {
+            if !amount.is_finite() || amount < 0.0 {
+                return Err(Error::InvalidDerivatives {
+                    message: "open interest, sizes, volumes and liquidations must be finite and non-negative",
+                });
+            }
+        }
+        Ok(Self {
+            funding_rate,
+            mark_price,
+            index_price,
+            futures_price,
+            open_interest,
+            long_size,
+            short_size,
+            taker_buy_volume,
+            taker_sell_volume,
+            long_liquidation,
+            short_liquidation,
+            timestamp,
+        })
+    }
+
+    /// Construct a derivatives tick without validation. The caller asserts that
+    /// every field invariant documented on [`DerivativesTick`] holds.
+    #[allow(clippy::too_many_arguments)]
+    #[must_use]
+    pub const fn new_unchecked(
+        funding_rate: f64,
+        mark_price: f64,
+        index_price: f64,
+        futures_price: f64,
+        open_interest: f64,
+        long_size: f64,
+        short_size: f64,
+        taker_buy_volume: f64,
+        taker_sell_volume: f64,
+        long_liquidation: f64,
+        short_liquidation: f64,
+        timestamp: i64,
+    ) -> Self {
+        Self {
+            funding_rate,
+            mark_price,
+            index_price,
+            futures_price,
+            open_interest,
+            long_size,
+            short_size,
+            taker_buy_volume,
+            taker_sell_volume,
+            long_liquidation,
+            short_liquidation,
+            timestamp,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A fully valid tick used as a baseline; individual tests override one
+    /// field to exercise a single reject branch.
+    fn valid() -> DerivativesTick {
+        DerivativesTick::new(
+            0.0001, 100.0, 99.5, 100.5, 1_000.0, 600.0, 400.0, 50.0, 40.0, 5.0, 3.0, 42,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn new_accepts_valid() {
+        let tick = valid();
+        assert_eq!(tick.funding_rate, 0.0001);
+        assert_eq!(tick.mark_price, 100.0);
+        assert_eq!(tick.index_price, 99.5);
+        assert_eq!(tick.futures_price, 100.5);
+        assert_eq!(tick.open_interest, 1_000.0);
+        assert_eq!(tick.long_size, 600.0);
+        assert_eq!(tick.short_size, 400.0);
+        assert_eq!(tick.taker_buy_volume, 50.0);
+        assert_eq!(tick.taker_sell_volume, 40.0);
+        assert_eq!(tick.long_liquidation, 5.0);
+        assert_eq!(tick.short_liquidation, 3.0);
+        assert_eq!(tick.timestamp, 42);
+    }
+
+    #[test]
+    fn new_accepts_negative_funding_and_zero_amounts() {
+        let tick = DerivativesTick::new(
+            -0.0005, 100.0, 100.0, 100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0,
+        )
+        .unwrap();
+        assert_eq!(tick.funding_rate, -0.0005);
+        assert_eq!(tick.open_interest, 0.0);
+    }
+
+    #[test]
+    fn new_rejects_non_finite_funding() {
+        assert!(matches!(
+            DerivativesTick::new(
+                f64::NAN,
+                100.0,
+                100.0,
+                100.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0
+            ),
+            Err(Error::InvalidDerivatives { .. })
+        ));
+        assert!(matches!(
+            DerivativesTick::new(
+                f64::INFINITY,
+                100.0,
+                100.0,
+                100.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0
+            ),
+            Err(Error::InvalidDerivatives { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_non_positive_mark() {
+        assert!(matches!(
+            DerivativesTick::new(0.0, 0.0, 100.0, 100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0),
+            Err(Error::InvalidDerivatives { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_non_positive_index() {
+        assert!(matches!(
+            DerivativesTick::new(0.0, 100.0, -1.0, 100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0),
+            Err(Error::InvalidDerivatives { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_non_finite_futures() {
+        assert!(matches!(
+            DerivativesTick::new(
+                0.0,
+                100.0,
+                100.0,
+                f64::NAN,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0
+            ),
+            Err(Error::InvalidDerivatives { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_negative_open_interest() {
+        assert!(matches!(
+            DerivativesTick::new(0.0, 100.0, 100.0, 100.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0),
+            Err(Error::InvalidDerivatives { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_non_finite_size() {
+        assert!(matches!(
+            DerivativesTick::new(
+                0.0,
+                100.0,
+                100.0,
+                100.0,
+                0.0,
+                f64::INFINITY,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+                0
+            ),
+            Err(Error::InvalidDerivatives { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_negative_liquidation() {
+        assert!(matches!(
+            DerivativesTick::new(0.0, 100.0, 100.0, 100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -2.0, 0),
+            Err(Error::InvalidDerivatives { .. })
+        ));
+    }
+
+    #[test]
+    fn new_unchecked_preserves_fields() {
+        let tick = DerivativesTick::new_unchecked(
+            -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0, -10.0, -11.0, 7,
+        );
+        assert_eq!(tick.funding_rate, -1.0);
+        assert_eq!(tick.mark_price, -2.0);
+        assert_eq!(tick.short_liquidation, -11.0);
+        assert_eq!(tick.timestamp, 7);
+    }
+}

crates/wickra-core/src/error.rs

@@ -31,6 +31,27 @@ 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 },
+
+    /// A derivatives tick whose components do not satisfy the tick invariants
+    /// (e.g. a non-positive price, a non-finite funding rate, or a negative
+    /// size/volume/liquidation) was provided. Derivatives ticks (funding /
+    /// open-interest / liquidation feeds) are a perpetual-futures input
+    /// distinct from candles, order books and trades, so they surface as their
+    /// own variant.
+    #[error("invalid derivatives tick: {message}")]
+    InvalidDerivatives { message: &'static str },
 }
 
 /// Convenience alias for `Result<T, wickra_core::Error>`.

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

@@ -0,0 +1,247 @@
+//! Abandoned Baby candlestick pattern.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Abandoned Baby — a strong 3-bar reversal where a doji is "abandoned" by price
+/// gaps on both sides, isolating it from the candles before and after.
+///
+/// ```text
+/// tol           = tolerance * max(|bar2.open|, |bar2.close|)
+/// bar2 doji                                   (|bar2.close − bar2.open| <= tol)
+///
+/// bullish  (+1.0): bar1 red, bar2 gaps fully below bar1 (bar2.high < bar1.low),
+///                  bar3 green and gaps fully above bar2 (bar3.low > bar2.high)
+/// bearish  (−1.0): bar1 green, bar2 gaps fully above bar1 (bar2.low > bar1.high),
+///                  bar3 red and gaps fully below bar2 (bar3.high < bar2.low)
+/// ```
+///
+/// Output is `0.0` otherwise. The first two bars always return `0.0` because the
+/// three-bar window is not yet filled. `tolerance` defaults to `0.001` (10 bps
+/// relative) and bounds how flat the middle candle must be to count as a doji; it
+/// must lie in `[0, 1)`. Pattern-shape check only — no trend filter is applied;
+/// combine with a trend indicator for actionable signals.
+///
+/// # Signed ±1 encoding
+///
+/// This detector emits the uniform candlestick sign convention shared across the
+/// pattern family — `+1.0` bullish, `−1.0` bearish, `0.0` no pattern — so it
+/// drops straight into a machine-learning feature matrix where the bullish and
+/// bearish variants occupy a single dimension.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AbandonedBaby, Candle, Indicator};
+///
+/// let mut indicator = AbandonedBaby::new();
+/// indicator.update(Candle::new(20.0, 20.1, 14.9, 15.0, 1.0, 0).unwrap());
+/// indicator.update(Candle::new(13.0, 13.1, 12.9, 13.0, 1.0, 1).unwrap());
+/// let out = indicator
+///     .update(Candle::new(16.0, 18.1, 15.9, 18.0, 1.0, 2).unwrap());
+/// assert_eq!(out, Some(1.0));
+/// ```
+#[derive(Debug, Clone)]
+pub struct AbandonedBaby {
+    tolerance: f64,
+    prev: Option<Candle>,
+    prev_prev: Option<Candle>,
+    has_emitted: bool,
+}
+
+impl Default for AbandonedBaby {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AbandonedBaby {
+    /// Construct a detector with the default relative doji tolerance (1e-3).
+    pub const fn new() -> Self {
+        Self {
+            tolerance: 0.001,
+            prev: None,
+            prev_prev: None,
+            has_emitted: false,
+        }
+    }
+
+    /// Construct a detector with a custom relative doji tolerance.
+    ///
+    /// `tolerance` must lie in `[0, 1)`.
+    pub fn with_tolerance(tolerance: f64) -> Result<Self> {
+        if !(0.0..1.0).contains(&tolerance) {
+            return Err(Error::InvalidPeriod {
+                message: "abandoned baby tolerance must lie in [0, 1)",
+            });
+        }
+        Ok(Self {
+            tolerance,
+            prev: None,
+            prev_prev: None,
+            has_emitted: false,
+        })
+    }
+
+    /// Configured relative doji tolerance.
+    pub fn tolerance(&self) -> f64 {
+        self.tolerance
+    }
+}
+
+impl Indicator for AbandonedBaby {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        let pp = self.prev_prev;
+        let p = self.prev;
+        self.prev_prev = self.prev;
+        self.prev = Some(candle);
+        let (Some(bar1), Some(bar2)) = (pp, p) else {
+            return Some(0.0);
+        };
+        let tol = self.tolerance * bar2.open.abs().max(bar2.close.abs());
+        let bar2_is_doji = (bar2.close - bar2.open).abs() <= tol;
+        if !bar2_is_doji {
+            return Some(0.0);
+        }
+        // Bullish: red bar1, doji gaps below, green bar3 gaps above.
+        if bar1.close < bar1.open
+            && bar2.high < bar1.low
+            && candle.close > candle.open
+            && candle.low > bar2.high
+        {
+            return Some(1.0);
+        }
+        // Bearish: green bar1, doji gaps above, red bar3 gaps below.
+        if bar1.close > bar1.open
+            && bar2.low > bar1.high
+            && candle.close < candle.open
+            && candle.high < bar2.low
+        {
+            return Some(-1.0);
+        }
+        Some(0.0)
+    }
+
+    fn reset(&mut self) {
+        self.prev = None;
+        self.prev_prev = None;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        3
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "AbandonedBaby"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(open: f64, high: f64, low: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn rejects_invalid_tolerance() {
+        assert!(AbandonedBaby::with_tolerance(-0.01).is_err());
+        assert!(AbandonedBaby::with_tolerance(1.0).is_err());
+    }
+
+    #[test]
+    fn accepts_valid_tolerance() {
+        let t = AbandonedBaby::with_tolerance(0.0).unwrap();
+        assert!((t.tolerance() - 0.0).abs() < 1e-12);
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let t = AbandonedBaby::default();
+        assert_eq!(t.name(), "AbandonedBaby");
+        assert_eq!(t.warmup_period(), 3);
+        assert!(!t.is_ready());
+        assert!((t.tolerance() - 0.001).abs() < 1e-12);
+    }
+
+    #[test]
+    fn bullish_abandoned_baby_is_plus_one() {
+        let mut t = AbandonedBaby::new();
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(13.0, 13.1, 12.9, 13.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(16.0, 18.1, 15.9, 18.0, 2)), Some(1.0));
+    }
+
+    #[test]
+    fn bearish_abandoned_baby_is_minus_one() {
+        let mut t = AbandonedBaby::new();
+        assert_eq!(t.update(c(15.0, 20.1, 14.9, 20.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(22.0, 22.1, 21.9, 22.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(19.0, 19.1, 16.9, 17.0, 2)), Some(-1.0));
+    }
+
+    #[test]
+    fn middle_not_doji_yields_zero() {
+        let mut t = AbandonedBaby::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        // Middle bar has a wide body -> not a doji.
+        assert_eq!(t.update(c(13.0, 14.0, 11.0, 11.5, 1)), Some(0.0));
+        assert_eq!(t.update(c(16.0, 18.1, 15.9, 18.0, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn no_gap_yields_zero() {
+        let mut t = AbandonedBaby::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        // Doji overlaps bar1's range -> no gap.
+        assert_eq!(t.update(c(15.0, 15.1, 14.9, 15.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(16.0, 18.1, 15.9, 18.0, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn first_two_bars_return_zero() {
+        let mut t = AbandonedBaby::new();
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(13.0, 13.1, 12.9, 13.0, 1)), Some(0.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| {
+                let base = 100.0 + (i as f64 * 0.3).sin() * 5.0;
+                c(base, base + 1.0, base - 1.0, base + 0.5, i)
+            })
+            .collect();
+        let mut a = AbandonedBaby::new();
+        let mut b = AbandonedBaby::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = AbandonedBaby::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        t.update(c(13.0, 13.1, 12.9, 13.0, 1));
+        t.update(c(16.0, 18.1, 15.9, 18.0, 2));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 0)), Some(0.0));
+    }
+}

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/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/advance_block.rs

@@ -0,0 +1,192 @@
+//! Advance Block candlestick pattern.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Advance Block — a 3-bar bearish warning: three green candles still pushing to
+/// higher closes, but visibly running out of steam — each real body shrinks while
+/// the upper shadows lengthen, hinting the advance is about to stall.
+///
+/// ```text
+/// all three green & higher closes
+/// each opens inside the prior body
+/// shrinking bodies   (body3 < body2 < body1)
+/// upper shadow of bar3 >= upper shadow of bar2 and bar3 has an upper shadow
+/// ```
+///
+/// Output is `−1.0` when the pattern completes and `0.0` otherwise. Advance Block
+/// is a single-direction (bearish-only) warning, so it never emits `+1.0`. The
+/// first two bars always return `0.0` because the three-bar window is not yet
+/// filled. Pattern-shape check only — no trend filter is applied; combine with a
+/// trend indicator for actionable signals.
+///
+/// # Signed ±1 encoding
+///
+/// This detector emits the uniform candlestick sign convention shared across the
+/// pattern family — `−1.0` bearish, `0.0` no pattern — so it drops straight into
+/// a machine-learning feature matrix as a single dimension.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AdvanceBlock, Candle, Indicator};
+///
+/// let mut indicator = AdvanceBlock::new();
+/// indicator.update(Candle::new(10.0, 13.1, 9.9, 13.0, 1.0, 0).unwrap());
+/// indicator.update(Candle::new(12.0, 14.3, 11.9, 14.0, 1.0, 1).unwrap());
+/// let out = indicator
+///     .update(Candle::new(13.5, 15.0, 13.4, 14.5, 1.0, 2).unwrap());
+/// assert_eq!(out, Some(-1.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AdvanceBlock {
+    prev: Option<Candle>,
+    prev_prev: Option<Candle>,
+    has_emitted: bool,
+}
+
+impl AdvanceBlock {
+    /// Construct a new Advance Block detector.
+    pub const fn new() -> Self {
+        Self {
+            prev: None,
+            prev_prev: None,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for AdvanceBlock {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        let pp = self.prev_prev;
+        let p = self.prev;
+        self.prev_prev = self.prev;
+        self.prev = Some(candle);
+        let (Some(bar1), Some(bar2)) = (pp, p) else {
+            return Some(0.0);
+        };
+        let body1 = bar1.close - bar1.open;
+        let body2 = bar2.close - bar2.open;
+        let body3 = candle.close - candle.open;
+        let upper2 = bar2.high - bar2.close;
+        let upper3 = candle.high - candle.close;
+        if bar1.close > bar1.open
+            && bar2.close > bar2.open
+            && candle.close > candle.open
+            && bar2.close > bar1.close
+            && candle.close > bar2.close
+            && bar2.open >= bar1.open
+            && bar2.open <= bar1.close
+            && candle.open >= bar2.open
+            && candle.open <= bar2.close
+            && body2 < body1
+            && body3 < body2
+            && upper3 >= upper2
+            && upper3 > 0.0
+        {
+            return Some(-1.0);
+        }
+        Some(0.0)
+    }
+
+    fn reset(&mut self) {
+        self.prev = None;
+        self.prev_prev = None;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        3
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "AdvanceBlock"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(open: f64, high: f64, low: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let t = AdvanceBlock::new();
+        assert_eq!(t.name(), "AdvanceBlock");
+        assert_eq!(t.warmup_period(), 3);
+        assert!(!t.is_ready());
+    }
+
+    #[test]
+    fn advance_block_is_minus_one() {
+        let mut t = AdvanceBlock::new();
+        assert_eq!(t.update(c(10.0, 13.1, 9.9, 13.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(12.0, 14.3, 11.9, 14.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(13.5, 15.0, 13.4, 14.5, 2)), Some(-1.0));
+    }
+
+    #[test]
+    fn strong_advance_yields_zero() {
+        let mut t = AdvanceBlock::new();
+        // Bodies grow instead of shrinking -> a strong advance, not blocked.
+        assert_eq!(t.update(c(10.0, 11.1, 9.9, 11.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(10.5, 12.6, 10.4, 12.5, 1)), Some(0.0));
+        assert_eq!(t.update(c(11.5, 14.1, 11.4, 14.0, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn no_upper_shadow_growth_yields_zero() {
+        let mut t = AdvanceBlock::new();
+        t.update(c(10.0, 13.1, 9.9, 13.0, 0));
+        t.update(c(12.0, 14.3, 11.9, 14.0, 1));
+        // bar3 shrinking body but no upper shadow -> not blocked.
+        assert_eq!(t.update(c(13.5, 14.5, 13.4, 14.5, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn first_two_bars_return_zero() {
+        let mut t = AdvanceBlock::new();
+        assert_eq!(t.update(c(10.0, 13.1, 9.9, 13.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(12.0, 14.3, 11.9, 14.0, 1)), Some(0.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| {
+                let base = 100.0 + i as f64;
+                c(base, base + 2.0, base - 0.2, base + 1.5, i)
+            })
+            .collect();
+        let mut a = AdvanceBlock::new();
+        let mut b = AdvanceBlock::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = AdvanceBlock::new();
+        t.update(c(10.0, 13.1, 9.9, 13.0, 0));
+        t.update(c(12.0, 14.3, 11.9, 14.0, 1));
+        t.update(c(13.5, 15.0, 13.4, 14.5, 2));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+        assert_eq!(t.update(c(10.0, 13.1, 9.9, 13.0, 0)), Some(0.0));
+    }
+}

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/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/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_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/belt_hold.rs

@@ -0,0 +1,211 @@
+//! Belt-hold candlestick pattern.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Belt-hold — a single-bar reversal: a long candle that opens at one extreme of
+/// its range (an "opening marubozu") and runs the other way.
+///
+/// ```text
+/// range        = high − low
+/// bullish (+1.0): green, opens at the low  (open − low <= tol * range) & long body
+/// bearish (−1.0): red,   opens at the high (high − open <= tol * range) & long body
+/// long body    = |close − open| >= 0.5 * range
+/// ```
+///
+/// Output is `0.0` when the opening side carries a shadow, the body is short, or
+/// the range is degenerate. `shadow_tolerance` defaults to `0.05` (5 % of the bar
+/// range allowed on the opening side) and must lie in `[0, 1)`. Pattern-shape
+/// check only — no trend filter is applied; combine with a trend indicator for
+/// actionable signals.
+///
+/// # Signed ±1 encoding
+///
+/// This detector emits the uniform candlestick sign convention shared across the
+/// pattern family — `+1.0` bullish, `−1.0` bearish, `0.0` no pattern — so it
+/// drops straight into a machine-learning feature matrix where the bullish and
+/// bearish variants occupy a single dimension.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{BeltHold, Candle, Indicator};
+///
+/// let mut indicator = BeltHold::new();
+/// // Bullish belt-hold: opens at the low, closes near the high.
+/// let candle = Candle::new(10.0, 12.0, 10.0, 11.5, 1.0, 0).unwrap();
+/// assert_eq!(indicator.update(candle), Some(1.0));
+/// ```
+#[derive(Debug, Clone)]
+pub struct BeltHold {
+    shadow_tolerance: f64,
+    has_emitted: bool,
+}
+
+impl Default for BeltHold {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl BeltHold {
+    /// Construct a Belt-hold detector with the default 5 % opening-shadow tolerance.
+    pub const fn new() -> Self {
+        Self {
+            shadow_tolerance: 0.05,
+            has_emitted: false,
+        }
+    }
+
+    /// Construct a Belt-hold detector with a custom opening-shadow tolerance.
+    ///
+    /// `shadow_tolerance` must lie in `[0, 1)`.
+    pub fn with_tolerance(shadow_tolerance: f64) -> Result<Self> {
+        if !(0.0..1.0).contains(&shadow_tolerance) {
+            return Err(Error::InvalidPeriod {
+                message: "belt-hold shadow tolerance must lie in [0, 1)",
+            });
+        }
+        Ok(Self {
+            shadow_tolerance,
+            has_emitted: false,
+        })
+    }
+
+    /// Configured opening-shadow tolerance.
+    pub fn shadow_tolerance(&self) -> f64 {
+        self.shadow_tolerance
+    }
+}
+
+impl Indicator for BeltHold {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        let range = candle.high - candle.low;
+        if range <= 0.0 {
+            return Some(0.0);
+        }
+        let body = candle.close - candle.open;
+        if body.abs() < 0.5 * range {
+            return Some(0.0);
+        }
+        let tol = self.shadow_tolerance * range;
+        // Bullish: opens at the low (no lower shadow), green body.
+        if body > 0.0 && candle.open - candle.low <= tol {
+            return Some(1.0);
+        }
+        // Bearish: opens at the high (no upper shadow), red body.
+        if body < 0.0 && candle.high - candle.open <= tol {
+            return Some(-1.0);
+        }
+        Some(0.0)
+    }
+
+    fn reset(&mut self) {
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "BeltHold"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(open: f64, high: f64, low: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn rejects_invalid_tolerance() {
+        assert!(BeltHold::with_tolerance(-0.01).is_err());
+        assert!(BeltHold::with_tolerance(1.0).is_err());
+    }
+
+    #[test]
+    fn accepts_valid_tolerance() {
+        let t = BeltHold::with_tolerance(0.0).unwrap();
+        assert!((t.shadow_tolerance() - 0.0).abs() < 1e-12);
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let t = BeltHold::default();
+        assert_eq!(t.name(), "BeltHold");
+        assert_eq!(t.warmup_period(), 1);
+        assert!(!t.is_ready());
+        assert!((t.shadow_tolerance() - 0.05).abs() < 1e-12);
+    }
+
+    #[test]
+    fn bullish_belt_hold_is_plus_one() {
+        let mut t = BeltHold::new();
+        assert_eq!(t.update(c(10.0, 12.0, 10.0, 11.5, 0)), Some(1.0));
+    }
+
+    #[test]
+    fn bearish_belt_hold_is_minus_one() {
+        let mut t = BeltHold::new();
+        assert_eq!(t.update(c(12.0, 12.0, 10.0, 10.5, 0)), Some(-1.0));
+    }
+
+    #[test]
+    fn opening_shadow_yields_zero() {
+        let mut t = BeltHold::new();
+        // Opens 0.5 above the low -> lower shadow exceeds tolerance.
+        assert_eq!(t.update(c(10.5, 12.0, 10.0, 11.5, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn short_body_yields_zero() {
+        let mut t = BeltHold::new();
+        // Body 0.5 < half the range (1.0) -> not a long belt-hold.
+        assert_eq!(t.update(c(10.0, 12.0, 10.0, 10.5, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn zero_range_yields_zero() {
+        let mut t = BeltHold::new();
+        assert_eq!(t.update(c(10.0, 10.0, 10.0, 10.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| {
+                let base = 100.0 + i as f64;
+                c(base, base + 2.0, base, base + 1.8, i)
+            })
+            .collect();
+        let mut a = BeltHold::new();
+        let mut b = BeltHold::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = BeltHold::new();
+        t.update(c(10.0, 12.0, 10.0, 11.5, 0));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+    }
+}

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/breakaway.rs

@@ -0,0 +1,250 @@
+//! Breakaway candlestick pattern.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Breakaway — a 5-bar reversal that fades an exhausted run. A trend gaps away on
+/// the second bar, drifts two more bars in the same direction, then the fifth bar
+/// snaps the other way and closes back inside the body gap left between the first
+/// and second bars, signalling the move has broken away from the crowd and is
+/// turning.
+///
+/// ```text
+/// bullish (+1.0)  — appears in a decline:
+///   bar1 black (close < open)
+///   bar2 black & its body gaps DOWN below bar1's body  (bar2.open < bar1.close)
+///   bar3 extends lower            (high & low below bar2)
+///   bar4 black & extends lower    (high & low below bar3)
+///   bar5 green & closes inside the bar1/bar2 body gap   (bar2.open < close < bar1.close)
+///
+/// bearish (−1.0) — the mirror in an advance:
+///   bar1 white (close > open)
+///   bar2 white & its body gaps UP above bar1's body    (bar2.open > bar1.close)
+///   bar3 extends higher           (high & low above bar2)
+///   bar4 white & extends higher   (high & low above bar3)
+///   bar5 red & closes inside the bar1/bar2 body gap     (bar1.close < close < bar2.open)
+/// ```
+///
+/// The middle bar (`bar3`) may be either colour — only its high/low must extend
+/// the run. Output is `+1.0` bullish, `−1.0` bearish, `0.0` otherwise. The first
+/// four bars always return `0.0` because the five-bar window is not yet filled.
+/// Pattern-shape check only — no trend filter is applied; combine with a trend
+/// indicator for actionable signals. Recognition uses TA-Lib's
+/// `CDLBREAKAWAY` body-gap and high/low ordering rules directly; it does not add
+/// TA-Lib's rolling body-length average, matching the geometric house style of
+/// the other multi-bar patterns in this family.
+///
+/// # Signed ±1 encoding
+///
+/// This detector emits the uniform candlestick sign convention shared across the
+/// pattern family — `+1.0` bullish, `−1.0` bearish, `0.0` no pattern — so it
+/// drops straight into a machine-learning feature matrix where the bullish and
+/// bearish variants occupy a single dimension.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Breakaway, Candle, Indicator};
+///
+/// let mut indicator = Breakaway::new();
+/// indicator.update(Candle::new(20.0, 20.2, 14.8, 15.0, 1.0, 0).unwrap());
+/// indicator.update(Candle::new(14.0, 14.1, 11.9, 12.0, 1.0, 1).unwrap());
+/// indicator.update(Candle::new(12.5, 13.0, 10.5, 11.0, 1.0, 2).unwrap());
+/// indicator.update(Candle::new(11.0, 11.5, 9.0, 9.5, 1.0, 3).unwrap());
+/// let out = indicator
+///     .update(Candle::new(9.5, 14.7, 9.4, 14.5, 1.0, 4).unwrap());
+/// assert_eq!(out, Some(1.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct Breakaway {
+    c1: Option<Candle>,
+    c2: Option<Candle>,
+    c3: Option<Candle>,
+    c4: Option<Candle>,
+    has_emitted: bool,
+}
+
+impl Breakaway {
+    /// Construct a new Breakaway detector.
+    pub const fn new() -> Self {
+        Self {
+            c1: None,
+            c2: None,
+            c3: None,
+            c4: None,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for Breakaway {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        let bar1 = self.c1;
+        let bar2 = self.c2;
+        let bar3 = self.c3;
+        let bar4 = self.c4;
+        self.c1 = self.c2;
+        self.c2 = self.c3;
+        self.c3 = self.c4;
+        self.c4 = Some(candle);
+        let (Some(bar1), Some(bar2), Some(bar3), Some(bar4)) = (bar1, bar2, bar3, bar4) else {
+            return Some(0.0);
+        };
+        // Bullish: a decline gaps lower, runs two more bars down, then a green
+        // bar5 closes back inside the bar1/bar2 body gap.
+        if bar1.close < bar1.open
+            && bar2.close < bar2.open
+            && bar2.open < bar1.close
+            && bar3.high < bar2.high
+            && bar3.low < bar2.low
+            && bar4.close < bar4.open
+            && bar4.high < bar3.high
+            && bar4.low < bar3.low
+            && candle.close > candle.open
+            && candle.close > bar2.open
+            && candle.close < bar1.close
+        {
+            return Some(1.0);
+        }
+        // Bearish: the mirror — an advance gaps higher, runs two more bars up,
+        // then a red bar5 closes back inside the bar1/bar2 body gap.
+        if bar1.close > bar1.open
+            && bar2.close > bar2.open
+            && bar2.open > bar1.close
+            && bar3.high > bar2.high
+            && bar3.low > bar2.low
+            && bar4.close > bar4.open
+            && bar4.high > bar3.high
+            && bar4.low > bar3.low
+            && candle.close < candle.open
+            && candle.close < bar2.open
+            && candle.close > bar1.close
+        {
+            return Some(-1.0);
+        }
+        Some(0.0)
+    }
+
+    fn reset(&mut self) {
+        self.c1 = None;
+        self.c2 = None;
+        self.c3 = None;
+        self.c4 = None;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        5
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "Breakaway"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(open: f64, high: f64, low: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let t = Breakaway::new();
+        assert_eq!(t.name(), "Breakaway");
+        assert_eq!(t.warmup_period(), 5);
+        assert!(!t.is_ready());
+    }
+
+    #[test]
+    fn bullish_breakaway_is_plus_one() {
+        let mut t = Breakaway::new();
+        assert_eq!(t.update(c(20.0, 20.2, 14.8, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(14.0, 14.1, 11.9, 12.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(12.5, 13.0, 10.5, 11.0, 2)), Some(0.0));
+        assert_eq!(t.update(c(11.0, 11.5, 9.0, 9.5, 3)), Some(0.0));
+        assert_eq!(t.update(c(9.5, 14.7, 9.4, 14.5, 4)), Some(1.0));
+    }
+
+    #[test]
+    fn bearish_breakaway_is_minus_one() {
+        let mut t = Breakaway::new();
+        assert_eq!(t.update(c(15.0, 20.2, 14.8, 20.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(21.0, 23.1, 20.9, 23.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(22.5, 24.5, 21.5, 24.0, 2)), Some(0.0));
+        assert_eq!(t.update(c(24.0, 26.5, 23.0, 26.0, 3)), Some(0.0));
+        assert_eq!(t.update(c(27.0, 27.2, 20.4, 20.5, 4)), Some(-1.0));
+    }
+
+    #[test]
+    fn no_body_gap_yields_zero() {
+        let mut t = Breakaway::new();
+        // bar2 does not gap below bar1's body (bar2.open >= bar1.close).
+        t.update(c(20.0, 20.2, 14.8, 15.0, 0));
+        t.update(c(16.0, 16.1, 13.9, 14.0, 1));
+        t.update(c(13.5, 14.0, 11.5, 12.0, 2));
+        t.update(c(12.0, 12.5, 10.0, 10.5, 3));
+        assert_eq!(t.update(c(10.5, 15.7, 10.4, 15.5, 4)), Some(0.0));
+    }
+
+    #[test]
+    fn bullish_close_outside_gap_yields_zero() {
+        let mut t = Breakaway::new();
+        t.update(c(20.0, 20.2, 14.8, 15.0, 0));
+        t.update(c(14.0, 14.1, 11.9, 12.0, 1));
+        t.update(c(12.5, 13.0, 10.5, 11.0, 2));
+        t.update(c(11.0, 11.5, 9.0, 9.5, 3));
+        // bar5 closes at 13.0 — below bar2.open (14), so outside the body gap.
+        assert_eq!(t.update(c(9.5, 13.2, 9.4, 13.0, 4)), Some(0.0));
+    }
+
+    #[test]
+    fn first_four_bars_return_zero() {
+        let mut t = Breakaway::new();
+        assert_eq!(t.update(c(20.0, 20.2, 14.8, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(14.0, 14.1, 11.9, 12.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(12.5, 13.0, 10.5, 11.0, 2)), Some(0.0));
+        assert_eq!(t.update(c(11.0, 11.5, 9.0, 9.5, 3)), Some(0.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| {
+                let base = 100.0 + i as f64;
+                c(base, base + 2.0, base - 0.5, base + 1.5, i)
+            })
+            .collect();
+        let mut a = Breakaway::new();
+        let mut b = Breakaway::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = Breakaway::new();
+        t.update(c(20.0, 20.2, 14.8, 15.0, 0));
+        t.update(c(14.0, 14.1, 11.9, 12.0, 1));
+        t.update(c(12.5, 13.0, 10.5, 11.0, 2));
+        t.update(c(11.0, 11.5, 9.0, 9.5, 3));
+        t.update(c(9.5, 14.7, 9.4, 14.5, 4));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+        assert_eq!(t.update(c(20.0, 20.2, 14.8, 15.0, 0)), Some(0.0));
+    }
+}

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

@@ -0,0 +1,141 @@
+//! Calendar Spread — the dated future's relative premium to the perpetual.
+
+use crate::derivatives::DerivativesTick;
+use crate::traits::Indicator;
+
+/// Calendar Spread — the relative spread between a dated (e.g. quarterly)
+/// futures price and the perpetual mark price.
+///
+/// ```text
+/// spread = (futuresPrice − markPrice) / markPrice
+/// ```
+///
+/// A calendar (or inter-delivery) spread trades the *near* leg against the
+/// *far* leg — here the perpetual against a dated future. The relative spread is
+/// the roll yield available between the two contracts: positive when the future
+/// trades over the perpetual (contango roll), negative when under
+/// (backwardation). Where [`TermStructureBasis`] measures the future against
+/// spot, this measures it against the perpetual — the leg a perp-vs-future
+/// basis trade actually holds. The output is a fraction; multiply by `10_000`
+/// for basis points.
+///
+/// `Input = DerivativesTick`, `Output = f64`. Stateless; ready after the first
+/// tick.
+///
+/// [`TermStructureBasis`]: crate::TermStructureBasis
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{CalendarSpread, DerivativesTick, Indicator};
+///
+/// fn tick(futures: f64, mark: f64) -> DerivativesTick {
+///     DerivativesTick::new(0.0, mark, mark, futures, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0)
+///         .unwrap()
+/// }
+///
+/// let mut cs = CalendarSpread::new();
+/// // futures 101 vs perpetual mark 100 -> 0.01.
+/// assert!((cs.update(tick(101.0, 100.0)).unwrap() - 0.01).abs() < 1e-12);
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct CalendarSpread {
+    has_emitted: bool,
+}
+
+impl CalendarSpread {
+    /// Construct a new calendar-spread indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for CalendarSpread {
+    type Input = DerivativesTick;
+    type Output = f64;
+
+    fn update(&mut self, tick: DerivativesTick) -> Option<f64> {
+        self.has_emitted = true;
+        Some((tick.futures_price - tick.mark_price) / tick.mark_price)
+    }
+
+    fn reset(&mut self) {
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "CalendarSpread"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn tick(futures: f64, mark: f64) -> DerivativesTick {
+        DerivativesTick::new_unchecked(
+            0.0, mark, mark, futures, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0,
+        )
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let cs = CalendarSpread::new();
+        assert_eq!(cs.name(), "CalendarSpread");
+        assert_eq!(cs.warmup_period(), 1);
+        assert!(!cs.is_ready());
+    }
+
+    #[test]
+    fn future_over_perp_is_positive() {
+        let mut cs = CalendarSpread::new();
+        let out = cs.update(tick(101.0, 100.0)).unwrap();
+        assert!((out - 0.01).abs() < 1e-12);
+        assert!(cs.is_ready());
+    }
+
+    #[test]
+    fn future_under_perp_is_negative() {
+        let mut cs = CalendarSpread::new();
+        let out = cs.update(tick(99.0, 100.0)).unwrap();
+        assert!((out + 0.01).abs() < 1e-12);
+    }
+
+    #[test]
+    fn flat_is_zero() {
+        let mut cs = CalendarSpread::new();
+        assert_eq!(cs.update(tick(100.0, 100.0)), Some(0.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let ticks: Vec<DerivativesTick> = (0..20)
+            .map(|i| tick(100.0 + f64::from(i % 5), 100.0))
+            .collect();
+        let mut a = CalendarSpread::new();
+        let mut b = CalendarSpread::new();
+        assert_eq!(
+            a.batch(&ticks),
+            ticks.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut cs = CalendarSpread::new();
+        cs.update(tick(101.0, 100.0));
+        assert!(cs.is_ready());
+        cs.reset();
+        assert!(!cs.is_ready());
+    }
+}

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

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

@@ -0,0 +1,197 @@
+//! Camarilla Pivot Points (Nick Stott).
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Camarilla Pivot Points output: four resistances, the pivot, four supports.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CamarillaPivotsOutput {
+    /// Pivot Point: `(H + L + C) / 3` (informational, not in the Camarilla R/S formulas).
+    pub pp: f64,
+    /// Resistance 1: `C + (H − L)·1.1/12`.
+    pub r1: f64,
+    /// Resistance 2: `C + (H − L)·1.1/6`.
+    pub r2: f64,
+    /// Resistance 3: `C + (H − L)·1.1/4`.
+    pub r3: f64,
+    /// Resistance 4: `C + (H − L)·1.1/2`.
+    pub r4: f64,
+    /// Support 1: `C − (H − L)·1.1/12`.
+    pub s1: f64,
+    /// Support 2: `C − (H − L)·1.1/6`.
+    pub s2: f64,
+    /// Support 3: `C − (H − L)·1.1/4`.
+    pub s3: f64,
+    /// Support 4: `C − (H − L)·1.1/2`.
+    pub s4: f64,
+}
+
+/// Camarilla Pivot Points — Nick Stott's four-tier range-based level set.
+/// Anchored on the prior close rather than the typical price, with widths
+/// scaled by the constant `1.1` divided by `{12, 6, 4, 2}`.
+///
+/// ```text
+/// PP = (H + L + C) / 3
+/// R_n = C + (H − L) · 1.1 / d_n     S_n = C − (H − L) · 1.1 / d_n
+///   where d_1 = 12, d_2 = 6, d_3 = 4, d_4 = 2
+/// ```
+///
+/// R3/S3 are typically used as reversal levels; R4/S4 as breakout levels. As
+/// with the other pivot variants there are no parameters and no warmup — the
+/// first candle produces the first set of levels.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Camarilla, Candle, Indicator};
+///
+/// let prev = Candle::new(100.0, 110.0, 90.0, 105.0, 1.0, 0).unwrap();
+/// let levels = Camarilla::new().update(prev).unwrap();
+/// assert!(levels.r4 > levels.r3);
+/// assert!(levels.s4 < levels.s3);
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct Camarilla {
+    ready: bool,
+}
+
+impl Camarilla {
+    /// Construct a new Camarilla Pivot Points indicator.
+    pub const fn new() -> Self {
+        Self { ready: false }
+    }
+}
+
+const CAM: f64 = 1.1;
+
+impl Indicator for Camarilla {
+    type Input = Candle;
+    type Output = CamarillaPivotsOutput;
+
+    fn update(&mut self, candle: Candle) -> Option<CamarillaPivotsOutput> {
+        let (h, l, c) = (candle.high, candle.low, candle.close);
+        let range = h - l;
+        let pp = (h + l + c) / 3.0;
+        let w1 = range * CAM / 12.0;
+        let w2 = range * CAM / 6.0;
+        let w3 = range * CAM / 4.0;
+        let w4 = range * CAM / 2.0;
+        let out = CamarillaPivotsOutput {
+            pp,
+            r1: c + w1,
+            r2: c + w2,
+            r3: c + w3,
+            r4: c + w4,
+            s1: c - w1,
+            s2: c - w2,
+            s3: c - w3,
+            s4: c - w4,
+        };
+        self.ready = true;
+        Some(out)
+    }
+
+    fn reset(&mut self) {
+        self.ready = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.ready
+    }
+
+    fn name(&self) -> &'static str {
+        "Camarilla"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(h: f64, l: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(close, h, l, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn formula_reference_values() {
+        // H=110, L=90, C=105, range=20.
+        let levels = Camarilla::new().update(c(110.0, 90.0, 105.0, 0)).unwrap();
+        let range = 20.0;
+        assert!((levels.r1 - (105.0 + range * 1.1 / 12.0)).abs() < 1e-12);
+        assert!((levels.r2 - (105.0 + range * 1.1 / 6.0)).abs() < 1e-12);
+        assert!((levels.r3 - (105.0 + range * 1.1 / 4.0)).abs() < 1e-12);
+        assert!((levels.r4 - (105.0 + range * 1.1 / 2.0)).abs() < 1e-12);
+        assert!((levels.s1 - (105.0 - range * 1.1 / 12.0)).abs() < 1e-12);
+        assert!((levels.s4 - (105.0 - range * 1.1 / 2.0)).abs() < 1e-12);
+    }
+
+    #[test]
+    fn resistance_strictly_widens_with_index() {
+        let levels = Camarilla::new().update(c(120.0, 80.0, 110.0, 0)).unwrap();
+        assert!(levels.r4 > levels.r3);
+        assert!(levels.r3 > levels.r2);
+        assert!(levels.r2 > levels.r1);
+        assert!(levels.r1 > 110.0);
+        assert!(levels.s1 < 110.0);
+        assert!(levels.s2 < levels.s1);
+        assert!(levels.s3 < levels.s2);
+        assert!(levels.s4 < levels.s3);
+    }
+
+    #[test]
+    fn constant_series_collapses_levels() {
+        let levels = Camarilla::new().update(c(50.0, 50.0, 50.0, 0)).unwrap();
+        assert_eq!(levels.r4, 50.0);
+        assert_eq!(levels.s4, 50.0);
+        assert_eq!(levels.pp, 50.0);
+    }
+
+    #[test]
+    fn warmup_and_ready() {
+        let mut p = Camarilla::new();
+        assert!(!p.is_ready());
+        assert_eq!(p.warmup_period(), 1);
+        p.update(c(11.0, 9.0, 10.0, 0));
+        assert!(p.is_ready());
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut p = Camarilla::new();
+        p.update(c(11.0, 9.0, 10.0, 0));
+        p.reset();
+        assert!(!p.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0_i32..40)
+            .map(|i| {
+                c(
+                    f64::from(i) + 2.0,
+                    f64::from(i),
+                    f64::from(i) + 1.0,
+                    i.into(),
+                )
+            })
+            .collect();
+        let mut a = Camarilla::new();
+        let mut b = Camarilla::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let p = Camarilla::new();
+        assert_eq!(p.warmup_period(), 1);
+        assert_eq!(p.name(), "Camarilla");
+    }
+}

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

@@ -0,0 +1,204 @@
+//! Ehlers Center of Gravity Oscillator.
+#![allow(clippy::manual_midpoint)]
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Ehlers' Center of Gravity (CG) oscillator.
+///
+/// Treats the most recent `period` prices as masses and reports the
+/// weighted "center" of that mass distribution, negated so positive readings
+/// correspond to recent strength:
+///
+/// ```text
+/// num = sum_{k=0..period-1} (1 + k) * price[t - k]
+/// den = sum_{k=0..period-1} price[t - k]
+/// cg  = - num / den + (period + 1) / 2
+/// ```
+///
+/// The constant offset centres the oscillator around zero. From Ehlers,
+/// *Cybernetic Analysis for Stocks and Futures* (2004, ch. 7).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Indicator, CenterOfGravity};
+///
+/// let mut cg = CenterOfGravity::new(10).unwrap();
+/// let mut last = None;
+/// for i in 0..30 {
+///     last = cg.update(100.0 + (f64::from(i) * 0.2).sin() * 5.0);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct CenterOfGravity {
+    period: usize,
+    window: VecDeque<f64>,
+    last_value: Option<f64>,
+}
+
+impl CenterOfGravity {
+    /// Construct with the rolling window length.
+    ///
+    /// # 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),
+            last_value: None,
+        })
+    }
+
+    /// Configured period.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+
+    /// Current value if available.
+    pub const fn value(&self) -> Option<f64> {
+        self.last_value
+    }
+}
+
+impl Indicator for CenterOfGravity {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, input: f64) -> Option<f64> {
+        if !input.is_finite() {
+            return self.last_value;
+        }
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(input);
+        if self.window.len() < self.period {
+            return None;
+        }
+        // Most recent has weight 1; oldest has weight `period`.
+        let mut num = 0.0;
+        let mut den = 0.0;
+        for (k, p) in self.window.iter().rev().enumerate() {
+            let w = 1.0 + k as f64;
+            num += w * p;
+            den += p;
+        }
+        let v = if den.abs() > f64::EPSILON {
+            -num / den + (self.period as f64 + 1.0) / 2.0
+        } else {
+            0.0
+        };
+        self.last_value = Some(v);
+        Some(v)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.last_value = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last_value.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "CenterOfGravity"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn new_rejects_zero_period() {
+        assert!(matches!(CenterOfGravity::new(0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let mut cg = CenterOfGravity::new(10).unwrap();
+        assert_eq!(cg.period(), 10);
+        assert_eq!(cg.warmup_period(), 10);
+        assert_eq!(cg.name(), "CenterOfGravity");
+        assert!(!cg.is_ready());
+        for i in 1..=10 {
+            cg.update(f64::from(i));
+        }
+        assert!(cg.is_ready());
+        assert!(cg.value().is_some());
+    }
+
+    #[test]
+    fn constant_series_yields_zero() {
+        // num = sum k * p, den = period * p, ratio = (period + 1) / 2,
+        // so cg = - (period+1)/2 + (period+1)/2 = 0.
+        let mut cg = CenterOfGravity::new(5).unwrap();
+        let out = cg.batch(&[7.0_f64; 30]);
+        for x in out.iter().skip(5).flatten() {
+            assert_relative_eq!(*x, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (1..=50).map(f64::from).collect();
+        let mut a = CenterOfGravity::new(10).unwrap();
+        let mut b = CenterOfGravity::new(10).unwrap();
+        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 cg = CenterOfGravity::new(5).unwrap();
+        cg.batch(&(1..=10).map(f64::from).collect::<Vec<_>>());
+        let before = cg.value();
+        assert!(before.is_some());
+        assert_eq!(cg.update(f64::NAN), before);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut cg = CenterOfGravity::new(5).unwrap();
+        cg.batch(&(1..=10).map(f64::from).collect::<Vec<_>>());
+        assert!(cg.is_ready());
+        cg.reset();
+        assert!(!cg.is_ready());
+    }
+
+    #[test]
+    fn warmup_returns_none_until_seed() {
+        let mut cg = CenterOfGravity::new(4).unwrap();
+        assert_eq!(cg.update(1.0), None);
+        assert_eq!(cg.update(2.0), None);
+        assert_eq!(cg.update(3.0), None);
+        assert!(cg.update(4.0).is_some());
+    }
+
+    #[test]
+    fn zero_window_uses_zero_fallback() {
+        // den == sum(prices) == 0 when the rolling window is all zeros, which
+        // exercises the protective fallback in the divisor guard.
+        let mut cg = CenterOfGravity::new(5).unwrap();
+        let out = cg.batch(&[0.0_f64; 10]);
+        for x in out.iter().skip(5).flatten() {
+            assert_relative_eq!(*x, 0.0, epsilon = 1e-12);
+        }
+    }
+}

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

@@ -0,0 +1,173 @@
+//! Chande Forecast Oscillator (CFO).
+
+use crate::error::{Error, Result};
+use crate::indicators::linreg::LinearRegression;
+use crate::traits::Indicator;
+
+/// Tushar Chande's Forecast Oscillator — the percentage difference between
+/// the close and the endpoint of an `n`-bar linear-regression forecast of the
+/// close.
+///
+/// ```text
+/// CFO_t = 100 · (close_t − LinearRegression(close, period)_t) / close_t
+/// ```
+///
+/// Positive readings mean the close is *above* the linear forecast (price has
+/// overshot trend); negative readings mean it sits below. Wraps the existing
+/// `LinearRegression` so the warmup matches.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Cfo, Indicator};
+///
+/// let mut cfo = Cfo::new(14).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     last = cfo.update(100.0 + f64::from(i));
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct Cfo {
+    period: usize,
+    linreg: LinearRegression,
+    current: Option<f64>,
+}
+
+impl Cfo {
+    /// # Errors
+    /// Returns [`Error::PeriodZero`] if `period == 0`.
+    pub fn new(period: usize) -> Result<Self> {
+        if period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            period,
+            linreg: LinearRegression::new(period)?,
+            current: None,
+        })
+    }
+
+    /// Configured period.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+}
+
+impl Indicator for Cfo {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, input: f64) -> Option<f64> {
+        let forecast = self.linreg.update(input)?;
+        // Hold the previous value if the close is zero — the percentage form
+        // is undefined and a return of inf would propagate badly.
+        if input == 0.0 {
+            return self.current;
+        }
+        let value = 100.0 * (input - forecast) / input;
+        self.current = Some(value);
+        Some(value)
+    }
+
+    fn reset(&mut self) {
+        self.linreg.reset();
+        self.current = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.current.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "CFO"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(Cfo::new(0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let cfo = Cfo::new(14).unwrap();
+        assert_eq!(cfo.period(), 14);
+        assert_eq!(cfo.warmup_period(), 14);
+        assert_eq!(cfo.name(), "CFO");
+    }
+
+    #[test]
+    fn constant_series_yields_zero() {
+        // LinReg of a constant series equals the constant, so close − forecast
+        // is 0 and CFO is 0.
+        let mut cfo = Cfo::new(5).unwrap();
+        let out = cfo.batch(&[42.0_f64; 30]);
+        for v in out.iter().skip(4).flatten() {
+            assert_relative_eq!(*v, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn perfect_linear_series_yields_zero() {
+        // LinReg of a perfectly linear input fits the line exactly, so the
+        // close lands on the forecast and CFO = 0.
+        let mut cfo = Cfo::new(5).unwrap();
+        let prices: Vec<f64> = (1..=20).map(|i| f64::from(i) * 2.0).collect();
+        let out = cfo.batch(&prices);
+        for v in out.iter().skip(4).flatten() {
+            assert_relative_eq!(*v, 0.0, epsilon = 1e-9);
+        }
+    }
+
+    #[test]
+    fn warmup_emits_first_value_at_period() {
+        let mut cfo = Cfo::new(3).unwrap();
+        for i in 1..=2 {
+            assert_eq!(cfo.update(f64::from(i)), None);
+        }
+        assert!(cfo.update(3.0).is_some());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (1..=80)
+            .map(|i| 100.0 + (f64::from(i) * 0.3).sin() * 5.0)
+            .collect();
+        let mut a = Cfo::new(14).unwrap();
+        let mut b = Cfo::new(14).unwrap();
+        assert_eq!(
+            a.batch(&prices),
+            prices.iter().map(|p| b.update(*p)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut cfo = Cfo::new(5).unwrap();
+        cfo.batch(&(1..=20).map(f64::from).collect::<Vec<_>>());
+        assert!(cfo.is_ready());
+        cfo.reset();
+        assert!(!cfo.is_ready());
+        assert_eq!(cfo.update(1.0), None);
+    }
+
+    #[test]
+    fn zero_close_holds_value() {
+        let mut cfo = Cfo::new(3).unwrap();
+        cfo.batch(&[1.0_f64, 2.0, 3.0]);
+        let before = cfo.current;
+        assert_eq!(cfo.update(0.0), before);
+    }
+}

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

@@ -0,0 +1,202 @@
+//! Classic (Floor-Trader) Pivot Points.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Classic Pivot Points output: pivot plus three resistances and three supports.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct ClassicPivotsOutput {
+    /// Pivot Point: `(H + L + C) / 3`.
+    pub pp: f64,
+    /// Resistance 1: `2·PP − L`.
+    pub r1: f64,
+    /// Resistance 2: `PP + (H − L)`.
+    pub r2: f64,
+    /// Resistance 3: `H + 2·(PP − L)`.
+    pub r3: f64,
+    /// Support 1: `2·PP − H`.
+    pub s1: f64,
+    /// Support 2: `PP − (H − L)`.
+    pub s2: f64,
+    /// Support 3: `L − 2·(H − PP)`.
+    pub s3: f64,
+}
+
+/// Classic (Floor-Trader) Pivot Points — the standard pivot/resistance/support
+/// levels computed from a completed candle's high, low and close.
+///
+/// ```text
+/// PP = (H + L + C) / 3
+/// R1 = 2·PP − L          S1 = 2·PP − H
+/// R2 = PP + (H − L)      S2 = PP − (H − L)
+/// R3 = H + 2·(PP − L)    S3 = L − 2·(H − PP)
+/// ```
+///
+/// Pivots are typically computed once per session (day, week, month) from the
+/// **previous** session's bar and used as fixed reference levels for the next
+/// session. The streaming API here simply re-evaluates the formula on every
+/// candle it sees, which makes it a one-step transform you can wire to any
+/// pre-aggregated session bar. There are no parameters and no warmup — the
+/// first candle produces the first set of levels.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, ClassicPivots, Indicator};
+///
+/// let prev = Candle::new(100.0, 110.0, 90.0, 105.0, 1.0, 0).unwrap();
+/// let mut pp = ClassicPivots::new();
+/// let levels = pp.update(prev).unwrap();
+/// assert!((levels.pp - 101.6666666666).abs() < 1e-9);
+/// assert!(levels.r1 > levels.pp);
+/// assert!(levels.s1 < levels.pp);
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct ClassicPivots {
+    ready: bool,
+}
+
+impl ClassicPivots {
+    /// Construct a new Classic Pivot Points indicator. The indicator has no
+    /// parameters and no warmup.
+    pub const fn new() -> Self {
+        Self { ready: false }
+    }
+}
+
+impl Indicator for ClassicPivots {
+    type Input = Candle;
+    type Output = ClassicPivotsOutput;
+
+    fn update(&mut self, candle: Candle) -> Option<ClassicPivotsOutput> {
+        let (h, l, c) = (candle.high, candle.low, candle.close);
+        let pp = (h + l + c) / 3.0;
+        let range = h - l;
+        let out = ClassicPivotsOutput {
+            pp,
+            r1: 2.0 * pp - l,
+            r2: pp + range,
+            r3: h + 2.0 * (pp - l),
+            s1: 2.0 * pp - h,
+            s2: pp - range,
+            s3: l - 2.0 * (h - pp),
+        };
+        self.ready = true;
+        Some(out)
+    }
+
+    fn reset(&mut self) {
+        self.ready = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.ready
+    }
+
+    fn name(&self) -> &'static str {
+        "ClassicPivots"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(h: f64, l: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(close, h, l, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn formula_reference_values() {
+        // H=110, L=90, C=105 -> PP = 305/3 ≈ 101.6667.
+        let levels = ClassicPivots::new()
+            .update(c(110.0, 90.0, 105.0, 0))
+            .unwrap();
+        let pp = 305.0 / 3.0;
+        let range = 20.0;
+        assert!((levels.pp - pp).abs() < 1e-12);
+        assert!((levels.r1 - (2.0 * pp - 90.0)).abs() < 1e-12);
+        assert!((levels.s1 - (2.0 * pp - 110.0)).abs() < 1e-12);
+        assert!((levels.r2 - (pp + range)).abs() < 1e-12);
+        assert!((levels.s2 - (pp - range)).abs() < 1e-12);
+        assert!((levels.r3 - (110.0 + 2.0 * (pp - 90.0))).abs() < 1e-12);
+        assert!((levels.s3 - (90.0 - 2.0 * (110.0 - pp))).abs() < 1e-12);
+    }
+
+    #[test]
+    fn ordering_resistance_above_pivot_above_support() {
+        // For any non-degenerate bar with H > L, R-levels exceed PP and S-levels lie below.
+        let levels = ClassicPivots::new()
+            .update(c(200.0, 100.0, 150.0, 0))
+            .unwrap();
+        assert!(levels.r3 >= levels.r2);
+        assert!(levels.r2 >= levels.r1);
+        assert!(levels.r1 >= levels.pp);
+        assert!(levels.pp >= levels.s1);
+        assert!(levels.s1 >= levels.s2);
+        assert!(levels.s2 >= levels.s3);
+    }
+
+    #[test]
+    fn constant_series_collapses_levels() {
+        // H = L = C means range = 0 and every level equals the close.
+        let levels = ClassicPivots::new().update(c(50.0, 50.0, 50.0, 0)).unwrap();
+        assert_eq!(levels.pp, 50.0);
+        assert_eq!(levels.r1, 50.0);
+        assert_eq!(levels.s1, 50.0);
+        assert_eq!(levels.r2, 50.0);
+        assert_eq!(levels.s2, 50.0);
+        assert_eq!(levels.r3, 50.0);
+        assert_eq!(levels.s3, 50.0);
+    }
+
+    #[test]
+    fn ready_after_first_update_warmup_is_one() {
+        let mut pp = ClassicPivots::new();
+        assert!(!pp.is_ready());
+        assert_eq!(pp.warmup_period(), 1);
+        pp.update(c(11.0, 9.0, 10.0, 0));
+        assert!(pp.is_ready());
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut pp = ClassicPivots::new();
+        pp.update(c(11.0, 9.0, 10.0, 0));
+        assert!(pp.is_ready());
+        pp.reset();
+        assert!(!pp.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0_i32..40)
+            .map(|i| {
+                c(
+                    f64::from(i) + 2.0,
+                    f64::from(i),
+                    f64::from(i) + 1.0,
+                    i.into(),
+                )
+            })
+            .collect();
+        let mut a = ClassicPivots::new();
+        let mut b = ClassicPivots::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let pp = ClassicPivots::new();
+        assert_eq!(pp.warmup_period(), 1);
+        assert_eq!(pp.name(), "ClassicPivots");
+    }
+}

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

@@ -0,0 +1,177 @@
+//! Closing Marubozu candlestick pattern.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Closing Marubozu — a single-bar strong-momentum candle with a long body and no
+/// shadow on the *close* end. A white closing marubozu closes right at the high
+/// (no upper shadow) and may carry an opening shadow below; a black one closes
+/// right at the low (no lower shadow) and may carry an opening shadow above. The
+/// shaved close end shows the move ran unopposed into the bell.
+///
+/// ```text
+/// range = high − low
+/// long body: |close − open| >= 0.7 * range
+/// white: close > open and high − close <= 0.05 * range   (close at the high)
+/// black: close < open and close − low  <= 0.05 * range   (close at the low)
+/// ```
+///
+/// Output is `+1.0` for a white closing marubozu, `−1.0` for a black one, and
+/// `0.0` otherwise. Body and shadow thresholds follow the geometric house style
+/// rather than TA-Lib's rolling averages. The opposite shaved end is
+/// [`crate::OpeningMarubozu`]. Pattern-shape check only — no trend filter is
+/// applied; combine with a trend indicator for actionable signals.
+///
+/// # Signed ±1 encoding
+///
+/// This detector emits the uniform candlestick sign convention shared across the
+/// pattern family — `+1.0` bullish, `−1.0` bearish, `0.0` no pattern — so it drops
+/// straight into a machine-learning feature matrix where the bullish and bearish
+/// variants occupy a single dimension.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, ClosingMarubozu, Indicator};
+///
+/// let mut indicator = ClosingMarubozu::new();
+/// // White: closes at the high, small opening shadow below.
+/// let candle = Candle::new(10.5, 15.0, 10.0, 15.0, 1.0, 0).unwrap();
+/// assert_eq!(indicator.update(candle), Some(1.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct ClosingMarubozu {
+    has_emitted: bool,
+}
+
+impl ClosingMarubozu {
+    /// Construct a new Closing Marubozu detector.
+    pub const fn new() -> Self {
+        Self { has_emitted: false }
+    }
+}
+
+impl Indicator for ClosingMarubozu {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        let range = candle.high - candle.low;
+        if range <= 0.0 {
+            return Some(0.0);
+        }
+        let body = candle.close - candle.open;
+        if body.abs() < 0.7 * range {
+            return Some(0.0);
+        }
+        let tol = 0.05 * range;
+        if body > 0.0 && candle.high - candle.close <= tol {
+            return Some(1.0);
+        }
+        if body < 0.0 && candle.close - candle.low <= tol {
+            return Some(-1.0);
+        }
+        Some(0.0)
+    }
+
+    fn reset(&mut self) {
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "ClosingMarubozu"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(open: f64, high: f64, low: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let t = ClosingMarubozu::new();
+        assert_eq!(t.name(), "ClosingMarubozu");
+        assert_eq!(t.warmup_period(), 1);
+        assert!(!t.is_ready());
+    }
+
+    #[test]
+    fn white_closing_marubozu_is_plus_one() {
+        let mut t = ClosingMarubozu::new();
+        // Closes at the high, opening shadow below.
+        assert_eq!(t.update(c(10.5, 15.0, 10.0, 15.0, 0)), Some(1.0));
+    }
+
+    #[test]
+    fn black_closing_marubozu_is_minus_one() {
+        let mut t = ClosingMarubozu::new();
+        // Closes at the low, opening shadow above.
+        assert_eq!(t.update(c(14.5, 15.0, 10.0, 10.0, 0)), Some(-1.0));
+    }
+
+    #[test]
+    fn white_with_upper_shadow_yields_zero() {
+        let mut t = ClosingMarubozu::new();
+        // Long white body but a clear upper shadow -> close is not at the high.
+        assert_eq!(t.update(c(10.5, 16.0, 10.0, 15.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn black_with_lower_shadow_yields_zero() {
+        let mut t = ClosingMarubozu::new();
+        // Long black body but a clear lower shadow -> close is not at the low.
+        assert_eq!(t.update(c(14.5, 15.0, 9.0, 10.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn short_body_yields_zero() {
+        let mut t = ClosingMarubozu::new();
+        // Body is short relative to range.
+        assert_eq!(t.update(c(12.0, 15.0, 10.0, 12.5, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn zero_range_yields_zero() {
+        let mut t = ClosingMarubozu::new();
+        assert_eq!(t.update(c(10.0, 10.0, 10.0, 10.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| {
+                let base = 100.0 + i as f64;
+                c(base + 0.5, base + 5.0, base, base + 5.0, i)
+            })
+            .collect();
+        let mut a = ClosingMarubozu::new();
+        let mut b = ClosingMarubozu::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = ClosingMarubozu::new();
+        t.update(c(10.5, 15.0, 10.0, 15.0, 0));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+    }
+}

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

@@ -0,0 +1,184 @@
+//! Rolling Coefficient of Variation (`StdDev / Mean`).
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Coefficient of Variation — the rolling population standard deviation
+/// divided by the rolling mean.
+///
+/// ```text
+/// mean = (1/n) · Σ price
+/// sd   = √( (1/n) · Σ price² − mean² )
+/// CV   = sd / mean
+/// ```
+///
+/// CV is a dimensionless dispersion measure: it scales `StdDev` by the price
+/// level so two assets at very different price magnitudes can be compared
+/// directly. A higher CV means more relative variability for the same
+/// average price.
+///
+/// When the rolling mean is exactly zero the ratio is undefined; the
+/// indicator returns `0.0` in that degenerate case rather than producing a
+/// `NaN`/infinity.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{CoefficientOfVariation, Indicator};
+///
+/// let mut indicator = CoefficientOfVariation::new(20).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     last = indicator.update(100.0 + f64::from(i));
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct CoefficientOfVariation {
+    period: usize,
+    window: VecDeque<f64>,
+    sum: f64,
+    sum_sq: f64,
+}
+
+impl CoefficientOfVariation {
+    /// Construct a new rolling CV with the given 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,
+            window: VecDeque::with_capacity(period),
+            sum: 0.0,
+            sum_sq: 0.0,
+        })
+    }
+
+    /// Configured period.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+}
+
+impl Indicator for CoefficientOfVariation {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, value: f64) -> Option<f64> {
+        if self.window.len() == self.period {
+            let old = self.window.pop_front().expect("non-empty");
+            self.sum -= old;
+            self.sum_sq -= old * old;
+        }
+        self.window.push_back(value);
+        self.sum += value;
+        self.sum_sq += value * value;
+        if self.window.len() < self.period {
+            return None;
+        }
+        let n = self.period as f64;
+        let mean = self.sum / n;
+        let variance = (self.sum_sq / n - mean * mean).max(0.0);
+        let sd = variance.sqrt();
+        if mean == 0.0 {
+            // Undefined ratio: return 0 instead of NaN/inf so downstream
+            // consumers can keep arithmetic going on flat or zeroed series.
+            return Some(0.0);
+        }
+        Some(sd / mean)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.sum = 0.0;
+        self.sum_sq = 0.0;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.window.len() == self.period
+    }
+
+    fn name(&self) -> &'static str {
+        "CoefficientOfVariation"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(
+            CoefficientOfVariation::new(0),
+            Err(Error::PeriodZero)
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let cv = CoefficientOfVariation::new(14).unwrap();
+        assert_eq!(cv.period(), 14);
+        assert_eq!(cv.warmup_period(), 14);
+        assert_eq!(cv.name(), "CoefficientOfVariation");
+    }
+
+    #[test]
+    fn reference_value() {
+        // CV(3) of [2, 4, 6]: mean = 4, variance = 8/3, sd = √(8/3); CV = sd / 4.
+        let mut cv = CoefficientOfVariation::new(3).unwrap();
+        let out = cv.batch(&[2.0, 4.0, 6.0]);
+        assert_eq!(out[0], None);
+        let expected = (8.0_f64 / 3.0).sqrt() / 4.0;
+        assert_relative_eq!(out[2].unwrap(), expected, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn constant_series_yields_zero() {
+        let mut cv = CoefficientOfVariation::new(5).unwrap();
+        for o in cv.batch(&[42.0; 20]).into_iter().flatten() {
+            assert_relative_eq!(o, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn zero_mean_returns_zero() {
+        // [-1, 0, 1] has mean 0; the CV is defined to be 0 rather than NaN.
+        let mut cv = CoefficientOfVariation::new(3).unwrap();
+        let out = cv.batch(&[-1.0, 0.0, 1.0]);
+        assert_relative_eq!(out[2].unwrap(), 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut cv = CoefficientOfVariation::new(5).unwrap();
+        cv.batch(&[1.0, 2.0, 3.0, 4.0, 5.0]);
+        assert!(cv.is_ready());
+        cv.reset();
+        assert!(!cv.is_ready());
+        assert_eq!(cv.update(1.0), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (0..60)
+            .map(|i| 100.0 + (f64::from(i) * 0.4).sin() * 5.0)
+            .collect();
+        let batch = CoefficientOfVariation::new(14).unwrap().batch(&prices);
+        let mut b = CoefficientOfVariation::new(14).unwrap();
+        let streamed: Vec<_> = prices.iter().map(|p| b.update(*p)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

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

@@ -0,0 +1,446 @@
+//! Cointegration — rolling Engle–Granger hedge ratio plus an ADF stationarity test.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Output of [`Cointegration`].
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CointegrationOutput {
+    /// Engle–Granger hedge ratio `β`: the rolling OLS slope of `a` on `b`.
+    pub hedge_ratio: f64,
+    /// The current spread (regression residual) `a − (α + β·b)`.
+    pub spread: f64,
+    /// Augmented Dickey–Fuller `t`-statistic on the spread. **More negative**
+    /// means more strongly mean-reverting (cointegrated); compare against the
+    /// usual ADF/MacKinnon critical values (e.g. roughly `−2.9` at 5%). `0`
+    /// when the test is undefined (a degenerate, zero-variance spread).
+    pub adf_stat: f64,
+}
+
+/// Rolling cointegration test for a pair of assets (Engle–Granger two-step).
+///
+/// Each `update` receives one `(a, b)` pair (price levels, or log-levels if you
+/// prefer). Over the trailing window of `period` pairs the indicator:
+///
+/// 1. fits the **hedge ratio** `β` (and intercept `α`) by ordinary least
+///    squares of `a` on `b`, and forms the **spread** `eₜ = aₜ − (α + β·bₜ)`;
+/// 2. runs an **augmented Dickey–Fuller** test (no constant, no trend, with
+///    `adf_lags` lagged differences) on the spread series and reports its
+///    `t`-statistic.
+///
+/// A strongly negative ADF statistic means the spread reverts to its mean — the
+/// pair is cointegrated and the spread is tradeable. A statistic near zero
+/// means the spread wanders like a random walk (no cointegration). This is the
+/// classic pairs-trading screen: `β` tells you the hedge size, the spread is
+/// what you trade, and the ADF statistic tells you whether it is worth trading.
+///
+/// Each `update` is `O(period + adf_lags³)`: the hedge ratio is maintained from
+/// running sums, while the spread series and the small ADF regression are
+/// recomputed over the window — both bounded by the fixed parameters, not the
+/// series length.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Cointegration, Indicator};
+///
+/// let mut c = Cointegration::new(30, 1).unwrap();
+/// let mut last = None;
+/// for t in 0..60 {
+///     let b = 100.0 + f64::from(t);
+///     // `a` tracks 2·b with a small mean-reverting wobble ⇒ cointegrated.
+///     let a = 2.0 * b + 5.0 + 0.5 * (f64::from(t) * 0.7).sin();
+///     last = c.update((a, b));
+/// }
+/// let out = last.unwrap();
+/// assert!((out.hedge_ratio - 2.0).abs() < 0.1);
+/// assert!(out.adf_stat < 0.0); // mean-reverting spread
+/// ```
+#[derive(Debug, Clone)]
+pub struct Cointegration {
+    period: usize,
+    adf_lags: usize,
+    window: VecDeque<(f64, f64)>,
+    sum_a: f64,
+    sum_b: f64,
+    sum_bb: f64,
+    sum_ab: f64,
+}
+
+impl Cointegration {
+    /// Construct a new rolling cointegration test.
+    ///
+    /// `period` is the look-back window; `adf_lags` is the number of lagged
+    /// differences in the augmented Dickey–Fuller regression (`0` is the plain
+    /// Dickey–Fuller test).
+    ///
+    /// # Errors
+    /// Returns [`Error::InvalidPeriod`] if `period < 2·adf_lags + 4`, which is
+    /// the smallest window that leaves the ADF regression at least one degree
+    /// of freedom.
+    pub fn new(period: usize, adf_lags: usize) -> Result<Self> {
+        let min_period = 2 * adf_lags + 4;
+        if period < min_period {
+            return Err(Error::InvalidPeriod {
+                message: "cointegration needs period >= 2*adf_lags + 4",
+            });
+        }
+        Ok(Self {
+            period,
+            adf_lags,
+            window: VecDeque::with_capacity(period),
+            sum_a: 0.0,
+            sum_b: 0.0,
+            sum_bb: 0.0,
+            sum_ab: 0.0,
+        })
+    }
+
+    /// Look-back window length.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+
+    /// Number of lagged differences in the ADF regression.
+    pub const fn adf_lags(&self) -> usize {
+        self.adf_lags
+    }
+}
+
+impl Indicator for Cointegration {
+    /// `(a, b)` price pair.
+    type Input = (f64, f64);
+    type Output = CointegrationOutput;
+
+    fn update(&mut self, input: (f64, f64)) -> Option<CointegrationOutput> {
+        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 (hedge_ratio, intercept) = if var_b == 0.0 {
+            // A flat `b` window has no defined slope; fall back to a level shift.
+            (0.0, mean_a)
+        } else {
+            let cov = self.sum_ab / n - mean_a * mean_b;
+            let beta = cov / var_b;
+            (beta, mean_a - beta * mean_b)
+        };
+        // Build the spread (residual) series over the window, oldest → newest.
+        let spreads: Vec<f64> = self
+            .window
+            .iter()
+            .map(|&(ai, bi)| ai - (intercept + hedge_ratio * bi))
+            .collect();
+        let spread = *spreads.last().expect("window is full");
+        let adf_stat = adf_no_constant(&spreads, self.adf_lags);
+        Some(CointegrationOutput {
+            hedge_ratio,
+            spread,
+            adf_stat,
+        })
+    }
+
+    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 {
+        "Cointegration"
+    }
+}
+
+/// Solve the linear system `mat·x = rhs` for a small square system by Gaussian
+/// elimination, returning `None` if the matrix is (numerically) singular.
+///
+/// `mat` is row-major and consumed; `rhs` is the right-hand side.
+fn solve(mut mat: Vec<Vec<f64>>, mut rhs: Vec<f64>) -> Option<Vec<f64>> {
+    let dim = rhs.len();
+    for col in 0..dim {
+        let pivot = mat[col][col];
+        if pivot.abs() < 1e-12 {
+            return None;
+        }
+        let pivot_row = mat[col].clone();
+        for row in (col + 1)..dim {
+            let factor = mat[row][col] / pivot;
+            for (cell, &above) in mat[row].iter_mut().zip(&pivot_row).skip(col) {
+                *cell -= factor * above;
+            }
+            rhs[row] -= factor * rhs[col];
+        }
+    }
+    let mut sol = vec![0.0; dim];
+    for row in (0..dim).rev() {
+        let known: f64 = mat[row]
+            .iter()
+            .zip(&sol)
+            .skip(row + 1)
+            .map(|(coeff, value)| coeff * value)
+            .sum();
+        sol[row] = (rhs[row] - known) / mat[row][row];
+    }
+    Some(sol)
+}
+
+/// Augmented Dickey–Fuller `t`-statistic on `series`, with `lags` lagged
+/// differences and **no** constant or trend term (the Engle–Granger residual
+/// form). Returns `0.0` when the regression is degenerate.
+///
+/// The regression is `Δeₜ = ρ·eₜ₋₁ + Σ γᵢ·Δeₜ₋ᵢ + εₜ`; the reported statistic
+/// is `ρ̂ / se(ρ̂)`.
+fn adf_no_constant(series: &[f64], lags: usize) -> f64 {
+    let len = series.len();
+    let num_reg = lags + 1; // regressors: eₜ₋₁ plus `lags` lagged differences
+    let first = lags + 1; // first usable observation index
+    if len <= first {
+        return 0.0;
+    }
+    let num_obs = len - first;
+    if num_obs <= num_reg {
+        return 0.0; // need at least one residual degree of freedom
+    }
+    let regressors = |idx: usize| -> Vec<f64> {
+        let mut row = vec![0.0; num_reg];
+        row[0] = series[idx - 1];
+        for lag in 1..=lags {
+            row[lag] = series[idx - lag] - series[idx - lag - 1];
+        }
+        row
+    };
+    let mut xtx = vec![vec![0.0; num_reg]; num_reg];
+    let mut xty = vec![0.0; num_reg];
+    for idx in first..len {
+        let diff = series[idx] - series[idx - 1];
+        let row = regressors(idx);
+        for (ri, &left) in row.iter().enumerate() {
+            xty[ri] += left * diff;
+            for (ci, &right) in row.iter().enumerate() {
+                xtx[ri][ci] += left * right;
+            }
+        }
+    }
+    let Some(theta) = solve(xtx.clone(), xty) else {
+        return 0.0;
+    };
+    let rho = theta[0];
+    let mut rss = 0.0;
+    for idx in first..len {
+        let diff = series[idx] - series[idx - 1];
+        let pred: f64 = regressors(idx)
+            .iter()
+            .zip(&theta)
+            .map(|(coeff, value)| coeff * value)
+            .sum();
+        let resid = diff - pred;
+        rss += resid * resid;
+    }
+    let dof = (num_obs - num_reg) as f64;
+    let sigma2 = rss / dof;
+    // (XᵀX)⁻¹₀₀ from solving XᵀX·x = e₀. `xtx` is the same matrix the first
+    // solve already factored successfully, so this one cannot be singular.
+    let mut unit = vec![0.0; num_reg];
+    unit[0] = 1.0;
+    let inverse = solve(xtx, unit).expect("xtx is non-singular: the coefficient solve succeeded");
+    let var_rho = sigma2 * inverse[0];
+    if var_rho <= 0.0 {
+        return 0.0;
+    }
+    rho / var_rho.sqrt()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_too_small_period() {
+        // period must be >= 2*lags + 4.
+        assert!(Cointegration::new(3, 0).is_err()); // needs >= 4
+        assert!(Cointegration::new(4, 0).is_ok());
+        assert!(Cointegration::new(5, 1).is_err()); // needs >= 6
+        assert!(Cointegration::new(6, 1).is_ok());
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let c = Cointegration::new(30, 2).unwrap();
+        assert_eq!(c.period(), 30);
+        assert_eq!(c.adf_lags(), 2);
+        assert_eq!(c.warmup_period(), 30);
+        assert_eq!(c.name(), "Cointegration");
+    }
+
+    #[test]
+    fn adf_guards_and_degenerate_spread() {
+        // Series too short for any observation ⇒ 0.
+        assert_eq!(adf_no_constant(&[1.0], 1), 0.0);
+        // Long enough but too few degrees of freedom ⇒ 0.
+        assert_eq!(adf_no_constant(&[1.0, 2.0, 3.0], 1), 0.0);
+        // A perfect deterministic AR(1) spread (eₜ = 0.5·eₜ₋₁) is fit exactly,
+        // so the residual variance — and hence the t-statistic — is 0.
+        let geom: Vec<f64> = (0..8).map(|t| 0.5_f64.powi(t)).collect();
+        assert_eq!(adf_no_constant(&geom, 0), 0.0);
+    }
+
+    #[test]
+    fn recovers_hedge_ratio() {
+        // a = 2·b + 5 + small wobble ⇒ β ≈ 2.
+        let pairs: Vec<(f64, f64)> = (0..60)
+            .map(|t| {
+                let b = 100.0 + f64::from(t);
+                let a = 2.0 * b + 5.0 + 0.4 * (f64::from(t) * 0.9).sin();
+                (a, b)
+            })
+            .collect();
+        let out = Cointegration::new(30, 1)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert!(
+            (out.hedge_ratio - 2.0).abs() < 0.1,
+            "beta {}",
+            out.hedge_ratio
+        );
+    }
+
+    #[test]
+    fn stationary_spread_is_strongly_negative() {
+        // A clean mean-reverting (sinusoidal) spread ⇒ very negative ADF.
+        let pairs: Vec<(f64, f64)> = (0..80)
+            .map(|t| {
+                let b = 50.0 + 0.5 * f64::from(t);
+                let a = 2.0 * b + 1.0 + 0.5 * (f64::from(t) * 0.6).sin();
+                (a, b)
+            })
+            .collect();
+        let out = Cointegration::new(40, 1)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert!(out.adf_stat < -2.0, "adf {}", out.adf_stat);
+    }
+
+    #[test]
+    fn perfect_cointegration_has_zero_spread_and_defined_ratio() {
+        // a = 2·b + 5 exactly ⇒ residuals all zero ⇒ ADF degenerate ⇒ 0.
+        let pairs: Vec<(f64, f64)> = (0..40)
+            .map(|t| {
+                let b = 100.0 + f64::from(t);
+                (2.0 * b + 5.0, b)
+            })
+            .collect();
+        let out = Cointegration::new(20, 1)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_relative_eq!(out.hedge_ratio, 2.0, epsilon = 1e-9);
+        assert_relative_eq!(out.spread, 0.0, epsilon = 1e-6);
+        assert_relative_eq!(out.adf_stat, 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn flat_b_falls_back_to_level() {
+        // Constant b ⇒ no slope ⇒ hedge ratio 0, spread = a − mean(a).
+        let pairs: Vec<(f64, f64)> = (0..20)
+            .map(|t| (10.0 + 0.3 * (f64::from(t) * 0.5).sin(), 7.0))
+            .collect();
+        let out = Cointegration::new(10, 0)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_relative_eq!(out.hedge_ratio, 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn plain_dickey_fuller_lags_zero() {
+        // Exercise the lags = 0 path (1×1 ADF system).
+        let pairs: Vec<(f64, f64)> = (0..40)
+            .map(|t| {
+                let b = 20.0 + 0.4 * f64::from(t);
+                let a = 1.5 * b + 0.6 * (f64::from(t) * 0.7).sin();
+                (a, b)
+            })
+            .collect();
+        let out = Cointegration::new(20, 0)
+            .unwrap()
+            .batch(&pairs)
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert!((out.hedge_ratio - 1.5).abs() < 0.1);
+        assert!(out.adf_stat < 0.0);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut c = Cointegration::new(10, 1).unwrap();
+        for t in 0..20 {
+            let b = 100.0 + f64::from(t);
+            c.update((2.0 * b + (f64::from(t) * 0.5).sin(), b));
+        }
+        assert!(c.is_ready());
+        c.reset();
+        assert!(!c.is_ready());
+        assert_eq!(c.update((1.0, 1.0)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let pairs: Vec<(f64, f64)> = (0..80)
+            .map(|t| {
+                let b = 30.0 + 0.7 * f64::from(t);
+                let a = 1.8 * b + 2.0 + 0.5 * (f64::from(t) * 0.4).sin();
+                (a, b)
+            })
+            .collect();
+        let batch = Cointegration::new(25, 2).unwrap().batch(&pairs);
+        let mut c = Cointegration::new(25, 2).unwrap();
+        let streamed: Vec<_> = pairs.iter().map(|p| c.update(*p)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

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

@@ -0,0 +1,278 @@
+//! Concealing Baby Swallow candlestick pattern.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Returns `true` when `candle` is a black marubozu: a down candle whose body fills
+/// the range with negligible shadows on both ends.
+fn black_marubozu(candle: Candle) -> bool {
+    let range = candle.high - candle.low;
+    if range <= 0.0 {
+        return false;
+    }
+    let upper = candle.high - candle.open;
+    let lower = candle.close - candle.low;
+    candle.open > candle.close && upper <= 0.05 * range && lower <= 0.05 * range
+}
+
+/// Concealing Baby Swallow — a rare 4-bar bullish reversal. Two black marubozu lead
+/// a steep decline; the third is a black candle that gaps down on the open yet
+/// throws a long upper shadow back up into the second body; the fourth is a large
+/// black candle that completely engulfs the third, shadows included. The relentless
+/// selling that can no longer make ground signals capitulation.
+///
+/// ```text
+/// bar1, bar2 black marubozu (body == range, negligible shadows)
+/// bar3 black, opens below bar2's body (open3 < close2) with an upper
+///   shadow into it (high3 > close2)
+/// bar4 black, engulfs bar3 including shadows: open4 > high3 and close4 < low3
+/// ```
+///
+/// Output is `+1.0` when the pattern completes and `0.0` otherwise. Concealing Baby
+/// Swallow is a single-direction (bullish-only) reversal, so it never emits `−1.0`.
+/// The first three bars always return `0.0` because the four-bar window is not yet
+/// filled. Body and shadow thresholds follow the geometric house style rather than
+/// TA-Lib's rolling averages. Pattern-shape check only — no trend filter is applied;
+/// combine with a trend indicator for actionable signals.
+///
+/// # Signed ±1 encoding
+///
+/// This detector emits the uniform candlestick sign convention shared across the
+/// pattern family — `+1.0` bullish, `0.0` no pattern — so it drops straight into
+/// a machine-learning feature matrix as a single dimension.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, ConcealingBabySwallow, Indicator};
+///
+/// let mut indicator = ConcealingBabySwallow::new();
+/// indicator.update(Candle::new(20.0, 20.1, 14.9, 15.0, 1.0, 0).unwrap());
+/// indicator.update(Candle::new(16.0, 16.1, 11.9, 12.0, 1.0, 1).unwrap());
+/// indicator.update(Candle::new(11.0, 13.0, 9.9, 10.0, 1.0, 2).unwrap());
+/// let out = indicator
+///     .update(Candle::new(14.0, 14.1, 8.9, 9.0, 1.0, 3).unwrap());
+/// assert_eq!(out, Some(1.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct ConcealingBabySwallow {
+    c1: Option<Candle>,
+    c2: Option<Candle>,
+    c3: Option<Candle>,
+    has_emitted: bool,
+}
+
+impl ConcealingBabySwallow {
+    /// Construct a new Concealing Baby Swallow detector.
+    pub const fn new() -> Self {
+        Self {
+            c1: None,
+            c2: None,
+            c3: None,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for ConcealingBabySwallow {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        let bar1 = self.c1;
+        let bar2 = self.c2;
+        let bar3 = self.c3;
+        self.c1 = self.c2;
+        self.c2 = self.c3;
+        self.c3 = Some(candle);
+        let (Some(bar1), Some(bar2), Some(bar3)) = (bar1, bar2, bar3) else {
+            return Some(0.0);
+        };
+        // bar1 and bar2 are black marubozu.
+        if !black_marubozu(bar1) || !black_marubozu(bar2) {
+            return Some(0.0);
+        }
+        // bar3 is black, gaps down on the open, throws an upper shadow into bar2.
+        if bar3.open <= bar3.close {
+            return Some(0.0);
+        }
+        if bar3.open >= bar2.close {
+            return Some(0.0); // no downside open gap
+        }
+        if bar3.high <= bar2.close {
+            return Some(0.0); // upper shadow does not reach into bar2's body
+        }
+        // bar4 is black and engulfs bar3 including its shadows.
+        if candle.open <= candle.close {
+            return Some(0.0);
+        }
+        if candle.open > bar3.high && candle.close < bar3.low {
+            return Some(1.0);
+        }
+        Some(0.0)
+    }
+
+    fn reset(&mut self) {
+        self.c1 = None;
+        self.c2 = None;
+        self.c3 = None;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        4
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "ConcealingBabySwallow"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(open: f64, high: f64, low: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let t = ConcealingBabySwallow::new();
+        assert_eq!(t.name(), "ConcealingBabySwallow");
+        assert_eq!(t.warmup_period(), 4);
+        assert!(!t.is_ready());
+    }
+
+    #[test]
+    fn concealing_baby_swallow_is_plus_one() {
+        let mut t = ConcealingBabySwallow::new();
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(16.0, 16.1, 11.9, 12.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(11.0, 13.0, 9.9, 10.0, 2)), Some(0.0));
+        assert_eq!(t.update(c(14.0, 14.1, 8.9, 9.0, 3)), Some(1.0));
+    }
+
+    #[test]
+    fn warmup_returns_zero() {
+        let mut t = ConcealingBabySwallow::new();
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(16.0, 16.1, 11.9, 12.0, 1)), Some(0.0));
+        assert_eq!(t.update(c(11.0, 13.0, 9.9, 10.0, 2)), Some(0.0));
+    }
+
+    #[test]
+    fn first_bar_not_marubozu_yields_zero() {
+        let mut t = ConcealingBabySwallow::new();
+        // bar1 white.
+        t.update(c(15.0, 20.1, 14.9, 20.0, 0));
+        t.update(c(16.0, 16.1, 11.9, 12.0, 1));
+        t.update(c(11.0, 13.0, 9.9, 10.0, 2));
+        assert_eq!(t.update(c(14.0, 14.1, 8.9, 9.0, 3)), Some(0.0));
+    }
+
+    #[test]
+    fn first_bar_zero_range_yields_zero() {
+        let mut t = ConcealingBabySwallow::new();
+        // bar1 zero range -> not a marubozu.
+        t.update(c(15.0, 15.0, 15.0, 15.0, 0));
+        t.update(c(16.0, 16.1, 11.9, 12.0, 1));
+        t.update(c(11.0, 13.0, 9.9, 10.0, 2));
+        assert_eq!(t.update(c(14.0, 14.1, 8.9, 9.0, 3)), Some(0.0));
+    }
+
+    #[test]
+    fn second_bar_not_marubozu_yields_zero() {
+        let mut t = ConcealingBabySwallow::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        // bar2 white.
+        t.update(c(12.0, 16.1, 11.9, 16.0, 1));
+        t.update(c(11.0, 13.0, 9.9, 10.0, 2));
+        assert_eq!(t.update(c(14.0, 14.1, 8.9, 9.0, 3)), Some(0.0));
+    }
+
+    #[test]
+    fn third_bar_not_black_yields_zero() {
+        let mut t = ConcealingBabySwallow::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        t.update(c(16.0, 16.1, 11.9, 12.0, 1));
+        // bar3 white.
+        t.update(c(11.0, 13.0, 9.9, 12.5, 2));
+        assert_eq!(t.update(c(14.0, 14.1, 8.9, 9.0, 3)), Some(0.0));
+    }
+
+    #[test]
+    fn third_bar_no_gap_yields_zero() {
+        let mut t = ConcealingBabySwallow::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        t.update(c(16.0, 16.1, 11.9, 12.0, 1));
+        // bar3 black but opens at/above bar2's close -> no downside gap.
+        t.update(c(12.5, 13.0, 9.9, 10.0, 2));
+        assert_eq!(t.update(c(14.0, 14.1, 8.9, 9.0, 3)), Some(0.0));
+    }
+
+    #[test]
+    fn third_bar_no_upper_shadow_yields_zero() {
+        let mut t = ConcealingBabySwallow::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        t.update(c(16.0, 16.1, 11.9, 12.0, 1));
+        // bar3 black, gaps down, but its high does not reach into bar2's body.
+        t.update(c(11.0, 11.5, 9.9, 10.0, 2));
+        assert_eq!(t.update(c(14.0, 14.1, 8.9, 9.0, 3)), Some(0.0));
+    }
+
+    #[test]
+    fn fourth_bar_not_black_yields_zero() {
+        let mut t = ConcealingBabySwallow::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        t.update(c(16.0, 16.1, 11.9, 12.0, 1));
+        t.update(c(11.0, 13.0, 9.9, 10.0, 2));
+        // bar4 white.
+        assert_eq!(t.update(c(14.0, 14.1, 8.9, 14.05, 3)), Some(0.0));
+    }
+
+    #[test]
+    fn fourth_bar_not_engulfing_yields_zero() {
+        let mut t = ConcealingBabySwallow::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        t.update(c(16.0, 16.1, 11.9, 12.0, 1));
+        t.update(c(11.0, 13.0, 9.9, 10.0, 2));
+        // bar4 black but does not engulf bar3's high.
+        assert_eq!(t.update(c(12.5, 12.6, 8.9, 9.0, 3)), Some(0.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| {
+                let base = 200.0 - i as f64;
+                c(base, base + 0.05, base - 5.0, base - 5.0, i)
+            })
+            .collect();
+        let mut a = ConcealingBabySwallow::new();
+        let mut b = ConcealingBabySwallow::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = ConcealingBabySwallow::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        t.update(c(16.0, 16.1, 11.9, 12.0, 1));
+        t.update(c(11.0, 13.0, 9.9, 10.0, 2));
+        t.update(c(14.0, 14.1, 8.9, 9.0, 3));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 0)), Some(0.0));
+    }
+}

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

@@ -0,0 +1,221 @@
+//! Rolling Conditional Value-at-Risk (`CVaR` / Expected Shortfall).
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Rolling Conditional Value-at-Risk (Expected Shortfall).
+///
+/// Where [`crate::ValueAtRisk`] reports the loss at the lower-tail quantile,
+/// `CVaR` averages **all** returns below that quantile — the expected loss
+/// conditional on being in the bad tail:
+///
+/// ```text
+/// q       = 1 − confidence
+/// tail    = returns over window with rank fraction ≤ q
+/// CVaR    = − mean(tail)                        if mean is negative
+/// CVaR    = 0                                   otherwise
+/// ```
+///
+/// The tail comprises the `floor(q · n)` smallest returns; if `floor` rounds
+/// down to zero the smallest single return is used so the metric stays
+/// defined for any `period ≥ 2`. Output is the magnitude of the expected
+/// shortfall (sign-flipped to be non-negative). `CVaR` is by construction
+/// `≥ VaR` because it averages losses *beyond* the `VaR` threshold.
+///
+/// Each `update` is O(period · log period).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{ConditionalValueAtRisk, Indicator};
+///
+/// let mut c = ConditionalValueAtRisk::new(100, 0.95).unwrap();
+/// let mut last = None;
+/// for i in 0..120 {
+///     last = c.update((f64::from(i) * 0.1).sin() * 0.02);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct ConditionalValueAtRisk {
+    period: usize,
+    confidence: f64,
+    window: VecDeque<f64>,
+}
+
+impl ConditionalValueAtRisk {
+    /// Construct a new rolling `CVaR`.
+    ///
+    /// # Errors
+    /// Returns [`Error::InvalidPeriod`] if `period < 2`, or if
+    /// `confidence` is outside `(0, 1)`.
+    pub fn new(period: usize, confidence: f64) -> Result<Self> {
+        if period < 2 {
+            return Err(Error::InvalidPeriod {
+                message: "conditional value-at-risk needs period >= 2",
+            });
+        }
+        if !confidence.is_finite() || confidence <= 0.0 || confidence >= 1.0 {
+            return Err(Error::InvalidPeriod {
+                message: "confidence must lie strictly between 0 and 1",
+            });
+        }
+        Ok(Self {
+            period,
+            confidence,
+            window: VecDeque::with_capacity(period),
+        })
+    }
+
+    /// Configured window length.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+
+    /// Configured confidence level.
+    pub const fn confidence(&self) -> f64 {
+        self.confidence
+    }
+}
+
+impl Indicator for ConditionalValueAtRisk {
+    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 sorted: Vec<f64> = self.window.iter().copied().collect();
+        sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+        let q = 1.0 - self.confidence;
+        let n = sorted.len();
+        // Number of samples in the tail. Floor, with a min of 1 so the
+        // expectation is always defined.
+        let k = ((q * n as f64).floor() as usize).max(1);
+        let tail = &sorted[..k];
+        let mean = tail.iter().sum::<f64>() / k as f64;
+        Some((-mean).max(0.0))
+    }
+
+    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 {
+        "ConditionalValueAtRisk"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_invalid_params() {
+        assert!(matches!(
+            ConditionalValueAtRisk::new(1, 0.95),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            ConditionalValueAtRisk::new(20, 0.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+        assert!(matches!(
+            ConditionalValueAtRisk::new(20, 1.0),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let c = ConditionalValueAtRisk::new(100, 0.95).unwrap();
+        assert_eq!(c.period(), 100);
+        assert_relative_eq!(c.confidence(), 0.95, epsilon = 1e-12);
+        assert_eq!(c.name(), "ConditionalValueAtRisk");
+        assert_eq!(c.warmup_period(), 100);
+    }
+
+    #[test]
+    fn reference_value() {
+        // 20 returns -10..9 (each *0.01); confidence 0.95.
+        // q = 0.05, n = 20, k = floor(0.05*20) = 1.
+        // Tail = {-0.10}, CVaR = 0.10.
+        let mut c = ConditionalValueAtRisk::new(20, 0.95).unwrap();
+        let returns: Vec<f64> = (-10..10).map(|i| f64::from(i) * 0.01).collect();
+        let out = c.batch(&returns);
+        assert_relative_eq!(out[19].unwrap(), 0.10, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn cvar_geq_var_on_same_window() {
+        // Sanity: with confidence 0.9, the tail of 10 returns has 1 sample;
+        // VaR uses interpolation between 0 and 1, so CVaR (mean of just the
+        // worst) >= VaR.
+        use crate::ValueAtRisk;
+        let returns: Vec<f64> = vec![
+            -0.05, -0.02, -0.01, 0.0, 0.005, 0.01, 0.02, 0.03, 0.04, 0.05,
+        ];
+        let mut v = ValueAtRisk::new(10, 0.9).unwrap();
+        let mut c = ConditionalValueAtRisk::new(10, 0.9).unwrap();
+        let v_out = v.batch(&returns);
+        let c_out = c.batch(&returns);
+        let var = v_out[9].unwrap();
+        let cvar = c_out[9].unwrap();
+        assert!(cvar >= var - 1e-12, "CVaR {cvar} should be >= VaR {var}");
+    }
+
+    #[test]
+    fn all_positive_returns_yield_zero() {
+        let mut c = ConditionalValueAtRisk::new(5, 0.95).unwrap();
+        let out = c.batch(&[0.01, 0.02, 0.03, 0.04, 0.05]);
+        assert_eq!(out[4], Some(0.0));
+    }
+
+    #[test]
+    fn ignores_non_finite_input() {
+        let mut c = ConditionalValueAtRisk::new(3, 0.95).unwrap();
+        assert_eq!(c.update(f64::NAN), None);
+        assert_eq!(c.update(f64::INFINITY), None);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut c = ConditionalValueAtRisk::new(3, 0.95).unwrap();
+        c.batch(&[-0.01, -0.02, -0.03]);
+        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| (f64::from(i) * 0.2).sin() * 0.02).collect();
+        let batch = ConditionalValueAtRisk::new(10, 0.95)
+            .unwrap()
+            .batch(&returns);
+        let mut s = ConditionalValueAtRisk::new(10, 0.95).unwrap();
+        let streamed: Vec<_> = returns.iter().map(|r| s.update(*r)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

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

@@ -0,0 +1,307 @@
+//! Connors RSI (CRSI).
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::indicators::rsi::Rsi;
+use crate::traits::Indicator;
+
+/// Larry Connors' RSI — average of three short-term mean-reversion components,
+/// each individually bounded in `[0, 100]` so the aggregate is too:
+///
+/// 1. `RSI(close, period_rsi)` — a fast `RSI` (Connors' default `3`).
+/// 2. `RSI(streak, period_streak)` — `RSI` of the current up/down run length
+///    (`+1, +2, ...` for consecutive up closes, `−1, −2, ...` for down closes,
+///    `0` for unchanged). Connors' default `2`.
+/// 3. `PercentRank(ROC(1), period_rank)` — the percentile rank of yesterday's
+///    1-period return in the last `period_rank` returns. Connors' default `100`.
+///
+/// ```text
+/// CRSI = (RSI(close)_t + RSI(streak)_t + PercentRank(roc1)_t) / 3
+/// ```
+///
+/// All three components live in `[0, 100]`, so `CRSI ∈ [0, 100]`. Connors'
+/// trading rule of thumb: `CRSI < 5` is oversold, `CRSI > 95` is overbought
+/// — both rare conditions, hence the short lookbacks.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{ConnorsRsi, Indicator};
+///
+/// let mut crsi = ConnorsRsi::classic();
+/// let mut last = None;
+/// for i in 0..200 {
+///     last = crsi.update(100.0 + f64::from(i));
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct ConnorsRsi {
+    period_rsi: usize,
+    period_streak: usize,
+    period_rank: usize,
+    rsi_close: Rsi,
+    rsi_streak: Rsi,
+    prev_price: Option<f64>,
+    streak: f64,
+    /// Rolling window of the last `period_rank` 1-period returns
+    /// (`(price_t − price_{t-1}) / price_{t-1}`).
+    rocs: VecDeque<f64>,
+    current: Option<f64>,
+}
+
+impl ConnorsRsi {
+    /// # Errors
+    /// Returns [`Error::PeriodZero`] if any of the three periods is zero.
+    pub fn new(period_rsi: usize, period_streak: usize, period_rank: usize) -> Result<Self> {
+        if period_rsi == 0 || period_streak == 0 || period_rank == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            period_rsi,
+            period_streak,
+            period_rank,
+            rsi_close: Rsi::new(period_rsi)?,
+            rsi_streak: Rsi::new(period_streak)?,
+            prev_price: None,
+            streak: 0.0,
+            rocs: VecDeque::with_capacity(period_rank),
+            current: None,
+        })
+    }
+
+    /// Connors' recommended defaults: `(period_rsi = 3, period_streak = 2, period_rank = 100)`.
+    pub fn classic() -> Self {
+        Self::new(3, 2, 100).expect("classic Connors RSI parameters are valid")
+    }
+
+    /// Configured `(period_rsi, period_streak, period_rank)`.
+    pub const fn periods(&self) -> (usize, usize, usize) {
+        (self.period_rsi, self.period_streak, self.period_rank)
+    }
+}
+
+impl Indicator for ConnorsRsi {
+    type Input = f64;
+    type Output = f64;
+
+    fn update(&mut self, input: f64) -> Option<f64> {
+        if !input.is_finite() {
+            return self.current;
+        }
+        // Run the close-RSI on every input so it warms up regardless of the
+        // streak / percent-rank branches.
+        let rsi_close = self.rsi_close.update(input);
+
+        let Some(prev) = self.prev_price else {
+            self.prev_price = Some(input);
+            return None;
+        };
+
+        // Update the up/down streak run length.
+        self.streak = if input > prev {
+            self.streak.max(0.0) + 1.0
+        } else if input < prev {
+            self.streak.min(0.0) - 1.0
+        } else {
+            0.0
+        };
+        let rsi_streak = self.rsi_streak.update(self.streak);
+
+        // 1-period return; defined only when the previous price is non-zero.
+        if prev != 0.0 {
+            let roc = (input - prev) / prev;
+            if self.rocs.len() == self.period_rank {
+                self.rocs.pop_front();
+            }
+            self.rocs.push_back(roc);
+        }
+        self.prev_price = Some(input);
+
+        // PercentRank emits once the ROC window has filled.
+        let percent_rank = if self.rocs.len() == self.period_rank {
+            let latest = *self.rocs.back().expect("non-empty window");
+            let below = self.rocs.iter().filter(|&&r| r < latest).count();
+            Some(100.0 * below as f64 / self.period_rank as f64)
+        } else {
+            None
+        };
+
+        let value = (rsi_close?, rsi_streak?, percent_rank?);
+        let crsi = (value.0 + value.1 + value.2) / 3.0;
+        self.current = Some(crsi);
+        Some(crsi)
+    }
+
+    fn reset(&mut self) {
+        self.rsi_close.reset();
+        self.rsi_streak.reset();
+        self.prev_price = None;
+        self.streak = 0.0;
+        self.rocs.clear();
+        self.current = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        // The slowest branch is the percent-rank: it needs period_rank + 1
+        // prices (period_rank one-period returns). The close-RSI needs
+        // period_rsi + 1 prices and the streak-RSI needs period_streak + 1
+        // streak values = period_streak + 2 prices. The rank branch dominates
+        // for Connors' defaults.
+        let rsi_close = self.period_rsi + 1;
+        let rsi_streak = self.period_streak + 2;
+        let rank = self.period_rank + 1;
+        rsi_close.max(rsi_streak).max(rank)
+    }
+
+    fn is_ready(&self) -> bool {
+        self.current.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "ConnorsRSI"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(ConnorsRsi::new(0, 2, 100), Err(Error::PeriodZero)));
+        assert!(matches!(ConnorsRsi::new(3, 0, 100), Err(Error::PeriodZero)));
+        assert!(matches!(ConnorsRsi::new(3, 2, 0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let crsi = ConnorsRsi::classic();
+        assert_eq!(crsi.periods(), (3, 2, 100));
+        assert_eq!(crsi.name(), "ConnorsRSI");
+        // Slowest branch: percent_rank with period_rank + 1 = 101.
+        assert_eq!(crsi.warmup_period(), 101);
+    }
+
+    #[test]
+    fn classic_factory() {
+        assert_eq!(ConnorsRsi::classic().periods(), (3, 2, 100));
+    }
+
+    #[test]
+    fn warmup_emits_first_value_at_warmup_period() {
+        // Use small periods so the test is fast.
+        let mut crsi = ConnorsRsi::new(3, 2, 5).unwrap();
+        // Slowest: 5 + 1 = 6.
+        assert_eq!(crsi.warmup_period(), 6);
+        let prices: Vec<f64> = (1..=8).map(f64::from).collect();
+        let out = crsi.batch(&prices);
+        for v in out.iter().take(5) {
+            assert!(v.is_none());
+        }
+        assert!(out[5].is_some());
+    }
+
+    #[test]
+    fn pure_uptrend_saturates_high() {
+        // A monotonic uptrend drives all three components toward 100:
+        // RSI of monotonic ups is 100, streak stays positive and growing so
+        // its RSI is 100, and every new 1-period return matches the prior
+        // ones so percent rank stabilises near 0 — but the average of all
+        // three still climbs well above 50.
+        let mut crsi = ConnorsRsi::classic();
+        for i in 1..=200 {
+            crsi.update(f64::from(i));
+        }
+        let v = crsi.current.unwrap();
+        assert!(
+            v > 60.0,
+            "uptrend should drive Connors RSI well above 50: {v}"
+        );
+    }
+
+    #[test]
+    fn output_is_bounded() {
+        let mut crsi = ConnorsRsi::classic();
+        let prices: Vec<f64> = (0..300)
+            .map(|i| 100.0 + (f64::from(i) * 0.3).sin() * 20.0)
+            .collect();
+        for v in crsi.batch(&prices).iter().flatten() {
+            assert!(
+                (0.0..=100.0).contains(v),
+                "Connors RSI out of [0, 100]: {v}"
+            );
+        }
+    }
+
+    #[test]
+    fn streak_resets_to_zero_on_unchanged_close() {
+        // Helper: feed a sequence and inspect the internal streak.
+        let mut crsi = ConnorsRsi::new(3, 2, 100).unwrap();
+        crsi.update(10.0);
+        crsi.update(11.0);
+        crsi.update(12.0);
+        assert_eq!(crsi.streak, 2.0);
+        crsi.update(12.0);
+        assert_relative_eq!(crsi.streak, 0.0, epsilon = 1e-12);
+        crsi.update(11.0);
+        assert_eq!(crsi.streak, -1.0);
+        crsi.update(10.0);
+        assert_eq!(crsi.streak, -2.0);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let prices: Vec<f64> = (1..=200)
+            .map(|i| 100.0 + (f64::from(i) * 0.2).sin() * 5.0 + f64::from(i) * 0.1)
+            .collect();
+        let mut a = ConnorsRsi::classic();
+        let mut b = ConnorsRsi::classic();
+        assert_eq!(
+            a.batch(&prices),
+            prices.iter().map(|p| b.update(*p)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut crsi = ConnorsRsi::classic();
+        let prices: Vec<f64> = (1..=200).map(f64::from).collect();
+        crsi.batch(&prices);
+        assert!(crsi.is_ready());
+        crsi.reset();
+        assert!(!crsi.is_ready());
+        assert_eq!(crsi.streak, 0.0);
+        assert!(crsi.prev_price.is_none());
+    }
+
+    #[test]
+    fn ignores_non_finite_input() {
+        let mut crsi = ConnorsRsi::classic();
+        let prices: Vec<f64> = (1..=200).map(f64::from).collect();
+        crsi.batch(&prices);
+        let before = crsi.current;
+        assert_eq!(crsi.update(f64::NAN), before);
+        assert_eq!(crsi.update(f64::INFINITY), before);
+    }
+
+    #[test]
+    fn zero_prev_skips_roc_update() {
+        // A previous price of 0.0 makes the 1-bar return undefined; the
+        // ROC ring buffer must be left unchanged on that step. Feeding
+        // 0.0 as the very first price seeds `prev_price = Some(0.0)`, so
+        // the next bar takes the `prev == 0.0` branch.
+        let mut crsi = ConnorsRsi::new(3, 2, 4).unwrap();
+        // Bar 1 seeds prev_price to 0.0.
+        crsi.update(0.0);
+        // Bar 2 must not push onto the ROC window; we cannot observe the
+        // ring directly but the indicator must not panic and must not
+        // emit until at least period_rank distinct non-zero returns have
+        // accumulated.
+        let after = crsi.update(1.0);
+        assert!(after.is_none(), "CRSI cannot emit on bar 2: {after:?}");
+    }
+}

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

@@ -0,0 +1,245 @@
+//! Counterattack candlestick pattern.
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Counterattack — a 2-bar reversal where the second bar storms back to close
+/// right where the first bar closed. A long candle runs with the trend, then an
+/// opposite-coloured long candle opens far in the trend direction and rallies (or
+/// sells off) all the way back to the prior close — the two closes meeting forms
+/// the "counterattack line".
+///
+/// ```text
+/// long bodies   = |close − open| >= 0.5 * (high − low)   (both bars)
+/// equal closes  = |close2 − close1| <= tol * mean(range1, range2)
+/// bullish (+1.0): bar1 black (down), bar2 white (up), equal closes
+/// bearish (−1.0): bar1 white (up),   bar2 black (down), equal closes
+/// ```
+///
+/// Output is `+1.0` bullish, `−1.0` bearish, and `0.0` when the bodies are short,
+/// the colours match, or the closes are not level. The first bar always returns
+/// `0.0` because the two-bar window is not yet filled. `equal_tolerance` defaults
+/// to `0.05` (TA-Lib's `CDLCOUNTERATTACK` "equal" factor — 5 % of the mean bar
+/// range) and must lie in `[0, 1)`. The body-length test uses a fixed half-range
+/// fraction rather than TA-Lib's rolling body average, matching the geometric
+/// house style of this pattern family. Pattern-shape check only — no trend filter
+/// is applied; combine with a trend indicator for actionable signals.
+///
+/// # Signed ±1 encoding
+///
+/// This detector emits the uniform candlestick sign convention shared across the
+/// pattern family — `+1.0` bullish, `−1.0` bearish, `0.0` no pattern — so it
+/// drops straight into a machine-learning feature matrix where the bullish and
+/// bearish variants occupy a single dimension.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Counterattack, Indicator};
+///
+/// let mut indicator = Counterattack::new();
+/// // Bullish: a long black bar, then a long white bar closing at the same level.
+/// indicator.update(Candle::new(20.0, 20.1, 14.9, 15.0, 1.0, 0).unwrap());
+/// let out = indicator
+///     .update(Candle::new(10.0, 15.1, 9.9, 15.0, 1.0, 1).unwrap());
+/// assert_eq!(out, Some(1.0));
+/// ```
+#[derive(Debug, Clone)]
+pub struct Counterattack {
+    equal_tolerance: f64,
+    prev: Option<Candle>,
+    has_emitted: bool,
+}
+
+impl Default for Counterattack {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Counterattack {
+    /// Construct a Counterattack detector with the default 5 % equal-close tolerance.
+    pub const fn new() -> Self {
+        Self {
+            equal_tolerance: 0.05,
+            prev: None,
+            has_emitted: false,
+        }
+    }
+
+    /// Construct a Counterattack detector with a custom equal-close tolerance.
+    ///
+    /// `equal_tolerance` is the fraction of the mean bar range within which the
+    /// two closes must agree and must lie in `[0, 1)`.
+    pub fn with_tolerance(equal_tolerance: f64) -> Result<Self> {
+        if !(0.0..1.0).contains(&equal_tolerance) {
+            return Err(Error::InvalidPeriod {
+                message: "counterattack equal tolerance must lie in [0, 1)",
+            });
+        }
+        Ok(Self {
+            equal_tolerance,
+            prev: None,
+            has_emitted: false,
+        })
+    }
+
+    /// Configured equal-close tolerance.
+    pub fn equal_tolerance(&self) -> f64 {
+        self.equal_tolerance
+    }
+}
+
+impl Indicator for Counterattack {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        let prev = self.prev;
+        self.prev = Some(candle);
+        let Some(bar1) = prev else {
+            return Some(0.0);
+        };
+        let range1 = bar1.high - bar1.low;
+        let range2 = candle.high - candle.low;
+        let body1 = bar1.close - bar1.open;
+        let body2 = candle.close - candle.open;
+        let long1 = body1.abs() >= 0.5 * range1;
+        let long2 = body2.abs() >= 0.5 * range2;
+        let tol = self.equal_tolerance * 0.5 * (range1 + range2);
+        let equal_close = (candle.close - bar1.close).abs() <= tol;
+        if !(long1 && long2 && equal_close) {
+            return Some(0.0);
+        }
+        // Bullish: a long black bar met by a long white bar closing level.
+        if body1 < 0.0 && body2 > 0.0 {
+            return Some(1.0);
+        }
+        // Bearish: a long white bar met by a long black bar closing level.
+        if body1 > 0.0 && body2 < 0.0 {
+            return Some(-1.0);
+        }
+        Some(0.0)
+    }
+
+    fn reset(&mut self) {
+        self.prev = None;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        2
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "Counterattack"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(open: f64, high: f64, low: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn rejects_invalid_tolerance() {
+        assert!(Counterattack::with_tolerance(-0.01).is_err());
+        assert!(Counterattack::with_tolerance(1.0).is_err());
+    }
+
+    #[test]
+    fn accepts_valid_tolerance() {
+        let t = Counterattack::with_tolerance(0.0).unwrap();
+        assert!((t.equal_tolerance() - 0.0).abs() < 1e-12);
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let t = Counterattack::default();
+        assert_eq!(t.name(), "Counterattack");
+        assert_eq!(t.warmup_period(), 2);
+        assert!(!t.is_ready());
+        assert!((t.equal_tolerance() - 0.05).abs() < 1e-12);
+    }
+
+    #[test]
+    fn bullish_counterattack_is_plus_one() {
+        let mut t = Counterattack::new();
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(10.0, 15.1, 9.9, 15.0, 1)), Some(1.0));
+    }
+
+    #[test]
+    fn bearish_counterattack_is_minus_one() {
+        let mut t = Counterattack::new();
+        assert_eq!(t.update(c(15.0, 20.1, 14.9, 20.0, 0)), Some(0.0));
+        assert_eq!(t.update(c(25.0, 25.1, 19.9, 20.0, 1)), Some(-1.0));
+    }
+
+    #[test]
+    fn unequal_close_yields_zero() {
+        let mut t = Counterattack::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        // Second close at 17.0 is far from the first close (15.0) -> not level.
+        assert_eq!(t.update(c(10.0, 17.1, 9.9, 17.0, 1)), Some(0.0));
+    }
+
+    #[test]
+    fn same_color_yields_zero() {
+        let mut t = Counterattack::new();
+        // Both bars black -> not opposite colours.
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 1)), Some(0.0));
+    }
+
+    #[test]
+    fn short_body_yields_zero() {
+        let mut t = Counterattack::new();
+        // Second bar has a tiny body relative to its range.
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        assert_eq!(t.update(c(14.8, 20.0, 9.9, 15.2, 1)), Some(0.0));
+    }
+
+    #[test]
+    fn first_bar_returns_zero() {
+        let mut t = Counterattack::new();
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| {
+                let base = 100.0 + i as f64;
+                c(base, base + 2.0, base - 2.0, base + 1.5, i)
+            })
+            .collect();
+        let mut a = Counterattack::new();
+        let mut b = Counterattack::new();
+        assert_eq!(
+            a.batch(&candles),
+            candles.iter().map(|x| b.update(*x)).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut t = Counterattack::new();
+        t.update(c(20.0, 20.1, 14.9, 15.0, 0));
+        t.update(c(10.0, 15.1, 9.9, 15.0, 1));
+        assert!(t.is_ready());
+        t.reset();
+        assert!(!t.is_ready());
+        assert_eq!(t.update(c(20.0, 20.1, 14.9, 15.0, 0)), Some(0.0));
+    }
+}